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_deserializeOpAssociateFirewallRuleGroup struct { 22} 23 24func (*awsAwsjson11_deserializeOpAssociateFirewallRuleGroup) ID() string { 25 return "OperationDeserializer" 26} 27 28func (m *awsAwsjson11_deserializeOpAssociateFirewallRuleGroup) 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_deserializeOpErrorAssociateFirewallRuleGroup(response, &metadata) 43 } 44 output := &AssociateFirewallRuleGroupOutput{} 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_deserializeOpDocumentAssociateFirewallRuleGroupOutput(&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_deserializeOpErrorAssociateFirewallRuleGroup(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("AccessDeniedException", errorCode): 120 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 121 122 case strings.EqualFold("ConflictException", errorCode): 123 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 124 125 case strings.EqualFold("InternalServiceErrorException", errorCode): 126 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 127 128 case strings.EqualFold("LimitExceededException", errorCode): 129 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 130 131 case strings.EqualFold("ResourceNotFoundException", errorCode): 132 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 133 134 case strings.EqualFold("ThrottlingException", errorCode): 135 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 136 137 case strings.EqualFold("ValidationException", errorCode): 138 return awsAwsjson11_deserializeErrorValidationException(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_deserializeOpAssociateResolverEndpointIpAddress struct { 151} 152 153func (*awsAwsjson11_deserializeOpAssociateResolverEndpointIpAddress) ID() string { 154 return "OperationDeserializer" 155} 156 157func (m *awsAwsjson11_deserializeOpAssociateResolverEndpointIpAddress) 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_deserializeOpErrorAssociateResolverEndpointIpAddress(response, &metadata) 172 } 173 output := &AssociateResolverEndpointIpAddressOutput{} 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_deserializeOpDocumentAssociateResolverEndpointIpAddressOutput(&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_deserializeOpErrorAssociateResolverEndpointIpAddress(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("InternalServiceErrorException", errorCode): 249 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 250 251 case strings.EqualFold("InvalidParameterException", errorCode): 252 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 253 254 case strings.EqualFold("InvalidRequestException", errorCode): 255 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 256 257 case strings.EqualFold("LimitExceededException", errorCode): 258 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 259 260 case strings.EqualFold("ResourceExistsException", errorCode): 261 return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody) 262 263 case strings.EqualFold("ResourceNotFoundException", errorCode): 264 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 265 266 case strings.EqualFold("ThrottlingException", errorCode): 267 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 268 269 default: 270 genericError := &smithy.GenericAPIError{ 271 Code: errorCode, 272 Message: errorMessage, 273 } 274 return genericError 275 276 } 277} 278 279type awsAwsjson11_deserializeOpAssociateResolverQueryLogConfig struct { 280} 281 282func (*awsAwsjson11_deserializeOpAssociateResolverQueryLogConfig) ID() string { 283 return "OperationDeserializer" 284} 285 286func (m *awsAwsjson11_deserializeOpAssociateResolverQueryLogConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 287 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 288) { 289 out, metadata, err = next.HandleDeserialize(ctx, in) 290 if err != nil { 291 return out, metadata, err 292 } 293 294 response, ok := out.RawResponse.(*smithyhttp.Response) 295 if !ok { 296 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 297 } 298 299 if response.StatusCode < 200 || response.StatusCode >= 300 { 300 return out, metadata, awsAwsjson11_deserializeOpErrorAssociateResolverQueryLogConfig(response, &metadata) 301 } 302 output := &AssociateResolverQueryLogConfigOutput{} 303 out.Result = output 304 305 var buff [1024]byte 306 ringBuffer := smithyio.NewRingBuffer(buff[:]) 307 308 body := io.TeeReader(response.Body, ringBuffer) 309 decoder := json.NewDecoder(body) 310 decoder.UseNumber() 311 var shape interface{} 312 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 313 var snapshot bytes.Buffer 314 io.Copy(&snapshot, ringBuffer) 315 err = &smithy.DeserializationError{ 316 Err: fmt.Errorf("failed to decode response body, %w", err), 317 Snapshot: snapshot.Bytes(), 318 } 319 return out, metadata, err 320 } 321 322 err = awsAwsjson11_deserializeOpDocumentAssociateResolverQueryLogConfigOutput(&output, shape) 323 if err != nil { 324 var snapshot bytes.Buffer 325 io.Copy(&snapshot, ringBuffer) 326 err = &smithy.DeserializationError{ 327 Err: fmt.Errorf("failed to decode response body, %w", err), 328 Snapshot: snapshot.Bytes(), 329 } 330 return out, metadata, err 331 } 332 333 return out, metadata, err 334} 335 336func awsAwsjson11_deserializeOpErrorAssociateResolverQueryLogConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 337 var errorBuffer bytes.Buffer 338 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 339 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 340 } 341 errorBody := bytes.NewReader(errorBuffer.Bytes()) 342 343 errorCode := "UnknownError" 344 errorMessage := errorCode 345 346 code := response.Header.Get("X-Amzn-ErrorType") 347 if len(code) != 0 { 348 errorCode = restjson.SanitizeErrorCode(code) 349 } 350 351 var buff [1024]byte 352 ringBuffer := smithyio.NewRingBuffer(buff[:]) 353 354 body := io.TeeReader(errorBody, ringBuffer) 355 decoder := json.NewDecoder(body) 356 decoder.UseNumber() 357 code, message, err := restjson.GetErrorInfo(decoder) 358 if err != nil { 359 var snapshot bytes.Buffer 360 io.Copy(&snapshot, ringBuffer) 361 err = &smithy.DeserializationError{ 362 Err: fmt.Errorf("failed to decode response body, %w", err), 363 Snapshot: snapshot.Bytes(), 364 } 365 return err 366 } 367 368 errorBody.Seek(0, io.SeekStart) 369 if len(code) != 0 { 370 errorCode = restjson.SanitizeErrorCode(code) 371 } 372 if len(message) != 0 { 373 errorMessage = message 374 } 375 376 switch { 377 case strings.EqualFold("AccessDeniedException", errorCode): 378 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 379 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("ThrottlingException", errorCode): 399 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 400 401 default: 402 genericError := &smithy.GenericAPIError{ 403 Code: errorCode, 404 Message: errorMessage, 405 } 406 return genericError 407 408 } 409} 410 411type awsAwsjson11_deserializeOpAssociateResolverRule struct { 412} 413 414func (*awsAwsjson11_deserializeOpAssociateResolverRule) ID() string { 415 return "OperationDeserializer" 416} 417 418func (m *awsAwsjson11_deserializeOpAssociateResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 419 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 420) { 421 out, metadata, err = next.HandleDeserialize(ctx, in) 422 if err != nil { 423 return out, metadata, err 424 } 425 426 response, ok := out.RawResponse.(*smithyhttp.Response) 427 if !ok { 428 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 429 } 430 431 if response.StatusCode < 200 || response.StatusCode >= 300 { 432 return out, metadata, awsAwsjson11_deserializeOpErrorAssociateResolverRule(response, &metadata) 433 } 434 output := &AssociateResolverRuleOutput{} 435 out.Result = output 436 437 var buff [1024]byte 438 ringBuffer := smithyio.NewRingBuffer(buff[:]) 439 440 body := io.TeeReader(response.Body, ringBuffer) 441 decoder := json.NewDecoder(body) 442 decoder.UseNumber() 443 var shape interface{} 444 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 445 var snapshot bytes.Buffer 446 io.Copy(&snapshot, ringBuffer) 447 err = &smithy.DeserializationError{ 448 Err: fmt.Errorf("failed to decode response body, %w", err), 449 Snapshot: snapshot.Bytes(), 450 } 451 return out, metadata, err 452 } 453 454 err = awsAwsjson11_deserializeOpDocumentAssociateResolverRuleOutput(&output, shape) 455 if err != nil { 456 var snapshot bytes.Buffer 457 io.Copy(&snapshot, ringBuffer) 458 err = &smithy.DeserializationError{ 459 Err: fmt.Errorf("failed to decode response body, %w", err), 460 Snapshot: snapshot.Bytes(), 461 } 462 return out, metadata, err 463 } 464 465 return out, metadata, err 466} 467 468func awsAwsjson11_deserializeOpErrorAssociateResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 469 var errorBuffer bytes.Buffer 470 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 471 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 472 } 473 errorBody := bytes.NewReader(errorBuffer.Bytes()) 474 475 errorCode := "UnknownError" 476 errorMessage := errorCode 477 478 code := response.Header.Get("X-Amzn-ErrorType") 479 if len(code) != 0 { 480 errorCode = restjson.SanitizeErrorCode(code) 481 } 482 483 var buff [1024]byte 484 ringBuffer := smithyio.NewRingBuffer(buff[:]) 485 486 body := io.TeeReader(errorBody, ringBuffer) 487 decoder := json.NewDecoder(body) 488 decoder.UseNumber() 489 code, message, err := restjson.GetErrorInfo(decoder) 490 if err != nil { 491 var snapshot bytes.Buffer 492 io.Copy(&snapshot, ringBuffer) 493 err = &smithy.DeserializationError{ 494 Err: fmt.Errorf("failed to decode response body, %w", err), 495 Snapshot: snapshot.Bytes(), 496 } 497 return err 498 } 499 500 errorBody.Seek(0, io.SeekStart) 501 if len(code) != 0 { 502 errorCode = restjson.SanitizeErrorCode(code) 503 } 504 if len(message) != 0 { 505 errorMessage = message 506 } 507 508 switch { 509 case strings.EqualFold("InternalServiceErrorException", errorCode): 510 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 511 512 case strings.EqualFold("InvalidParameterException", errorCode): 513 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 514 515 case strings.EqualFold("InvalidRequestException", errorCode): 516 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 517 518 case strings.EqualFold("LimitExceededException", errorCode): 519 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 520 521 case strings.EqualFold("ResourceExistsException", errorCode): 522 return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody) 523 524 case strings.EqualFold("ResourceNotFoundException", errorCode): 525 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 526 527 case strings.EqualFold("ResourceUnavailableException", errorCode): 528 return awsAwsjson11_deserializeErrorResourceUnavailableException(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_deserializeOpCreateFirewallDomainList struct { 544} 545 546func (*awsAwsjson11_deserializeOpCreateFirewallDomainList) ID() string { 547 return "OperationDeserializer" 548} 549 550func (m *awsAwsjson11_deserializeOpCreateFirewallDomainList) 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_deserializeOpErrorCreateFirewallDomainList(response, &metadata) 565 } 566 output := &CreateFirewallDomainListOutput{} 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_deserializeOpDocumentCreateFirewallDomainListOutput(&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_deserializeOpErrorCreateFirewallDomainList(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("LimitExceededException", errorCode): 648 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 649 650 case strings.EqualFold("ThrottlingException", errorCode): 651 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 652 653 case strings.EqualFold("ValidationException", errorCode): 654 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 655 656 default: 657 genericError := &smithy.GenericAPIError{ 658 Code: errorCode, 659 Message: errorMessage, 660 } 661 return genericError 662 663 } 664} 665 666type awsAwsjson11_deserializeOpCreateFirewallRule struct { 667} 668 669func (*awsAwsjson11_deserializeOpCreateFirewallRule) ID() string { 670 return "OperationDeserializer" 671} 672 673func (m *awsAwsjson11_deserializeOpCreateFirewallRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 674 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 675) { 676 out, metadata, err = next.HandleDeserialize(ctx, in) 677 if err != nil { 678 return out, metadata, err 679 } 680 681 response, ok := out.RawResponse.(*smithyhttp.Response) 682 if !ok { 683 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 684 } 685 686 if response.StatusCode < 200 || response.StatusCode >= 300 { 687 return out, metadata, awsAwsjson11_deserializeOpErrorCreateFirewallRule(response, &metadata) 688 } 689 output := &CreateFirewallRuleOutput{} 690 out.Result = output 691 692 var buff [1024]byte 693 ringBuffer := smithyio.NewRingBuffer(buff[:]) 694 695 body := io.TeeReader(response.Body, ringBuffer) 696 decoder := json.NewDecoder(body) 697 decoder.UseNumber() 698 var shape interface{} 699 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 700 var snapshot bytes.Buffer 701 io.Copy(&snapshot, ringBuffer) 702 err = &smithy.DeserializationError{ 703 Err: fmt.Errorf("failed to decode response body, %w", err), 704 Snapshot: snapshot.Bytes(), 705 } 706 return out, metadata, err 707 } 708 709 err = awsAwsjson11_deserializeOpDocumentCreateFirewallRuleOutput(&output, shape) 710 if err != nil { 711 var snapshot bytes.Buffer 712 io.Copy(&snapshot, ringBuffer) 713 err = &smithy.DeserializationError{ 714 Err: fmt.Errorf("failed to decode response body, %w", err), 715 Snapshot: snapshot.Bytes(), 716 } 717 return out, metadata, err 718 } 719 720 return out, metadata, err 721} 722 723func awsAwsjson11_deserializeOpErrorCreateFirewallRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 724 var errorBuffer bytes.Buffer 725 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 726 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 727 } 728 errorBody := bytes.NewReader(errorBuffer.Bytes()) 729 730 errorCode := "UnknownError" 731 errorMessage := errorCode 732 733 code := response.Header.Get("X-Amzn-ErrorType") 734 if len(code) != 0 { 735 errorCode = restjson.SanitizeErrorCode(code) 736 } 737 738 var buff [1024]byte 739 ringBuffer := smithyio.NewRingBuffer(buff[:]) 740 741 body := io.TeeReader(errorBody, ringBuffer) 742 decoder := json.NewDecoder(body) 743 decoder.UseNumber() 744 code, message, err := restjson.GetErrorInfo(decoder) 745 if err != nil { 746 var snapshot bytes.Buffer 747 io.Copy(&snapshot, ringBuffer) 748 err = &smithy.DeserializationError{ 749 Err: fmt.Errorf("failed to decode response body, %w", err), 750 Snapshot: snapshot.Bytes(), 751 } 752 return err 753 } 754 755 errorBody.Seek(0, io.SeekStart) 756 if len(code) != 0 { 757 errorCode = restjson.SanitizeErrorCode(code) 758 } 759 if len(message) != 0 { 760 errorMessage = message 761 } 762 763 switch { 764 case strings.EqualFold("AccessDeniedException", errorCode): 765 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 766 767 case strings.EqualFold("InternalServiceErrorException", errorCode): 768 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 769 770 case strings.EqualFold("LimitExceededException", errorCode): 771 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 772 773 case strings.EqualFold("ResourceNotFoundException", errorCode): 774 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 775 776 case strings.EqualFold("ThrottlingException", errorCode): 777 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 778 779 case strings.EqualFold("ValidationException", errorCode): 780 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 781 782 default: 783 genericError := &smithy.GenericAPIError{ 784 Code: errorCode, 785 Message: errorMessage, 786 } 787 return genericError 788 789 } 790} 791 792type awsAwsjson11_deserializeOpCreateFirewallRuleGroup struct { 793} 794 795func (*awsAwsjson11_deserializeOpCreateFirewallRuleGroup) ID() string { 796 return "OperationDeserializer" 797} 798 799func (m *awsAwsjson11_deserializeOpCreateFirewallRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 800 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 801) { 802 out, metadata, err = next.HandleDeserialize(ctx, in) 803 if err != nil { 804 return out, metadata, err 805 } 806 807 response, ok := out.RawResponse.(*smithyhttp.Response) 808 if !ok { 809 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 810 } 811 812 if response.StatusCode < 200 || response.StatusCode >= 300 { 813 return out, metadata, awsAwsjson11_deserializeOpErrorCreateFirewallRuleGroup(response, &metadata) 814 } 815 output := &CreateFirewallRuleGroupOutput{} 816 out.Result = output 817 818 var buff [1024]byte 819 ringBuffer := smithyio.NewRingBuffer(buff[:]) 820 821 body := io.TeeReader(response.Body, ringBuffer) 822 decoder := json.NewDecoder(body) 823 decoder.UseNumber() 824 var shape interface{} 825 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 826 var snapshot bytes.Buffer 827 io.Copy(&snapshot, ringBuffer) 828 err = &smithy.DeserializationError{ 829 Err: fmt.Errorf("failed to decode response body, %w", err), 830 Snapshot: snapshot.Bytes(), 831 } 832 return out, metadata, err 833 } 834 835 err = awsAwsjson11_deserializeOpDocumentCreateFirewallRuleGroupOutput(&output, shape) 836 if err != nil { 837 var snapshot bytes.Buffer 838 io.Copy(&snapshot, ringBuffer) 839 err = &smithy.DeserializationError{ 840 Err: fmt.Errorf("failed to decode response body, %w", err), 841 Snapshot: snapshot.Bytes(), 842 } 843 return out, metadata, err 844 } 845 846 return out, metadata, err 847} 848 849func awsAwsjson11_deserializeOpErrorCreateFirewallRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 850 var errorBuffer bytes.Buffer 851 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 852 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 853 } 854 errorBody := bytes.NewReader(errorBuffer.Bytes()) 855 856 errorCode := "UnknownError" 857 errorMessage := errorCode 858 859 code := response.Header.Get("X-Amzn-ErrorType") 860 if len(code) != 0 { 861 errorCode = restjson.SanitizeErrorCode(code) 862 } 863 864 var buff [1024]byte 865 ringBuffer := smithyio.NewRingBuffer(buff[:]) 866 867 body := io.TeeReader(errorBody, ringBuffer) 868 decoder := json.NewDecoder(body) 869 decoder.UseNumber() 870 code, message, err := restjson.GetErrorInfo(decoder) 871 if err != nil { 872 var snapshot bytes.Buffer 873 io.Copy(&snapshot, ringBuffer) 874 err = &smithy.DeserializationError{ 875 Err: fmt.Errorf("failed to decode response body, %w", err), 876 Snapshot: snapshot.Bytes(), 877 } 878 return err 879 } 880 881 errorBody.Seek(0, io.SeekStart) 882 if len(code) != 0 { 883 errorCode = restjson.SanitizeErrorCode(code) 884 } 885 if len(message) != 0 { 886 errorMessage = message 887 } 888 889 switch { 890 case strings.EqualFold("AccessDeniedException", errorCode): 891 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 892 893 case strings.EqualFold("InternalServiceErrorException", errorCode): 894 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 895 896 case strings.EqualFold("LimitExceededException", errorCode): 897 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 898 899 case strings.EqualFold("ThrottlingException", errorCode): 900 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 901 902 case strings.EqualFold("ValidationException", errorCode): 903 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 904 905 default: 906 genericError := &smithy.GenericAPIError{ 907 Code: errorCode, 908 Message: errorMessage, 909 } 910 return genericError 911 912 } 913} 914 915type awsAwsjson11_deserializeOpCreateResolverEndpoint struct { 916} 917 918func (*awsAwsjson11_deserializeOpCreateResolverEndpoint) ID() string { 919 return "OperationDeserializer" 920} 921 922func (m *awsAwsjson11_deserializeOpCreateResolverEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 923 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 924) { 925 out, metadata, err = next.HandleDeserialize(ctx, in) 926 if err != nil { 927 return out, metadata, err 928 } 929 930 response, ok := out.RawResponse.(*smithyhttp.Response) 931 if !ok { 932 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 933 } 934 935 if response.StatusCode < 200 || response.StatusCode >= 300 { 936 return out, metadata, awsAwsjson11_deserializeOpErrorCreateResolverEndpoint(response, &metadata) 937 } 938 output := &CreateResolverEndpointOutput{} 939 out.Result = output 940 941 var buff [1024]byte 942 ringBuffer := smithyio.NewRingBuffer(buff[:]) 943 944 body := io.TeeReader(response.Body, ringBuffer) 945 decoder := json.NewDecoder(body) 946 decoder.UseNumber() 947 var shape interface{} 948 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 949 var snapshot bytes.Buffer 950 io.Copy(&snapshot, ringBuffer) 951 err = &smithy.DeserializationError{ 952 Err: fmt.Errorf("failed to decode response body, %w", err), 953 Snapshot: snapshot.Bytes(), 954 } 955 return out, metadata, err 956 } 957 958 err = awsAwsjson11_deserializeOpDocumentCreateResolverEndpointOutput(&output, shape) 959 if err != nil { 960 var snapshot bytes.Buffer 961 io.Copy(&snapshot, ringBuffer) 962 err = &smithy.DeserializationError{ 963 Err: fmt.Errorf("failed to decode response body, %w", err), 964 Snapshot: snapshot.Bytes(), 965 } 966 return out, metadata, err 967 } 968 969 return out, metadata, err 970} 971 972func awsAwsjson11_deserializeOpErrorCreateResolverEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 973 var errorBuffer bytes.Buffer 974 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 975 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 976 } 977 errorBody := bytes.NewReader(errorBuffer.Bytes()) 978 979 errorCode := "UnknownError" 980 errorMessage := errorCode 981 982 code := response.Header.Get("X-Amzn-ErrorType") 983 if len(code) != 0 { 984 errorCode = restjson.SanitizeErrorCode(code) 985 } 986 987 var buff [1024]byte 988 ringBuffer := smithyio.NewRingBuffer(buff[:]) 989 990 body := io.TeeReader(errorBody, ringBuffer) 991 decoder := json.NewDecoder(body) 992 decoder.UseNumber() 993 code, message, err := restjson.GetErrorInfo(decoder) 994 if err != nil { 995 var snapshot bytes.Buffer 996 io.Copy(&snapshot, ringBuffer) 997 err = &smithy.DeserializationError{ 998 Err: fmt.Errorf("failed to decode response body, %w", err), 999 Snapshot: snapshot.Bytes(), 1000 } 1001 return err 1002 } 1003 1004 errorBody.Seek(0, io.SeekStart) 1005 if len(code) != 0 { 1006 errorCode = restjson.SanitizeErrorCode(code) 1007 } 1008 if len(message) != 0 { 1009 errorMessage = message 1010 } 1011 1012 switch { 1013 case strings.EqualFold("InternalServiceErrorException", errorCode): 1014 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1015 1016 case strings.EqualFold("InvalidParameterException", errorCode): 1017 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1018 1019 case strings.EqualFold("InvalidRequestException", errorCode): 1020 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1021 1022 case strings.EqualFold("LimitExceededException", errorCode): 1023 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1024 1025 case strings.EqualFold("ResourceExistsException", errorCode): 1026 return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody) 1027 1028 case strings.EqualFold("ResourceNotFoundException", errorCode): 1029 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1030 1031 case strings.EqualFold("ThrottlingException", errorCode): 1032 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1033 1034 default: 1035 genericError := &smithy.GenericAPIError{ 1036 Code: errorCode, 1037 Message: errorMessage, 1038 } 1039 return genericError 1040 1041 } 1042} 1043 1044type awsAwsjson11_deserializeOpCreateResolverQueryLogConfig struct { 1045} 1046 1047func (*awsAwsjson11_deserializeOpCreateResolverQueryLogConfig) ID() string { 1048 return "OperationDeserializer" 1049} 1050 1051func (m *awsAwsjson11_deserializeOpCreateResolverQueryLogConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1052 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1053) { 1054 out, metadata, err = next.HandleDeserialize(ctx, in) 1055 if err != nil { 1056 return out, metadata, err 1057 } 1058 1059 response, ok := out.RawResponse.(*smithyhttp.Response) 1060 if !ok { 1061 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1062 } 1063 1064 if response.StatusCode < 200 || response.StatusCode >= 300 { 1065 return out, metadata, awsAwsjson11_deserializeOpErrorCreateResolverQueryLogConfig(response, &metadata) 1066 } 1067 output := &CreateResolverQueryLogConfigOutput{} 1068 out.Result = output 1069 1070 var buff [1024]byte 1071 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1072 1073 body := io.TeeReader(response.Body, ringBuffer) 1074 decoder := json.NewDecoder(body) 1075 decoder.UseNumber() 1076 var shape interface{} 1077 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1078 var snapshot bytes.Buffer 1079 io.Copy(&snapshot, ringBuffer) 1080 err = &smithy.DeserializationError{ 1081 Err: fmt.Errorf("failed to decode response body, %w", err), 1082 Snapshot: snapshot.Bytes(), 1083 } 1084 return out, metadata, err 1085 } 1086 1087 err = awsAwsjson11_deserializeOpDocumentCreateResolverQueryLogConfigOutput(&output, shape) 1088 if err != nil { 1089 var snapshot bytes.Buffer 1090 io.Copy(&snapshot, ringBuffer) 1091 err = &smithy.DeserializationError{ 1092 Err: fmt.Errorf("failed to decode response body, %w", err), 1093 Snapshot: snapshot.Bytes(), 1094 } 1095 return out, metadata, err 1096 } 1097 1098 return out, metadata, err 1099} 1100 1101func awsAwsjson11_deserializeOpErrorCreateResolverQueryLogConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1102 var errorBuffer bytes.Buffer 1103 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1104 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1105 } 1106 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1107 1108 errorCode := "UnknownError" 1109 errorMessage := errorCode 1110 1111 code := response.Header.Get("X-Amzn-ErrorType") 1112 if len(code) != 0 { 1113 errorCode = restjson.SanitizeErrorCode(code) 1114 } 1115 1116 var buff [1024]byte 1117 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1118 1119 body := io.TeeReader(errorBody, ringBuffer) 1120 decoder := json.NewDecoder(body) 1121 decoder.UseNumber() 1122 code, message, err := restjson.GetErrorInfo(decoder) 1123 if err != nil { 1124 var snapshot bytes.Buffer 1125 io.Copy(&snapshot, ringBuffer) 1126 err = &smithy.DeserializationError{ 1127 Err: fmt.Errorf("failed to decode response body, %w", err), 1128 Snapshot: snapshot.Bytes(), 1129 } 1130 return err 1131 } 1132 1133 errorBody.Seek(0, io.SeekStart) 1134 if len(code) != 0 { 1135 errorCode = restjson.SanitizeErrorCode(code) 1136 } 1137 if len(message) != 0 { 1138 errorMessage = message 1139 } 1140 1141 switch { 1142 case strings.EqualFold("AccessDeniedException", errorCode): 1143 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1144 1145 case strings.EqualFold("InternalServiceErrorException", errorCode): 1146 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1147 1148 case strings.EqualFold("InvalidParameterException", errorCode): 1149 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1150 1151 case strings.EqualFold("InvalidRequestException", errorCode): 1152 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1153 1154 case strings.EqualFold("LimitExceededException", errorCode): 1155 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1156 1157 case strings.EqualFold("ResourceExistsException", errorCode): 1158 return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody) 1159 1160 case strings.EqualFold("ResourceNotFoundException", errorCode): 1161 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1162 1163 case strings.EqualFold("ThrottlingException", errorCode): 1164 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1165 1166 default: 1167 genericError := &smithy.GenericAPIError{ 1168 Code: errorCode, 1169 Message: errorMessage, 1170 } 1171 return genericError 1172 1173 } 1174} 1175 1176type awsAwsjson11_deserializeOpCreateResolverRule struct { 1177} 1178 1179func (*awsAwsjson11_deserializeOpCreateResolverRule) ID() string { 1180 return "OperationDeserializer" 1181} 1182 1183func (m *awsAwsjson11_deserializeOpCreateResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1184 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1185) { 1186 out, metadata, err = next.HandleDeserialize(ctx, in) 1187 if err != nil { 1188 return out, metadata, err 1189 } 1190 1191 response, ok := out.RawResponse.(*smithyhttp.Response) 1192 if !ok { 1193 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1194 } 1195 1196 if response.StatusCode < 200 || response.StatusCode >= 300 { 1197 return out, metadata, awsAwsjson11_deserializeOpErrorCreateResolverRule(response, &metadata) 1198 } 1199 output := &CreateResolverRuleOutput{} 1200 out.Result = output 1201 1202 var buff [1024]byte 1203 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1204 1205 body := io.TeeReader(response.Body, ringBuffer) 1206 decoder := json.NewDecoder(body) 1207 decoder.UseNumber() 1208 var shape interface{} 1209 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1210 var snapshot bytes.Buffer 1211 io.Copy(&snapshot, ringBuffer) 1212 err = &smithy.DeserializationError{ 1213 Err: fmt.Errorf("failed to decode response body, %w", err), 1214 Snapshot: snapshot.Bytes(), 1215 } 1216 return out, metadata, err 1217 } 1218 1219 err = awsAwsjson11_deserializeOpDocumentCreateResolverRuleOutput(&output, shape) 1220 if err != nil { 1221 var snapshot bytes.Buffer 1222 io.Copy(&snapshot, ringBuffer) 1223 err = &smithy.DeserializationError{ 1224 Err: fmt.Errorf("failed to decode response body, %w", err), 1225 Snapshot: snapshot.Bytes(), 1226 } 1227 return out, metadata, err 1228 } 1229 1230 return out, metadata, err 1231} 1232 1233func awsAwsjson11_deserializeOpErrorCreateResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1234 var errorBuffer bytes.Buffer 1235 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1236 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1237 } 1238 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1239 1240 errorCode := "UnknownError" 1241 errorMessage := errorCode 1242 1243 code := response.Header.Get("X-Amzn-ErrorType") 1244 if len(code) != 0 { 1245 errorCode = restjson.SanitizeErrorCode(code) 1246 } 1247 1248 var buff [1024]byte 1249 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1250 1251 body := io.TeeReader(errorBody, ringBuffer) 1252 decoder := json.NewDecoder(body) 1253 decoder.UseNumber() 1254 code, message, err := restjson.GetErrorInfo(decoder) 1255 if err != nil { 1256 var snapshot bytes.Buffer 1257 io.Copy(&snapshot, ringBuffer) 1258 err = &smithy.DeserializationError{ 1259 Err: fmt.Errorf("failed to decode response body, %w", err), 1260 Snapshot: snapshot.Bytes(), 1261 } 1262 return err 1263 } 1264 1265 errorBody.Seek(0, io.SeekStart) 1266 if len(code) != 0 { 1267 errorCode = restjson.SanitizeErrorCode(code) 1268 } 1269 if len(message) != 0 { 1270 errorMessage = message 1271 } 1272 1273 switch { 1274 case strings.EqualFold("InternalServiceErrorException", errorCode): 1275 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1276 1277 case strings.EqualFold("InvalidParameterException", errorCode): 1278 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1279 1280 case strings.EqualFold("InvalidRequestException", errorCode): 1281 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1282 1283 case strings.EqualFold("LimitExceededException", errorCode): 1284 return awsAwsjson11_deserializeErrorLimitExceededException(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("ResourceUnavailableException", errorCode): 1293 return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody) 1294 1295 case strings.EqualFold("ThrottlingException", errorCode): 1296 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1297 1298 default: 1299 genericError := &smithy.GenericAPIError{ 1300 Code: errorCode, 1301 Message: errorMessage, 1302 } 1303 return genericError 1304 1305 } 1306} 1307 1308type awsAwsjson11_deserializeOpDeleteFirewallDomainList struct { 1309} 1310 1311func (*awsAwsjson11_deserializeOpDeleteFirewallDomainList) ID() string { 1312 return "OperationDeserializer" 1313} 1314 1315func (m *awsAwsjson11_deserializeOpDeleteFirewallDomainList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1316 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1317) { 1318 out, metadata, err = next.HandleDeserialize(ctx, in) 1319 if err != nil { 1320 return out, metadata, err 1321 } 1322 1323 response, ok := out.RawResponse.(*smithyhttp.Response) 1324 if !ok { 1325 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1326 } 1327 1328 if response.StatusCode < 200 || response.StatusCode >= 300 { 1329 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteFirewallDomainList(response, &metadata) 1330 } 1331 output := &DeleteFirewallDomainListOutput{} 1332 out.Result = output 1333 1334 var buff [1024]byte 1335 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1336 1337 body := io.TeeReader(response.Body, ringBuffer) 1338 decoder := json.NewDecoder(body) 1339 decoder.UseNumber() 1340 var shape interface{} 1341 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1342 var snapshot bytes.Buffer 1343 io.Copy(&snapshot, ringBuffer) 1344 err = &smithy.DeserializationError{ 1345 Err: fmt.Errorf("failed to decode response body, %w", err), 1346 Snapshot: snapshot.Bytes(), 1347 } 1348 return out, metadata, err 1349 } 1350 1351 err = awsAwsjson11_deserializeOpDocumentDeleteFirewallDomainListOutput(&output, shape) 1352 if err != nil { 1353 var snapshot bytes.Buffer 1354 io.Copy(&snapshot, ringBuffer) 1355 err = &smithy.DeserializationError{ 1356 Err: fmt.Errorf("failed to decode response body, %w", err), 1357 Snapshot: snapshot.Bytes(), 1358 } 1359 return out, metadata, err 1360 } 1361 1362 return out, metadata, err 1363} 1364 1365func awsAwsjson11_deserializeOpErrorDeleteFirewallDomainList(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1366 var errorBuffer bytes.Buffer 1367 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1368 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1369 } 1370 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1371 1372 errorCode := "UnknownError" 1373 errorMessage := errorCode 1374 1375 code := response.Header.Get("X-Amzn-ErrorType") 1376 if len(code) != 0 { 1377 errorCode = restjson.SanitizeErrorCode(code) 1378 } 1379 1380 var buff [1024]byte 1381 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1382 1383 body := io.TeeReader(errorBody, ringBuffer) 1384 decoder := json.NewDecoder(body) 1385 decoder.UseNumber() 1386 code, message, err := restjson.GetErrorInfo(decoder) 1387 if err != nil { 1388 var snapshot bytes.Buffer 1389 io.Copy(&snapshot, ringBuffer) 1390 err = &smithy.DeserializationError{ 1391 Err: fmt.Errorf("failed to decode response body, %w", err), 1392 Snapshot: snapshot.Bytes(), 1393 } 1394 return err 1395 } 1396 1397 errorBody.Seek(0, io.SeekStart) 1398 if len(code) != 0 { 1399 errorCode = restjson.SanitizeErrorCode(code) 1400 } 1401 if len(message) != 0 { 1402 errorMessage = message 1403 } 1404 1405 switch { 1406 case strings.EqualFold("AccessDeniedException", errorCode): 1407 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1408 1409 case strings.EqualFold("ConflictException", errorCode): 1410 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 1411 1412 case strings.EqualFold("InternalServiceErrorException", errorCode): 1413 return awsAwsjson11_deserializeErrorInternalServiceErrorException(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_deserializeOpDeleteFirewallRule struct { 1432} 1433 1434func (*awsAwsjson11_deserializeOpDeleteFirewallRule) ID() string { 1435 return "OperationDeserializer" 1436} 1437 1438func (m *awsAwsjson11_deserializeOpDeleteFirewallRule) 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_deserializeOpErrorDeleteFirewallRule(response, &metadata) 1453 } 1454 output := &DeleteFirewallRuleOutput{} 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_deserializeOpDocumentDeleteFirewallRuleOutput(&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_deserializeOpErrorDeleteFirewallRule(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("AccessDeniedException", errorCode): 1530 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1531 1532 case strings.EqualFold("InternalServiceErrorException", errorCode): 1533 return awsAwsjson11_deserializeErrorInternalServiceErrorException(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_deserializeOpDeleteFirewallRuleGroup struct { 1552} 1553 1554func (*awsAwsjson11_deserializeOpDeleteFirewallRuleGroup) ID() string { 1555 return "OperationDeserializer" 1556} 1557 1558func (m *awsAwsjson11_deserializeOpDeleteFirewallRuleGroup) 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_deserializeOpErrorDeleteFirewallRuleGroup(response, &metadata) 1573 } 1574 output := &DeleteFirewallRuleGroupOutput{} 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_deserializeOpDocumentDeleteFirewallRuleGroupOutput(&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_deserializeOpErrorDeleteFirewallRuleGroup(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("AccessDeniedException", errorCode): 1650 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1651 1652 case strings.EqualFold("ConflictException", errorCode): 1653 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 1654 1655 case strings.EqualFold("InternalServiceErrorException", errorCode): 1656 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1657 1658 case strings.EqualFold("ResourceNotFoundException", errorCode): 1659 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1660 1661 case strings.EqualFold("ThrottlingException", errorCode): 1662 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1663 1664 case strings.EqualFold("ValidationException", errorCode): 1665 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1666 1667 default: 1668 genericError := &smithy.GenericAPIError{ 1669 Code: errorCode, 1670 Message: errorMessage, 1671 } 1672 return genericError 1673 1674 } 1675} 1676 1677type awsAwsjson11_deserializeOpDeleteResolverEndpoint struct { 1678} 1679 1680func (*awsAwsjson11_deserializeOpDeleteResolverEndpoint) ID() string { 1681 return "OperationDeserializer" 1682} 1683 1684func (m *awsAwsjson11_deserializeOpDeleteResolverEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1685 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1686) { 1687 out, metadata, err = next.HandleDeserialize(ctx, in) 1688 if err != nil { 1689 return out, metadata, err 1690 } 1691 1692 response, ok := out.RawResponse.(*smithyhttp.Response) 1693 if !ok { 1694 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1695 } 1696 1697 if response.StatusCode < 200 || response.StatusCode >= 300 { 1698 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResolverEndpoint(response, &metadata) 1699 } 1700 output := &DeleteResolverEndpointOutput{} 1701 out.Result = output 1702 1703 var buff [1024]byte 1704 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1705 1706 body := io.TeeReader(response.Body, ringBuffer) 1707 decoder := json.NewDecoder(body) 1708 decoder.UseNumber() 1709 var shape interface{} 1710 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1711 var snapshot bytes.Buffer 1712 io.Copy(&snapshot, ringBuffer) 1713 err = &smithy.DeserializationError{ 1714 Err: fmt.Errorf("failed to decode response body, %w", err), 1715 Snapshot: snapshot.Bytes(), 1716 } 1717 return out, metadata, err 1718 } 1719 1720 err = awsAwsjson11_deserializeOpDocumentDeleteResolverEndpointOutput(&output, shape) 1721 if err != nil { 1722 var snapshot bytes.Buffer 1723 io.Copy(&snapshot, ringBuffer) 1724 err = &smithy.DeserializationError{ 1725 Err: fmt.Errorf("failed to decode response body, %w", err), 1726 Snapshot: snapshot.Bytes(), 1727 } 1728 return out, metadata, err 1729 } 1730 1731 return out, metadata, err 1732} 1733 1734func awsAwsjson11_deserializeOpErrorDeleteResolverEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1735 var errorBuffer bytes.Buffer 1736 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1737 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1738 } 1739 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1740 1741 errorCode := "UnknownError" 1742 errorMessage := errorCode 1743 1744 code := response.Header.Get("X-Amzn-ErrorType") 1745 if len(code) != 0 { 1746 errorCode = restjson.SanitizeErrorCode(code) 1747 } 1748 1749 var buff [1024]byte 1750 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1751 1752 body := io.TeeReader(errorBody, ringBuffer) 1753 decoder := json.NewDecoder(body) 1754 decoder.UseNumber() 1755 code, message, err := restjson.GetErrorInfo(decoder) 1756 if err != nil { 1757 var snapshot bytes.Buffer 1758 io.Copy(&snapshot, ringBuffer) 1759 err = &smithy.DeserializationError{ 1760 Err: fmt.Errorf("failed to decode response body, %w", err), 1761 Snapshot: snapshot.Bytes(), 1762 } 1763 return err 1764 } 1765 1766 errorBody.Seek(0, io.SeekStart) 1767 if len(code) != 0 { 1768 errorCode = restjson.SanitizeErrorCode(code) 1769 } 1770 if len(message) != 0 { 1771 errorMessage = message 1772 } 1773 1774 switch { 1775 case strings.EqualFold("InternalServiceErrorException", errorCode): 1776 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1777 1778 case strings.EqualFold("InvalidParameterException", errorCode): 1779 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1780 1781 case strings.EqualFold("InvalidRequestException", errorCode): 1782 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1783 1784 case strings.EqualFold("ResourceNotFoundException", errorCode): 1785 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1786 1787 case strings.EqualFold("ThrottlingException", errorCode): 1788 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1789 1790 default: 1791 genericError := &smithy.GenericAPIError{ 1792 Code: errorCode, 1793 Message: errorMessage, 1794 } 1795 return genericError 1796 1797 } 1798} 1799 1800type awsAwsjson11_deserializeOpDeleteResolverQueryLogConfig struct { 1801} 1802 1803func (*awsAwsjson11_deserializeOpDeleteResolverQueryLogConfig) ID() string { 1804 return "OperationDeserializer" 1805} 1806 1807func (m *awsAwsjson11_deserializeOpDeleteResolverQueryLogConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1808 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1809) { 1810 out, metadata, err = next.HandleDeserialize(ctx, in) 1811 if err != nil { 1812 return out, metadata, err 1813 } 1814 1815 response, ok := out.RawResponse.(*smithyhttp.Response) 1816 if !ok { 1817 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1818 } 1819 1820 if response.StatusCode < 200 || response.StatusCode >= 300 { 1821 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResolverQueryLogConfig(response, &metadata) 1822 } 1823 output := &DeleteResolverQueryLogConfigOutput{} 1824 out.Result = output 1825 1826 var buff [1024]byte 1827 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1828 1829 body := io.TeeReader(response.Body, ringBuffer) 1830 decoder := json.NewDecoder(body) 1831 decoder.UseNumber() 1832 var shape interface{} 1833 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1834 var snapshot bytes.Buffer 1835 io.Copy(&snapshot, ringBuffer) 1836 err = &smithy.DeserializationError{ 1837 Err: fmt.Errorf("failed to decode response body, %w", err), 1838 Snapshot: snapshot.Bytes(), 1839 } 1840 return out, metadata, err 1841 } 1842 1843 err = awsAwsjson11_deserializeOpDocumentDeleteResolverQueryLogConfigOutput(&output, shape) 1844 if err != nil { 1845 var snapshot bytes.Buffer 1846 io.Copy(&snapshot, ringBuffer) 1847 err = &smithy.DeserializationError{ 1848 Err: fmt.Errorf("failed to decode response body, %w", err), 1849 Snapshot: snapshot.Bytes(), 1850 } 1851 return out, metadata, err 1852 } 1853 1854 return out, metadata, err 1855} 1856 1857func awsAwsjson11_deserializeOpErrorDeleteResolverQueryLogConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1858 var errorBuffer bytes.Buffer 1859 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1860 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1861 } 1862 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1863 1864 errorCode := "UnknownError" 1865 errorMessage := errorCode 1866 1867 code := response.Header.Get("X-Amzn-ErrorType") 1868 if len(code) != 0 { 1869 errorCode = restjson.SanitizeErrorCode(code) 1870 } 1871 1872 var buff [1024]byte 1873 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1874 1875 body := io.TeeReader(errorBody, ringBuffer) 1876 decoder := json.NewDecoder(body) 1877 decoder.UseNumber() 1878 code, message, err := restjson.GetErrorInfo(decoder) 1879 if err != nil { 1880 var snapshot bytes.Buffer 1881 io.Copy(&snapshot, ringBuffer) 1882 err = &smithy.DeserializationError{ 1883 Err: fmt.Errorf("failed to decode response body, %w", err), 1884 Snapshot: snapshot.Bytes(), 1885 } 1886 return err 1887 } 1888 1889 errorBody.Seek(0, io.SeekStart) 1890 if len(code) != 0 { 1891 errorCode = restjson.SanitizeErrorCode(code) 1892 } 1893 if len(message) != 0 { 1894 errorMessage = message 1895 } 1896 1897 switch { 1898 case strings.EqualFold("AccessDeniedException", errorCode): 1899 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1900 1901 case strings.EqualFold("InternalServiceErrorException", errorCode): 1902 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1903 1904 case strings.EqualFold("InvalidParameterException", errorCode): 1905 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1906 1907 case strings.EqualFold("InvalidRequestException", errorCode): 1908 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1909 1910 case strings.EqualFold("ResourceNotFoundException", errorCode): 1911 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1912 1913 case strings.EqualFold("ThrottlingException", errorCode): 1914 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1915 1916 default: 1917 genericError := &smithy.GenericAPIError{ 1918 Code: errorCode, 1919 Message: errorMessage, 1920 } 1921 return genericError 1922 1923 } 1924} 1925 1926type awsAwsjson11_deserializeOpDeleteResolverRule struct { 1927} 1928 1929func (*awsAwsjson11_deserializeOpDeleteResolverRule) ID() string { 1930 return "OperationDeserializer" 1931} 1932 1933func (m *awsAwsjson11_deserializeOpDeleteResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1934 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1935) { 1936 out, metadata, err = next.HandleDeserialize(ctx, in) 1937 if err != nil { 1938 return out, metadata, err 1939 } 1940 1941 response, ok := out.RawResponse.(*smithyhttp.Response) 1942 if !ok { 1943 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1944 } 1945 1946 if response.StatusCode < 200 || response.StatusCode >= 300 { 1947 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResolverRule(response, &metadata) 1948 } 1949 output := &DeleteResolverRuleOutput{} 1950 out.Result = output 1951 1952 var buff [1024]byte 1953 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1954 1955 body := io.TeeReader(response.Body, ringBuffer) 1956 decoder := json.NewDecoder(body) 1957 decoder.UseNumber() 1958 var shape interface{} 1959 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1960 var snapshot bytes.Buffer 1961 io.Copy(&snapshot, ringBuffer) 1962 err = &smithy.DeserializationError{ 1963 Err: fmt.Errorf("failed to decode response body, %w", err), 1964 Snapshot: snapshot.Bytes(), 1965 } 1966 return out, metadata, err 1967 } 1968 1969 err = awsAwsjson11_deserializeOpDocumentDeleteResolverRuleOutput(&output, shape) 1970 if err != nil { 1971 var snapshot bytes.Buffer 1972 io.Copy(&snapshot, ringBuffer) 1973 err = &smithy.DeserializationError{ 1974 Err: fmt.Errorf("failed to decode response body, %w", err), 1975 Snapshot: snapshot.Bytes(), 1976 } 1977 return out, metadata, err 1978 } 1979 1980 return out, metadata, err 1981} 1982 1983func awsAwsjson11_deserializeOpErrorDeleteResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1984 var errorBuffer bytes.Buffer 1985 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1986 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1987 } 1988 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1989 1990 errorCode := "UnknownError" 1991 errorMessage := errorCode 1992 1993 code := response.Header.Get("X-Amzn-ErrorType") 1994 if len(code) != 0 { 1995 errorCode = restjson.SanitizeErrorCode(code) 1996 } 1997 1998 var buff [1024]byte 1999 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2000 2001 body := io.TeeReader(errorBody, ringBuffer) 2002 decoder := json.NewDecoder(body) 2003 decoder.UseNumber() 2004 code, message, err := restjson.GetErrorInfo(decoder) 2005 if err != nil { 2006 var snapshot bytes.Buffer 2007 io.Copy(&snapshot, ringBuffer) 2008 err = &smithy.DeserializationError{ 2009 Err: fmt.Errorf("failed to decode response body, %w", err), 2010 Snapshot: snapshot.Bytes(), 2011 } 2012 return err 2013 } 2014 2015 errorBody.Seek(0, io.SeekStart) 2016 if len(code) != 0 { 2017 errorCode = restjson.SanitizeErrorCode(code) 2018 } 2019 if len(message) != 0 { 2020 errorMessage = message 2021 } 2022 2023 switch { 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("ResourceInUseException", errorCode): 2031 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2032 2033 case strings.EqualFold("ResourceNotFoundException", errorCode): 2034 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2035 2036 case strings.EqualFold("ThrottlingException", errorCode): 2037 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2038 2039 default: 2040 genericError := &smithy.GenericAPIError{ 2041 Code: errorCode, 2042 Message: errorMessage, 2043 } 2044 return genericError 2045 2046 } 2047} 2048 2049type awsAwsjson11_deserializeOpDisassociateFirewallRuleGroup struct { 2050} 2051 2052func (*awsAwsjson11_deserializeOpDisassociateFirewallRuleGroup) ID() string { 2053 return "OperationDeserializer" 2054} 2055 2056func (m *awsAwsjson11_deserializeOpDisassociateFirewallRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2057 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2058) { 2059 out, metadata, err = next.HandleDeserialize(ctx, in) 2060 if err != nil { 2061 return out, metadata, err 2062 } 2063 2064 response, ok := out.RawResponse.(*smithyhttp.Response) 2065 if !ok { 2066 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2067 } 2068 2069 if response.StatusCode < 200 || response.StatusCode >= 300 { 2070 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateFirewallRuleGroup(response, &metadata) 2071 } 2072 output := &DisassociateFirewallRuleGroupOutput{} 2073 out.Result = output 2074 2075 var buff [1024]byte 2076 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2077 2078 body := io.TeeReader(response.Body, ringBuffer) 2079 decoder := json.NewDecoder(body) 2080 decoder.UseNumber() 2081 var shape interface{} 2082 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2083 var snapshot bytes.Buffer 2084 io.Copy(&snapshot, ringBuffer) 2085 err = &smithy.DeserializationError{ 2086 Err: fmt.Errorf("failed to decode response body, %w", err), 2087 Snapshot: snapshot.Bytes(), 2088 } 2089 return out, metadata, err 2090 } 2091 2092 err = awsAwsjson11_deserializeOpDocumentDisassociateFirewallRuleGroupOutput(&output, shape) 2093 if err != nil { 2094 var snapshot bytes.Buffer 2095 io.Copy(&snapshot, ringBuffer) 2096 err = &smithy.DeserializationError{ 2097 Err: fmt.Errorf("failed to decode response body, %w", err), 2098 Snapshot: snapshot.Bytes(), 2099 } 2100 return out, metadata, err 2101 } 2102 2103 return out, metadata, err 2104} 2105 2106func awsAwsjson11_deserializeOpErrorDisassociateFirewallRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2107 var errorBuffer bytes.Buffer 2108 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2109 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2110 } 2111 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2112 2113 errorCode := "UnknownError" 2114 errorMessage := errorCode 2115 2116 code := response.Header.Get("X-Amzn-ErrorType") 2117 if len(code) != 0 { 2118 errorCode = restjson.SanitizeErrorCode(code) 2119 } 2120 2121 var buff [1024]byte 2122 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2123 2124 body := io.TeeReader(errorBody, ringBuffer) 2125 decoder := json.NewDecoder(body) 2126 decoder.UseNumber() 2127 code, message, err := restjson.GetErrorInfo(decoder) 2128 if err != nil { 2129 var snapshot bytes.Buffer 2130 io.Copy(&snapshot, ringBuffer) 2131 err = &smithy.DeserializationError{ 2132 Err: fmt.Errorf("failed to decode response body, %w", err), 2133 Snapshot: snapshot.Bytes(), 2134 } 2135 return err 2136 } 2137 2138 errorBody.Seek(0, io.SeekStart) 2139 if len(code) != 0 { 2140 errorCode = restjson.SanitizeErrorCode(code) 2141 } 2142 if len(message) != 0 { 2143 errorMessage = message 2144 } 2145 2146 switch { 2147 case strings.EqualFold("AccessDeniedException", errorCode): 2148 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2149 2150 case strings.EqualFold("ConflictException", errorCode): 2151 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 2152 2153 case strings.EqualFold("InternalServiceErrorException", errorCode): 2154 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2155 2156 case strings.EqualFold("ResourceNotFoundException", errorCode): 2157 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2158 2159 case strings.EqualFold("ThrottlingException", errorCode): 2160 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2161 2162 case strings.EqualFold("ValidationException", errorCode): 2163 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2164 2165 default: 2166 genericError := &smithy.GenericAPIError{ 2167 Code: errorCode, 2168 Message: errorMessage, 2169 } 2170 return genericError 2171 2172 } 2173} 2174 2175type awsAwsjson11_deserializeOpDisassociateResolverEndpointIpAddress struct { 2176} 2177 2178func (*awsAwsjson11_deserializeOpDisassociateResolverEndpointIpAddress) ID() string { 2179 return "OperationDeserializer" 2180} 2181 2182func (m *awsAwsjson11_deserializeOpDisassociateResolverEndpointIpAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2183 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2184) { 2185 out, metadata, err = next.HandleDeserialize(ctx, in) 2186 if err != nil { 2187 return out, metadata, err 2188 } 2189 2190 response, ok := out.RawResponse.(*smithyhttp.Response) 2191 if !ok { 2192 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2193 } 2194 2195 if response.StatusCode < 200 || response.StatusCode >= 300 { 2196 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateResolverEndpointIpAddress(response, &metadata) 2197 } 2198 output := &DisassociateResolverEndpointIpAddressOutput{} 2199 out.Result = output 2200 2201 var buff [1024]byte 2202 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2203 2204 body := io.TeeReader(response.Body, ringBuffer) 2205 decoder := json.NewDecoder(body) 2206 decoder.UseNumber() 2207 var shape interface{} 2208 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2209 var snapshot bytes.Buffer 2210 io.Copy(&snapshot, ringBuffer) 2211 err = &smithy.DeserializationError{ 2212 Err: fmt.Errorf("failed to decode response body, %w", err), 2213 Snapshot: snapshot.Bytes(), 2214 } 2215 return out, metadata, err 2216 } 2217 2218 err = awsAwsjson11_deserializeOpDocumentDisassociateResolverEndpointIpAddressOutput(&output, shape) 2219 if err != nil { 2220 var snapshot bytes.Buffer 2221 io.Copy(&snapshot, ringBuffer) 2222 err = &smithy.DeserializationError{ 2223 Err: fmt.Errorf("failed to decode response body, %w", err), 2224 Snapshot: snapshot.Bytes(), 2225 } 2226 return out, metadata, err 2227 } 2228 2229 return out, metadata, err 2230} 2231 2232func awsAwsjson11_deserializeOpErrorDisassociateResolverEndpointIpAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2233 var errorBuffer bytes.Buffer 2234 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2235 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2236 } 2237 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2238 2239 errorCode := "UnknownError" 2240 errorMessage := errorCode 2241 2242 code := response.Header.Get("X-Amzn-ErrorType") 2243 if len(code) != 0 { 2244 errorCode = restjson.SanitizeErrorCode(code) 2245 } 2246 2247 var buff [1024]byte 2248 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2249 2250 body := io.TeeReader(errorBody, ringBuffer) 2251 decoder := json.NewDecoder(body) 2252 decoder.UseNumber() 2253 code, message, err := restjson.GetErrorInfo(decoder) 2254 if err != nil { 2255 var snapshot bytes.Buffer 2256 io.Copy(&snapshot, ringBuffer) 2257 err = &smithy.DeserializationError{ 2258 Err: fmt.Errorf("failed to decode response body, %w", err), 2259 Snapshot: snapshot.Bytes(), 2260 } 2261 return err 2262 } 2263 2264 errorBody.Seek(0, io.SeekStart) 2265 if len(code) != 0 { 2266 errorCode = restjson.SanitizeErrorCode(code) 2267 } 2268 if len(message) != 0 { 2269 errorMessage = message 2270 } 2271 2272 switch { 2273 case strings.EqualFold("InternalServiceErrorException", errorCode): 2274 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2275 2276 case strings.EqualFold("InvalidParameterException", errorCode): 2277 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2278 2279 case strings.EqualFold("InvalidRequestException", errorCode): 2280 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2281 2282 case strings.EqualFold("ResourceExistsException", errorCode): 2283 return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody) 2284 2285 case strings.EqualFold("ResourceNotFoundException", errorCode): 2286 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2287 2288 case strings.EqualFold("ThrottlingException", errorCode): 2289 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2290 2291 default: 2292 genericError := &smithy.GenericAPIError{ 2293 Code: errorCode, 2294 Message: errorMessage, 2295 } 2296 return genericError 2297 2298 } 2299} 2300 2301type awsAwsjson11_deserializeOpDisassociateResolverQueryLogConfig struct { 2302} 2303 2304func (*awsAwsjson11_deserializeOpDisassociateResolverQueryLogConfig) ID() string { 2305 return "OperationDeserializer" 2306} 2307 2308func (m *awsAwsjson11_deserializeOpDisassociateResolverQueryLogConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2309 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2310) { 2311 out, metadata, err = next.HandleDeserialize(ctx, in) 2312 if err != nil { 2313 return out, metadata, err 2314 } 2315 2316 response, ok := out.RawResponse.(*smithyhttp.Response) 2317 if !ok { 2318 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2319 } 2320 2321 if response.StatusCode < 200 || response.StatusCode >= 300 { 2322 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateResolverQueryLogConfig(response, &metadata) 2323 } 2324 output := &DisassociateResolverQueryLogConfigOutput{} 2325 out.Result = output 2326 2327 var buff [1024]byte 2328 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2329 2330 body := io.TeeReader(response.Body, ringBuffer) 2331 decoder := json.NewDecoder(body) 2332 decoder.UseNumber() 2333 var shape interface{} 2334 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2335 var snapshot bytes.Buffer 2336 io.Copy(&snapshot, ringBuffer) 2337 err = &smithy.DeserializationError{ 2338 Err: fmt.Errorf("failed to decode response body, %w", err), 2339 Snapshot: snapshot.Bytes(), 2340 } 2341 return out, metadata, err 2342 } 2343 2344 err = awsAwsjson11_deserializeOpDocumentDisassociateResolverQueryLogConfigOutput(&output, shape) 2345 if err != nil { 2346 var snapshot bytes.Buffer 2347 io.Copy(&snapshot, ringBuffer) 2348 err = &smithy.DeserializationError{ 2349 Err: fmt.Errorf("failed to decode response body, %w", err), 2350 Snapshot: snapshot.Bytes(), 2351 } 2352 return out, metadata, err 2353 } 2354 2355 return out, metadata, err 2356} 2357 2358func awsAwsjson11_deserializeOpErrorDisassociateResolverQueryLogConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2359 var errorBuffer bytes.Buffer 2360 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2361 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2362 } 2363 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2364 2365 errorCode := "UnknownError" 2366 errorMessage := errorCode 2367 2368 code := response.Header.Get("X-Amzn-ErrorType") 2369 if len(code) != 0 { 2370 errorCode = restjson.SanitizeErrorCode(code) 2371 } 2372 2373 var buff [1024]byte 2374 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2375 2376 body := io.TeeReader(errorBody, ringBuffer) 2377 decoder := json.NewDecoder(body) 2378 decoder.UseNumber() 2379 code, message, err := restjson.GetErrorInfo(decoder) 2380 if err != nil { 2381 var snapshot bytes.Buffer 2382 io.Copy(&snapshot, ringBuffer) 2383 err = &smithy.DeserializationError{ 2384 Err: fmt.Errorf("failed to decode response body, %w", err), 2385 Snapshot: snapshot.Bytes(), 2386 } 2387 return err 2388 } 2389 2390 errorBody.Seek(0, io.SeekStart) 2391 if len(code) != 0 { 2392 errorCode = restjson.SanitizeErrorCode(code) 2393 } 2394 if len(message) != 0 { 2395 errorMessage = message 2396 } 2397 2398 switch { 2399 case strings.EqualFold("AccessDeniedException", errorCode): 2400 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2401 2402 case strings.EqualFold("InternalServiceErrorException", errorCode): 2403 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2404 2405 case strings.EqualFold("InvalidParameterException", errorCode): 2406 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2407 2408 case strings.EqualFold("InvalidRequestException", errorCode): 2409 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2410 2411 case strings.EqualFold("ResourceNotFoundException", errorCode): 2412 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2413 2414 case strings.EqualFold("ThrottlingException", errorCode): 2415 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2416 2417 default: 2418 genericError := &smithy.GenericAPIError{ 2419 Code: errorCode, 2420 Message: errorMessage, 2421 } 2422 return genericError 2423 2424 } 2425} 2426 2427type awsAwsjson11_deserializeOpDisassociateResolverRule struct { 2428} 2429 2430func (*awsAwsjson11_deserializeOpDisassociateResolverRule) ID() string { 2431 return "OperationDeserializer" 2432} 2433 2434func (m *awsAwsjson11_deserializeOpDisassociateResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2435 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2436) { 2437 out, metadata, err = next.HandleDeserialize(ctx, in) 2438 if err != nil { 2439 return out, metadata, err 2440 } 2441 2442 response, ok := out.RawResponse.(*smithyhttp.Response) 2443 if !ok { 2444 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2445 } 2446 2447 if response.StatusCode < 200 || response.StatusCode >= 300 { 2448 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateResolverRule(response, &metadata) 2449 } 2450 output := &DisassociateResolverRuleOutput{} 2451 out.Result = output 2452 2453 var buff [1024]byte 2454 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2455 2456 body := io.TeeReader(response.Body, ringBuffer) 2457 decoder := json.NewDecoder(body) 2458 decoder.UseNumber() 2459 var shape interface{} 2460 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2461 var snapshot bytes.Buffer 2462 io.Copy(&snapshot, ringBuffer) 2463 err = &smithy.DeserializationError{ 2464 Err: fmt.Errorf("failed to decode response body, %w", err), 2465 Snapshot: snapshot.Bytes(), 2466 } 2467 return out, metadata, err 2468 } 2469 2470 err = awsAwsjson11_deserializeOpDocumentDisassociateResolverRuleOutput(&output, shape) 2471 if err != nil { 2472 var snapshot bytes.Buffer 2473 io.Copy(&snapshot, ringBuffer) 2474 err = &smithy.DeserializationError{ 2475 Err: fmt.Errorf("failed to decode response body, %w", err), 2476 Snapshot: snapshot.Bytes(), 2477 } 2478 return out, metadata, err 2479 } 2480 2481 return out, metadata, err 2482} 2483 2484func awsAwsjson11_deserializeOpErrorDisassociateResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2485 var errorBuffer bytes.Buffer 2486 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2487 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2488 } 2489 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2490 2491 errorCode := "UnknownError" 2492 errorMessage := errorCode 2493 2494 code := response.Header.Get("X-Amzn-ErrorType") 2495 if len(code) != 0 { 2496 errorCode = restjson.SanitizeErrorCode(code) 2497 } 2498 2499 var buff [1024]byte 2500 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2501 2502 body := io.TeeReader(errorBody, ringBuffer) 2503 decoder := json.NewDecoder(body) 2504 decoder.UseNumber() 2505 code, message, err := restjson.GetErrorInfo(decoder) 2506 if err != nil { 2507 var snapshot bytes.Buffer 2508 io.Copy(&snapshot, ringBuffer) 2509 err = &smithy.DeserializationError{ 2510 Err: fmt.Errorf("failed to decode response body, %w", err), 2511 Snapshot: snapshot.Bytes(), 2512 } 2513 return err 2514 } 2515 2516 errorBody.Seek(0, io.SeekStart) 2517 if len(code) != 0 { 2518 errorCode = restjson.SanitizeErrorCode(code) 2519 } 2520 if len(message) != 0 { 2521 errorMessage = message 2522 } 2523 2524 switch { 2525 case strings.EqualFold("InternalServiceErrorException", errorCode): 2526 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2527 2528 case strings.EqualFold("InvalidParameterException", errorCode): 2529 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2530 2531 case strings.EqualFold("ResourceNotFoundException", errorCode): 2532 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2533 2534 case strings.EqualFold("ThrottlingException", errorCode): 2535 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2536 2537 default: 2538 genericError := &smithy.GenericAPIError{ 2539 Code: errorCode, 2540 Message: errorMessage, 2541 } 2542 return genericError 2543 2544 } 2545} 2546 2547type awsAwsjson11_deserializeOpGetFirewallConfig struct { 2548} 2549 2550func (*awsAwsjson11_deserializeOpGetFirewallConfig) ID() string { 2551 return "OperationDeserializer" 2552} 2553 2554func (m *awsAwsjson11_deserializeOpGetFirewallConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2555 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2556) { 2557 out, metadata, err = next.HandleDeserialize(ctx, in) 2558 if err != nil { 2559 return out, metadata, err 2560 } 2561 2562 response, ok := out.RawResponse.(*smithyhttp.Response) 2563 if !ok { 2564 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2565 } 2566 2567 if response.StatusCode < 200 || response.StatusCode >= 300 { 2568 return out, metadata, awsAwsjson11_deserializeOpErrorGetFirewallConfig(response, &metadata) 2569 } 2570 output := &GetFirewallConfigOutput{} 2571 out.Result = output 2572 2573 var buff [1024]byte 2574 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2575 2576 body := io.TeeReader(response.Body, ringBuffer) 2577 decoder := json.NewDecoder(body) 2578 decoder.UseNumber() 2579 var shape interface{} 2580 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2581 var snapshot bytes.Buffer 2582 io.Copy(&snapshot, ringBuffer) 2583 err = &smithy.DeserializationError{ 2584 Err: fmt.Errorf("failed to decode response body, %w", err), 2585 Snapshot: snapshot.Bytes(), 2586 } 2587 return out, metadata, err 2588 } 2589 2590 err = awsAwsjson11_deserializeOpDocumentGetFirewallConfigOutput(&output, shape) 2591 if err != nil { 2592 var snapshot bytes.Buffer 2593 io.Copy(&snapshot, ringBuffer) 2594 err = &smithy.DeserializationError{ 2595 Err: fmt.Errorf("failed to decode response body, %w", err), 2596 Snapshot: snapshot.Bytes(), 2597 } 2598 return out, metadata, err 2599 } 2600 2601 return out, metadata, err 2602} 2603 2604func awsAwsjson11_deserializeOpErrorGetFirewallConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2605 var errorBuffer bytes.Buffer 2606 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2607 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2608 } 2609 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2610 2611 errorCode := "UnknownError" 2612 errorMessage := errorCode 2613 2614 code := response.Header.Get("X-Amzn-ErrorType") 2615 if len(code) != 0 { 2616 errorCode = restjson.SanitizeErrorCode(code) 2617 } 2618 2619 var buff [1024]byte 2620 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2621 2622 body := io.TeeReader(errorBody, ringBuffer) 2623 decoder := json.NewDecoder(body) 2624 decoder.UseNumber() 2625 code, message, err := restjson.GetErrorInfo(decoder) 2626 if err != nil { 2627 var snapshot bytes.Buffer 2628 io.Copy(&snapshot, ringBuffer) 2629 err = &smithy.DeserializationError{ 2630 Err: fmt.Errorf("failed to decode response body, %w", err), 2631 Snapshot: snapshot.Bytes(), 2632 } 2633 return err 2634 } 2635 2636 errorBody.Seek(0, io.SeekStart) 2637 if len(code) != 0 { 2638 errorCode = restjson.SanitizeErrorCode(code) 2639 } 2640 if len(message) != 0 { 2641 errorMessage = message 2642 } 2643 2644 switch { 2645 case strings.EqualFold("AccessDeniedException", errorCode): 2646 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2647 2648 case strings.EqualFold("InternalServiceErrorException", errorCode): 2649 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2650 2651 case strings.EqualFold("ResourceNotFoundException", errorCode): 2652 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2653 2654 case strings.EqualFold("ThrottlingException", errorCode): 2655 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2656 2657 case strings.EqualFold("ValidationException", errorCode): 2658 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2659 2660 default: 2661 genericError := &smithy.GenericAPIError{ 2662 Code: errorCode, 2663 Message: errorMessage, 2664 } 2665 return genericError 2666 2667 } 2668} 2669 2670type awsAwsjson11_deserializeOpGetFirewallDomainList struct { 2671} 2672 2673func (*awsAwsjson11_deserializeOpGetFirewallDomainList) ID() string { 2674 return "OperationDeserializer" 2675} 2676 2677func (m *awsAwsjson11_deserializeOpGetFirewallDomainList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2678 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2679) { 2680 out, metadata, err = next.HandleDeserialize(ctx, in) 2681 if err != nil { 2682 return out, metadata, err 2683 } 2684 2685 response, ok := out.RawResponse.(*smithyhttp.Response) 2686 if !ok { 2687 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2688 } 2689 2690 if response.StatusCode < 200 || response.StatusCode >= 300 { 2691 return out, metadata, awsAwsjson11_deserializeOpErrorGetFirewallDomainList(response, &metadata) 2692 } 2693 output := &GetFirewallDomainListOutput{} 2694 out.Result = output 2695 2696 var buff [1024]byte 2697 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2698 2699 body := io.TeeReader(response.Body, ringBuffer) 2700 decoder := json.NewDecoder(body) 2701 decoder.UseNumber() 2702 var shape interface{} 2703 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2704 var snapshot bytes.Buffer 2705 io.Copy(&snapshot, ringBuffer) 2706 err = &smithy.DeserializationError{ 2707 Err: fmt.Errorf("failed to decode response body, %w", err), 2708 Snapshot: snapshot.Bytes(), 2709 } 2710 return out, metadata, err 2711 } 2712 2713 err = awsAwsjson11_deserializeOpDocumentGetFirewallDomainListOutput(&output, shape) 2714 if err != nil { 2715 var snapshot bytes.Buffer 2716 io.Copy(&snapshot, ringBuffer) 2717 err = &smithy.DeserializationError{ 2718 Err: fmt.Errorf("failed to decode response body, %w", err), 2719 Snapshot: snapshot.Bytes(), 2720 } 2721 return out, metadata, err 2722 } 2723 2724 return out, metadata, err 2725} 2726 2727func awsAwsjson11_deserializeOpErrorGetFirewallDomainList(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2728 var errorBuffer bytes.Buffer 2729 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2730 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2731 } 2732 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2733 2734 errorCode := "UnknownError" 2735 errorMessage := errorCode 2736 2737 code := response.Header.Get("X-Amzn-ErrorType") 2738 if len(code) != 0 { 2739 errorCode = restjson.SanitizeErrorCode(code) 2740 } 2741 2742 var buff [1024]byte 2743 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2744 2745 body := io.TeeReader(errorBody, ringBuffer) 2746 decoder := json.NewDecoder(body) 2747 decoder.UseNumber() 2748 code, message, err := restjson.GetErrorInfo(decoder) 2749 if err != nil { 2750 var snapshot bytes.Buffer 2751 io.Copy(&snapshot, ringBuffer) 2752 err = &smithy.DeserializationError{ 2753 Err: fmt.Errorf("failed to decode response body, %w", err), 2754 Snapshot: snapshot.Bytes(), 2755 } 2756 return err 2757 } 2758 2759 errorBody.Seek(0, io.SeekStart) 2760 if len(code) != 0 { 2761 errorCode = restjson.SanitizeErrorCode(code) 2762 } 2763 if len(message) != 0 { 2764 errorMessage = message 2765 } 2766 2767 switch { 2768 case strings.EqualFold("AccessDeniedException", errorCode): 2769 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2770 2771 case strings.EqualFold("InternalServiceErrorException", errorCode): 2772 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2773 2774 case strings.EqualFold("ResourceNotFoundException", errorCode): 2775 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2776 2777 case strings.EqualFold("ThrottlingException", errorCode): 2778 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2779 2780 default: 2781 genericError := &smithy.GenericAPIError{ 2782 Code: errorCode, 2783 Message: errorMessage, 2784 } 2785 return genericError 2786 2787 } 2788} 2789 2790type awsAwsjson11_deserializeOpGetFirewallRuleGroup struct { 2791} 2792 2793func (*awsAwsjson11_deserializeOpGetFirewallRuleGroup) ID() string { 2794 return "OperationDeserializer" 2795} 2796 2797func (m *awsAwsjson11_deserializeOpGetFirewallRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2798 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2799) { 2800 out, metadata, err = next.HandleDeserialize(ctx, in) 2801 if err != nil { 2802 return out, metadata, err 2803 } 2804 2805 response, ok := out.RawResponse.(*smithyhttp.Response) 2806 if !ok { 2807 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2808 } 2809 2810 if response.StatusCode < 200 || response.StatusCode >= 300 { 2811 return out, metadata, awsAwsjson11_deserializeOpErrorGetFirewallRuleGroup(response, &metadata) 2812 } 2813 output := &GetFirewallRuleGroupOutput{} 2814 out.Result = output 2815 2816 var buff [1024]byte 2817 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2818 2819 body := io.TeeReader(response.Body, ringBuffer) 2820 decoder := json.NewDecoder(body) 2821 decoder.UseNumber() 2822 var shape interface{} 2823 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2824 var snapshot bytes.Buffer 2825 io.Copy(&snapshot, ringBuffer) 2826 err = &smithy.DeserializationError{ 2827 Err: fmt.Errorf("failed to decode response body, %w", err), 2828 Snapshot: snapshot.Bytes(), 2829 } 2830 return out, metadata, err 2831 } 2832 2833 err = awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupOutput(&output, shape) 2834 if err != nil { 2835 var snapshot bytes.Buffer 2836 io.Copy(&snapshot, ringBuffer) 2837 err = &smithy.DeserializationError{ 2838 Err: fmt.Errorf("failed to decode response body, %w", err), 2839 Snapshot: snapshot.Bytes(), 2840 } 2841 return out, metadata, err 2842 } 2843 2844 return out, metadata, err 2845} 2846 2847func awsAwsjson11_deserializeOpErrorGetFirewallRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2848 var errorBuffer bytes.Buffer 2849 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2850 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2851 } 2852 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2853 2854 errorCode := "UnknownError" 2855 errorMessage := errorCode 2856 2857 code := response.Header.Get("X-Amzn-ErrorType") 2858 if len(code) != 0 { 2859 errorCode = restjson.SanitizeErrorCode(code) 2860 } 2861 2862 var buff [1024]byte 2863 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2864 2865 body := io.TeeReader(errorBody, ringBuffer) 2866 decoder := json.NewDecoder(body) 2867 decoder.UseNumber() 2868 code, message, err := restjson.GetErrorInfo(decoder) 2869 if err != nil { 2870 var snapshot bytes.Buffer 2871 io.Copy(&snapshot, ringBuffer) 2872 err = &smithy.DeserializationError{ 2873 Err: fmt.Errorf("failed to decode response body, %w", err), 2874 Snapshot: snapshot.Bytes(), 2875 } 2876 return err 2877 } 2878 2879 errorBody.Seek(0, io.SeekStart) 2880 if len(code) != 0 { 2881 errorCode = restjson.SanitizeErrorCode(code) 2882 } 2883 if len(message) != 0 { 2884 errorMessage = message 2885 } 2886 2887 switch { 2888 case strings.EqualFold("AccessDeniedException", errorCode): 2889 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2890 2891 case strings.EqualFold("InternalServiceErrorException", errorCode): 2892 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2893 2894 case strings.EqualFold("ResourceNotFoundException", errorCode): 2895 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2896 2897 case strings.EqualFold("ThrottlingException", errorCode): 2898 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2899 2900 default: 2901 genericError := &smithy.GenericAPIError{ 2902 Code: errorCode, 2903 Message: errorMessage, 2904 } 2905 return genericError 2906 2907 } 2908} 2909 2910type awsAwsjson11_deserializeOpGetFirewallRuleGroupAssociation struct { 2911} 2912 2913func (*awsAwsjson11_deserializeOpGetFirewallRuleGroupAssociation) ID() string { 2914 return "OperationDeserializer" 2915} 2916 2917func (m *awsAwsjson11_deserializeOpGetFirewallRuleGroupAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2918 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2919) { 2920 out, metadata, err = next.HandleDeserialize(ctx, in) 2921 if err != nil { 2922 return out, metadata, err 2923 } 2924 2925 response, ok := out.RawResponse.(*smithyhttp.Response) 2926 if !ok { 2927 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2928 } 2929 2930 if response.StatusCode < 200 || response.StatusCode >= 300 { 2931 return out, metadata, awsAwsjson11_deserializeOpErrorGetFirewallRuleGroupAssociation(response, &metadata) 2932 } 2933 output := &GetFirewallRuleGroupAssociationOutput{} 2934 out.Result = output 2935 2936 var buff [1024]byte 2937 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2938 2939 body := io.TeeReader(response.Body, ringBuffer) 2940 decoder := json.NewDecoder(body) 2941 decoder.UseNumber() 2942 var shape interface{} 2943 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2944 var snapshot bytes.Buffer 2945 io.Copy(&snapshot, ringBuffer) 2946 err = &smithy.DeserializationError{ 2947 Err: fmt.Errorf("failed to decode response body, %w", err), 2948 Snapshot: snapshot.Bytes(), 2949 } 2950 return out, metadata, err 2951 } 2952 2953 err = awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupAssociationOutput(&output, shape) 2954 if err != nil { 2955 var snapshot bytes.Buffer 2956 io.Copy(&snapshot, ringBuffer) 2957 err = &smithy.DeserializationError{ 2958 Err: fmt.Errorf("failed to decode response body, %w", err), 2959 Snapshot: snapshot.Bytes(), 2960 } 2961 return out, metadata, err 2962 } 2963 2964 return out, metadata, err 2965} 2966 2967func awsAwsjson11_deserializeOpErrorGetFirewallRuleGroupAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2968 var errorBuffer bytes.Buffer 2969 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2970 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2971 } 2972 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2973 2974 errorCode := "UnknownError" 2975 errorMessage := errorCode 2976 2977 code := response.Header.Get("X-Amzn-ErrorType") 2978 if len(code) != 0 { 2979 errorCode = restjson.SanitizeErrorCode(code) 2980 } 2981 2982 var buff [1024]byte 2983 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2984 2985 body := io.TeeReader(errorBody, ringBuffer) 2986 decoder := json.NewDecoder(body) 2987 decoder.UseNumber() 2988 code, message, err := restjson.GetErrorInfo(decoder) 2989 if err != nil { 2990 var snapshot bytes.Buffer 2991 io.Copy(&snapshot, ringBuffer) 2992 err = &smithy.DeserializationError{ 2993 Err: fmt.Errorf("failed to decode response body, %w", err), 2994 Snapshot: snapshot.Bytes(), 2995 } 2996 return err 2997 } 2998 2999 errorBody.Seek(0, io.SeekStart) 3000 if len(code) != 0 { 3001 errorCode = restjson.SanitizeErrorCode(code) 3002 } 3003 if len(message) != 0 { 3004 errorMessage = message 3005 } 3006 3007 switch { 3008 case strings.EqualFold("AccessDeniedException", errorCode): 3009 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3010 3011 case strings.EqualFold("InternalServiceErrorException", errorCode): 3012 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3013 3014 case strings.EqualFold("ResourceNotFoundException", errorCode): 3015 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3016 3017 case strings.EqualFold("ThrottlingException", errorCode): 3018 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3019 3020 default: 3021 genericError := &smithy.GenericAPIError{ 3022 Code: errorCode, 3023 Message: errorMessage, 3024 } 3025 return genericError 3026 3027 } 3028} 3029 3030type awsAwsjson11_deserializeOpGetFirewallRuleGroupPolicy struct { 3031} 3032 3033func (*awsAwsjson11_deserializeOpGetFirewallRuleGroupPolicy) ID() string { 3034 return "OperationDeserializer" 3035} 3036 3037func (m *awsAwsjson11_deserializeOpGetFirewallRuleGroupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3038 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3039) { 3040 out, metadata, err = next.HandleDeserialize(ctx, in) 3041 if err != nil { 3042 return out, metadata, err 3043 } 3044 3045 response, ok := out.RawResponse.(*smithyhttp.Response) 3046 if !ok { 3047 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3048 } 3049 3050 if response.StatusCode < 200 || response.StatusCode >= 300 { 3051 return out, metadata, awsAwsjson11_deserializeOpErrorGetFirewallRuleGroupPolicy(response, &metadata) 3052 } 3053 output := &GetFirewallRuleGroupPolicyOutput{} 3054 out.Result = output 3055 3056 var buff [1024]byte 3057 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3058 3059 body := io.TeeReader(response.Body, ringBuffer) 3060 decoder := json.NewDecoder(body) 3061 decoder.UseNumber() 3062 var shape interface{} 3063 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3064 var snapshot bytes.Buffer 3065 io.Copy(&snapshot, ringBuffer) 3066 err = &smithy.DeserializationError{ 3067 Err: fmt.Errorf("failed to decode response body, %w", err), 3068 Snapshot: snapshot.Bytes(), 3069 } 3070 return out, metadata, err 3071 } 3072 3073 err = awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupPolicyOutput(&output, shape) 3074 if err != nil { 3075 var snapshot bytes.Buffer 3076 io.Copy(&snapshot, ringBuffer) 3077 err = &smithy.DeserializationError{ 3078 Err: fmt.Errorf("failed to decode response body, %w", err), 3079 Snapshot: snapshot.Bytes(), 3080 } 3081 return out, metadata, err 3082 } 3083 3084 return out, metadata, err 3085} 3086 3087func awsAwsjson11_deserializeOpErrorGetFirewallRuleGroupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3088 var errorBuffer bytes.Buffer 3089 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3090 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3091 } 3092 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3093 3094 errorCode := "UnknownError" 3095 errorMessage := errorCode 3096 3097 code := response.Header.Get("X-Amzn-ErrorType") 3098 if len(code) != 0 { 3099 errorCode = restjson.SanitizeErrorCode(code) 3100 } 3101 3102 var buff [1024]byte 3103 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3104 3105 body := io.TeeReader(errorBody, ringBuffer) 3106 decoder := json.NewDecoder(body) 3107 decoder.UseNumber() 3108 code, message, err := restjson.GetErrorInfo(decoder) 3109 if err != nil { 3110 var snapshot bytes.Buffer 3111 io.Copy(&snapshot, ringBuffer) 3112 err = &smithy.DeserializationError{ 3113 Err: fmt.Errorf("failed to decode response body, %w", err), 3114 Snapshot: snapshot.Bytes(), 3115 } 3116 return err 3117 } 3118 3119 errorBody.Seek(0, io.SeekStart) 3120 if len(code) != 0 { 3121 errorCode = restjson.SanitizeErrorCode(code) 3122 } 3123 if len(message) != 0 { 3124 errorMessage = message 3125 } 3126 3127 switch { 3128 case strings.EqualFold("AccessDeniedException", errorCode): 3129 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3130 3131 case strings.EqualFold("InternalServiceErrorException", errorCode): 3132 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3133 3134 case strings.EqualFold("ResourceNotFoundException", errorCode): 3135 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3136 3137 case strings.EqualFold("ThrottlingException", errorCode): 3138 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3139 3140 case strings.EqualFold("ValidationException", errorCode): 3141 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3142 3143 default: 3144 genericError := &smithy.GenericAPIError{ 3145 Code: errorCode, 3146 Message: errorMessage, 3147 } 3148 return genericError 3149 3150 } 3151} 3152 3153type awsAwsjson11_deserializeOpGetResolverDnssecConfig struct { 3154} 3155 3156func (*awsAwsjson11_deserializeOpGetResolverDnssecConfig) ID() string { 3157 return "OperationDeserializer" 3158} 3159 3160func (m *awsAwsjson11_deserializeOpGetResolverDnssecConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3161 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3162) { 3163 out, metadata, err = next.HandleDeserialize(ctx, in) 3164 if err != nil { 3165 return out, metadata, err 3166 } 3167 3168 response, ok := out.RawResponse.(*smithyhttp.Response) 3169 if !ok { 3170 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3171 } 3172 3173 if response.StatusCode < 200 || response.StatusCode >= 300 { 3174 return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverDnssecConfig(response, &metadata) 3175 } 3176 output := &GetResolverDnssecConfigOutput{} 3177 out.Result = output 3178 3179 var buff [1024]byte 3180 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3181 3182 body := io.TeeReader(response.Body, ringBuffer) 3183 decoder := json.NewDecoder(body) 3184 decoder.UseNumber() 3185 var shape interface{} 3186 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3187 var snapshot bytes.Buffer 3188 io.Copy(&snapshot, ringBuffer) 3189 err = &smithy.DeserializationError{ 3190 Err: fmt.Errorf("failed to decode response body, %w", err), 3191 Snapshot: snapshot.Bytes(), 3192 } 3193 return out, metadata, err 3194 } 3195 3196 err = awsAwsjson11_deserializeOpDocumentGetResolverDnssecConfigOutput(&output, shape) 3197 if err != nil { 3198 var snapshot bytes.Buffer 3199 io.Copy(&snapshot, ringBuffer) 3200 err = &smithy.DeserializationError{ 3201 Err: fmt.Errorf("failed to decode response body, %w", err), 3202 Snapshot: snapshot.Bytes(), 3203 } 3204 return out, metadata, err 3205 } 3206 3207 return out, metadata, err 3208} 3209 3210func awsAwsjson11_deserializeOpErrorGetResolverDnssecConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3211 var errorBuffer bytes.Buffer 3212 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3213 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3214 } 3215 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3216 3217 errorCode := "UnknownError" 3218 errorMessage := errorCode 3219 3220 code := response.Header.Get("X-Amzn-ErrorType") 3221 if len(code) != 0 { 3222 errorCode = restjson.SanitizeErrorCode(code) 3223 } 3224 3225 var buff [1024]byte 3226 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3227 3228 body := io.TeeReader(errorBody, ringBuffer) 3229 decoder := json.NewDecoder(body) 3230 decoder.UseNumber() 3231 code, message, err := restjson.GetErrorInfo(decoder) 3232 if err != nil { 3233 var snapshot bytes.Buffer 3234 io.Copy(&snapshot, ringBuffer) 3235 err = &smithy.DeserializationError{ 3236 Err: fmt.Errorf("failed to decode response body, %w", err), 3237 Snapshot: snapshot.Bytes(), 3238 } 3239 return err 3240 } 3241 3242 errorBody.Seek(0, io.SeekStart) 3243 if len(code) != 0 { 3244 errorCode = restjson.SanitizeErrorCode(code) 3245 } 3246 if len(message) != 0 { 3247 errorMessage = message 3248 } 3249 3250 switch { 3251 case strings.EqualFold("AccessDeniedException", errorCode): 3252 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3253 3254 case strings.EqualFold("InternalServiceErrorException", errorCode): 3255 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3256 3257 case strings.EqualFold("InvalidParameterException", errorCode): 3258 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3259 3260 case strings.EqualFold("InvalidRequestException", errorCode): 3261 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3262 3263 case strings.EqualFold("ResourceNotFoundException", errorCode): 3264 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3265 3266 case strings.EqualFold("ThrottlingException", errorCode): 3267 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3268 3269 default: 3270 genericError := &smithy.GenericAPIError{ 3271 Code: errorCode, 3272 Message: errorMessage, 3273 } 3274 return genericError 3275 3276 } 3277} 3278 3279type awsAwsjson11_deserializeOpGetResolverEndpoint struct { 3280} 3281 3282func (*awsAwsjson11_deserializeOpGetResolverEndpoint) ID() string { 3283 return "OperationDeserializer" 3284} 3285 3286func (m *awsAwsjson11_deserializeOpGetResolverEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3287 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3288) { 3289 out, metadata, err = next.HandleDeserialize(ctx, in) 3290 if err != nil { 3291 return out, metadata, err 3292 } 3293 3294 response, ok := out.RawResponse.(*smithyhttp.Response) 3295 if !ok { 3296 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3297 } 3298 3299 if response.StatusCode < 200 || response.StatusCode >= 300 { 3300 return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverEndpoint(response, &metadata) 3301 } 3302 output := &GetResolverEndpointOutput{} 3303 out.Result = output 3304 3305 var buff [1024]byte 3306 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3307 3308 body := io.TeeReader(response.Body, ringBuffer) 3309 decoder := json.NewDecoder(body) 3310 decoder.UseNumber() 3311 var shape interface{} 3312 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3313 var snapshot bytes.Buffer 3314 io.Copy(&snapshot, ringBuffer) 3315 err = &smithy.DeserializationError{ 3316 Err: fmt.Errorf("failed to decode response body, %w", err), 3317 Snapshot: snapshot.Bytes(), 3318 } 3319 return out, metadata, err 3320 } 3321 3322 err = awsAwsjson11_deserializeOpDocumentGetResolverEndpointOutput(&output, shape) 3323 if err != nil { 3324 var snapshot bytes.Buffer 3325 io.Copy(&snapshot, ringBuffer) 3326 err = &smithy.DeserializationError{ 3327 Err: fmt.Errorf("failed to decode response body, %w", err), 3328 Snapshot: snapshot.Bytes(), 3329 } 3330 return out, metadata, err 3331 } 3332 3333 return out, metadata, err 3334} 3335 3336func awsAwsjson11_deserializeOpErrorGetResolverEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3337 var errorBuffer bytes.Buffer 3338 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3339 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3340 } 3341 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3342 3343 errorCode := "UnknownError" 3344 errorMessage := errorCode 3345 3346 code := response.Header.Get("X-Amzn-ErrorType") 3347 if len(code) != 0 { 3348 errorCode = restjson.SanitizeErrorCode(code) 3349 } 3350 3351 var buff [1024]byte 3352 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3353 3354 body := io.TeeReader(errorBody, ringBuffer) 3355 decoder := json.NewDecoder(body) 3356 decoder.UseNumber() 3357 code, message, err := restjson.GetErrorInfo(decoder) 3358 if err != nil { 3359 var snapshot bytes.Buffer 3360 io.Copy(&snapshot, ringBuffer) 3361 err = &smithy.DeserializationError{ 3362 Err: fmt.Errorf("failed to decode response body, %w", err), 3363 Snapshot: snapshot.Bytes(), 3364 } 3365 return err 3366 } 3367 3368 errorBody.Seek(0, io.SeekStart) 3369 if len(code) != 0 { 3370 errorCode = restjson.SanitizeErrorCode(code) 3371 } 3372 if len(message) != 0 { 3373 errorMessage = message 3374 } 3375 3376 switch { 3377 case strings.EqualFold("InternalServiceErrorException", errorCode): 3378 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3379 3380 case strings.EqualFold("InvalidParameterException", errorCode): 3381 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3382 3383 case strings.EqualFold("ResourceNotFoundException", errorCode): 3384 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3385 3386 case strings.EqualFold("ThrottlingException", errorCode): 3387 return awsAwsjson11_deserializeErrorThrottlingException(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_deserializeOpGetResolverQueryLogConfig struct { 3400} 3401 3402func (*awsAwsjson11_deserializeOpGetResolverQueryLogConfig) ID() string { 3403 return "OperationDeserializer" 3404} 3405 3406func (m *awsAwsjson11_deserializeOpGetResolverQueryLogConfig) 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_deserializeOpErrorGetResolverQueryLogConfig(response, &metadata) 3421 } 3422 output := &GetResolverQueryLogConfigOutput{} 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_deserializeOpDocumentGetResolverQueryLogConfigOutput(&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_deserializeOpErrorGetResolverQueryLogConfig(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("AccessDeniedException", errorCode): 3498 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3499 3500 case strings.EqualFold("InternalServiceErrorException", errorCode): 3501 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3502 3503 case strings.EqualFold("InvalidParameterException", errorCode): 3504 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3505 3506 case strings.EqualFold("InvalidRequestException", errorCode): 3507 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3508 3509 case strings.EqualFold("ResourceNotFoundException", errorCode): 3510 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3511 3512 case strings.EqualFold("ThrottlingException", errorCode): 3513 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3514 3515 default: 3516 genericError := &smithy.GenericAPIError{ 3517 Code: errorCode, 3518 Message: errorMessage, 3519 } 3520 return genericError 3521 3522 } 3523} 3524 3525type awsAwsjson11_deserializeOpGetResolverQueryLogConfigAssociation struct { 3526} 3527 3528func (*awsAwsjson11_deserializeOpGetResolverQueryLogConfigAssociation) ID() string { 3529 return "OperationDeserializer" 3530} 3531 3532func (m *awsAwsjson11_deserializeOpGetResolverQueryLogConfigAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3533 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3534) { 3535 out, metadata, err = next.HandleDeserialize(ctx, in) 3536 if err != nil { 3537 return out, metadata, err 3538 } 3539 3540 response, ok := out.RawResponse.(*smithyhttp.Response) 3541 if !ok { 3542 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3543 } 3544 3545 if response.StatusCode < 200 || response.StatusCode >= 300 { 3546 return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverQueryLogConfigAssociation(response, &metadata) 3547 } 3548 output := &GetResolverQueryLogConfigAssociationOutput{} 3549 out.Result = output 3550 3551 var buff [1024]byte 3552 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3553 3554 body := io.TeeReader(response.Body, ringBuffer) 3555 decoder := json.NewDecoder(body) 3556 decoder.UseNumber() 3557 var shape interface{} 3558 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3559 var snapshot bytes.Buffer 3560 io.Copy(&snapshot, ringBuffer) 3561 err = &smithy.DeserializationError{ 3562 Err: fmt.Errorf("failed to decode response body, %w", err), 3563 Snapshot: snapshot.Bytes(), 3564 } 3565 return out, metadata, err 3566 } 3567 3568 err = awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigAssociationOutput(&output, shape) 3569 if err != nil { 3570 var snapshot bytes.Buffer 3571 io.Copy(&snapshot, ringBuffer) 3572 err = &smithy.DeserializationError{ 3573 Err: fmt.Errorf("failed to decode response body, %w", err), 3574 Snapshot: snapshot.Bytes(), 3575 } 3576 return out, metadata, err 3577 } 3578 3579 return out, metadata, err 3580} 3581 3582func awsAwsjson11_deserializeOpErrorGetResolverQueryLogConfigAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3583 var errorBuffer bytes.Buffer 3584 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3585 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3586 } 3587 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3588 3589 errorCode := "UnknownError" 3590 errorMessage := errorCode 3591 3592 code := response.Header.Get("X-Amzn-ErrorType") 3593 if len(code) != 0 { 3594 errorCode = restjson.SanitizeErrorCode(code) 3595 } 3596 3597 var buff [1024]byte 3598 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3599 3600 body := io.TeeReader(errorBody, ringBuffer) 3601 decoder := json.NewDecoder(body) 3602 decoder.UseNumber() 3603 code, message, err := restjson.GetErrorInfo(decoder) 3604 if err != nil { 3605 var snapshot bytes.Buffer 3606 io.Copy(&snapshot, ringBuffer) 3607 err = &smithy.DeserializationError{ 3608 Err: fmt.Errorf("failed to decode response body, %w", err), 3609 Snapshot: snapshot.Bytes(), 3610 } 3611 return err 3612 } 3613 3614 errorBody.Seek(0, io.SeekStart) 3615 if len(code) != 0 { 3616 errorCode = restjson.SanitizeErrorCode(code) 3617 } 3618 if len(message) != 0 { 3619 errorMessage = message 3620 } 3621 3622 switch { 3623 case strings.EqualFold("AccessDeniedException", errorCode): 3624 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3625 3626 case strings.EqualFold("InternalServiceErrorException", errorCode): 3627 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3628 3629 case strings.EqualFold("InvalidParameterException", errorCode): 3630 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3631 3632 case strings.EqualFold("InvalidRequestException", errorCode): 3633 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3634 3635 case strings.EqualFold("ResourceNotFoundException", errorCode): 3636 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3637 3638 case strings.EqualFold("ThrottlingException", errorCode): 3639 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3640 3641 default: 3642 genericError := &smithy.GenericAPIError{ 3643 Code: errorCode, 3644 Message: errorMessage, 3645 } 3646 return genericError 3647 3648 } 3649} 3650 3651type awsAwsjson11_deserializeOpGetResolverQueryLogConfigPolicy struct { 3652} 3653 3654func (*awsAwsjson11_deserializeOpGetResolverQueryLogConfigPolicy) ID() string { 3655 return "OperationDeserializer" 3656} 3657 3658func (m *awsAwsjson11_deserializeOpGetResolverQueryLogConfigPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3659 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3660) { 3661 out, metadata, err = next.HandleDeserialize(ctx, in) 3662 if err != nil { 3663 return out, metadata, err 3664 } 3665 3666 response, ok := out.RawResponse.(*smithyhttp.Response) 3667 if !ok { 3668 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3669 } 3670 3671 if response.StatusCode < 200 || response.StatusCode >= 300 { 3672 return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverQueryLogConfigPolicy(response, &metadata) 3673 } 3674 output := &GetResolverQueryLogConfigPolicyOutput{} 3675 out.Result = output 3676 3677 var buff [1024]byte 3678 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3679 3680 body := io.TeeReader(response.Body, ringBuffer) 3681 decoder := json.NewDecoder(body) 3682 decoder.UseNumber() 3683 var shape interface{} 3684 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3685 var snapshot bytes.Buffer 3686 io.Copy(&snapshot, ringBuffer) 3687 err = &smithy.DeserializationError{ 3688 Err: fmt.Errorf("failed to decode response body, %w", err), 3689 Snapshot: snapshot.Bytes(), 3690 } 3691 return out, metadata, err 3692 } 3693 3694 err = awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigPolicyOutput(&output, shape) 3695 if err != nil { 3696 var snapshot bytes.Buffer 3697 io.Copy(&snapshot, ringBuffer) 3698 err = &smithy.DeserializationError{ 3699 Err: fmt.Errorf("failed to decode response body, %w", err), 3700 Snapshot: snapshot.Bytes(), 3701 } 3702 return out, metadata, err 3703 } 3704 3705 return out, metadata, err 3706} 3707 3708func awsAwsjson11_deserializeOpErrorGetResolverQueryLogConfigPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3709 var errorBuffer bytes.Buffer 3710 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3711 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3712 } 3713 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3714 3715 errorCode := "UnknownError" 3716 errorMessage := errorCode 3717 3718 code := response.Header.Get("X-Amzn-ErrorType") 3719 if len(code) != 0 { 3720 errorCode = restjson.SanitizeErrorCode(code) 3721 } 3722 3723 var buff [1024]byte 3724 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3725 3726 body := io.TeeReader(errorBody, ringBuffer) 3727 decoder := json.NewDecoder(body) 3728 decoder.UseNumber() 3729 code, message, err := restjson.GetErrorInfo(decoder) 3730 if err != nil { 3731 var snapshot bytes.Buffer 3732 io.Copy(&snapshot, ringBuffer) 3733 err = &smithy.DeserializationError{ 3734 Err: fmt.Errorf("failed to decode response body, %w", err), 3735 Snapshot: snapshot.Bytes(), 3736 } 3737 return err 3738 } 3739 3740 errorBody.Seek(0, io.SeekStart) 3741 if len(code) != 0 { 3742 errorCode = restjson.SanitizeErrorCode(code) 3743 } 3744 if len(message) != 0 { 3745 errorMessage = message 3746 } 3747 3748 switch { 3749 case strings.EqualFold("AccessDeniedException", errorCode): 3750 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3751 3752 case strings.EqualFold("InternalServiceErrorException", errorCode): 3753 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3754 3755 case strings.EqualFold("InvalidParameterException", errorCode): 3756 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3757 3758 case strings.EqualFold("InvalidRequestException", errorCode): 3759 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3760 3761 case strings.EqualFold("UnknownResourceException", errorCode): 3762 return awsAwsjson11_deserializeErrorUnknownResourceException(response, errorBody) 3763 3764 default: 3765 genericError := &smithy.GenericAPIError{ 3766 Code: errorCode, 3767 Message: errorMessage, 3768 } 3769 return genericError 3770 3771 } 3772} 3773 3774type awsAwsjson11_deserializeOpGetResolverRule struct { 3775} 3776 3777func (*awsAwsjson11_deserializeOpGetResolverRule) ID() string { 3778 return "OperationDeserializer" 3779} 3780 3781func (m *awsAwsjson11_deserializeOpGetResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3782 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3783) { 3784 out, metadata, err = next.HandleDeserialize(ctx, in) 3785 if err != nil { 3786 return out, metadata, err 3787 } 3788 3789 response, ok := out.RawResponse.(*smithyhttp.Response) 3790 if !ok { 3791 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3792 } 3793 3794 if response.StatusCode < 200 || response.StatusCode >= 300 { 3795 return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverRule(response, &metadata) 3796 } 3797 output := &GetResolverRuleOutput{} 3798 out.Result = output 3799 3800 var buff [1024]byte 3801 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3802 3803 body := io.TeeReader(response.Body, ringBuffer) 3804 decoder := json.NewDecoder(body) 3805 decoder.UseNumber() 3806 var shape interface{} 3807 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3808 var snapshot bytes.Buffer 3809 io.Copy(&snapshot, ringBuffer) 3810 err = &smithy.DeserializationError{ 3811 Err: fmt.Errorf("failed to decode response body, %w", err), 3812 Snapshot: snapshot.Bytes(), 3813 } 3814 return out, metadata, err 3815 } 3816 3817 err = awsAwsjson11_deserializeOpDocumentGetResolverRuleOutput(&output, shape) 3818 if err != nil { 3819 var snapshot bytes.Buffer 3820 io.Copy(&snapshot, ringBuffer) 3821 err = &smithy.DeserializationError{ 3822 Err: fmt.Errorf("failed to decode response body, %w", err), 3823 Snapshot: snapshot.Bytes(), 3824 } 3825 return out, metadata, err 3826 } 3827 3828 return out, metadata, err 3829} 3830 3831func awsAwsjson11_deserializeOpErrorGetResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3832 var errorBuffer bytes.Buffer 3833 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3834 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3835 } 3836 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3837 3838 errorCode := "UnknownError" 3839 errorMessage := errorCode 3840 3841 code := response.Header.Get("X-Amzn-ErrorType") 3842 if len(code) != 0 { 3843 errorCode = restjson.SanitizeErrorCode(code) 3844 } 3845 3846 var buff [1024]byte 3847 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3848 3849 body := io.TeeReader(errorBody, ringBuffer) 3850 decoder := json.NewDecoder(body) 3851 decoder.UseNumber() 3852 code, message, err := restjson.GetErrorInfo(decoder) 3853 if err != nil { 3854 var snapshot bytes.Buffer 3855 io.Copy(&snapshot, ringBuffer) 3856 err = &smithy.DeserializationError{ 3857 Err: fmt.Errorf("failed to decode response body, %w", err), 3858 Snapshot: snapshot.Bytes(), 3859 } 3860 return err 3861 } 3862 3863 errorBody.Seek(0, io.SeekStart) 3864 if len(code) != 0 { 3865 errorCode = restjson.SanitizeErrorCode(code) 3866 } 3867 if len(message) != 0 { 3868 errorMessage = message 3869 } 3870 3871 switch { 3872 case strings.EqualFold("InternalServiceErrorException", errorCode): 3873 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3874 3875 case strings.EqualFold("InvalidParameterException", errorCode): 3876 return awsAwsjson11_deserializeErrorInvalidParameterException(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_deserializeOpGetResolverRuleAssociation struct { 3895} 3896 3897func (*awsAwsjson11_deserializeOpGetResolverRuleAssociation) ID() string { 3898 return "OperationDeserializer" 3899} 3900 3901func (m *awsAwsjson11_deserializeOpGetResolverRuleAssociation) 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_deserializeOpErrorGetResolverRuleAssociation(response, &metadata) 3916 } 3917 output := &GetResolverRuleAssociationOutput{} 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_deserializeOpDocumentGetResolverRuleAssociationOutput(&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_deserializeOpErrorGetResolverRuleAssociation(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("ResourceNotFoundException", errorCode): 3999 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4000 4001 case strings.EqualFold("ThrottlingException", errorCode): 4002 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 4003 4004 default: 4005 genericError := &smithy.GenericAPIError{ 4006 Code: errorCode, 4007 Message: errorMessage, 4008 } 4009 return genericError 4010 4011 } 4012} 4013 4014type awsAwsjson11_deserializeOpGetResolverRulePolicy struct { 4015} 4016 4017func (*awsAwsjson11_deserializeOpGetResolverRulePolicy) ID() string { 4018 return "OperationDeserializer" 4019} 4020 4021func (m *awsAwsjson11_deserializeOpGetResolverRulePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4022 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4023) { 4024 out, metadata, err = next.HandleDeserialize(ctx, in) 4025 if err != nil { 4026 return out, metadata, err 4027 } 4028 4029 response, ok := out.RawResponse.(*smithyhttp.Response) 4030 if !ok { 4031 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4032 } 4033 4034 if response.StatusCode < 200 || response.StatusCode >= 300 { 4035 return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverRulePolicy(response, &metadata) 4036 } 4037 output := &GetResolverRulePolicyOutput{} 4038 out.Result = output 4039 4040 var buff [1024]byte 4041 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4042 4043 body := io.TeeReader(response.Body, ringBuffer) 4044 decoder := json.NewDecoder(body) 4045 decoder.UseNumber() 4046 var shape interface{} 4047 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4048 var snapshot bytes.Buffer 4049 io.Copy(&snapshot, ringBuffer) 4050 err = &smithy.DeserializationError{ 4051 Err: fmt.Errorf("failed to decode response body, %w", err), 4052 Snapshot: snapshot.Bytes(), 4053 } 4054 return out, metadata, err 4055 } 4056 4057 err = awsAwsjson11_deserializeOpDocumentGetResolverRulePolicyOutput(&output, shape) 4058 if err != nil { 4059 var snapshot bytes.Buffer 4060 io.Copy(&snapshot, ringBuffer) 4061 err = &smithy.DeserializationError{ 4062 Err: fmt.Errorf("failed to decode response body, %w", err), 4063 Snapshot: snapshot.Bytes(), 4064 } 4065 return out, metadata, err 4066 } 4067 4068 return out, metadata, err 4069} 4070 4071func awsAwsjson11_deserializeOpErrorGetResolverRulePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4072 var errorBuffer bytes.Buffer 4073 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4074 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4075 } 4076 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4077 4078 errorCode := "UnknownError" 4079 errorMessage := errorCode 4080 4081 code := response.Header.Get("X-Amzn-ErrorType") 4082 if len(code) != 0 { 4083 errorCode = restjson.SanitizeErrorCode(code) 4084 } 4085 4086 var buff [1024]byte 4087 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4088 4089 body := io.TeeReader(errorBody, ringBuffer) 4090 decoder := json.NewDecoder(body) 4091 decoder.UseNumber() 4092 code, message, err := restjson.GetErrorInfo(decoder) 4093 if err != nil { 4094 var snapshot bytes.Buffer 4095 io.Copy(&snapshot, ringBuffer) 4096 err = &smithy.DeserializationError{ 4097 Err: fmt.Errorf("failed to decode response body, %w", err), 4098 Snapshot: snapshot.Bytes(), 4099 } 4100 return err 4101 } 4102 4103 errorBody.Seek(0, io.SeekStart) 4104 if len(code) != 0 { 4105 errorCode = restjson.SanitizeErrorCode(code) 4106 } 4107 if len(message) != 0 { 4108 errorMessage = message 4109 } 4110 4111 switch { 4112 case strings.EqualFold("InternalServiceErrorException", errorCode): 4113 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4114 4115 case strings.EqualFold("InvalidParameterException", errorCode): 4116 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4117 4118 case strings.EqualFold("UnknownResourceException", errorCode): 4119 return awsAwsjson11_deserializeErrorUnknownResourceException(response, errorBody) 4120 4121 default: 4122 genericError := &smithy.GenericAPIError{ 4123 Code: errorCode, 4124 Message: errorMessage, 4125 } 4126 return genericError 4127 4128 } 4129} 4130 4131type awsAwsjson11_deserializeOpImportFirewallDomains struct { 4132} 4133 4134func (*awsAwsjson11_deserializeOpImportFirewallDomains) ID() string { 4135 return "OperationDeserializer" 4136} 4137 4138func (m *awsAwsjson11_deserializeOpImportFirewallDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4139 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4140) { 4141 out, metadata, err = next.HandleDeserialize(ctx, in) 4142 if err != nil { 4143 return out, metadata, err 4144 } 4145 4146 response, ok := out.RawResponse.(*smithyhttp.Response) 4147 if !ok { 4148 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4149 } 4150 4151 if response.StatusCode < 200 || response.StatusCode >= 300 { 4152 return out, metadata, awsAwsjson11_deserializeOpErrorImportFirewallDomains(response, &metadata) 4153 } 4154 output := &ImportFirewallDomainsOutput{} 4155 out.Result = output 4156 4157 var buff [1024]byte 4158 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4159 4160 body := io.TeeReader(response.Body, ringBuffer) 4161 decoder := json.NewDecoder(body) 4162 decoder.UseNumber() 4163 var shape interface{} 4164 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4165 var snapshot bytes.Buffer 4166 io.Copy(&snapshot, ringBuffer) 4167 err = &smithy.DeserializationError{ 4168 Err: fmt.Errorf("failed to decode response body, %w", err), 4169 Snapshot: snapshot.Bytes(), 4170 } 4171 return out, metadata, err 4172 } 4173 4174 err = awsAwsjson11_deserializeOpDocumentImportFirewallDomainsOutput(&output, shape) 4175 if err != nil { 4176 var snapshot bytes.Buffer 4177 io.Copy(&snapshot, ringBuffer) 4178 err = &smithy.DeserializationError{ 4179 Err: fmt.Errorf("failed to decode response body, %w", err), 4180 Snapshot: snapshot.Bytes(), 4181 } 4182 return out, metadata, err 4183 } 4184 4185 return out, metadata, err 4186} 4187 4188func awsAwsjson11_deserializeOpErrorImportFirewallDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4189 var errorBuffer bytes.Buffer 4190 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4191 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4192 } 4193 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4194 4195 errorCode := "UnknownError" 4196 errorMessage := errorCode 4197 4198 code := response.Header.Get("X-Amzn-ErrorType") 4199 if len(code) != 0 { 4200 errorCode = restjson.SanitizeErrorCode(code) 4201 } 4202 4203 var buff [1024]byte 4204 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4205 4206 body := io.TeeReader(errorBody, ringBuffer) 4207 decoder := json.NewDecoder(body) 4208 decoder.UseNumber() 4209 code, message, err := restjson.GetErrorInfo(decoder) 4210 if err != nil { 4211 var snapshot bytes.Buffer 4212 io.Copy(&snapshot, ringBuffer) 4213 err = &smithy.DeserializationError{ 4214 Err: fmt.Errorf("failed to decode response body, %w", err), 4215 Snapshot: snapshot.Bytes(), 4216 } 4217 return err 4218 } 4219 4220 errorBody.Seek(0, io.SeekStart) 4221 if len(code) != 0 { 4222 errorCode = restjson.SanitizeErrorCode(code) 4223 } 4224 if len(message) != 0 { 4225 errorMessage = message 4226 } 4227 4228 switch { 4229 case strings.EqualFold("AccessDeniedException", errorCode): 4230 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4231 4232 case strings.EqualFold("ConflictException", errorCode): 4233 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 4234 4235 case strings.EqualFold("InternalServiceErrorException", errorCode): 4236 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4237 4238 case strings.EqualFold("LimitExceededException", errorCode): 4239 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 4240 4241 case strings.EqualFold("ResourceNotFoundException", errorCode): 4242 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4243 4244 case strings.EqualFold("ThrottlingException", errorCode): 4245 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 4246 4247 case strings.EqualFold("ValidationException", errorCode): 4248 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4249 4250 default: 4251 genericError := &smithy.GenericAPIError{ 4252 Code: errorCode, 4253 Message: errorMessage, 4254 } 4255 return genericError 4256 4257 } 4258} 4259 4260type awsAwsjson11_deserializeOpListFirewallConfigs struct { 4261} 4262 4263func (*awsAwsjson11_deserializeOpListFirewallConfigs) ID() string { 4264 return "OperationDeserializer" 4265} 4266 4267func (m *awsAwsjson11_deserializeOpListFirewallConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4268 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4269) { 4270 out, metadata, err = next.HandleDeserialize(ctx, in) 4271 if err != nil { 4272 return out, metadata, err 4273 } 4274 4275 response, ok := out.RawResponse.(*smithyhttp.Response) 4276 if !ok { 4277 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4278 } 4279 4280 if response.StatusCode < 200 || response.StatusCode >= 300 { 4281 return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallConfigs(response, &metadata) 4282 } 4283 output := &ListFirewallConfigsOutput{} 4284 out.Result = output 4285 4286 var buff [1024]byte 4287 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4288 4289 body := io.TeeReader(response.Body, ringBuffer) 4290 decoder := json.NewDecoder(body) 4291 decoder.UseNumber() 4292 var shape interface{} 4293 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4294 var snapshot bytes.Buffer 4295 io.Copy(&snapshot, ringBuffer) 4296 err = &smithy.DeserializationError{ 4297 Err: fmt.Errorf("failed to decode response body, %w", err), 4298 Snapshot: snapshot.Bytes(), 4299 } 4300 return out, metadata, err 4301 } 4302 4303 err = awsAwsjson11_deserializeOpDocumentListFirewallConfigsOutput(&output, shape) 4304 if err != nil { 4305 var snapshot bytes.Buffer 4306 io.Copy(&snapshot, ringBuffer) 4307 err = &smithy.DeserializationError{ 4308 Err: fmt.Errorf("failed to decode response body, %w", err), 4309 Snapshot: snapshot.Bytes(), 4310 } 4311 return out, metadata, err 4312 } 4313 4314 return out, metadata, err 4315} 4316 4317func awsAwsjson11_deserializeOpErrorListFirewallConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4318 var errorBuffer bytes.Buffer 4319 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4320 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4321 } 4322 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4323 4324 errorCode := "UnknownError" 4325 errorMessage := errorCode 4326 4327 code := response.Header.Get("X-Amzn-ErrorType") 4328 if len(code) != 0 { 4329 errorCode = restjson.SanitizeErrorCode(code) 4330 } 4331 4332 var buff [1024]byte 4333 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4334 4335 body := io.TeeReader(errorBody, ringBuffer) 4336 decoder := json.NewDecoder(body) 4337 decoder.UseNumber() 4338 code, message, err := restjson.GetErrorInfo(decoder) 4339 if err != nil { 4340 var snapshot bytes.Buffer 4341 io.Copy(&snapshot, ringBuffer) 4342 err = &smithy.DeserializationError{ 4343 Err: fmt.Errorf("failed to decode response body, %w", err), 4344 Snapshot: snapshot.Bytes(), 4345 } 4346 return err 4347 } 4348 4349 errorBody.Seek(0, io.SeekStart) 4350 if len(code) != 0 { 4351 errorCode = restjson.SanitizeErrorCode(code) 4352 } 4353 if len(message) != 0 { 4354 errorMessage = message 4355 } 4356 4357 switch { 4358 case strings.EqualFold("AccessDeniedException", errorCode): 4359 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4360 4361 case strings.EqualFold("InternalServiceErrorException", errorCode): 4362 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4363 4364 case strings.EqualFold("ThrottlingException", errorCode): 4365 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 4366 4367 case strings.EqualFold("ValidationException", errorCode): 4368 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4369 4370 default: 4371 genericError := &smithy.GenericAPIError{ 4372 Code: errorCode, 4373 Message: errorMessage, 4374 } 4375 return genericError 4376 4377 } 4378} 4379 4380type awsAwsjson11_deserializeOpListFirewallDomainLists struct { 4381} 4382 4383func (*awsAwsjson11_deserializeOpListFirewallDomainLists) ID() string { 4384 return "OperationDeserializer" 4385} 4386 4387func (m *awsAwsjson11_deserializeOpListFirewallDomainLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4388 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4389) { 4390 out, metadata, err = next.HandleDeserialize(ctx, in) 4391 if err != nil { 4392 return out, metadata, err 4393 } 4394 4395 response, ok := out.RawResponse.(*smithyhttp.Response) 4396 if !ok { 4397 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4398 } 4399 4400 if response.StatusCode < 200 || response.StatusCode >= 300 { 4401 return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallDomainLists(response, &metadata) 4402 } 4403 output := &ListFirewallDomainListsOutput{} 4404 out.Result = output 4405 4406 var buff [1024]byte 4407 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4408 4409 body := io.TeeReader(response.Body, ringBuffer) 4410 decoder := json.NewDecoder(body) 4411 decoder.UseNumber() 4412 var shape interface{} 4413 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4414 var snapshot bytes.Buffer 4415 io.Copy(&snapshot, ringBuffer) 4416 err = &smithy.DeserializationError{ 4417 Err: fmt.Errorf("failed to decode response body, %w", err), 4418 Snapshot: snapshot.Bytes(), 4419 } 4420 return out, metadata, err 4421 } 4422 4423 err = awsAwsjson11_deserializeOpDocumentListFirewallDomainListsOutput(&output, shape) 4424 if err != nil { 4425 var snapshot bytes.Buffer 4426 io.Copy(&snapshot, ringBuffer) 4427 err = &smithy.DeserializationError{ 4428 Err: fmt.Errorf("failed to decode response body, %w", err), 4429 Snapshot: snapshot.Bytes(), 4430 } 4431 return out, metadata, err 4432 } 4433 4434 return out, metadata, err 4435} 4436 4437func awsAwsjson11_deserializeOpErrorListFirewallDomainLists(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4438 var errorBuffer bytes.Buffer 4439 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4440 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4441 } 4442 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4443 4444 errorCode := "UnknownError" 4445 errorMessage := errorCode 4446 4447 code := response.Header.Get("X-Amzn-ErrorType") 4448 if len(code) != 0 { 4449 errorCode = restjson.SanitizeErrorCode(code) 4450 } 4451 4452 var buff [1024]byte 4453 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4454 4455 body := io.TeeReader(errorBody, ringBuffer) 4456 decoder := json.NewDecoder(body) 4457 decoder.UseNumber() 4458 code, message, err := restjson.GetErrorInfo(decoder) 4459 if err != nil { 4460 var snapshot bytes.Buffer 4461 io.Copy(&snapshot, ringBuffer) 4462 err = &smithy.DeserializationError{ 4463 Err: fmt.Errorf("failed to decode response body, %w", err), 4464 Snapshot: snapshot.Bytes(), 4465 } 4466 return err 4467 } 4468 4469 errorBody.Seek(0, io.SeekStart) 4470 if len(code) != 0 { 4471 errorCode = restjson.SanitizeErrorCode(code) 4472 } 4473 if len(message) != 0 { 4474 errorMessage = message 4475 } 4476 4477 switch { 4478 case strings.EqualFold("AccessDeniedException", errorCode): 4479 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4480 4481 case strings.EqualFold("InternalServiceErrorException", errorCode): 4482 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4483 4484 case strings.EqualFold("ThrottlingException", errorCode): 4485 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 4486 4487 case strings.EqualFold("ValidationException", errorCode): 4488 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4489 4490 default: 4491 genericError := &smithy.GenericAPIError{ 4492 Code: errorCode, 4493 Message: errorMessage, 4494 } 4495 return genericError 4496 4497 } 4498} 4499 4500type awsAwsjson11_deserializeOpListFirewallDomains struct { 4501} 4502 4503func (*awsAwsjson11_deserializeOpListFirewallDomains) ID() string { 4504 return "OperationDeserializer" 4505} 4506 4507func (m *awsAwsjson11_deserializeOpListFirewallDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4508 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4509) { 4510 out, metadata, err = next.HandleDeserialize(ctx, in) 4511 if err != nil { 4512 return out, metadata, err 4513 } 4514 4515 response, ok := out.RawResponse.(*smithyhttp.Response) 4516 if !ok { 4517 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4518 } 4519 4520 if response.StatusCode < 200 || response.StatusCode >= 300 { 4521 return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallDomains(response, &metadata) 4522 } 4523 output := &ListFirewallDomainsOutput{} 4524 out.Result = output 4525 4526 var buff [1024]byte 4527 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4528 4529 body := io.TeeReader(response.Body, ringBuffer) 4530 decoder := json.NewDecoder(body) 4531 decoder.UseNumber() 4532 var shape interface{} 4533 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4534 var snapshot bytes.Buffer 4535 io.Copy(&snapshot, ringBuffer) 4536 err = &smithy.DeserializationError{ 4537 Err: fmt.Errorf("failed to decode response body, %w", err), 4538 Snapshot: snapshot.Bytes(), 4539 } 4540 return out, metadata, err 4541 } 4542 4543 err = awsAwsjson11_deserializeOpDocumentListFirewallDomainsOutput(&output, shape) 4544 if err != nil { 4545 var snapshot bytes.Buffer 4546 io.Copy(&snapshot, ringBuffer) 4547 err = &smithy.DeserializationError{ 4548 Err: fmt.Errorf("failed to decode response body, %w", err), 4549 Snapshot: snapshot.Bytes(), 4550 } 4551 return out, metadata, err 4552 } 4553 4554 return out, metadata, err 4555} 4556 4557func awsAwsjson11_deserializeOpErrorListFirewallDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4558 var errorBuffer bytes.Buffer 4559 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4560 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4561 } 4562 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4563 4564 errorCode := "UnknownError" 4565 errorMessage := errorCode 4566 4567 code := response.Header.Get("X-Amzn-ErrorType") 4568 if len(code) != 0 { 4569 errorCode = restjson.SanitizeErrorCode(code) 4570 } 4571 4572 var buff [1024]byte 4573 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4574 4575 body := io.TeeReader(errorBody, ringBuffer) 4576 decoder := json.NewDecoder(body) 4577 decoder.UseNumber() 4578 code, message, err := restjson.GetErrorInfo(decoder) 4579 if err != nil { 4580 var snapshot bytes.Buffer 4581 io.Copy(&snapshot, ringBuffer) 4582 err = &smithy.DeserializationError{ 4583 Err: fmt.Errorf("failed to decode response body, %w", err), 4584 Snapshot: snapshot.Bytes(), 4585 } 4586 return err 4587 } 4588 4589 errorBody.Seek(0, io.SeekStart) 4590 if len(code) != 0 { 4591 errorCode = restjson.SanitizeErrorCode(code) 4592 } 4593 if len(message) != 0 { 4594 errorMessage = message 4595 } 4596 4597 switch { 4598 case strings.EqualFold("AccessDeniedException", errorCode): 4599 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4600 4601 case strings.EqualFold("InternalServiceErrorException", errorCode): 4602 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4603 4604 case strings.EqualFold("ResourceNotFoundException", errorCode): 4605 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4606 4607 case strings.EqualFold("ThrottlingException", errorCode): 4608 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 4609 4610 case strings.EqualFold("ValidationException", errorCode): 4611 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4612 4613 default: 4614 genericError := &smithy.GenericAPIError{ 4615 Code: errorCode, 4616 Message: errorMessage, 4617 } 4618 return genericError 4619 4620 } 4621} 4622 4623type awsAwsjson11_deserializeOpListFirewallRuleGroupAssociations struct { 4624} 4625 4626func (*awsAwsjson11_deserializeOpListFirewallRuleGroupAssociations) ID() string { 4627 return "OperationDeserializer" 4628} 4629 4630func (m *awsAwsjson11_deserializeOpListFirewallRuleGroupAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4631 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4632) { 4633 out, metadata, err = next.HandleDeserialize(ctx, in) 4634 if err != nil { 4635 return out, metadata, err 4636 } 4637 4638 response, ok := out.RawResponse.(*smithyhttp.Response) 4639 if !ok { 4640 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4641 } 4642 4643 if response.StatusCode < 200 || response.StatusCode >= 300 { 4644 return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallRuleGroupAssociations(response, &metadata) 4645 } 4646 output := &ListFirewallRuleGroupAssociationsOutput{} 4647 out.Result = output 4648 4649 var buff [1024]byte 4650 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4651 4652 body := io.TeeReader(response.Body, ringBuffer) 4653 decoder := json.NewDecoder(body) 4654 decoder.UseNumber() 4655 var shape interface{} 4656 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4657 var snapshot bytes.Buffer 4658 io.Copy(&snapshot, ringBuffer) 4659 err = &smithy.DeserializationError{ 4660 Err: fmt.Errorf("failed to decode response body, %w", err), 4661 Snapshot: snapshot.Bytes(), 4662 } 4663 return out, metadata, err 4664 } 4665 4666 err = awsAwsjson11_deserializeOpDocumentListFirewallRuleGroupAssociationsOutput(&output, shape) 4667 if err != nil { 4668 var snapshot bytes.Buffer 4669 io.Copy(&snapshot, ringBuffer) 4670 err = &smithy.DeserializationError{ 4671 Err: fmt.Errorf("failed to decode response body, %w", err), 4672 Snapshot: snapshot.Bytes(), 4673 } 4674 return out, metadata, err 4675 } 4676 4677 return out, metadata, err 4678} 4679 4680func awsAwsjson11_deserializeOpErrorListFirewallRuleGroupAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4681 var errorBuffer bytes.Buffer 4682 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4683 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4684 } 4685 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4686 4687 errorCode := "UnknownError" 4688 errorMessage := errorCode 4689 4690 code := response.Header.Get("X-Amzn-ErrorType") 4691 if len(code) != 0 { 4692 errorCode = restjson.SanitizeErrorCode(code) 4693 } 4694 4695 var buff [1024]byte 4696 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4697 4698 body := io.TeeReader(errorBody, ringBuffer) 4699 decoder := json.NewDecoder(body) 4700 decoder.UseNumber() 4701 code, message, err := restjson.GetErrorInfo(decoder) 4702 if err != nil { 4703 var snapshot bytes.Buffer 4704 io.Copy(&snapshot, ringBuffer) 4705 err = &smithy.DeserializationError{ 4706 Err: fmt.Errorf("failed to decode response body, %w", err), 4707 Snapshot: snapshot.Bytes(), 4708 } 4709 return err 4710 } 4711 4712 errorBody.Seek(0, io.SeekStart) 4713 if len(code) != 0 { 4714 errorCode = restjson.SanitizeErrorCode(code) 4715 } 4716 if len(message) != 0 { 4717 errorMessage = message 4718 } 4719 4720 switch { 4721 case strings.EqualFold("AccessDeniedException", errorCode): 4722 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4723 4724 case strings.EqualFold("InternalServiceErrorException", errorCode): 4725 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4726 4727 case strings.EqualFold("ThrottlingException", errorCode): 4728 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 4729 4730 case strings.EqualFold("ValidationException", errorCode): 4731 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4732 4733 default: 4734 genericError := &smithy.GenericAPIError{ 4735 Code: errorCode, 4736 Message: errorMessage, 4737 } 4738 return genericError 4739 4740 } 4741} 4742 4743type awsAwsjson11_deserializeOpListFirewallRuleGroups struct { 4744} 4745 4746func (*awsAwsjson11_deserializeOpListFirewallRuleGroups) ID() string { 4747 return "OperationDeserializer" 4748} 4749 4750func (m *awsAwsjson11_deserializeOpListFirewallRuleGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4751 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4752) { 4753 out, metadata, err = next.HandleDeserialize(ctx, in) 4754 if err != nil { 4755 return out, metadata, err 4756 } 4757 4758 response, ok := out.RawResponse.(*smithyhttp.Response) 4759 if !ok { 4760 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4761 } 4762 4763 if response.StatusCode < 200 || response.StatusCode >= 300 { 4764 return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallRuleGroups(response, &metadata) 4765 } 4766 output := &ListFirewallRuleGroupsOutput{} 4767 out.Result = output 4768 4769 var buff [1024]byte 4770 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4771 4772 body := io.TeeReader(response.Body, ringBuffer) 4773 decoder := json.NewDecoder(body) 4774 decoder.UseNumber() 4775 var shape interface{} 4776 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4777 var snapshot bytes.Buffer 4778 io.Copy(&snapshot, ringBuffer) 4779 err = &smithy.DeserializationError{ 4780 Err: fmt.Errorf("failed to decode response body, %w", err), 4781 Snapshot: snapshot.Bytes(), 4782 } 4783 return out, metadata, err 4784 } 4785 4786 err = awsAwsjson11_deserializeOpDocumentListFirewallRuleGroupsOutput(&output, shape) 4787 if err != nil { 4788 var snapshot bytes.Buffer 4789 io.Copy(&snapshot, ringBuffer) 4790 err = &smithy.DeserializationError{ 4791 Err: fmt.Errorf("failed to decode response body, %w", err), 4792 Snapshot: snapshot.Bytes(), 4793 } 4794 return out, metadata, err 4795 } 4796 4797 return out, metadata, err 4798} 4799 4800func awsAwsjson11_deserializeOpErrorListFirewallRuleGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4801 var errorBuffer bytes.Buffer 4802 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4803 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4804 } 4805 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4806 4807 errorCode := "UnknownError" 4808 errorMessage := errorCode 4809 4810 code := response.Header.Get("X-Amzn-ErrorType") 4811 if len(code) != 0 { 4812 errorCode = restjson.SanitizeErrorCode(code) 4813 } 4814 4815 var buff [1024]byte 4816 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4817 4818 body := io.TeeReader(errorBody, ringBuffer) 4819 decoder := json.NewDecoder(body) 4820 decoder.UseNumber() 4821 code, message, err := restjson.GetErrorInfo(decoder) 4822 if err != nil { 4823 var snapshot bytes.Buffer 4824 io.Copy(&snapshot, ringBuffer) 4825 err = &smithy.DeserializationError{ 4826 Err: fmt.Errorf("failed to decode response body, %w", err), 4827 Snapshot: snapshot.Bytes(), 4828 } 4829 return err 4830 } 4831 4832 errorBody.Seek(0, io.SeekStart) 4833 if len(code) != 0 { 4834 errorCode = restjson.SanitizeErrorCode(code) 4835 } 4836 if len(message) != 0 { 4837 errorMessage = message 4838 } 4839 4840 switch { 4841 case strings.EqualFold("AccessDeniedException", errorCode): 4842 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4843 4844 case strings.EqualFold("InternalServiceErrorException", errorCode): 4845 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4846 4847 case strings.EqualFold("ThrottlingException", errorCode): 4848 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 4849 4850 case strings.EqualFold("ValidationException", errorCode): 4851 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4852 4853 default: 4854 genericError := &smithy.GenericAPIError{ 4855 Code: errorCode, 4856 Message: errorMessage, 4857 } 4858 return genericError 4859 4860 } 4861} 4862 4863type awsAwsjson11_deserializeOpListFirewallRules struct { 4864} 4865 4866func (*awsAwsjson11_deserializeOpListFirewallRules) ID() string { 4867 return "OperationDeserializer" 4868} 4869 4870func (m *awsAwsjson11_deserializeOpListFirewallRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4871 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4872) { 4873 out, metadata, err = next.HandleDeserialize(ctx, in) 4874 if err != nil { 4875 return out, metadata, err 4876 } 4877 4878 response, ok := out.RawResponse.(*smithyhttp.Response) 4879 if !ok { 4880 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4881 } 4882 4883 if response.StatusCode < 200 || response.StatusCode >= 300 { 4884 return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallRules(response, &metadata) 4885 } 4886 output := &ListFirewallRulesOutput{} 4887 out.Result = output 4888 4889 var buff [1024]byte 4890 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4891 4892 body := io.TeeReader(response.Body, ringBuffer) 4893 decoder := json.NewDecoder(body) 4894 decoder.UseNumber() 4895 var shape interface{} 4896 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4897 var snapshot bytes.Buffer 4898 io.Copy(&snapshot, ringBuffer) 4899 err = &smithy.DeserializationError{ 4900 Err: fmt.Errorf("failed to decode response body, %w", err), 4901 Snapshot: snapshot.Bytes(), 4902 } 4903 return out, metadata, err 4904 } 4905 4906 err = awsAwsjson11_deserializeOpDocumentListFirewallRulesOutput(&output, shape) 4907 if err != nil { 4908 var snapshot bytes.Buffer 4909 io.Copy(&snapshot, ringBuffer) 4910 err = &smithy.DeserializationError{ 4911 Err: fmt.Errorf("failed to decode response body, %w", err), 4912 Snapshot: snapshot.Bytes(), 4913 } 4914 return out, metadata, err 4915 } 4916 4917 return out, metadata, err 4918} 4919 4920func awsAwsjson11_deserializeOpErrorListFirewallRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4921 var errorBuffer bytes.Buffer 4922 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4923 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4924 } 4925 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4926 4927 errorCode := "UnknownError" 4928 errorMessage := errorCode 4929 4930 code := response.Header.Get("X-Amzn-ErrorType") 4931 if len(code) != 0 { 4932 errorCode = restjson.SanitizeErrorCode(code) 4933 } 4934 4935 var buff [1024]byte 4936 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4937 4938 body := io.TeeReader(errorBody, ringBuffer) 4939 decoder := json.NewDecoder(body) 4940 decoder.UseNumber() 4941 code, message, err := restjson.GetErrorInfo(decoder) 4942 if err != nil { 4943 var snapshot bytes.Buffer 4944 io.Copy(&snapshot, ringBuffer) 4945 err = &smithy.DeserializationError{ 4946 Err: fmt.Errorf("failed to decode response body, %w", err), 4947 Snapshot: snapshot.Bytes(), 4948 } 4949 return err 4950 } 4951 4952 errorBody.Seek(0, io.SeekStart) 4953 if len(code) != 0 { 4954 errorCode = restjson.SanitizeErrorCode(code) 4955 } 4956 if len(message) != 0 { 4957 errorMessage = message 4958 } 4959 4960 switch { 4961 case strings.EqualFold("AccessDeniedException", errorCode): 4962 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4963 4964 case strings.EqualFold("InternalServiceErrorException", errorCode): 4965 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4966 4967 case strings.EqualFold("ResourceNotFoundException", errorCode): 4968 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4969 4970 case strings.EqualFold("ThrottlingException", errorCode): 4971 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 4972 4973 case strings.EqualFold("ValidationException", errorCode): 4974 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4975 4976 default: 4977 genericError := &smithy.GenericAPIError{ 4978 Code: errorCode, 4979 Message: errorMessage, 4980 } 4981 return genericError 4982 4983 } 4984} 4985 4986type awsAwsjson11_deserializeOpListResolverDnssecConfigs struct { 4987} 4988 4989func (*awsAwsjson11_deserializeOpListResolverDnssecConfigs) ID() string { 4990 return "OperationDeserializer" 4991} 4992 4993func (m *awsAwsjson11_deserializeOpListResolverDnssecConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4994 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4995) { 4996 out, metadata, err = next.HandleDeserialize(ctx, in) 4997 if err != nil { 4998 return out, metadata, err 4999 } 5000 5001 response, ok := out.RawResponse.(*smithyhttp.Response) 5002 if !ok { 5003 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5004 } 5005 5006 if response.StatusCode < 200 || response.StatusCode >= 300 { 5007 return out, metadata, awsAwsjson11_deserializeOpErrorListResolverDnssecConfigs(response, &metadata) 5008 } 5009 output := &ListResolverDnssecConfigsOutput{} 5010 out.Result = output 5011 5012 var buff [1024]byte 5013 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5014 5015 body := io.TeeReader(response.Body, ringBuffer) 5016 decoder := json.NewDecoder(body) 5017 decoder.UseNumber() 5018 var shape interface{} 5019 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5020 var snapshot bytes.Buffer 5021 io.Copy(&snapshot, ringBuffer) 5022 err = &smithy.DeserializationError{ 5023 Err: fmt.Errorf("failed to decode response body, %w", err), 5024 Snapshot: snapshot.Bytes(), 5025 } 5026 return out, metadata, err 5027 } 5028 5029 err = awsAwsjson11_deserializeOpDocumentListResolverDnssecConfigsOutput(&output, shape) 5030 if err != nil { 5031 var snapshot bytes.Buffer 5032 io.Copy(&snapshot, ringBuffer) 5033 err = &smithy.DeserializationError{ 5034 Err: fmt.Errorf("failed to decode response body, %w", err), 5035 Snapshot: snapshot.Bytes(), 5036 } 5037 return out, metadata, err 5038 } 5039 5040 return out, metadata, err 5041} 5042 5043func awsAwsjson11_deserializeOpErrorListResolverDnssecConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5044 var errorBuffer bytes.Buffer 5045 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5046 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5047 } 5048 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5049 5050 errorCode := "UnknownError" 5051 errorMessage := errorCode 5052 5053 code := response.Header.Get("X-Amzn-ErrorType") 5054 if len(code) != 0 { 5055 errorCode = restjson.SanitizeErrorCode(code) 5056 } 5057 5058 var buff [1024]byte 5059 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5060 5061 body := io.TeeReader(errorBody, ringBuffer) 5062 decoder := json.NewDecoder(body) 5063 decoder.UseNumber() 5064 code, message, err := restjson.GetErrorInfo(decoder) 5065 if err != nil { 5066 var snapshot bytes.Buffer 5067 io.Copy(&snapshot, ringBuffer) 5068 err = &smithy.DeserializationError{ 5069 Err: fmt.Errorf("failed to decode response body, %w", err), 5070 Snapshot: snapshot.Bytes(), 5071 } 5072 return err 5073 } 5074 5075 errorBody.Seek(0, io.SeekStart) 5076 if len(code) != 0 { 5077 errorCode = restjson.SanitizeErrorCode(code) 5078 } 5079 if len(message) != 0 { 5080 errorMessage = message 5081 } 5082 5083 switch { 5084 case strings.EqualFold("AccessDeniedException", errorCode): 5085 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5086 5087 case strings.EqualFold("InternalServiceErrorException", errorCode): 5088 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5089 5090 case strings.EqualFold("InvalidNextTokenException", errorCode): 5091 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 5092 5093 case strings.EqualFold("InvalidParameterException", errorCode): 5094 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5095 5096 case strings.EqualFold("InvalidRequestException", errorCode): 5097 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 5098 5099 case strings.EqualFold("ThrottlingException", errorCode): 5100 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 5101 5102 default: 5103 genericError := &smithy.GenericAPIError{ 5104 Code: errorCode, 5105 Message: errorMessage, 5106 } 5107 return genericError 5108 5109 } 5110} 5111 5112type awsAwsjson11_deserializeOpListResolverEndpointIpAddresses struct { 5113} 5114 5115func (*awsAwsjson11_deserializeOpListResolverEndpointIpAddresses) ID() string { 5116 return "OperationDeserializer" 5117} 5118 5119func (m *awsAwsjson11_deserializeOpListResolverEndpointIpAddresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5120 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5121) { 5122 out, metadata, err = next.HandleDeserialize(ctx, in) 5123 if err != nil { 5124 return out, metadata, err 5125 } 5126 5127 response, ok := out.RawResponse.(*smithyhttp.Response) 5128 if !ok { 5129 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5130 } 5131 5132 if response.StatusCode < 200 || response.StatusCode >= 300 { 5133 return out, metadata, awsAwsjson11_deserializeOpErrorListResolverEndpointIpAddresses(response, &metadata) 5134 } 5135 output := &ListResolverEndpointIpAddressesOutput{} 5136 out.Result = output 5137 5138 var buff [1024]byte 5139 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5140 5141 body := io.TeeReader(response.Body, ringBuffer) 5142 decoder := json.NewDecoder(body) 5143 decoder.UseNumber() 5144 var shape interface{} 5145 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5146 var snapshot bytes.Buffer 5147 io.Copy(&snapshot, ringBuffer) 5148 err = &smithy.DeserializationError{ 5149 Err: fmt.Errorf("failed to decode response body, %w", err), 5150 Snapshot: snapshot.Bytes(), 5151 } 5152 return out, metadata, err 5153 } 5154 5155 err = awsAwsjson11_deserializeOpDocumentListResolverEndpointIpAddressesOutput(&output, shape) 5156 if err != nil { 5157 var snapshot bytes.Buffer 5158 io.Copy(&snapshot, ringBuffer) 5159 err = &smithy.DeserializationError{ 5160 Err: fmt.Errorf("failed to decode response body, %w", err), 5161 Snapshot: snapshot.Bytes(), 5162 } 5163 return out, metadata, err 5164 } 5165 5166 return out, metadata, err 5167} 5168 5169func awsAwsjson11_deserializeOpErrorListResolverEndpointIpAddresses(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5170 var errorBuffer bytes.Buffer 5171 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5172 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5173 } 5174 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5175 5176 errorCode := "UnknownError" 5177 errorMessage := errorCode 5178 5179 code := response.Header.Get("X-Amzn-ErrorType") 5180 if len(code) != 0 { 5181 errorCode = restjson.SanitizeErrorCode(code) 5182 } 5183 5184 var buff [1024]byte 5185 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5186 5187 body := io.TeeReader(errorBody, ringBuffer) 5188 decoder := json.NewDecoder(body) 5189 decoder.UseNumber() 5190 code, message, err := restjson.GetErrorInfo(decoder) 5191 if err != nil { 5192 var snapshot bytes.Buffer 5193 io.Copy(&snapshot, ringBuffer) 5194 err = &smithy.DeserializationError{ 5195 Err: fmt.Errorf("failed to decode response body, %w", err), 5196 Snapshot: snapshot.Bytes(), 5197 } 5198 return err 5199 } 5200 5201 errorBody.Seek(0, io.SeekStart) 5202 if len(code) != 0 { 5203 errorCode = restjson.SanitizeErrorCode(code) 5204 } 5205 if len(message) != 0 { 5206 errorMessage = message 5207 } 5208 5209 switch { 5210 case strings.EqualFold("InternalServiceErrorException", errorCode): 5211 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5212 5213 case strings.EqualFold("InvalidNextTokenException", errorCode): 5214 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 5215 5216 case strings.EqualFold("InvalidParameterException", errorCode): 5217 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5218 5219 case strings.EqualFold("ResourceNotFoundException", errorCode): 5220 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5221 5222 case strings.EqualFold("ThrottlingException", errorCode): 5223 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 5224 5225 default: 5226 genericError := &smithy.GenericAPIError{ 5227 Code: errorCode, 5228 Message: errorMessage, 5229 } 5230 return genericError 5231 5232 } 5233} 5234 5235type awsAwsjson11_deserializeOpListResolverEndpoints struct { 5236} 5237 5238func (*awsAwsjson11_deserializeOpListResolverEndpoints) ID() string { 5239 return "OperationDeserializer" 5240} 5241 5242func (m *awsAwsjson11_deserializeOpListResolverEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5243 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5244) { 5245 out, metadata, err = next.HandleDeserialize(ctx, in) 5246 if err != nil { 5247 return out, metadata, err 5248 } 5249 5250 response, ok := out.RawResponse.(*smithyhttp.Response) 5251 if !ok { 5252 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5253 } 5254 5255 if response.StatusCode < 200 || response.StatusCode >= 300 { 5256 return out, metadata, awsAwsjson11_deserializeOpErrorListResolverEndpoints(response, &metadata) 5257 } 5258 output := &ListResolverEndpointsOutput{} 5259 out.Result = output 5260 5261 var buff [1024]byte 5262 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5263 5264 body := io.TeeReader(response.Body, ringBuffer) 5265 decoder := json.NewDecoder(body) 5266 decoder.UseNumber() 5267 var shape interface{} 5268 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5269 var snapshot bytes.Buffer 5270 io.Copy(&snapshot, ringBuffer) 5271 err = &smithy.DeserializationError{ 5272 Err: fmt.Errorf("failed to decode response body, %w", err), 5273 Snapshot: snapshot.Bytes(), 5274 } 5275 return out, metadata, err 5276 } 5277 5278 err = awsAwsjson11_deserializeOpDocumentListResolverEndpointsOutput(&output, shape) 5279 if err != nil { 5280 var snapshot bytes.Buffer 5281 io.Copy(&snapshot, ringBuffer) 5282 err = &smithy.DeserializationError{ 5283 Err: fmt.Errorf("failed to decode response body, %w", err), 5284 Snapshot: snapshot.Bytes(), 5285 } 5286 return out, metadata, err 5287 } 5288 5289 return out, metadata, err 5290} 5291 5292func awsAwsjson11_deserializeOpErrorListResolverEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5293 var errorBuffer bytes.Buffer 5294 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5295 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5296 } 5297 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5298 5299 errorCode := "UnknownError" 5300 errorMessage := errorCode 5301 5302 code := response.Header.Get("X-Amzn-ErrorType") 5303 if len(code) != 0 { 5304 errorCode = restjson.SanitizeErrorCode(code) 5305 } 5306 5307 var buff [1024]byte 5308 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5309 5310 body := io.TeeReader(errorBody, ringBuffer) 5311 decoder := json.NewDecoder(body) 5312 decoder.UseNumber() 5313 code, message, err := restjson.GetErrorInfo(decoder) 5314 if err != nil { 5315 var snapshot bytes.Buffer 5316 io.Copy(&snapshot, ringBuffer) 5317 err = &smithy.DeserializationError{ 5318 Err: fmt.Errorf("failed to decode response body, %w", err), 5319 Snapshot: snapshot.Bytes(), 5320 } 5321 return err 5322 } 5323 5324 errorBody.Seek(0, io.SeekStart) 5325 if len(code) != 0 { 5326 errorCode = restjson.SanitizeErrorCode(code) 5327 } 5328 if len(message) != 0 { 5329 errorMessage = message 5330 } 5331 5332 switch { 5333 case strings.EqualFold("InternalServiceErrorException", errorCode): 5334 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5335 5336 case strings.EqualFold("InvalidNextTokenException", errorCode): 5337 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 5338 5339 case strings.EqualFold("InvalidParameterException", errorCode): 5340 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5341 5342 case strings.EqualFold("InvalidRequestException", errorCode): 5343 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 5344 5345 case strings.EqualFold("ThrottlingException", errorCode): 5346 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 5347 5348 default: 5349 genericError := &smithy.GenericAPIError{ 5350 Code: errorCode, 5351 Message: errorMessage, 5352 } 5353 return genericError 5354 5355 } 5356} 5357 5358type awsAwsjson11_deserializeOpListResolverQueryLogConfigAssociations struct { 5359} 5360 5361func (*awsAwsjson11_deserializeOpListResolverQueryLogConfigAssociations) ID() string { 5362 return "OperationDeserializer" 5363} 5364 5365func (m *awsAwsjson11_deserializeOpListResolverQueryLogConfigAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5366 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5367) { 5368 out, metadata, err = next.HandleDeserialize(ctx, in) 5369 if err != nil { 5370 return out, metadata, err 5371 } 5372 5373 response, ok := out.RawResponse.(*smithyhttp.Response) 5374 if !ok { 5375 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5376 } 5377 5378 if response.StatusCode < 200 || response.StatusCode >= 300 { 5379 return out, metadata, awsAwsjson11_deserializeOpErrorListResolverQueryLogConfigAssociations(response, &metadata) 5380 } 5381 output := &ListResolverQueryLogConfigAssociationsOutput{} 5382 out.Result = output 5383 5384 var buff [1024]byte 5385 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5386 5387 body := io.TeeReader(response.Body, ringBuffer) 5388 decoder := json.NewDecoder(body) 5389 decoder.UseNumber() 5390 var shape interface{} 5391 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5392 var snapshot bytes.Buffer 5393 io.Copy(&snapshot, ringBuffer) 5394 err = &smithy.DeserializationError{ 5395 Err: fmt.Errorf("failed to decode response body, %w", err), 5396 Snapshot: snapshot.Bytes(), 5397 } 5398 return out, metadata, err 5399 } 5400 5401 err = awsAwsjson11_deserializeOpDocumentListResolverQueryLogConfigAssociationsOutput(&output, shape) 5402 if err != nil { 5403 var snapshot bytes.Buffer 5404 io.Copy(&snapshot, ringBuffer) 5405 err = &smithy.DeserializationError{ 5406 Err: fmt.Errorf("failed to decode response body, %w", err), 5407 Snapshot: snapshot.Bytes(), 5408 } 5409 return out, metadata, err 5410 } 5411 5412 return out, metadata, err 5413} 5414 5415func awsAwsjson11_deserializeOpErrorListResolverQueryLogConfigAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5416 var errorBuffer bytes.Buffer 5417 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5418 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5419 } 5420 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5421 5422 errorCode := "UnknownError" 5423 errorMessage := errorCode 5424 5425 code := response.Header.Get("X-Amzn-ErrorType") 5426 if len(code) != 0 { 5427 errorCode = restjson.SanitizeErrorCode(code) 5428 } 5429 5430 var buff [1024]byte 5431 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5432 5433 body := io.TeeReader(errorBody, ringBuffer) 5434 decoder := json.NewDecoder(body) 5435 decoder.UseNumber() 5436 code, message, err := restjson.GetErrorInfo(decoder) 5437 if err != nil { 5438 var snapshot bytes.Buffer 5439 io.Copy(&snapshot, ringBuffer) 5440 err = &smithy.DeserializationError{ 5441 Err: fmt.Errorf("failed to decode response body, %w", err), 5442 Snapshot: snapshot.Bytes(), 5443 } 5444 return err 5445 } 5446 5447 errorBody.Seek(0, io.SeekStart) 5448 if len(code) != 0 { 5449 errorCode = restjson.SanitizeErrorCode(code) 5450 } 5451 if len(message) != 0 { 5452 errorMessage = message 5453 } 5454 5455 switch { 5456 case strings.EqualFold("AccessDeniedException", errorCode): 5457 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5458 5459 case strings.EqualFold("InternalServiceErrorException", errorCode): 5460 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5461 5462 case strings.EqualFold("InvalidParameterException", errorCode): 5463 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5464 5465 case strings.EqualFold("InvalidRequestException", errorCode): 5466 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 5467 5468 case strings.EqualFold("LimitExceededException", errorCode): 5469 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 5470 5471 case strings.EqualFold("ThrottlingException", errorCode): 5472 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 5473 5474 default: 5475 genericError := &smithy.GenericAPIError{ 5476 Code: errorCode, 5477 Message: errorMessage, 5478 } 5479 return genericError 5480 5481 } 5482} 5483 5484type awsAwsjson11_deserializeOpListResolverQueryLogConfigs struct { 5485} 5486 5487func (*awsAwsjson11_deserializeOpListResolverQueryLogConfigs) ID() string { 5488 return "OperationDeserializer" 5489} 5490 5491func (m *awsAwsjson11_deserializeOpListResolverQueryLogConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5492 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5493) { 5494 out, metadata, err = next.HandleDeserialize(ctx, in) 5495 if err != nil { 5496 return out, metadata, err 5497 } 5498 5499 response, ok := out.RawResponse.(*smithyhttp.Response) 5500 if !ok { 5501 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5502 } 5503 5504 if response.StatusCode < 200 || response.StatusCode >= 300 { 5505 return out, metadata, awsAwsjson11_deserializeOpErrorListResolverQueryLogConfigs(response, &metadata) 5506 } 5507 output := &ListResolverQueryLogConfigsOutput{} 5508 out.Result = output 5509 5510 var buff [1024]byte 5511 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5512 5513 body := io.TeeReader(response.Body, ringBuffer) 5514 decoder := json.NewDecoder(body) 5515 decoder.UseNumber() 5516 var shape interface{} 5517 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5518 var snapshot bytes.Buffer 5519 io.Copy(&snapshot, ringBuffer) 5520 err = &smithy.DeserializationError{ 5521 Err: fmt.Errorf("failed to decode response body, %w", err), 5522 Snapshot: snapshot.Bytes(), 5523 } 5524 return out, metadata, err 5525 } 5526 5527 err = awsAwsjson11_deserializeOpDocumentListResolverQueryLogConfigsOutput(&output, shape) 5528 if err != nil { 5529 var snapshot bytes.Buffer 5530 io.Copy(&snapshot, ringBuffer) 5531 err = &smithy.DeserializationError{ 5532 Err: fmt.Errorf("failed to decode response body, %w", err), 5533 Snapshot: snapshot.Bytes(), 5534 } 5535 return out, metadata, err 5536 } 5537 5538 return out, metadata, err 5539} 5540 5541func awsAwsjson11_deserializeOpErrorListResolverQueryLogConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5542 var errorBuffer bytes.Buffer 5543 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5544 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5545 } 5546 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5547 5548 errorCode := "UnknownError" 5549 errorMessage := errorCode 5550 5551 code := response.Header.Get("X-Amzn-ErrorType") 5552 if len(code) != 0 { 5553 errorCode = restjson.SanitizeErrorCode(code) 5554 } 5555 5556 var buff [1024]byte 5557 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5558 5559 body := io.TeeReader(errorBody, ringBuffer) 5560 decoder := json.NewDecoder(body) 5561 decoder.UseNumber() 5562 code, message, err := restjson.GetErrorInfo(decoder) 5563 if err != nil { 5564 var snapshot bytes.Buffer 5565 io.Copy(&snapshot, ringBuffer) 5566 err = &smithy.DeserializationError{ 5567 Err: fmt.Errorf("failed to decode response body, %w", err), 5568 Snapshot: snapshot.Bytes(), 5569 } 5570 return err 5571 } 5572 5573 errorBody.Seek(0, io.SeekStart) 5574 if len(code) != 0 { 5575 errorCode = restjson.SanitizeErrorCode(code) 5576 } 5577 if len(message) != 0 { 5578 errorMessage = message 5579 } 5580 5581 switch { 5582 case strings.EqualFold("AccessDeniedException", errorCode): 5583 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5584 5585 case strings.EqualFold("InternalServiceErrorException", errorCode): 5586 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5587 5588 case strings.EqualFold("InvalidNextTokenException", errorCode): 5589 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 5590 5591 case strings.EqualFold("InvalidParameterException", errorCode): 5592 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5593 5594 case strings.EqualFold("InvalidRequestException", errorCode): 5595 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 5596 5597 case strings.EqualFold("ThrottlingException", errorCode): 5598 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 5599 5600 default: 5601 genericError := &smithy.GenericAPIError{ 5602 Code: errorCode, 5603 Message: errorMessage, 5604 } 5605 return genericError 5606 5607 } 5608} 5609 5610type awsAwsjson11_deserializeOpListResolverRuleAssociations struct { 5611} 5612 5613func (*awsAwsjson11_deserializeOpListResolverRuleAssociations) ID() string { 5614 return "OperationDeserializer" 5615} 5616 5617func (m *awsAwsjson11_deserializeOpListResolverRuleAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5618 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5619) { 5620 out, metadata, err = next.HandleDeserialize(ctx, in) 5621 if err != nil { 5622 return out, metadata, err 5623 } 5624 5625 response, ok := out.RawResponse.(*smithyhttp.Response) 5626 if !ok { 5627 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5628 } 5629 5630 if response.StatusCode < 200 || response.StatusCode >= 300 { 5631 return out, metadata, awsAwsjson11_deserializeOpErrorListResolverRuleAssociations(response, &metadata) 5632 } 5633 output := &ListResolverRuleAssociationsOutput{} 5634 out.Result = output 5635 5636 var buff [1024]byte 5637 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5638 5639 body := io.TeeReader(response.Body, ringBuffer) 5640 decoder := json.NewDecoder(body) 5641 decoder.UseNumber() 5642 var shape interface{} 5643 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5644 var snapshot bytes.Buffer 5645 io.Copy(&snapshot, ringBuffer) 5646 err = &smithy.DeserializationError{ 5647 Err: fmt.Errorf("failed to decode response body, %w", err), 5648 Snapshot: snapshot.Bytes(), 5649 } 5650 return out, metadata, err 5651 } 5652 5653 err = awsAwsjson11_deserializeOpDocumentListResolverRuleAssociationsOutput(&output, shape) 5654 if err != nil { 5655 var snapshot bytes.Buffer 5656 io.Copy(&snapshot, ringBuffer) 5657 err = &smithy.DeserializationError{ 5658 Err: fmt.Errorf("failed to decode response body, %w", err), 5659 Snapshot: snapshot.Bytes(), 5660 } 5661 return out, metadata, err 5662 } 5663 5664 return out, metadata, err 5665} 5666 5667func awsAwsjson11_deserializeOpErrorListResolverRuleAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5668 var errorBuffer bytes.Buffer 5669 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5670 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5671 } 5672 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5673 5674 errorCode := "UnknownError" 5675 errorMessage := errorCode 5676 5677 code := response.Header.Get("X-Amzn-ErrorType") 5678 if len(code) != 0 { 5679 errorCode = restjson.SanitizeErrorCode(code) 5680 } 5681 5682 var buff [1024]byte 5683 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5684 5685 body := io.TeeReader(errorBody, ringBuffer) 5686 decoder := json.NewDecoder(body) 5687 decoder.UseNumber() 5688 code, message, err := restjson.GetErrorInfo(decoder) 5689 if err != nil { 5690 var snapshot bytes.Buffer 5691 io.Copy(&snapshot, ringBuffer) 5692 err = &smithy.DeserializationError{ 5693 Err: fmt.Errorf("failed to decode response body, %w", err), 5694 Snapshot: snapshot.Bytes(), 5695 } 5696 return err 5697 } 5698 5699 errorBody.Seek(0, io.SeekStart) 5700 if len(code) != 0 { 5701 errorCode = restjson.SanitizeErrorCode(code) 5702 } 5703 if len(message) != 0 { 5704 errorMessage = message 5705 } 5706 5707 switch { 5708 case strings.EqualFold("InternalServiceErrorException", errorCode): 5709 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5710 5711 case strings.EqualFold("InvalidNextTokenException", errorCode): 5712 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 5713 5714 case strings.EqualFold("InvalidParameterException", errorCode): 5715 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5716 5717 case strings.EqualFold("InvalidRequestException", errorCode): 5718 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 5719 5720 case strings.EqualFold("ThrottlingException", errorCode): 5721 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 5722 5723 default: 5724 genericError := &smithy.GenericAPIError{ 5725 Code: errorCode, 5726 Message: errorMessage, 5727 } 5728 return genericError 5729 5730 } 5731} 5732 5733type awsAwsjson11_deserializeOpListResolverRules struct { 5734} 5735 5736func (*awsAwsjson11_deserializeOpListResolverRules) ID() string { 5737 return "OperationDeserializer" 5738} 5739 5740func (m *awsAwsjson11_deserializeOpListResolverRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5741 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5742) { 5743 out, metadata, err = next.HandleDeserialize(ctx, in) 5744 if err != nil { 5745 return out, metadata, err 5746 } 5747 5748 response, ok := out.RawResponse.(*smithyhttp.Response) 5749 if !ok { 5750 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5751 } 5752 5753 if response.StatusCode < 200 || response.StatusCode >= 300 { 5754 return out, metadata, awsAwsjson11_deserializeOpErrorListResolverRules(response, &metadata) 5755 } 5756 output := &ListResolverRulesOutput{} 5757 out.Result = output 5758 5759 var buff [1024]byte 5760 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5761 5762 body := io.TeeReader(response.Body, ringBuffer) 5763 decoder := json.NewDecoder(body) 5764 decoder.UseNumber() 5765 var shape interface{} 5766 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5767 var snapshot bytes.Buffer 5768 io.Copy(&snapshot, ringBuffer) 5769 err = &smithy.DeserializationError{ 5770 Err: fmt.Errorf("failed to decode response body, %w", err), 5771 Snapshot: snapshot.Bytes(), 5772 } 5773 return out, metadata, err 5774 } 5775 5776 err = awsAwsjson11_deserializeOpDocumentListResolverRulesOutput(&output, shape) 5777 if err != nil { 5778 var snapshot bytes.Buffer 5779 io.Copy(&snapshot, ringBuffer) 5780 err = &smithy.DeserializationError{ 5781 Err: fmt.Errorf("failed to decode response body, %w", err), 5782 Snapshot: snapshot.Bytes(), 5783 } 5784 return out, metadata, err 5785 } 5786 5787 return out, metadata, err 5788} 5789 5790func awsAwsjson11_deserializeOpErrorListResolverRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5791 var errorBuffer bytes.Buffer 5792 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5793 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5794 } 5795 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5796 5797 errorCode := "UnknownError" 5798 errorMessage := errorCode 5799 5800 code := response.Header.Get("X-Amzn-ErrorType") 5801 if len(code) != 0 { 5802 errorCode = restjson.SanitizeErrorCode(code) 5803 } 5804 5805 var buff [1024]byte 5806 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5807 5808 body := io.TeeReader(errorBody, ringBuffer) 5809 decoder := json.NewDecoder(body) 5810 decoder.UseNumber() 5811 code, message, err := restjson.GetErrorInfo(decoder) 5812 if err != nil { 5813 var snapshot bytes.Buffer 5814 io.Copy(&snapshot, ringBuffer) 5815 err = &smithy.DeserializationError{ 5816 Err: fmt.Errorf("failed to decode response body, %w", err), 5817 Snapshot: snapshot.Bytes(), 5818 } 5819 return err 5820 } 5821 5822 errorBody.Seek(0, io.SeekStart) 5823 if len(code) != 0 { 5824 errorCode = restjson.SanitizeErrorCode(code) 5825 } 5826 if len(message) != 0 { 5827 errorMessage = message 5828 } 5829 5830 switch { 5831 case strings.EqualFold("InternalServiceErrorException", errorCode): 5832 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5833 5834 case strings.EqualFold("InvalidNextTokenException", errorCode): 5835 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 5836 5837 case strings.EqualFold("InvalidParameterException", errorCode): 5838 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5839 5840 case strings.EqualFold("InvalidRequestException", errorCode): 5841 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 5842 5843 case strings.EqualFold("ThrottlingException", errorCode): 5844 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 5845 5846 default: 5847 genericError := &smithy.GenericAPIError{ 5848 Code: errorCode, 5849 Message: errorMessage, 5850 } 5851 return genericError 5852 5853 } 5854} 5855 5856type awsAwsjson11_deserializeOpListTagsForResource struct { 5857} 5858 5859func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 5860 return "OperationDeserializer" 5861} 5862 5863func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5864 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5865) { 5866 out, metadata, err = next.HandleDeserialize(ctx, in) 5867 if err != nil { 5868 return out, metadata, err 5869 } 5870 5871 response, ok := out.RawResponse.(*smithyhttp.Response) 5872 if !ok { 5873 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5874 } 5875 5876 if response.StatusCode < 200 || response.StatusCode >= 300 { 5877 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 5878 } 5879 output := &ListTagsForResourceOutput{} 5880 out.Result = output 5881 5882 var buff [1024]byte 5883 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5884 5885 body := io.TeeReader(response.Body, ringBuffer) 5886 decoder := json.NewDecoder(body) 5887 decoder.UseNumber() 5888 var shape interface{} 5889 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5890 var snapshot bytes.Buffer 5891 io.Copy(&snapshot, ringBuffer) 5892 err = &smithy.DeserializationError{ 5893 Err: fmt.Errorf("failed to decode response body, %w", err), 5894 Snapshot: snapshot.Bytes(), 5895 } 5896 return out, metadata, err 5897 } 5898 5899 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 5900 if err != nil { 5901 var snapshot bytes.Buffer 5902 io.Copy(&snapshot, ringBuffer) 5903 err = &smithy.DeserializationError{ 5904 Err: fmt.Errorf("failed to decode response body, %w", err), 5905 Snapshot: snapshot.Bytes(), 5906 } 5907 return out, metadata, err 5908 } 5909 5910 return out, metadata, err 5911} 5912 5913func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5914 var errorBuffer bytes.Buffer 5915 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5916 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5917 } 5918 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5919 5920 errorCode := "UnknownError" 5921 errorMessage := errorCode 5922 5923 code := response.Header.Get("X-Amzn-ErrorType") 5924 if len(code) != 0 { 5925 errorCode = restjson.SanitizeErrorCode(code) 5926 } 5927 5928 var buff [1024]byte 5929 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5930 5931 body := io.TeeReader(errorBody, ringBuffer) 5932 decoder := json.NewDecoder(body) 5933 decoder.UseNumber() 5934 code, message, err := restjson.GetErrorInfo(decoder) 5935 if err != nil { 5936 var snapshot bytes.Buffer 5937 io.Copy(&snapshot, ringBuffer) 5938 err = &smithy.DeserializationError{ 5939 Err: fmt.Errorf("failed to decode response body, %w", err), 5940 Snapshot: snapshot.Bytes(), 5941 } 5942 return err 5943 } 5944 5945 errorBody.Seek(0, io.SeekStart) 5946 if len(code) != 0 { 5947 errorCode = restjson.SanitizeErrorCode(code) 5948 } 5949 if len(message) != 0 { 5950 errorMessage = message 5951 } 5952 5953 switch { 5954 case strings.EqualFold("InternalServiceErrorException", errorCode): 5955 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5956 5957 case strings.EqualFold("InvalidNextTokenException", errorCode): 5958 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 5959 5960 case strings.EqualFold("InvalidParameterException", errorCode): 5961 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5962 5963 case strings.EqualFold("InvalidRequestException", errorCode): 5964 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 5965 5966 case strings.EqualFold("ResourceNotFoundException", errorCode): 5967 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5968 5969 case strings.EqualFold("ThrottlingException", errorCode): 5970 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 5971 5972 default: 5973 genericError := &smithy.GenericAPIError{ 5974 Code: errorCode, 5975 Message: errorMessage, 5976 } 5977 return genericError 5978 5979 } 5980} 5981 5982type awsAwsjson11_deserializeOpPutFirewallRuleGroupPolicy struct { 5983} 5984 5985func (*awsAwsjson11_deserializeOpPutFirewallRuleGroupPolicy) ID() string { 5986 return "OperationDeserializer" 5987} 5988 5989func (m *awsAwsjson11_deserializeOpPutFirewallRuleGroupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5990 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5991) { 5992 out, metadata, err = next.HandleDeserialize(ctx, in) 5993 if err != nil { 5994 return out, metadata, err 5995 } 5996 5997 response, ok := out.RawResponse.(*smithyhttp.Response) 5998 if !ok { 5999 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6000 } 6001 6002 if response.StatusCode < 200 || response.StatusCode >= 300 { 6003 return out, metadata, awsAwsjson11_deserializeOpErrorPutFirewallRuleGroupPolicy(response, &metadata) 6004 } 6005 output := &PutFirewallRuleGroupPolicyOutput{} 6006 out.Result = output 6007 6008 var buff [1024]byte 6009 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6010 6011 body := io.TeeReader(response.Body, ringBuffer) 6012 decoder := json.NewDecoder(body) 6013 decoder.UseNumber() 6014 var shape interface{} 6015 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6016 var snapshot bytes.Buffer 6017 io.Copy(&snapshot, ringBuffer) 6018 err = &smithy.DeserializationError{ 6019 Err: fmt.Errorf("failed to decode response body, %w", err), 6020 Snapshot: snapshot.Bytes(), 6021 } 6022 return out, metadata, err 6023 } 6024 6025 err = awsAwsjson11_deserializeOpDocumentPutFirewallRuleGroupPolicyOutput(&output, shape) 6026 if err != nil { 6027 var snapshot bytes.Buffer 6028 io.Copy(&snapshot, ringBuffer) 6029 err = &smithy.DeserializationError{ 6030 Err: fmt.Errorf("failed to decode response body, %w", err), 6031 Snapshot: snapshot.Bytes(), 6032 } 6033 return out, metadata, err 6034 } 6035 6036 return out, metadata, err 6037} 6038 6039func awsAwsjson11_deserializeOpErrorPutFirewallRuleGroupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6040 var errorBuffer bytes.Buffer 6041 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6042 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6043 } 6044 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6045 6046 errorCode := "UnknownError" 6047 errorMessage := errorCode 6048 6049 code := response.Header.Get("X-Amzn-ErrorType") 6050 if len(code) != 0 { 6051 errorCode = restjson.SanitizeErrorCode(code) 6052 } 6053 6054 var buff [1024]byte 6055 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6056 6057 body := io.TeeReader(errorBody, ringBuffer) 6058 decoder := json.NewDecoder(body) 6059 decoder.UseNumber() 6060 code, message, err := restjson.GetErrorInfo(decoder) 6061 if err != nil { 6062 var snapshot bytes.Buffer 6063 io.Copy(&snapshot, ringBuffer) 6064 err = &smithy.DeserializationError{ 6065 Err: fmt.Errorf("failed to decode response body, %w", err), 6066 Snapshot: snapshot.Bytes(), 6067 } 6068 return err 6069 } 6070 6071 errorBody.Seek(0, io.SeekStart) 6072 if len(code) != 0 { 6073 errorCode = restjson.SanitizeErrorCode(code) 6074 } 6075 if len(message) != 0 { 6076 errorMessage = message 6077 } 6078 6079 switch { 6080 case strings.EqualFold("AccessDeniedException", errorCode): 6081 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6082 6083 case strings.EqualFold("InternalServiceErrorException", errorCode): 6084 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 6085 6086 case strings.EqualFold("ResourceNotFoundException", errorCode): 6087 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6088 6089 case strings.EqualFold("ThrottlingException", errorCode): 6090 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 6091 6092 case strings.EqualFold("ValidationException", errorCode): 6093 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 6094 6095 default: 6096 genericError := &smithy.GenericAPIError{ 6097 Code: errorCode, 6098 Message: errorMessage, 6099 } 6100 return genericError 6101 6102 } 6103} 6104 6105type awsAwsjson11_deserializeOpPutResolverQueryLogConfigPolicy struct { 6106} 6107 6108func (*awsAwsjson11_deserializeOpPutResolverQueryLogConfigPolicy) ID() string { 6109 return "OperationDeserializer" 6110} 6111 6112func (m *awsAwsjson11_deserializeOpPutResolverQueryLogConfigPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6113 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6114) { 6115 out, metadata, err = next.HandleDeserialize(ctx, in) 6116 if err != nil { 6117 return out, metadata, err 6118 } 6119 6120 response, ok := out.RawResponse.(*smithyhttp.Response) 6121 if !ok { 6122 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6123 } 6124 6125 if response.StatusCode < 200 || response.StatusCode >= 300 { 6126 return out, metadata, awsAwsjson11_deserializeOpErrorPutResolverQueryLogConfigPolicy(response, &metadata) 6127 } 6128 output := &PutResolverQueryLogConfigPolicyOutput{} 6129 out.Result = output 6130 6131 var buff [1024]byte 6132 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6133 6134 body := io.TeeReader(response.Body, ringBuffer) 6135 decoder := json.NewDecoder(body) 6136 decoder.UseNumber() 6137 var shape interface{} 6138 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6139 var snapshot bytes.Buffer 6140 io.Copy(&snapshot, ringBuffer) 6141 err = &smithy.DeserializationError{ 6142 Err: fmt.Errorf("failed to decode response body, %w", err), 6143 Snapshot: snapshot.Bytes(), 6144 } 6145 return out, metadata, err 6146 } 6147 6148 err = awsAwsjson11_deserializeOpDocumentPutResolverQueryLogConfigPolicyOutput(&output, shape) 6149 if err != nil { 6150 var snapshot bytes.Buffer 6151 io.Copy(&snapshot, ringBuffer) 6152 err = &smithy.DeserializationError{ 6153 Err: fmt.Errorf("failed to decode response body, %w", err), 6154 Snapshot: snapshot.Bytes(), 6155 } 6156 return out, metadata, err 6157 } 6158 6159 return out, metadata, err 6160} 6161 6162func awsAwsjson11_deserializeOpErrorPutResolverQueryLogConfigPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6163 var errorBuffer bytes.Buffer 6164 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6165 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6166 } 6167 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6168 6169 errorCode := "UnknownError" 6170 errorMessage := errorCode 6171 6172 code := response.Header.Get("X-Amzn-ErrorType") 6173 if len(code) != 0 { 6174 errorCode = restjson.SanitizeErrorCode(code) 6175 } 6176 6177 var buff [1024]byte 6178 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6179 6180 body := io.TeeReader(errorBody, ringBuffer) 6181 decoder := json.NewDecoder(body) 6182 decoder.UseNumber() 6183 code, message, err := restjson.GetErrorInfo(decoder) 6184 if err != nil { 6185 var snapshot bytes.Buffer 6186 io.Copy(&snapshot, ringBuffer) 6187 err = &smithy.DeserializationError{ 6188 Err: fmt.Errorf("failed to decode response body, %w", err), 6189 Snapshot: snapshot.Bytes(), 6190 } 6191 return err 6192 } 6193 6194 errorBody.Seek(0, io.SeekStart) 6195 if len(code) != 0 { 6196 errorCode = restjson.SanitizeErrorCode(code) 6197 } 6198 if len(message) != 0 { 6199 errorMessage = message 6200 } 6201 6202 switch { 6203 case strings.EqualFold("AccessDeniedException", errorCode): 6204 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6205 6206 case strings.EqualFold("InternalServiceErrorException", errorCode): 6207 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 6208 6209 case strings.EqualFold("InvalidParameterException", errorCode): 6210 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 6211 6212 case strings.EqualFold("InvalidPolicyDocument", errorCode): 6213 return awsAwsjson11_deserializeErrorInvalidPolicyDocument(response, errorBody) 6214 6215 case strings.EqualFold("InvalidRequestException", errorCode): 6216 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 6217 6218 case strings.EqualFold("UnknownResourceException", errorCode): 6219 return awsAwsjson11_deserializeErrorUnknownResourceException(response, errorBody) 6220 6221 default: 6222 genericError := &smithy.GenericAPIError{ 6223 Code: errorCode, 6224 Message: errorMessage, 6225 } 6226 return genericError 6227 6228 } 6229} 6230 6231type awsAwsjson11_deserializeOpPutResolverRulePolicy struct { 6232} 6233 6234func (*awsAwsjson11_deserializeOpPutResolverRulePolicy) ID() string { 6235 return "OperationDeserializer" 6236} 6237 6238func (m *awsAwsjson11_deserializeOpPutResolverRulePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6239 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6240) { 6241 out, metadata, err = next.HandleDeserialize(ctx, in) 6242 if err != nil { 6243 return out, metadata, err 6244 } 6245 6246 response, ok := out.RawResponse.(*smithyhttp.Response) 6247 if !ok { 6248 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6249 } 6250 6251 if response.StatusCode < 200 || response.StatusCode >= 300 { 6252 return out, metadata, awsAwsjson11_deserializeOpErrorPutResolverRulePolicy(response, &metadata) 6253 } 6254 output := &PutResolverRulePolicyOutput{} 6255 out.Result = output 6256 6257 var buff [1024]byte 6258 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6259 6260 body := io.TeeReader(response.Body, ringBuffer) 6261 decoder := json.NewDecoder(body) 6262 decoder.UseNumber() 6263 var shape interface{} 6264 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6265 var snapshot bytes.Buffer 6266 io.Copy(&snapshot, ringBuffer) 6267 err = &smithy.DeserializationError{ 6268 Err: fmt.Errorf("failed to decode response body, %w", err), 6269 Snapshot: snapshot.Bytes(), 6270 } 6271 return out, metadata, err 6272 } 6273 6274 err = awsAwsjson11_deserializeOpDocumentPutResolverRulePolicyOutput(&output, shape) 6275 if err != nil { 6276 var snapshot bytes.Buffer 6277 io.Copy(&snapshot, ringBuffer) 6278 err = &smithy.DeserializationError{ 6279 Err: fmt.Errorf("failed to decode response body, %w", err), 6280 Snapshot: snapshot.Bytes(), 6281 } 6282 return out, metadata, err 6283 } 6284 6285 return out, metadata, err 6286} 6287 6288func awsAwsjson11_deserializeOpErrorPutResolverRulePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6289 var errorBuffer bytes.Buffer 6290 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6291 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6292 } 6293 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6294 6295 errorCode := "UnknownError" 6296 errorMessage := errorCode 6297 6298 code := response.Header.Get("X-Amzn-ErrorType") 6299 if len(code) != 0 { 6300 errorCode = restjson.SanitizeErrorCode(code) 6301 } 6302 6303 var buff [1024]byte 6304 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6305 6306 body := io.TeeReader(errorBody, ringBuffer) 6307 decoder := json.NewDecoder(body) 6308 decoder.UseNumber() 6309 code, message, err := restjson.GetErrorInfo(decoder) 6310 if err != nil { 6311 var snapshot bytes.Buffer 6312 io.Copy(&snapshot, ringBuffer) 6313 err = &smithy.DeserializationError{ 6314 Err: fmt.Errorf("failed to decode response body, %w", err), 6315 Snapshot: snapshot.Bytes(), 6316 } 6317 return err 6318 } 6319 6320 errorBody.Seek(0, io.SeekStart) 6321 if len(code) != 0 { 6322 errorCode = restjson.SanitizeErrorCode(code) 6323 } 6324 if len(message) != 0 { 6325 errorMessage = message 6326 } 6327 6328 switch { 6329 case strings.EqualFold("InternalServiceErrorException", errorCode): 6330 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 6331 6332 case strings.EqualFold("InvalidParameterException", errorCode): 6333 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 6334 6335 case strings.EqualFold("InvalidPolicyDocument", errorCode): 6336 return awsAwsjson11_deserializeErrorInvalidPolicyDocument(response, errorBody) 6337 6338 case strings.EqualFold("UnknownResourceException", errorCode): 6339 return awsAwsjson11_deserializeErrorUnknownResourceException(response, errorBody) 6340 6341 default: 6342 genericError := &smithy.GenericAPIError{ 6343 Code: errorCode, 6344 Message: errorMessage, 6345 } 6346 return genericError 6347 6348 } 6349} 6350 6351type awsAwsjson11_deserializeOpTagResource struct { 6352} 6353 6354func (*awsAwsjson11_deserializeOpTagResource) ID() string { 6355 return "OperationDeserializer" 6356} 6357 6358func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6359 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6360) { 6361 out, metadata, err = next.HandleDeserialize(ctx, in) 6362 if err != nil { 6363 return out, metadata, err 6364 } 6365 6366 response, ok := out.RawResponse.(*smithyhttp.Response) 6367 if !ok { 6368 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6369 } 6370 6371 if response.StatusCode < 200 || response.StatusCode >= 300 { 6372 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 6373 } 6374 output := &TagResourceOutput{} 6375 out.Result = output 6376 6377 var buff [1024]byte 6378 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6379 6380 body := io.TeeReader(response.Body, ringBuffer) 6381 decoder := json.NewDecoder(body) 6382 decoder.UseNumber() 6383 var shape interface{} 6384 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6385 var snapshot bytes.Buffer 6386 io.Copy(&snapshot, ringBuffer) 6387 err = &smithy.DeserializationError{ 6388 Err: fmt.Errorf("failed to decode response body, %w", err), 6389 Snapshot: snapshot.Bytes(), 6390 } 6391 return out, metadata, err 6392 } 6393 6394 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 6395 if err != nil { 6396 var snapshot bytes.Buffer 6397 io.Copy(&snapshot, ringBuffer) 6398 err = &smithy.DeserializationError{ 6399 Err: fmt.Errorf("failed to decode response body, %w", err), 6400 Snapshot: snapshot.Bytes(), 6401 } 6402 return out, metadata, err 6403 } 6404 6405 return out, metadata, err 6406} 6407 6408func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6409 var errorBuffer bytes.Buffer 6410 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6411 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6412 } 6413 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6414 6415 errorCode := "UnknownError" 6416 errorMessage := errorCode 6417 6418 code := response.Header.Get("X-Amzn-ErrorType") 6419 if len(code) != 0 { 6420 errorCode = restjson.SanitizeErrorCode(code) 6421 } 6422 6423 var buff [1024]byte 6424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6425 6426 body := io.TeeReader(errorBody, ringBuffer) 6427 decoder := json.NewDecoder(body) 6428 decoder.UseNumber() 6429 code, message, err := restjson.GetErrorInfo(decoder) 6430 if err != nil { 6431 var snapshot bytes.Buffer 6432 io.Copy(&snapshot, ringBuffer) 6433 err = &smithy.DeserializationError{ 6434 Err: fmt.Errorf("failed to decode response body, %w", err), 6435 Snapshot: snapshot.Bytes(), 6436 } 6437 return err 6438 } 6439 6440 errorBody.Seek(0, io.SeekStart) 6441 if len(code) != 0 { 6442 errorCode = restjson.SanitizeErrorCode(code) 6443 } 6444 if len(message) != 0 { 6445 errorMessage = message 6446 } 6447 6448 switch { 6449 case strings.EqualFold("InternalServiceErrorException", errorCode): 6450 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 6451 6452 case strings.EqualFold("InvalidParameterException", errorCode): 6453 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 6454 6455 case strings.EqualFold("InvalidRequestException", errorCode): 6456 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 6457 6458 case strings.EqualFold("InvalidTagException", errorCode): 6459 return awsAwsjson11_deserializeErrorInvalidTagException(response, errorBody) 6460 6461 case strings.EqualFold("LimitExceededException", errorCode): 6462 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 6463 6464 case strings.EqualFold("ResourceNotFoundException", errorCode): 6465 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6466 6467 case strings.EqualFold("ThrottlingException", errorCode): 6468 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 6469 6470 default: 6471 genericError := &smithy.GenericAPIError{ 6472 Code: errorCode, 6473 Message: errorMessage, 6474 } 6475 return genericError 6476 6477 } 6478} 6479 6480type awsAwsjson11_deserializeOpUntagResource struct { 6481} 6482 6483func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 6484 return "OperationDeserializer" 6485} 6486 6487func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6488 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6489) { 6490 out, metadata, err = next.HandleDeserialize(ctx, in) 6491 if err != nil { 6492 return out, metadata, err 6493 } 6494 6495 response, ok := out.RawResponse.(*smithyhttp.Response) 6496 if !ok { 6497 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6498 } 6499 6500 if response.StatusCode < 200 || response.StatusCode >= 300 { 6501 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 6502 } 6503 output := &UntagResourceOutput{} 6504 out.Result = output 6505 6506 var buff [1024]byte 6507 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6508 6509 body := io.TeeReader(response.Body, ringBuffer) 6510 decoder := json.NewDecoder(body) 6511 decoder.UseNumber() 6512 var shape interface{} 6513 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6514 var snapshot bytes.Buffer 6515 io.Copy(&snapshot, ringBuffer) 6516 err = &smithy.DeserializationError{ 6517 Err: fmt.Errorf("failed to decode response body, %w", err), 6518 Snapshot: snapshot.Bytes(), 6519 } 6520 return out, metadata, err 6521 } 6522 6523 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 6524 if err != nil { 6525 var snapshot bytes.Buffer 6526 io.Copy(&snapshot, ringBuffer) 6527 err = &smithy.DeserializationError{ 6528 Err: fmt.Errorf("failed to decode response body, %w", err), 6529 Snapshot: snapshot.Bytes(), 6530 } 6531 return out, metadata, err 6532 } 6533 6534 return out, metadata, err 6535} 6536 6537func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6538 var errorBuffer bytes.Buffer 6539 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6540 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6541 } 6542 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6543 6544 errorCode := "UnknownError" 6545 errorMessage := errorCode 6546 6547 code := response.Header.Get("X-Amzn-ErrorType") 6548 if len(code) != 0 { 6549 errorCode = restjson.SanitizeErrorCode(code) 6550 } 6551 6552 var buff [1024]byte 6553 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6554 6555 body := io.TeeReader(errorBody, ringBuffer) 6556 decoder := json.NewDecoder(body) 6557 decoder.UseNumber() 6558 code, message, err := restjson.GetErrorInfo(decoder) 6559 if err != nil { 6560 var snapshot bytes.Buffer 6561 io.Copy(&snapshot, ringBuffer) 6562 err = &smithy.DeserializationError{ 6563 Err: fmt.Errorf("failed to decode response body, %w", err), 6564 Snapshot: snapshot.Bytes(), 6565 } 6566 return err 6567 } 6568 6569 errorBody.Seek(0, io.SeekStart) 6570 if len(code) != 0 { 6571 errorCode = restjson.SanitizeErrorCode(code) 6572 } 6573 if len(message) != 0 { 6574 errorMessage = message 6575 } 6576 6577 switch { 6578 case strings.EqualFold("InternalServiceErrorException", errorCode): 6579 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 6580 6581 case strings.EqualFold("InvalidParameterException", errorCode): 6582 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 6583 6584 case strings.EqualFold("InvalidRequestException", errorCode): 6585 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 6586 6587 case strings.EqualFold("ResourceNotFoundException", errorCode): 6588 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6589 6590 case strings.EqualFold("ThrottlingException", errorCode): 6591 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 6592 6593 default: 6594 genericError := &smithy.GenericAPIError{ 6595 Code: errorCode, 6596 Message: errorMessage, 6597 } 6598 return genericError 6599 6600 } 6601} 6602 6603type awsAwsjson11_deserializeOpUpdateFirewallConfig struct { 6604} 6605 6606func (*awsAwsjson11_deserializeOpUpdateFirewallConfig) ID() string { 6607 return "OperationDeserializer" 6608} 6609 6610func (m *awsAwsjson11_deserializeOpUpdateFirewallConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6611 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6612) { 6613 out, metadata, err = next.HandleDeserialize(ctx, in) 6614 if err != nil { 6615 return out, metadata, err 6616 } 6617 6618 response, ok := out.RawResponse.(*smithyhttp.Response) 6619 if !ok { 6620 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6621 } 6622 6623 if response.StatusCode < 200 || response.StatusCode >= 300 { 6624 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateFirewallConfig(response, &metadata) 6625 } 6626 output := &UpdateFirewallConfigOutput{} 6627 out.Result = output 6628 6629 var buff [1024]byte 6630 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6631 6632 body := io.TeeReader(response.Body, ringBuffer) 6633 decoder := json.NewDecoder(body) 6634 decoder.UseNumber() 6635 var shape interface{} 6636 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6637 var snapshot bytes.Buffer 6638 io.Copy(&snapshot, ringBuffer) 6639 err = &smithy.DeserializationError{ 6640 Err: fmt.Errorf("failed to decode response body, %w", err), 6641 Snapshot: snapshot.Bytes(), 6642 } 6643 return out, metadata, err 6644 } 6645 6646 err = awsAwsjson11_deserializeOpDocumentUpdateFirewallConfigOutput(&output, shape) 6647 if err != nil { 6648 var snapshot bytes.Buffer 6649 io.Copy(&snapshot, ringBuffer) 6650 err = &smithy.DeserializationError{ 6651 Err: fmt.Errorf("failed to decode response body, %w", err), 6652 Snapshot: snapshot.Bytes(), 6653 } 6654 return out, metadata, err 6655 } 6656 6657 return out, metadata, err 6658} 6659 6660func awsAwsjson11_deserializeOpErrorUpdateFirewallConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6661 var errorBuffer bytes.Buffer 6662 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6663 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6664 } 6665 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6666 6667 errorCode := "UnknownError" 6668 errorMessage := errorCode 6669 6670 code := response.Header.Get("X-Amzn-ErrorType") 6671 if len(code) != 0 { 6672 errorCode = restjson.SanitizeErrorCode(code) 6673 } 6674 6675 var buff [1024]byte 6676 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6677 6678 body := io.TeeReader(errorBody, ringBuffer) 6679 decoder := json.NewDecoder(body) 6680 decoder.UseNumber() 6681 code, message, err := restjson.GetErrorInfo(decoder) 6682 if err != nil { 6683 var snapshot bytes.Buffer 6684 io.Copy(&snapshot, ringBuffer) 6685 err = &smithy.DeserializationError{ 6686 Err: fmt.Errorf("failed to decode response body, %w", err), 6687 Snapshot: snapshot.Bytes(), 6688 } 6689 return err 6690 } 6691 6692 errorBody.Seek(0, io.SeekStart) 6693 if len(code) != 0 { 6694 errorCode = restjson.SanitizeErrorCode(code) 6695 } 6696 if len(message) != 0 { 6697 errorMessage = message 6698 } 6699 6700 switch { 6701 case strings.EqualFold("AccessDeniedException", errorCode): 6702 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6703 6704 case strings.EqualFold("InternalServiceErrorException", errorCode): 6705 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 6706 6707 case strings.EqualFold("ResourceNotFoundException", errorCode): 6708 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6709 6710 case strings.EqualFold("ThrottlingException", errorCode): 6711 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 6712 6713 case strings.EqualFold("ValidationException", errorCode): 6714 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 6715 6716 default: 6717 genericError := &smithy.GenericAPIError{ 6718 Code: errorCode, 6719 Message: errorMessage, 6720 } 6721 return genericError 6722 6723 } 6724} 6725 6726type awsAwsjson11_deserializeOpUpdateFirewallDomains struct { 6727} 6728 6729func (*awsAwsjson11_deserializeOpUpdateFirewallDomains) ID() string { 6730 return "OperationDeserializer" 6731} 6732 6733func (m *awsAwsjson11_deserializeOpUpdateFirewallDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6734 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6735) { 6736 out, metadata, err = next.HandleDeserialize(ctx, in) 6737 if err != nil { 6738 return out, metadata, err 6739 } 6740 6741 response, ok := out.RawResponse.(*smithyhttp.Response) 6742 if !ok { 6743 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6744 } 6745 6746 if response.StatusCode < 200 || response.StatusCode >= 300 { 6747 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateFirewallDomains(response, &metadata) 6748 } 6749 output := &UpdateFirewallDomainsOutput{} 6750 out.Result = output 6751 6752 var buff [1024]byte 6753 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6754 6755 body := io.TeeReader(response.Body, ringBuffer) 6756 decoder := json.NewDecoder(body) 6757 decoder.UseNumber() 6758 var shape interface{} 6759 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6760 var snapshot bytes.Buffer 6761 io.Copy(&snapshot, ringBuffer) 6762 err = &smithy.DeserializationError{ 6763 Err: fmt.Errorf("failed to decode response body, %w", err), 6764 Snapshot: snapshot.Bytes(), 6765 } 6766 return out, metadata, err 6767 } 6768 6769 err = awsAwsjson11_deserializeOpDocumentUpdateFirewallDomainsOutput(&output, shape) 6770 if err != nil { 6771 var snapshot bytes.Buffer 6772 io.Copy(&snapshot, ringBuffer) 6773 err = &smithy.DeserializationError{ 6774 Err: fmt.Errorf("failed to decode response body, %w", err), 6775 Snapshot: snapshot.Bytes(), 6776 } 6777 return out, metadata, err 6778 } 6779 6780 return out, metadata, err 6781} 6782 6783func awsAwsjson11_deserializeOpErrorUpdateFirewallDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6784 var errorBuffer bytes.Buffer 6785 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6786 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6787 } 6788 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6789 6790 errorCode := "UnknownError" 6791 errorMessage := errorCode 6792 6793 code := response.Header.Get("X-Amzn-ErrorType") 6794 if len(code) != 0 { 6795 errorCode = restjson.SanitizeErrorCode(code) 6796 } 6797 6798 var buff [1024]byte 6799 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6800 6801 body := io.TeeReader(errorBody, ringBuffer) 6802 decoder := json.NewDecoder(body) 6803 decoder.UseNumber() 6804 code, message, err := restjson.GetErrorInfo(decoder) 6805 if err != nil { 6806 var snapshot bytes.Buffer 6807 io.Copy(&snapshot, ringBuffer) 6808 err = &smithy.DeserializationError{ 6809 Err: fmt.Errorf("failed to decode response body, %w", err), 6810 Snapshot: snapshot.Bytes(), 6811 } 6812 return err 6813 } 6814 6815 errorBody.Seek(0, io.SeekStart) 6816 if len(code) != 0 { 6817 errorCode = restjson.SanitizeErrorCode(code) 6818 } 6819 if len(message) != 0 { 6820 errorMessage = message 6821 } 6822 6823 switch { 6824 case strings.EqualFold("AccessDeniedException", errorCode): 6825 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6826 6827 case strings.EqualFold("ConflictException", errorCode): 6828 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 6829 6830 case strings.EqualFold("InternalServiceErrorException", errorCode): 6831 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 6832 6833 case strings.EqualFold("LimitExceededException", errorCode): 6834 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 6835 6836 case strings.EqualFold("ResourceNotFoundException", errorCode): 6837 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6838 6839 case strings.EqualFold("ThrottlingException", errorCode): 6840 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 6841 6842 case strings.EqualFold("ValidationException", errorCode): 6843 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 6844 6845 default: 6846 genericError := &smithy.GenericAPIError{ 6847 Code: errorCode, 6848 Message: errorMessage, 6849 } 6850 return genericError 6851 6852 } 6853} 6854 6855type awsAwsjson11_deserializeOpUpdateFirewallRule struct { 6856} 6857 6858func (*awsAwsjson11_deserializeOpUpdateFirewallRule) ID() string { 6859 return "OperationDeserializer" 6860} 6861 6862func (m *awsAwsjson11_deserializeOpUpdateFirewallRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6863 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6864) { 6865 out, metadata, err = next.HandleDeserialize(ctx, in) 6866 if err != nil { 6867 return out, metadata, err 6868 } 6869 6870 response, ok := out.RawResponse.(*smithyhttp.Response) 6871 if !ok { 6872 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6873 } 6874 6875 if response.StatusCode < 200 || response.StatusCode >= 300 { 6876 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateFirewallRule(response, &metadata) 6877 } 6878 output := &UpdateFirewallRuleOutput{} 6879 out.Result = output 6880 6881 var buff [1024]byte 6882 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6883 6884 body := io.TeeReader(response.Body, ringBuffer) 6885 decoder := json.NewDecoder(body) 6886 decoder.UseNumber() 6887 var shape interface{} 6888 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6889 var snapshot bytes.Buffer 6890 io.Copy(&snapshot, ringBuffer) 6891 err = &smithy.DeserializationError{ 6892 Err: fmt.Errorf("failed to decode response body, %w", err), 6893 Snapshot: snapshot.Bytes(), 6894 } 6895 return out, metadata, err 6896 } 6897 6898 err = awsAwsjson11_deserializeOpDocumentUpdateFirewallRuleOutput(&output, shape) 6899 if err != nil { 6900 var snapshot bytes.Buffer 6901 io.Copy(&snapshot, ringBuffer) 6902 err = &smithy.DeserializationError{ 6903 Err: fmt.Errorf("failed to decode response body, %w", err), 6904 Snapshot: snapshot.Bytes(), 6905 } 6906 return out, metadata, err 6907 } 6908 6909 return out, metadata, err 6910} 6911 6912func awsAwsjson11_deserializeOpErrorUpdateFirewallRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6913 var errorBuffer bytes.Buffer 6914 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6915 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6916 } 6917 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6918 6919 errorCode := "UnknownError" 6920 errorMessage := errorCode 6921 6922 code := response.Header.Get("X-Amzn-ErrorType") 6923 if len(code) != 0 { 6924 errorCode = restjson.SanitizeErrorCode(code) 6925 } 6926 6927 var buff [1024]byte 6928 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6929 6930 body := io.TeeReader(errorBody, ringBuffer) 6931 decoder := json.NewDecoder(body) 6932 decoder.UseNumber() 6933 code, message, err := restjson.GetErrorInfo(decoder) 6934 if err != nil { 6935 var snapshot bytes.Buffer 6936 io.Copy(&snapshot, ringBuffer) 6937 err = &smithy.DeserializationError{ 6938 Err: fmt.Errorf("failed to decode response body, %w", err), 6939 Snapshot: snapshot.Bytes(), 6940 } 6941 return err 6942 } 6943 6944 errorBody.Seek(0, io.SeekStart) 6945 if len(code) != 0 { 6946 errorCode = restjson.SanitizeErrorCode(code) 6947 } 6948 if len(message) != 0 { 6949 errorMessage = message 6950 } 6951 6952 switch { 6953 case strings.EqualFold("AccessDeniedException", errorCode): 6954 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6955 6956 case strings.EqualFold("ConflictException", errorCode): 6957 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 6958 6959 case strings.EqualFold("InternalServiceErrorException", errorCode): 6960 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 6961 6962 case strings.EqualFold("ResourceNotFoundException", errorCode): 6963 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6964 6965 case strings.EqualFold("ThrottlingException", errorCode): 6966 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 6967 6968 case strings.EqualFold("ValidationException", errorCode): 6969 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 6970 6971 default: 6972 genericError := &smithy.GenericAPIError{ 6973 Code: errorCode, 6974 Message: errorMessage, 6975 } 6976 return genericError 6977 6978 } 6979} 6980 6981type awsAwsjson11_deserializeOpUpdateFirewallRuleGroupAssociation struct { 6982} 6983 6984func (*awsAwsjson11_deserializeOpUpdateFirewallRuleGroupAssociation) ID() string { 6985 return "OperationDeserializer" 6986} 6987 6988func (m *awsAwsjson11_deserializeOpUpdateFirewallRuleGroupAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6989 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6990) { 6991 out, metadata, err = next.HandleDeserialize(ctx, in) 6992 if err != nil { 6993 return out, metadata, err 6994 } 6995 6996 response, ok := out.RawResponse.(*smithyhttp.Response) 6997 if !ok { 6998 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6999 } 7000 7001 if response.StatusCode < 200 || response.StatusCode >= 300 { 7002 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateFirewallRuleGroupAssociation(response, &metadata) 7003 } 7004 output := &UpdateFirewallRuleGroupAssociationOutput{} 7005 out.Result = output 7006 7007 var buff [1024]byte 7008 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7009 7010 body := io.TeeReader(response.Body, ringBuffer) 7011 decoder := json.NewDecoder(body) 7012 decoder.UseNumber() 7013 var shape interface{} 7014 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7015 var snapshot bytes.Buffer 7016 io.Copy(&snapshot, ringBuffer) 7017 err = &smithy.DeserializationError{ 7018 Err: fmt.Errorf("failed to decode response body, %w", err), 7019 Snapshot: snapshot.Bytes(), 7020 } 7021 return out, metadata, err 7022 } 7023 7024 err = awsAwsjson11_deserializeOpDocumentUpdateFirewallRuleGroupAssociationOutput(&output, shape) 7025 if err != nil { 7026 var snapshot bytes.Buffer 7027 io.Copy(&snapshot, ringBuffer) 7028 err = &smithy.DeserializationError{ 7029 Err: fmt.Errorf("failed to decode response body, %w", err), 7030 Snapshot: snapshot.Bytes(), 7031 } 7032 return out, metadata, err 7033 } 7034 7035 return out, metadata, err 7036} 7037 7038func awsAwsjson11_deserializeOpErrorUpdateFirewallRuleGroupAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7039 var errorBuffer bytes.Buffer 7040 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7041 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7042 } 7043 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7044 7045 errorCode := "UnknownError" 7046 errorMessage := errorCode 7047 7048 code := response.Header.Get("X-Amzn-ErrorType") 7049 if len(code) != 0 { 7050 errorCode = restjson.SanitizeErrorCode(code) 7051 } 7052 7053 var buff [1024]byte 7054 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7055 7056 body := io.TeeReader(errorBody, ringBuffer) 7057 decoder := json.NewDecoder(body) 7058 decoder.UseNumber() 7059 code, message, err := restjson.GetErrorInfo(decoder) 7060 if err != nil { 7061 var snapshot bytes.Buffer 7062 io.Copy(&snapshot, ringBuffer) 7063 err = &smithy.DeserializationError{ 7064 Err: fmt.Errorf("failed to decode response body, %w", err), 7065 Snapshot: snapshot.Bytes(), 7066 } 7067 return err 7068 } 7069 7070 errorBody.Seek(0, io.SeekStart) 7071 if len(code) != 0 { 7072 errorCode = restjson.SanitizeErrorCode(code) 7073 } 7074 if len(message) != 0 { 7075 errorMessage = message 7076 } 7077 7078 switch { 7079 case strings.EqualFold("AccessDeniedException", errorCode): 7080 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 7081 7082 case strings.EqualFold("ConflictException", errorCode): 7083 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 7084 7085 case strings.EqualFold("InternalServiceErrorException", errorCode): 7086 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 7087 7088 case strings.EqualFold("ResourceNotFoundException", errorCode): 7089 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7090 7091 case strings.EqualFold("ThrottlingException", errorCode): 7092 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 7093 7094 case strings.EqualFold("ValidationException", errorCode): 7095 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 7096 7097 default: 7098 genericError := &smithy.GenericAPIError{ 7099 Code: errorCode, 7100 Message: errorMessage, 7101 } 7102 return genericError 7103 7104 } 7105} 7106 7107type awsAwsjson11_deserializeOpUpdateResolverDnssecConfig struct { 7108} 7109 7110func (*awsAwsjson11_deserializeOpUpdateResolverDnssecConfig) ID() string { 7111 return "OperationDeserializer" 7112} 7113 7114func (m *awsAwsjson11_deserializeOpUpdateResolverDnssecConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7115 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7116) { 7117 out, metadata, err = next.HandleDeserialize(ctx, in) 7118 if err != nil { 7119 return out, metadata, err 7120 } 7121 7122 response, ok := out.RawResponse.(*smithyhttp.Response) 7123 if !ok { 7124 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7125 } 7126 7127 if response.StatusCode < 200 || response.StatusCode >= 300 { 7128 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateResolverDnssecConfig(response, &metadata) 7129 } 7130 output := &UpdateResolverDnssecConfigOutput{} 7131 out.Result = output 7132 7133 var buff [1024]byte 7134 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7135 7136 body := io.TeeReader(response.Body, ringBuffer) 7137 decoder := json.NewDecoder(body) 7138 decoder.UseNumber() 7139 var shape interface{} 7140 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7141 var snapshot bytes.Buffer 7142 io.Copy(&snapshot, ringBuffer) 7143 err = &smithy.DeserializationError{ 7144 Err: fmt.Errorf("failed to decode response body, %w", err), 7145 Snapshot: snapshot.Bytes(), 7146 } 7147 return out, metadata, err 7148 } 7149 7150 err = awsAwsjson11_deserializeOpDocumentUpdateResolverDnssecConfigOutput(&output, shape) 7151 if err != nil { 7152 var snapshot bytes.Buffer 7153 io.Copy(&snapshot, ringBuffer) 7154 err = &smithy.DeserializationError{ 7155 Err: fmt.Errorf("failed to decode response body, %w", err), 7156 Snapshot: snapshot.Bytes(), 7157 } 7158 return out, metadata, err 7159 } 7160 7161 return out, metadata, err 7162} 7163 7164func awsAwsjson11_deserializeOpErrorUpdateResolverDnssecConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7165 var errorBuffer bytes.Buffer 7166 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7167 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7168 } 7169 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7170 7171 errorCode := "UnknownError" 7172 errorMessage := errorCode 7173 7174 code := response.Header.Get("X-Amzn-ErrorType") 7175 if len(code) != 0 { 7176 errorCode = restjson.SanitizeErrorCode(code) 7177 } 7178 7179 var buff [1024]byte 7180 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7181 7182 body := io.TeeReader(errorBody, ringBuffer) 7183 decoder := json.NewDecoder(body) 7184 decoder.UseNumber() 7185 code, message, err := restjson.GetErrorInfo(decoder) 7186 if err != nil { 7187 var snapshot bytes.Buffer 7188 io.Copy(&snapshot, ringBuffer) 7189 err = &smithy.DeserializationError{ 7190 Err: fmt.Errorf("failed to decode response body, %w", err), 7191 Snapshot: snapshot.Bytes(), 7192 } 7193 return err 7194 } 7195 7196 errorBody.Seek(0, io.SeekStart) 7197 if len(code) != 0 { 7198 errorCode = restjson.SanitizeErrorCode(code) 7199 } 7200 if len(message) != 0 { 7201 errorMessage = message 7202 } 7203 7204 switch { 7205 case strings.EqualFold("AccessDeniedException", errorCode): 7206 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 7207 7208 case strings.EqualFold("InternalServiceErrorException", errorCode): 7209 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 7210 7211 case strings.EqualFold("InvalidParameterException", errorCode): 7212 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 7213 7214 case strings.EqualFold("InvalidRequestException", errorCode): 7215 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 7216 7217 case strings.EqualFold("ResourceNotFoundException", errorCode): 7218 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7219 7220 case strings.EqualFold("ThrottlingException", errorCode): 7221 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 7222 7223 default: 7224 genericError := &smithy.GenericAPIError{ 7225 Code: errorCode, 7226 Message: errorMessage, 7227 } 7228 return genericError 7229 7230 } 7231} 7232 7233type awsAwsjson11_deserializeOpUpdateResolverEndpoint struct { 7234} 7235 7236func (*awsAwsjson11_deserializeOpUpdateResolverEndpoint) ID() string { 7237 return "OperationDeserializer" 7238} 7239 7240func (m *awsAwsjson11_deserializeOpUpdateResolverEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7241 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7242) { 7243 out, metadata, err = next.HandleDeserialize(ctx, in) 7244 if err != nil { 7245 return out, metadata, err 7246 } 7247 7248 response, ok := out.RawResponse.(*smithyhttp.Response) 7249 if !ok { 7250 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7251 } 7252 7253 if response.StatusCode < 200 || response.StatusCode >= 300 { 7254 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateResolverEndpoint(response, &metadata) 7255 } 7256 output := &UpdateResolverEndpointOutput{} 7257 out.Result = output 7258 7259 var buff [1024]byte 7260 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7261 7262 body := io.TeeReader(response.Body, ringBuffer) 7263 decoder := json.NewDecoder(body) 7264 decoder.UseNumber() 7265 var shape interface{} 7266 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7267 var snapshot bytes.Buffer 7268 io.Copy(&snapshot, ringBuffer) 7269 err = &smithy.DeserializationError{ 7270 Err: fmt.Errorf("failed to decode response body, %w", err), 7271 Snapshot: snapshot.Bytes(), 7272 } 7273 return out, metadata, err 7274 } 7275 7276 err = awsAwsjson11_deserializeOpDocumentUpdateResolverEndpointOutput(&output, shape) 7277 if err != nil { 7278 var snapshot bytes.Buffer 7279 io.Copy(&snapshot, ringBuffer) 7280 err = &smithy.DeserializationError{ 7281 Err: fmt.Errorf("failed to decode response body, %w", err), 7282 Snapshot: snapshot.Bytes(), 7283 } 7284 return out, metadata, err 7285 } 7286 7287 return out, metadata, err 7288} 7289 7290func awsAwsjson11_deserializeOpErrorUpdateResolverEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7291 var errorBuffer bytes.Buffer 7292 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7293 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7294 } 7295 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7296 7297 errorCode := "UnknownError" 7298 errorMessage := errorCode 7299 7300 code := response.Header.Get("X-Amzn-ErrorType") 7301 if len(code) != 0 { 7302 errorCode = restjson.SanitizeErrorCode(code) 7303 } 7304 7305 var buff [1024]byte 7306 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7307 7308 body := io.TeeReader(errorBody, ringBuffer) 7309 decoder := json.NewDecoder(body) 7310 decoder.UseNumber() 7311 code, message, err := restjson.GetErrorInfo(decoder) 7312 if err != nil { 7313 var snapshot bytes.Buffer 7314 io.Copy(&snapshot, ringBuffer) 7315 err = &smithy.DeserializationError{ 7316 Err: fmt.Errorf("failed to decode response body, %w", err), 7317 Snapshot: snapshot.Bytes(), 7318 } 7319 return err 7320 } 7321 7322 errorBody.Seek(0, io.SeekStart) 7323 if len(code) != 0 { 7324 errorCode = restjson.SanitizeErrorCode(code) 7325 } 7326 if len(message) != 0 { 7327 errorMessage = message 7328 } 7329 7330 switch { 7331 case strings.EqualFold("InternalServiceErrorException", errorCode): 7332 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 7333 7334 case strings.EqualFold("InvalidParameterException", errorCode): 7335 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 7336 7337 case strings.EqualFold("InvalidRequestException", errorCode): 7338 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 7339 7340 case strings.EqualFold("ResourceNotFoundException", errorCode): 7341 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7342 7343 case strings.EqualFold("ThrottlingException", errorCode): 7344 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 7345 7346 default: 7347 genericError := &smithy.GenericAPIError{ 7348 Code: errorCode, 7349 Message: errorMessage, 7350 } 7351 return genericError 7352 7353 } 7354} 7355 7356type awsAwsjson11_deserializeOpUpdateResolverRule struct { 7357} 7358 7359func (*awsAwsjson11_deserializeOpUpdateResolverRule) ID() string { 7360 return "OperationDeserializer" 7361} 7362 7363func (m *awsAwsjson11_deserializeOpUpdateResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7364 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7365) { 7366 out, metadata, err = next.HandleDeserialize(ctx, in) 7367 if err != nil { 7368 return out, metadata, err 7369 } 7370 7371 response, ok := out.RawResponse.(*smithyhttp.Response) 7372 if !ok { 7373 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7374 } 7375 7376 if response.StatusCode < 200 || response.StatusCode >= 300 { 7377 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateResolverRule(response, &metadata) 7378 } 7379 output := &UpdateResolverRuleOutput{} 7380 out.Result = output 7381 7382 var buff [1024]byte 7383 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7384 7385 body := io.TeeReader(response.Body, ringBuffer) 7386 decoder := json.NewDecoder(body) 7387 decoder.UseNumber() 7388 var shape interface{} 7389 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7390 var snapshot bytes.Buffer 7391 io.Copy(&snapshot, ringBuffer) 7392 err = &smithy.DeserializationError{ 7393 Err: fmt.Errorf("failed to decode response body, %w", err), 7394 Snapshot: snapshot.Bytes(), 7395 } 7396 return out, metadata, err 7397 } 7398 7399 err = awsAwsjson11_deserializeOpDocumentUpdateResolverRuleOutput(&output, shape) 7400 if err != nil { 7401 var snapshot bytes.Buffer 7402 io.Copy(&snapshot, ringBuffer) 7403 err = &smithy.DeserializationError{ 7404 Err: fmt.Errorf("failed to decode response body, %w", err), 7405 Snapshot: snapshot.Bytes(), 7406 } 7407 return out, metadata, err 7408 } 7409 7410 return out, metadata, err 7411} 7412 7413func awsAwsjson11_deserializeOpErrorUpdateResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7414 var errorBuffer bytes.Buffer 7415 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7416 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7417 } 7418 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7419 7420 errorCode := "UnknownError" 7421 errorMessage := errorCode 7422 7423 code := response.Header.Get("X-Amzn-ErrorType") 7424 if len(code) != 0 { 7425 errorCode = restjson.SanitizeErrorCode(code) 7426 } 7427 7428 var buff [1024]byte 7429 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7430 7431 body := io.TeeReader(errorBody, ringBuffer) 7432 decoder := json.NewDecoder(body) 7433 decoder.UseNumber() 7434 code, message, err := restjson.GetErrorInfo(decoder) 7435 if err != nil { 7436 var snapshot bytes.Buffer 7437 io.Copy(&snapshot, ringBuffer) 7438 err = &smithy.DeserializationError{ 7439 Err: fmt.Errorf("failed to decode response body, %w", err), 7440 Snapshot: snapshot.Bytes(), 7441 } 7442 return err 7443 } 7444 7445 errorBody.Seek(0, io.SeekStart) 7446 if len(code) != 0 { 7447 errorCode = restjson.SanitizeErrorCode(code) 7448 } 7449 if len(message) != 0 { 7450 errorMessage = message 7451 } 7452 7453 switch { 7454 case strings.EqualFold("InternalServiceErrorException", errorCode): 7455 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 7456 7457 case strings.EqualFold("InvalidParameterException", errorCode): 7458 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 7459 7460 case strings.EqualFold("InvalidRequestException", errorCode): 7461 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 7462 7463 case strings.EqualFold("LimitExceededException", errorCode): 7464 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 7465 7466 case strings.EqualFold("ResourceNotFoundException", errorCode): 7467 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7468 7469 case strings.EqualFold("ResourceUnavailableException", errorCode): 7470 return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody) 7471 7472 case strings.EqualFold("ThrottlingException", errorCode): 7473 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 7474 7475 default: 7476 genericError := &smithy.GenericAPIError{ 7477 Code: errorCode, 7478 Message: errorMessage, 7479 } 7480 return genericError 7481 7482 } 7483} 7484 7485func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7486 var buff [1024]byte 7487 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7488 7489 body := io.TeeReader(errorBody, ringBuffer) 7490 decoder := json.NewDecoder(body) 7491 decoder.UseNumber() 7492 var shape interface{} 7493 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7494 var snapshot bytes.Buffer 7495 io.Copy(&snapshot, ringBuffer) 7496 err = &smithy.DeserializationError{ 7497 Err: fmt.Errorf("failed to decode response body, %w", err), 7498 Snapshot: snapshot.Bytes(), 7499 } 7500 return err 7501 } 7502 7503 output := &types.AccessDeniedException{} 7504 err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape) 7505 7506 if err != nil { 7507 var snapshot bytes.Buffer 7508 io.Copy(&snapshot, ringBuffer) 7509 err = &smithy.DeserializationError{ 7510 Err: fmt.Errorf("failed to decode response body, %w", err), 7511 Snapshot: snapshot.Bytes(), 7512 } 7513 return err 7514 } 7515 7516 errorBody.Seek(0, io.SeekStart) 7517 return output 7518} 7519 7520func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7521 var buff [1024]byte 7522 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7523 7524 body := io.TeeReader(errorBody, ringBuffer) 7525 decoder := json.NewDecoder(body) 7526 decoder.UseNumber() 7527 var shape interface{} 7528 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7529 var snapshot bytes.Buffer 7530 io.Copy(&snapshot, ringBuffer) 7531 err = &smithy.DeserializationError{ 7532 Err: fmt.Errorf("failed to decode response body, %w", err), 7533 Snapshot: snapshot.Bytes(), 7534 } 7535 return err 7536 } 7537 7538 output := &types.ConflictException{} 7539 err := awsAwsjson11_deserializeDocumentConflictException(&output, shape) 7540 7541 if err != nil { 7542 var snapshot bytes.Buffer 7543 io.Copy(&snapshot, ringBuffer) 7544 err = &smithy.DeserializationError{ 7545 Err: fmt.Errorf("failed to decode response body, %w", err), 7546 Snapshot: snapshot.Bytes(), 7547 } 7548 return err 7549 } 7550 7551 errorBody.Seek(0, io.SeekStart) 7552 return output 7553} 7554 7555func awsAwsjson11_deserializeErrorInternalServiceErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7556 var buff [1024]byte 7557 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7558 7559 body := io.TeeReader(errorBody, ringBuffer) 7560 decoder := json.NewDecoder(body) 7561 decoder.UseNumber() 7562 var shape interface{} 7563 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7564 var snapshot bytes.Buffer 7565 io.Copy(&snapshot, ringBuffer) 7566 err = &smithy.DeserializationError{ 7567 Err: fmt.Errorf("failed to decode response body, %w", err), 7568 Snapshot: snapshot.Bytes(), 7569 } 7570 return err 7571 } 7572 7573 output := &types.InternalServiceErrorException{} 7574 err := awsAwsjson11_deserializeDocumentInternalServiceErrorException(&output, shape) 7575 7576 if err != nil { 7577 var snapshot bytes.Buffer 7578 io.Copy(&snapshot, ringBuffer) 7579 err = &smithy.DeserializationError{ 7580 Err: fmt.Errorf("failed to decode response body, %w", err), 7581 Snapshot: snapshot.Bytes(), 7582 } 7583 return err 7584 } 7585 7586 errorBody.Seek(0, io.SeekStart) 7587 return output 7588} 7589 7590func awsAwsjson11_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7591 var buff [1024]byte 7592 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7593 7594 body := io.TeeReader(errorBody, ringBuffer) 7595 decoder := json.NewDecoder(body) 7596 decoder.UseNumber() 7597 var shape interface{} 7598 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7599 var snapshot bytes.Buffer 7600 io.Copy(&snapshot, ringBuffer) 7601 err = &smithy.DeserializationError{ 7602 Err: fmt.Errorf("failed to decode response body, %w", err), 7603 Snapshot: snapshot.Bytes(), 7604 } 7605 return err 7606 } 7607 7608 output := &types.InvalidNextTokenException{} 7609 err := awsAwsjson11_deserializeDocumentInvalidNextTokenException(&output, shape) 7610 7611 if err != nil { 7612 var snapshot bytes.Buffer 7613 io.Copy(&snapshot, ringBuffer) 7614 err = &smithy.DeserializationError{ 7615 Err: fmt.Errorf("failed to decode response body, %w", err), 7616 Snapshot: snapshot.Bytes(), 7617 } 7618 return err 7619 } 7620 7621 errorBody.Seek(0, io.SeekStart) 7622 return output 7623} 7624 7625func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7626 var buff [1024]byte 7627 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7628 7629 body := io.TeeReader(errorBody, ringBuffer) 7630 decoder := json.NewDecoder(body) 7631 decoder.UseNumber() 7632 var shape interface{} 7633 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7634 var snapshot bytes.Buffer 7635 io.Copy(&snapshot, ringBuffer) 7636 err = &smithy.DeserializationError{ 7637 Err: fmt.Errorf("failed to decode response body, %w", err), 7638 Snapshot: snapshot.Bytes(), 7639 } 7640 return err 7641 } 7642 7643 output := &types.InvalidParameterException{} 7644 err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape) 7645 7646 if err != nil { 7647 var snapshot bytes.Buffer 7648 io.Copy(&snapshot, ringBuffer) 7649 err = &smithy.DeserializationError{ 7650 Err: fmt.Errorf("failed to decode response body, %w", err), 7651 Snapshot: snapshot.Bytes(), 7652 } 7653 return err 7654 } 7655 7656 errorBody.Seek(0, io.SeekStart) 7657 return output 7658} 7659 7660func awsAwsjson11_deserializeErrorInvalidPolicyDocument(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7661 var buff [1024]byte 7662 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7663 7664 body := io.TeeReader(errorBody, ringBuffer) 7665 decoder := json.NewDecoder(body) 7666 decoder.UseNumber() 7667 var shape interface{} 7668 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7669 var snapshot bytes.Buffer 7670 io.Copy(&snapshot, ringBuffer) 7671 err = &smithy.DeserializationError{ 7672 Err: fmt.Errorf("failed to decode response body, %w", err), 7673 Snapshot: snapshot.Bytes(), 7674 } 7675 return err 7676 } 7677 7678 output := &types.InvalidPolicyDocument{} 7679 err := awsAwsjson11_deserializeDocumentInvalidPolicyDocument(&output, shape) 7680 7681 if err != nil { 7682 var snapshot bytes.Buffer 7683 io.Copy(&snapshot, ringBuffer) 7684 err = &smithy.DeserializationError{ 7685 Err: fmt.Errorf("failed to decode response body, %w", err), 7686 Snapshot: snapshot.Bytes(), 7687 } 7688 return err 7689 } 7690 7691 errorBody.Seek(0, io.SeekStart) 7692 return output 7693} 7694 7695func awsAwsjson11_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7696 var buff [1024]byte 7697 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7698 7699 body := io.TeeReader(errorBody, ringBuffer) 7700 decoder := json.NewDecoder(body) 7701 decoder.UseNumber() 7702 var shape interface{} 7703 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7704 var snapshot bytes.Buffer 7705 io.Copy(&snapshot, ringBuffer) 7706 err = &smithy.DeserializationError{ 7707 Err: fmt.Errorf("failed to decode response body, %w", err), 7708 Snapshot: snapshot.Bytes(), 7709 } 7710 return err 7711 } 7712 7713 output := &types.InvalidRequestException{} 7714 err := awsAwsjson11_deserializeDocumentInvalidRequestException(&output, shape) 7715 7716 if err != nil { 7717 var snapshot bytes.Buffer 7718 io.Copy(&snapshot, ringBuffer) 7719 err = &smithy.DeserializationError{ 7720 Err: fmt.Errorf("failed to decode response body, %w", err), 7721 Snapshot: snapshot.Bytes(), 7722 } 7723 return err 7724 } 7725 7726 errorBody.Seek(0, io.SeekStart) 7727 return output 7728} 7729 7730func awsAwsjson11_deserializeErrorInvalidTagException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7731 var buff [1024]byte 7732 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7733 7734 body := io.TeeReader(errorBody, ringBuffer) 7735 decoder := json.NewDecoder(body) 7736 decoder.UseNumber() 7737 var shape interface{} 7738 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7739 var snapshot bytes.Buffer 7740 io.Copy(&snapshot, ringBuffer) 7741 err = &smithy.DeserializationError{ 7742 Err: fmt.Errorf("failed to decode response body, %w", err), 7743 Snapshot: snapshot.Bytes(), 7744 } 7745 return err 7746 } 7747 7748 output := &types.InvalidTagException{} 7749 err := awsAwsjson11_deserializeDocumentInvalidTagException(&output, shape) 7750 7751 if err != nil { 7752 var snapshot bytes.Buffer 7753 io.Copy(&snapshot, ringBuffer) 7754 err = &smithy.DeserializationError{ 7755 Err: fmt.Errorf("failed to decode response body, %w", err), 7756 Snapshot: snapshot.Bytes(), 7757 } 7758 return err 7759 } 7760 7761 errorBody.Seek(0, io.SeekStart) 7762 return output 7763} 7764 7765func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7766 var buff [1024]byte 7767 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7768 7769 body := io.TeeReader(errorBody, ringBuffer) 7770 decoder := json.NewDecoder(body) 7771 decoder.UseNumber() 7772 var shape interface{} 7773 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7774 var snapshot bytes.Buffer 7775 io.Copy(&snapshot, ringBuffer) 7776 err = &smithy.DeserializationError{ 7777 Err: fmt.Errorf("failed to decode response body, %w", err), 7778 Snapshot: snapshot.Bytes(), 7779 } 7780 return err 7781 } 7782 7783 output := &types.LimitExceededException{} 7784 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 7785 7786 if err != nil { 7787 var snapshot bytes.Buffer 7788 io.Copy(&snapshot, ringBuffer) 7789 err = &smithy.DeserializationError{ 7790 Err: fmt.Errorf("failed to decode response body, %w", err), 7791 Snapshot: snapshot.Bytes(), 7792 } 7793 return err 7794 } 7795 7796 errorBody.Seek(0, io.SeekStart) 7797 return output 7798} 7799 7800func awsAwsjson11_deserializeErrorResourceExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7801 var buff [1024]byte 7802 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7803 7804 body := io.TeeReader(errorBody, ringBuffer) 7805 decoder := json.NewDecoder(body) 7806 decoder.UseNumber() 7807 var shape interface{} 7808 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7809 var snapshot bytes.Buffer 7810 io.Copy(&snapshot, ringBuffer) 7811 err = &smithy.DeserializationError{ 7812 Err: fmt.Errorf("failed to decode response body, %w", err), 7813 Snapshot: snapshot.Bytes(), 7814 } 7815 return err 7816 } 7817 7818 output := &types.ResourceExistsException{} 7819 err := awsAwsjson11_deserializeDocumentResourceExistsException(&output, shape) 7820 7821 if err != nil { 7822 var snapshot bytes.Buffer 7823 io.Copy(&snapshot, ringBuffer) 7824 err = &smithy.DeserializationError{ 7825 Err: fmt.Errorf("failed to decode response body, %w", err), 7826 Snapshot: snapshot.Bytes(), 7827 } 7828 return err 7829 } 7830 7831 errorBody.Seek(0, io.SeekStart) 7832 return output 7833} 7834 7835func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7836 var buff [1024]byte 7837 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7838 7839 body := io.TeeReader(errorBody, ringBuffer) 7840 decoder := json.NewDecoder(body) 7841 decoder.UseNumber() 7842 var shape interface{} 7843 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7844 var snapshot bytes.Buffer 7845 io.Copy(&snapshot, ringBuffer) 7846 err = &smithy.DeserializationError{ 7847 Err: fmt.Errorf("failed to decode response body, %w", err), 7848 Snapshot: snapshot.Bytes(), 7849 } 7850 return err 7851 } 7852 7853 output := &types.ResourceInUseException{} 7854 err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape) 7855 7856 if err != nil { 7857 var snapshot bytes.Buffer 7858 io.Copy(&snapshot, ringBuffer) 7859 err = &smithy.DeserializationError{ 7860 Err: fmt.Errorf("failed to decode response body, %w", err), 7861 Snapshot: snapshot.Bytes(), 7862 } 7863 return err 7864 } 7865 7866 errorBody.Seek(0, io.SeekStart) 7867 return output 7868} 7869 7870func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7871 var buff [1024]byte 7872 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7873 7874 body := io.TeeReader(errorBody, ringBuffer) 7875 decoder := json.NewDecoder(body) 7876 decoder.UseNumber() 7877 var shape interface{} 7878 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7879 var snapshot bytes.Buffer 7880 io.Copy(&snapshot, ringBuffer) 7881 err = &smithy.DeserializationError{ 7882 Err: fmt.Errorf("failed to decode response body, %w", err), 7883 Snapshot: snapshot.Bytes(), 7884 } 7885 return err 7886 } 7887 7888 output := &types.ResourceNotFoundException{} 7889 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 7890 7891 if err != nil { 7892 var snapshot bytes.Buffer 7893 io.Copy(&snapshot, ringBuffer) 7894 err = &smithy.DeserializationError{ 7895 Err: fmt.Errorf("failed to decode response body, %w", err), 7896 Snapshot: snapshot.Bytes(), 7897 } 7898 return err 7899 } 7900 7901 errorBody.Seek(0, io.SeekStart) 7902 return output 7903} 7904 7905func awsAwsjson11_deserializeErrorResourceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7906 var buff [1024]byte 7907 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7908 7909 body := io.TeeReader(errorBody, ringBuffer) 7910 decoder := json.NewDecoder(body) 7911 decoder.UseNumber() 7912 var shape interface{} 7913 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7914 var snapshot bytes.Buffer 7915 io.Copy(&snapshot, ringBuffer) 7916 err = &smithy.DeserializationError{ 7917 Err: fmt.Errorf("failed to decode response body, %w", err), 7918 Snapshot: snapshot.Bytes(), 7919 } 7920 return err 7921 } 7922 7923 output := &types.ResourceUnavailableException{} 7924 err := awsAwsjson11_deserializeDocumentResourceUnavailableException(&output, shape) 7925 7926 if err != nil { 7927 var snapshot bytes.Buffer 7928 io.Copy(&snapshot, ringBuffer) 7929 err = &smithy.DeserializationError{ 7930 Err: fmt.Errorf("failed to decode response body, %w", err), 7931 Snapshot: snapshot.Bytes(), 7932 } 7933 return err 7934 } 7935 7936 errorBody.Seek(0, io.SeekStart) 7937 return output 7938} 7939 7940func awsAwsjson11_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7941 var buff [1024]byte 7942 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7943 7944 body := io.TeeReader(errorBody, ringBuffer) 7945 decoder := json.NewDecoder(body) 7946 decoder.UseNumber() 7947 var shape interface{} 7948 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7949 var snapshot bytes.Buffer 7950 io.Copy(&snapshot, ringBuffer) 7951 err = &smithy.DeserializationError{ 7952 Err: fmt.Errorf("failed to decode response body, %w", err), 7953 Snapshot: snapshot.Bytes(), 7954 } 7955 return err 7956 } 7957 7958 output := &types.ThrottlingException{} 7959 err := awsAwsjson11_deserializeDocumentThrottlingException(&output, shape) 7960 7961 if err != nil { 7962 var snapshot bytes.Buffer 7963 io.Copy(&snapshot, ringBuffer) 7964 err = &smithy.DeserializationError{ 7965 Err: fmt.Errorf("failed to decode response body, %w", err), 7966 Snapshot: snapshot.Bytes(), 7967 } 7968 return err 7969 } 7970 7971 errorBody.Seek(0, io.SeekStart) 7972 return output 7973} 7974 7975func awsAwsjson11_deserializeErrorUnknownResourceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7976 var buff [1024]byte 7977 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7978 7979 body := io.TeeReader(errorBody, ringBuffer) 7980 decoder := json.NewDecoder(body) 7981 decoder.UseNumber() 7982 var shape interface{} 7983 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7984 var snapshot bytes.Buffer 7985 io.Copy(&snapshot, ringBuffer) 7986 err = &smithy.DeserializationError{ 7987 Err: fmt.Errorf("failed to decode response body, %w", err), 7988 Snapshot: snapshot.Bytes(), 7989 } 7990 return err 7991 } 7992 7993 output := &types.UnknownResourceException{} 7994 err := awsAwsjson11_deserializeDocumentUnknownResourceException(&output, shape) 7995 7996 if err != nil { 7997 var snapshot bytes.Buffer 7998 io.Copy(&snapshot, ringBuffer) 7999 err = &smithy.DeserializationError{ 8000 Err: fmt.Errorf("failed to decode response body, %w", err), 8001 Snapshot: snapshot.Bytes(), 8002 } 8003 return err 8004 } 8005 8006 errorBody.Seek(0, io.SeekStart) 8007 return output 8008} 8009 8010func awsAwsjson11_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8011 var buff [1024]byte 8012 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8013 8014 body := io.TeeReader(errorBody, ringBuffer) 8015 decoder := json.NewDecoder(body) 8016 decoder.UseNumber() 8017 var shape interface{} 8018 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8019 var snapshot bytes.Buffer 8020 io.Copy(&snapshot, ringBuffer) 8021 err = &smithy.DeserializationError{ 8022 Err: fmt.Errorf("failed to decode response body, %w", err), 8023 Snapshot: snapshot.Bytes(), 8024 } 8025 return err 8026 } 8027 8028 output := &types.ValidationException{} 8029 err := awsAwsjson11_deserializeDocumentValidationException(&output, shape) 8030 8031 if err != nil { 8032 var snapshot bytes.Buffer 8033 io.Copy(&snapshot, ringBuffer) 8034 err = &smithy.DeserializationError{ 8035 Err: fmt.Errorf("failed to decode response body, %w", err), 8036 Snapshot: snapshot.Bytes(), 8037 } 8038 return err 8039 } 8040 8041 errorBody.Seek(0, io.SeekStart) 8042 return output 8043} 8044 8045func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 8046 if v == nil { 8047 return fmt.Errorf("unexpected nil of type %T", v) 8048 } 8049 if value == nil { 8050 return nil 8051 } 8052 8053 shape, ok := value.(map[string]interface{}) 8054 if !ok { 8055 return fmt.Errorf("unexpected JSON type %v", value) 8056 } 8057 8058 var sv *types.AccessDeniedException 8059 if *v == nil { 8060 sv = &types.AccessDeniedException{} 8061 } else { 8062 sv = *v 8063 } 8064 8065 for key, value := range shape { 8066 switch key { 8067 case "Message": 8068 if value != nil { 8069 jtv, ok := value.(string) 8070 if !ok { 8071 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8072 } 8073 sv.Message = ptr.String(jtv) 8074 } 8075 8076 default: 8077 _, _ = key, value 8078 8079 } 8080 } 8081 *v = sv 8082 return nil 8083} 8084 8085func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 8086 if v == nil { 8087 return fmt.Errorf("unexpected nil of type %T", v) 8088 } 8089 if value == nil { 8090 return nil 8091 } 8092 8093 shape, ok := value.(map[string]interface{}) 8094 if !ok { 8095 return fmt.Errorf("unexpected JSON type %v", value) 8096 } 8097 8098 var sv *types.ConflictException 8099 if *v == nil { 8100 sv = &types.ConflictException{} 8101 } else { 8102 sv = *v 8103 } 8104 8105 for key, value := range shape { 8106 switch key { 8107 case "Message": 8108 if value != nil { 8109 jtv, ok := value.(string) 8110 if !ok { 8111 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8112 } 8113 sv.Message = ptr.String(jtv) 8114 } 8115 8116 default: 8117 _, _ = key, value 8118 8119 } 8120 } 8121 *v = sv 8122 return nil 8123} 8124 8125func awsAwsjson11_deserializeDocumentFirewallConfig(v **types.FirewallConfig, value interface{}) error { 8126 if v == nil { 8127 return fmt.Errorf("unexpected nil of type %T", v) 8128 } 8129 if value == nil { 8130 return nil 8131 } 8132 8133 shape, ok := value.(map[string]interface{}) 8134 if !ok { 8135 return fmt.Errorf("unexpected JSON type %v", value) 8136 } 8137 8138 var sv *types.FirewallConfig 8139 if *v == nil { 8140 sv = &types.FirewallConfig{} 8141 } else { 8142 sv = *v 8143 } 8144 8145 for key, value := range shape { 8146 switch key { 8147 case "FirewallFailOpen": 8148 if value != nil { 8149 jtv, ok := value.(string) 8150 if !ok { 8151 return fmt.Errorf("expected FirewallFailOpenStatus to be of type string, got %T instead", value) 8152 } 8153 sv.FirewallFailOpen = types.FirewallFailOpenStatus(jtv) 8154 } 8155 8156 case "Id": 8157 if value != nil { 8158 jtv, ok := value.(string) 8159 if !ok { 8160 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8161 } 8162 sv.Id = ptr.String(jtv) 8163 } 8164 8165 case "OwnerId": 8166 if value != nil { 8167 jtv, ok := value.(string) 8168 if !ok { 8169 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 8170 } 8171 sv.OwnerId = ptr.String(jtv) 8172 } 8173 8174 case "ResourceId": 8175 if value != nil { 8176 jtv, ok := value.(string) 8177 if !ok { 8178 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8179 } 8180 sv.ResourceId = ptr.String(jtv) 8181 } 8182 8183 default: 8184 _, _ = key, value 8185 8186 } 8187 } 8188 *v = sv 8189 return nil 8190} 8191 8192func awsAwsjson11_deserializeDocumentFirewallConfigList(v *[]types.FirewallConfig, value interface{}) error { 8193 if v == nil { 8194 return fmt.Errorf("unexpected nil of type %T", v) 8195 } 8196 if value == nil { 8197 return nil 8198 } 8199 8200 shape, ok := value.([]interface{}) 8201 if !ok { 8202 return fmt.Errorf("unexpected JSON type %v", value) 8203 } 8204 8205 var cv []types.FirewallConfig 8206 if *v == nil { 8207 cv = []types.FirewallConfig{} 8208 } else { 8209 cv = *v 8210 } 8211 8212 for _, value := range shape { 8213 var col types.FirewallConfig 8214 destAddr := &col 8215 if err := awsAwsjson11_deserializeDocumentFirewallConfig(&destAddr, value); err != nil { 8216 return err 8217 } 8218 col = *destAddr 8219 cv = append(cv, col) 8220 8221 } 8222 *v = cv 8223 return nil 8224} 8225 8226func awsAwsjson11_deserializeDocumentFirewallDomainList(v **types.FirewallDomainList, value interface{}) error { 8227 if v == nil { 8228 return fmt.Errorf("unexpected nil of type %T", v) 8229 } 8230 if value == nil { 8231 return nil 8232 } 8233 8234 shape, ok := value.(map[string]interface{}) 8235 if !ok { 8236 return fmt.Errorf("unexpected JSON type %v", value) 8237 } 8238 8239 var sv *types.FirewallDomainList 8240 if *v == nil { 8241 sv = &types.FirewallDomainList{} 8242 } else { 8243 sv = *v 8244 } 8245 8246 for key, value := range shape { 8247 switch key { 8248 case "Arn": 8249 if value != nil { 8250 jtv, ok := value.(string) 8251 if !ok { 8252 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8253 } 8254 sv.Arn = ptr.String(jtv) 8255 } 8256 8257 case "CreationTime": 8258 if value != nil { 8259 jtv, ok := value.(string) 8260 if !ok { 8261 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 8262 } 8263 sv.CreationTime = ptr.String(jtv) 8264 } 8265 8266 case "CreatorRequestId": 8267 if value != nil { 8268 jtv, ok := value.(string) 8269 if !ok { 8270 return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value) 8271 } 8272 sv.CreatorRequestId = ptr.String(jtv) 8273 } 8274 8275 case "DomainCount": 8276 if value != nil { 8277 jtv, ok := value.(json.Number) 8278 if !ok { 8279 return fmt.Errorf("expected Unsigned to be json.Number, got %T instead", value) 8280 } 8281 i64, err := jtv.Int64() 8282 if err != nil { 8283 return err 8284 } 8285 sv.DomainCount = ptr.Int32(int32(i64)) 8286 } 8287 8288 case "Id": 8289 if value != nil { 8290 jtv, ok := value.(string) 8291 if !ok { 8292 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8293 } 8294 sv.Id = ptr.String(jtv) 8295 } 8296 8297 case "ManagedOwnerName": 8298 if value != nil { 8299 jtv, ok := value.(string) 8300 if !ok { 8301 return fmt.Errorf("expected ServicePrinciple to be of type string, got %T instead", value) 8302 } 8303 sv.ManagedOwnerName = ptr.String(jtv) 8304 } 8305 8306 case "ModificationTime": 8307 if value != nil { 8308 jtv, ok := value.(string) 8309 if !ok { 8310 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 8311 } 8312 sv.ModificationTime = ptr.String(jtv) 8313 } 8314 8315 case "Name": 8316 if value != nil { 8317 jtv, ok := value.(string) 8318 if !ok { 8319 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 8320 } 8321 sv.Name = ptr.String(jtv) 8322 } 8323 8324 case "Status": 8325 if value != nil { 8326 jtv, ok := value.(string) 8327 if !ok { 8328 return fmt.Errorf("expected FirewallDomainListStatus to be of type string, got %T instead", value) 8329 } 8330 sv.Status = types.FirewallDomainListStatus(jtv) 8331 } 8332 8333 case "StatusMessage": 8334 if value != nil { 8335 jtv, ok := value.(string) 8336 if !ok { 8337 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 8338 } 8339 sv.StatusMessage = ptr.String(jtv) 8340 } 8341 8342 default: 8343 _, _ = key, value 8344 8345 } 8346 } 8347 *v = sv 8348 return nil 8349} 8350 8351func awsAwsjson11_deserializeDocumentFirewallDomainListMetadata(v **types.FirewallDomainListMetadata, value interface{}) error { 8352 if v == nil { 8353 return fmt.Errorf("unexpected nil of type %T", v) 8354 } 8355 if value == nil { 8356 return nil 8357 } 8358 8359 shape, ok := value.(map[string]interface{}) 8360 if !ok { 8361 return fmt.Errorf("unexpected JSON type %v", value) 8362 } 8363 8364 var sv *types.FirewallDomainListMetadata 8365 if *v == nil { 8366 sv = &types.FirewallDomainListMetadata{} 8367 } else { 8368 sv = *v 8369 } 8370 8371 for key, value := range shape { 8372 switch key { 8373 case "Arn": 8374 if value != nil { 8375 jtv, ok := value.(string) 8376 if !ok { 8377 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8378 } 8379 sv.Arn = ptr.String(jtv) 8380 } 8381 8382 case "CreatorRequestId": 8383 if value != nil { 8384 jtv, ok := value.(string) 8385 if !ok { 8386 return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value) 8387 } 8388 sv.CreatorRequestId = ptr.String(jtv) 8389 } 8390 8391 case "Id": 8392 if value != nil { 8393 jtv, ok := value.(string) 8394 if !ok { 8395 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8396 } 8397 sv.Id = ptr.String(jtv) 8398 } 8399 8400 case "ManagedOwnerName": 8401 if value != nil { 8402 jtv, ok := value.(string) 8403 if !ok { 8404 return fmt.Errorf("expected ServicePrinciple to be of type string, got %T instead", value) 8405 } 8406 sv.ManagedOwnerName = ptr.String(jtv) 8407 } 8408 8409 case "Name": 8410 if value != nil { 8411 jtv, ok := value.(string) 8412 if !ok { 8413 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 8414 } 8415 sv.Name = ptr.String(jtv) 8416 } 8417 8418 default: 8419 _, _ = key, value 8420 8421 } 8422 } 8423 *v = sv 8424 return nil 8425} 8426 8427func awsAwsjson11_deserializeDocumentFirewallDomainListMetadataList(v *[]types.FirewallDomainListMetadata, value interface{}) error { 8428 if v == nil { 8429 return fmt.Errorf("unexpected nil of type %T", v) 8430 } 8431 if value == nil { 8432 return nil 8433 } 8434 8435 shape, ok := value.([]interface{}) 8436 if !ok { 8437 return fmt.Errorf("unexpected JSON type %v", value) 8438 } 8439 8440 var cv []types.FirewallDomainListMetadata 8441 if *v == nil { 8442 cv = []types.FirewallDomainListMetadata{} 8443 } else { 8444 cv = *v 8445 } 8446 8447 for _, value := range shape { 8448 var col types.FirewallDomainListMetadata 8449 destAddr := &col 8450 if err := awsAwsjson11_deserializeDocumentFirewallDomainListMetadata(&destAddr, value); err != nil { 8451 return err 8452 } 8453 col = *destAddr 8454 cv = append(cv, col) 8455 8456 } 8457 *v = cv 8458 return nil 8459} 8460 8461func awsAwsjson11_deserializeDocumentFirewallDomains(v *[]string, value interface{}) error { 8462 if v == nil { 8463 return fmt.Errorf("unexpected nil of type %T", v) 8464 } 8465 if value == nil { 8466 return nil 8467 } 8468 8469 shape, ok := value.([]interface{}) 8470 if !ok { 8471 return fmt.Errorf("unexpected JSON type %v", value) 8472 } 8473 8474 var cv []string 8475 if *v == nil { 8476 cv = []string{} 8477 } else { 8478 cv = *v 8479 } 8480 8481 for _, value := range shape { 8482 var col string 8483 if value != nil { 8484 jtv, ok := value.(string) 8485 if !ok { 8486 return fmt.Errorf("expected FirewallDomainName to be of type string, got %T instead", value) 8487 } 8488 col = jtv 8489 } 8490 cv = append(cv, col) 8491 8492 } 8493 *v = cv 8494 return nil 8495} 8496 8497func awsAwsjson11_deserializeDocumentFirewallRule(v **types.FirewallRule, value interface{}) error { 8498 if v == nil { 8499 return fmt.Errorf("unexpected nil of type %T", v) 8500 } 8501 if value == nil { 8502 return nil 8503 } 8504 8505 shape, ok := value.(map[string]interface{}) 8506 if !ok { 8507 return fmt.Errorf("unexpected JSON type %v", value) 8508 } 8509 8510 var sv *types.FirewallRule 8511 if *v == nil { 8512 sv = &types.FirewallRule{} 8513 } else { 8514 sv = *v 8515 } 8516 8517 for key, value := range shape { 8518 switch key { 8519 case "Action": 8520 if value != nil { 8521 jtv, ok := value.(string) 8522 if !ok { 8523 return fmt.Errorf("expected Action to be of type string, got %T instead", value) 8524 } 8525 sv.Action = types.Action(jtv) 8526 } 8527 8528 case "BlockOverrideDnsType": 8529 if value != nil { 8530 jtv, ok := value.(string) 8531 if !ok { 8532 return fmt.Errorf("expected BlockOverrideDnsType to be of type string, got %T instead", value) 8533 } 8534 sv.BlockOverrideDnsType = types.BlockOverrideDnsType(jtv) 8535 } 8536 8537 case "BlockOverrideDomain": 8538 if value != nil { 8539 jtv, ok := value.(string) 8540 if !ok { 8541 return fmt.Errorf("expected BlockOverrideDomain to be of type string, got %T instead", value) 8542 } 8543 sv.BlockOverrideDomain = ptr.String(jtv) 8544 } 8545 8546 case "BlockOverrideTtl": 8547 if value != nil { 8548 jtv, ok := value.(json.Number) 8549 if !ok { 8550 return fmt.Errorf("expected Unsigned to be json.Number, got %T instead", value) 8551 } 8552 i64, err := jtv.Int64() 8553 if err != nil { 8554 return err 8555 } 8556 sv.BlockOverrideTtl = ptr.Int32(int32(i64)) 8557 } 8558 8559 case "BlockResponse": 8560 if value != nil { 8561 jtv, ok := value.(string) 8562 if !ok { 8563 return fmt.Errorf("expected BlockResponse to be of type string, got %T instead", value) 8564 } 8565 sv.BlockResponse = types.BlockResponse(jtv) 8566 } 8567 8568 case "CreationTime": 8569 if value != nil { 8570 jtv, ok := value.(string) 8571 if !ok { 8572 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 8573 } 8574 sv.CreationTime = ptr.String(jtv) 8575 } 8576 8577 case "CreatorRequestId": 8578 if value != nil { 8579 jtv, ok := value.(string) 8580 if !ok { 8581 return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value) 8582 } 8583 sv.CreatorRequestId = ptr.String(jtv) 8584 } 8585 8586 case "FirewallDomainListId": 8587 if value != nil { 8588 jtv, ok := value.(string) 8589 if !ok { 8590 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8591 } 8592 sv.FirewallDomainListId = ptr.String(jtv) 8593 } 8594 8595 case "FirewallRuleGroupId": 8596 if value != nil { 8597 jtv, ok := value.(string) 8598 if !ok { 8599 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8600 } 8601 sv.FirewallRuleGroupId = ptr.String(jtv) 8602 } 8603 8604 case "ModificationTime": 8605 if value != nil { 8606 jtv, ok := value.(string) 8607 if !ok { 8608 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 8609 } 8610 sv.ModificationTime = ptr.String(jtv) 8611 } 8612 8613 case "Name": 8614 if value != nil { 8615 jtv, ok := value.(string) 8616 if !ok { 8617 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 8618 } 8619 sv.Name = ptr.String(jtv) 8620 } 8621 8622 case "Priority": 8623 if value != nil { 8624 jtv, ok := value.(json.Number) 8625 if !ok { 8626 return fmt.Errorf("expected Priority to be json.Number, got %T instead", value) 8627 } 8628 i64, err := jtv.Int64() 8629 if err != nil { 8630 return err 8631 } 8632 sv.Priority = ptr.Int32(int32(i64)) 8633 } 8634 8635 default: 8636 _, _ = key, value 8637 8638 } 8639 } 8640 *v = sv 8641 return nil 8642} 8643 8644func awsAwsjson11_deserializeDocumentFirewallRuleGroup(v **types.FirewallRuleGroup, value interface{}) error { 8645 if v == nil { 8646 return fmt.Errorf("unexpected nil of type %T", v) 8647 } 8648 if value == nil { 8649 return nil 8650 } 8651 8652 shape, ok := value.(map[string]interface{}) 8653 if !ok { 8654 return fmt.Errorf("unexpected JSON type %v", value) 8655 } 8656 8657 var sv *types.FirewallRuleGroup 8658 if *v == nil { 8659 sv = &types.FirewallRuleGroup{} 8660 } else { 8661 sv = *v 8662 } 8663 8664 for key, value := range shape { 8665 switch key { 8666 case "Arn": 8667 if value != nil { 8668 jtv, ok := value.(string) 8669 if !ok { 8670 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8671 } 8672 sv.Arn = ptr.String(jtv) 8673 } 8674 8675 case "CreationTime": 8676 if value != nil { 8677 jtv, ok := value.(string) 8678 if !ok { 8679 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 8680 } 8681 sv.CreationTime = ptr.String(jtv) 8682 } 8683 8684 case "CreatorRequestId": 8685 if value != nil { 8686 jtv, ok := value.(string) 8687 if !ok { 8688 return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value) 8689 } 8690 sv.CreatorRequestId = ptr.String(jtv) 8691 } 8692 8693 case "Id": 8694 if value != nil { 8695 jtv, ok := value.(string) 8696 if !ok { 8697 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8698 } 8699 sv.Id = ptr.String(jtv) 8700 } 8701 8702 case "ModificationTime": 8703 if value != nil { 8704 jtv, ok := value.(string) 8705 if !ok { 8706 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 8707 } 8708 sv.ModificationTime = ptr.String(jtv) 8709 } 8710 8711 case "Name": 8712 if value != nil { 8713 jtv, ok := value.(string) 8714 if !ok { 8715 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 8716 } 8717 sv.Name = ptr.String(jtv) 8718 } 8719 8720 case "OwnerId": 8721 if value != nil { 8722 jtv, ok := value.(string) 8723 if !ok { 8724 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 8725 } 8726 sv.OwnerId = ptr.String(jtv) 8727 } 8728 8729 case "RuleCount": 8730 if value != nil { 8731 jtv, ok := value.(json.Number) 8732 if !ok { 8733 return fmt.Errorf("expected Unsigned to be json.Number, got %T instead", value) 8734 } 8735 i64, err := jtv.Int64() 8736 if err != nil { 8737 return err 8738 } 8739 sv.RuleCount = ptr.Int32(int32(i64)) 8740 } 8741 8742 case "ShareStatus": 8743 if value != nil { 8744 jtv, ok := value.(string) 8745 if !ok { 8746 return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value) 8747 } 8748 sv.ShareStatus = types.ShareStatus(jtv) 8749 } 8750 8751 case "Status": 8752 if value != nil { 8753 jtv, ok := value.(string) 8754 if !ok { 8755 return fmt.Errorf("expected FirewallRuleGroupStatus to be of type string, got %T instead", value) 8756 } 8757 sv.Status = types.FirewallRuleGroupStatus(jtv) 8758 } 8759 8760 case "StatusMessage": 8761 if value != nil { 8762 jtv, ok := value.(string) 8763 if !ok { 8764 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 8765 } 8766 sv.StatusMessage = ptr.String(jtv) 8767 } 8768 8769 default: 8770 _, _ = key, value 8771 8772 } 8773 } 8774 *v = sv 8775 return nil 8776} 8777 8778func awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(v **types.FirewallRuleGroupAssociation, value interface{}) error { 8779 if v == nil { 8780 return fmt.Errorf("unexpected nil of type %T", v) 8781 } 8782 if value == nil { 8783 return nil 8784 } 8785 8786 shape, ok := value.(map[string]interface{}) 8787 if !ok { 8788 return fmt.Errorf("unexpected JSON type %v", value) 8789 } 8790 8791 var sv *types.FirewallRuleGroupAssociation 8792 if *v == nil { 8793 sv = &types.FirewallRuleGroupAssociation{} 8794 } else { 8795 sv = *v 8796 } 8797 8798 for key, value := range shape { 8799 switch key { 8800 case "Arn": 8801 if value != nil { 8802 jtv, ok := value.(string) 8803 if !ok { 8804 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8805 } 8806 sv.Arn = ptr.String(jtv) 8807 } 8808 8809 case "CreationTime": 8810 if value != nil { 8811 jtv, ok := value.(string) 8812 if !ok { 8813 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 8814 } 8815 sv.CreationTime = ptr.String(jtv) 8816 } 8817 8818 case "CreatorRequestId": 8819 if value != nil { 8820 jtv, ok := value.(string) 8821 if !ok { 8822 return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value) 8823 } 8824 sv.CreatorRequestId = ptr.String(jtv) 8825 } 8826 8827 case "FirewallRuleGroupId": 8828 if value != nil { 8829 jtv, ok := value.(string) 8830 if !ok { 8831 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8832 } 8833 sv.FirewallRuleGroupId = ptr.String(jtv) 8834 } 8835 8836 case "Id": 8837 if value != nil { 8838 jtv, ok := value.(string) 8839 if !ok { 8840 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8841 } 8842 sv.Id = ptr.String(jtv) 8843 } 8844 8845 case "ManagedOwnerName": 8846 if value != nil { 8847 jtv, ok := value.(string) 8848 if !ok { 8849 return fmt.Errorf("expected ServicePrinciple to be of type string, got %T instead", value) 8850 } 8851 sv.ManagedOwnerName = ptr.String(jtv) 8852 } 8853 8854 case "ModificationTime": 8855 if value != nil { 8856 jtv, ok := value.(string) 8857 if !ok { 8858 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 8859 } 8860 sv.ModificationTime = ptr.String(jtv) 8861 } 8862 8863 case "MutationProtection": 8864 if value != nil { 8865 jtv, ok := value.(string) 8866 if !ok { 8867 return fmt.Errorf("expected MutationProtectionStatus to be of type string, got %T instead", value) 8868 } 8869 sv.MutationProtection = types.MutationProtectionStatus(jtv) 8870 } 8871 8872 case "Name": 8873 if value != nil { 8874 jtv, ok := value.(string) 8875 if !ok { 8876 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 8877 } 8878 sv.Name = ptr.String(jtv) 8879 } 8880 8881 case "Priority": 8882 if value != nil { 8883 jtv, ok := value.(json.Number) 8884 if !ok { 8885 return fmt.Errorf("expected Priority to be json.Number, got %T instead", value) 8886 } 8887 i64, err := jtv.Int64() 8888 if err != nil { 8889 return err 8890 } 8891 sv.Priority = ptr.Int32(int32(i64)) 8892 } 8893 8894 case "Status": 8895 if value != nil { 8896 jtv, ok := value.(string) 8897 if !ok { 8898 return fmt.Errorf("expected FirewallRuleGroupAssociationStatus to be of type string, got %T instead", value) 8899 } 8900 sv.Status = types.FirewallRuleGroupAssociationStatus(jtv) 8901 } 8902 8903 case "StatusMessage": 8904 if value != nil { 8905 jtv, ok := value.(string) 8906 if !ok { 8907 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 8908 } 8909 sv.StatusMessage = ptr.String(jtv) 8910 } 8911 8912 case "VpcId": 8913 if value != nil { 8914 jtv, ok := value.(string) 8915 if !ok { 8916 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8917 } 8918 sv.VpcId = ptr.String(jtv) 8919 } 8920 8921 default: 8922 _, _ = key, value 8923 8924 } 8925 } 8926 *v = sv 8927 return nil 8928} 8929 8930func awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociations(v *[]types.FirewallRuleGroupAssociation, value interface{}) error { 8931 if v == nil { 8932 return fmt.Errorf("unexpected nil of type %T", v) 8933 } 8934 if value == nil { 8935 return nil 8936 } 8937 8938 shape, ok := value.([]interface{}) 8939 if !ok { 8940 return fmt.Errorf("unexpected JSON type %v", value) 8941 } 8942 8943 var cv []types.FirewallRuleGroupAssociation 8944 if *v == nil { 8945 cv = []types.FirewallRuleGroupAssociation{} 8946 } else { 8947 cv = *v 8948 } 8949 8950 for _, value := range shape { 8951 var col types.FirewallRuleGroupAssociation 8952 destAddr := &col 8953 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(&destAddr, value); err != nil { 8954 return err 8955 } 8956 col = *destAddr 8957 cv = append(cv, col) 8958 8959 } 8960 *v = cv 8961 return nil 8962} 8963 8964func awsAwsjson11_deserializeDocumentFirewallRuleGroupMetadata(v **types.FirewallRuleGroupMetadata, value interface{}) error { 8965 if v == nil { 8966 return fmt.Errorf("unexpected nil of type %T", v) 8967 } 8968 if value == nil { 8969 return nil 8970 } 8971 8972 shape, ok := value.(map[string]interface{}) 8973 if !ok { 8974 return fmt.Errorf("unexpected JSON type %v", value) 8975 } 8976 8977 var sv *types.FirewallRuleGroupMetadata 8978 if *v == nil { 8979 sv = &types.FirewallRuleGroupMetadata{} 8980 } else { 8981 sv = *v 8982 } 8983 8984 for key, value := range shape { 8985 switch key { 8986 case "Arn": 8987 if value != nil { 8988 jtv, ok := value.(string) 8989 if !ok { 8990 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8991 } 8992 sv.Arn = ptr.String(jtv) 8993 } 8994 8995 case "CreatorRequestId": 8996 if value != nil { 8997 jtv, ok := value.(string) 8998 if !ok { 8999 return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value) 9000 } 9001 sv.CreatorRequestId = ptr.String(jtv) 9002 } 9003 9004 case "Id": 9005 if value != nil { 9006 jtv, ok := value.(string) 9007 if !ok { 9008 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 9009 } 9010 sv.Id = ptr.String(jtv) 9011 } 9012 9013 case "Name": 9014 if value != nil { 9015 jtv, ok := value.(string) 9016 if !ok { 9017 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 9018 } 9019 sv.Name = ptr.String(jtv) 9020 } 9021 9022 case "OwnerId": 9023 if value != nil { 9024 jtv, ok := value.(string) 9025 if !ok { 9026 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 9027 } 9028 sv.OwnerId = ptr.String(jtv) 9029 } 9030 9031 case "ShareStatus": 9032 if value != nil { 9033 jtv, ok := value.(string) 9034 if !ok { 9035 return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value) 9036 } 9037 sv.ShareStatus = types.ShareStatus(jtv) 9038 } 9039 9040 default: 9041 _, _ = key, value 9042 9043 } 9044 } 9045 *v = sv 9046 return nil 9047} 9048 9049func awsAwsjson11_deserializeDocumentFirewallRuleGroupMetadataList(v *[]types.FirewallRuleGroupMetadata, value interface{}) error { 9050 if v == nil { 9051 return fmt.Errorf("unexpected nil of type %T", v) 9052 } 9053 if value == nil { 9054 return nil 9055 } 9056 9057 shape, ok := value.([]interface{}) 9058 if !ok { 9059 return fmt.Errorf("unexpected JSON type %v", value) 9060 } 9061 9062 var cv []types.FirewallRuleGroupMetadata 9063 if *v == nil { 9064 cv = []types.FirewallRuleGroupMetadata{} 9065 } else { 9066 cv = *v 9067 } 9068 9069 for _, value := range shape { 9070 var col types.FirewallRuleGroupMetadata 9071 destAddr := &col 9072 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupMetadata(&destAddr, value); err != nil { 9073 return err 9074 } 9075 col = *destAddr 9076 cv = append(cv, col) 9077 9078 } 9079 *v = cv 9080 return nil 9081} 9082 9083func awsAwsjson11_deserializeDocumentFirewallRules(v *[]types.FirewallRule, value interface{}) error { 9084 if v == nil { 9085 return fmt.Errorf("unexpected nil of type %T", v) 9086 } 9087 if value == nil { 9088 return nil 9089 } 9090 9091 shape, ok := value.([]interface{}) 9092 if !ok { 9093 return fmt.Errorf("unexpected JSON type %v", value) 9094 } 9095 9096 var cv []types.FirewallRule 9097 if *v == nil { 9098 cv = []types.FirewallRule{} 9099 } else { 9100 cv = *v 9101 } 9102 9103 for _, value := range shape { 9104 var col types.FirewallRule 9105 destAddr := &col 9106 if err := awsAwsjson11_deserializeDocumentFirewallRule(&destAddr, value); err != nil { 9107 return err 9108 } 9109 col = *destAddr 9110 cv = append(cv, col) 9111 9112 } 9113 *v = cv 9114 return nil 9115} 9116 9117func awsAwsjson11_deserializeDocumentInternalServiceErrorException(v **types.InternalServiceErrorException, value interface{}) error { 9118 if v == nil { 9119 return fmt.Errorf("unexpected nil of type %T", v) 9120 } 9121 if value == nil { 9122 return nil 9123 } 9124 9125 shape, ok := value.(map[string]interface{}) 9126 if !ok { 9127 return fmt.Errorf("unexpected JSON type %v", value) 9128 } 9129 9130 var sv *types.InternalServiceErrorException 9131 if *v == nil { 9132 sv = &types.InternalServiceErrorException{} 9133 } else { 9134 sv = *v 9135 } 9136 9137 for key, value := range shape { 9138 switch key { 9139 case "Message": 9140 if value != nil { 9141 jtv, ok := value.(string) 9142 if !ok { 9143 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9144 } 9145 sv.Message = ptr.String(jtv) 9146 } 9147 9148 default: 9149 _, _ = key, value 9150 9151 } 9152 } 9153 *v = sv 9154 return nil 9155} 9156 9157func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error { 9158 if v == nil { 9159 return fmt.Errorf("unexpected nil of type %T", v) 9160 } 9161 if value == nil { 9162 return nil 9163 } 9164 9165 shape, ok := value.(map[string]interface{}) 9166 if !ok { 9167 return fmt.Errorf("unexpected JSON type %v", value) 9168 } 9169 9170 var sv *types.InvalidNextTokenException 9171 if *v == nil { 9172 sv = &types.InvalidNextTokenException{} 9173 } else { 9174 sv = *v 9175 } 9176 9177 for key, value := range shape { 9178 switch key { 9179 case "Message": 9180 if value != nil { 9181 jtv, ok := value.(string) 9182 if !ok { 9183 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9184 } 9185 sv.Message = ptr.String(jtv) 9186 } 9187 9188 default: 9189 _, _ = key, value 9190 9191 } 9192 } 9193 *v = sv 9194 return nil 9195} 9196 9197func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error { 9198 if v == nil { 9199 return fmt.Errorf("unexpected nil of type %T", v) 9200 } 9201 if value == nil { 9202 return nil 9203 } 9204 9205 shape, ok := value.(map[string]interface{}) 9206 if !ok { 9207 return fmt.Errorf("unexpected JSON type %v", value) 9208 } 9209 9210 var sv *types.InvalidParameterException 9211 if *v == nil { 9212 sv = &types.InvalidParameterException{} 9213 } else { 9214 sv = *v 9215 } 9216 9217 for key, value := range shape { 9218 switch key { 9219 case "FieldName": 9220 if value != nil { 9221 jtv, ok := value.(string) 9222 if !ok { 9223 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9224 } 9225 sv.FieldName = ptr.String(jtv) 9226 } 9227 9228 case "Message": 9229 if value != nil { 9230 jtv, ok := value.(string) 9231 if !ok { 9232 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9233 } 9234 sv.Message = ptr.String(jtv) 9235 } 9236 9237 default: 9238 _, _ = key, value 9239 9240 } 9241 } 9242 *v = sv 9243 return nil 9244} 9245 9246func awsAwsjson11_deserializeDocumentInvalidPolicyDocument(v **types.InvalidPolicyDocument, value interface{}) error { 9247 if v == nil { 9248 return fmt.Errorf("unexpected nil of type %T", v) 9249 } 9250 if value == nil { 9251 return nil 9252 } 9253 9254 shape, ok := value.(map[string]interface{}) 9255 if !ok { 9256 return fmt.Errorf("unexpected JSON type %v", value) 9257 } 9258 9259 var sv *types.InvalidPolicyDocument 9260 if *v == nil { 9261 sv = &types.InvalidPolicyDocument{} 9262 } else { 9263 sv = *v 9264 } 9265 9266 for key, value := range shape { 9267 switch key { 9268 case "Message": 9269 if value != nil { 9270 jtv, ok := value.(string) 9271 if !ok { 9272 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9273 } 9274 sv.Message = ptr.String(jtv) 9275 } 9276 9277 default: 9278 _, _ = key, value 9279 9280 } 9281 } 9282 *v = sv 9283 return nil 9284} 9285 9286func awsAwsjson11_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error { 9287 if v == nil { 9288 return fmt.Errorf("unexpected nil of type %T", v) 9289 } 9290 if value == nil { 9291 return nil 9292 } 9293 9294 shape, ok := value.(map[string]interface{}) 9295 if !ok { 9296 return fmt.Errorf("unexpected JSON type %v", value) 9297 } 9298 9299 var sv *types.InvalidRequestException 9300 if *v == nil { 9301 sv = &types.InvalidRequestException{} 9302 } else { 9303 sv = *v 9304 } 9305 9306 for key, value := range shape { 9307 switch key { 9308 case "Message": 9309 if value != nil { 9310 jtv, ok := value.(string) 9311 if !ok { 9312 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9313 } 9314 sv.Message = ptr.String(jtv) 9315 } 9316 9317 default: 9318 _, _ = key, value 9319 9320 } 9321 } 9322 *v = sv 9323 return nil 9324} 9325 9326func awsAwsjson11_deserializeDocumentInvalidTagException(v **types.InvalidTagException, value interface{}) error { 9327 if v == nil { 9328 return fmt.Errorf("unexpected nil of type %T", v) 9329 } 9330 if value == nil { 9331 return nil 9332 } 9333 9334 shape, ok := value.(map[string]interface{}) 9335 if !ok { 9336 return fmt.Errorf("unexpected JSON type %v", value) 9337 } 9338 9339 var sv *types.InvalidTagException 9340 if *v == nil { 9341 sv = &types.InvalidTagException{} 9342 } else { 9343 sv = *v 9344 } 9345 9346 for key, value := range shape { 9347 switch key { 9348 case "Message": 9349 if value != nil { 9350 jtv, ok := value.(string) 9351 if !ok { 9352 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9353 } 9354 sv.Message = ptr.String(jtv) 9355 } 9356 9357 default: 9358 _, _ = key, value 9359 9360 } 9361 } 9362 *v = sv 9363 return nil 9364} 9365 9366func awsAwsjson11_deserializeDocumentIpAddressesResponse(v *[]types.IpAddressResponse, value interface{}) error { 9367 if v == nil { 9368 return fmt.Errorf("unexpected nil of type %T", v) 9369 } 9370 if value == nil { 9371 return nil 9372 } 9373 9374 shape, ok := value.([]interface{}) 9375 if !ok { 9376 return fmt.Errorf("unexpected JSON type %v", value) 9377 } 9378 9379 var cv []types.IpAddressResponse 9380 if *v == nil { 9381 cv = []types.IpAddressResponse{} 9382 } else { 9383 cv = *v 9384 } 9385 9386 for _, value := range shape { 9387 var col types.IpAddressResponse 9388 destAddr := &col 9389 if err := awsAwsjson11_deserializeDocumentIpAddressResponse(&destAddr, value); err != nil { 9390 return err 9391 } 9392 col = *destAddr 9393 cv = append(cv, col) 9394 9395 } 9396 *v = cv 9397 return nil 9398} 9399 9400func awsAwsjson11_deserializeDocumentIpAddressResponse(v **types.IpAddressResponse, value interface{}) error { 9401 if v == nil { 9402 return fmt.Errorf("unexpected nil of type %T", v) 9403 } 9404 if value == nil { 9405 return nil 9406 } 9407 9408 shape, ok := value.(map[string]interface{}) 9409 if !ok { 9410 return fmt.Errorf("unexpected JSON type %v", value) 9411 } 9412 9413 var sv *types.IpAddressResponse 9414 if *v == nil { 9415 sv = &types.IpAddressResponse{} 9416 } else { 9417 sv = *v 9418 } 9419 9420 for key, value := range shape { 9421 switch key { 9422 case "CreationTime": 9423 if value != nil { 9424 jtv, ok := value.(string) 9425 if !ok { 9426 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 9427 } 9428 sv.CreationTime = ptr.String(jtv) 9429 } 9430 9431 case "Ip": 9432 if value != nil { 9433 jtv, ok := value.(string) 9434 if !ok { 9435 return fmt.Errorf("expected Ip to be of type string, got %T instead", value) 9436 } 9437 sv.Ip = ptr.String(jtv) 9438 } 9439 9440 case "IpId": 9441 if value != nil { 9442 jtv, ok := value.(string) 9443 if !ok { 9444 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 9445 } 9446 sv.IpId = ptr.String(jtv) 9447 } 9448 9449 case "ModificationTime": 9450 if value != nil { 9451 jtv, ok := value.(string) 9452 if !ok { 9453 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 9454 } 9455 sv.ModificationTime = ptr.String(jtv) 9456 } 9457 9458 case "Status": 9459 if value != nil { 9460 jtv, ok := value.(string) 9461 if !ok { 9462 return fmt.Errorf("expected IpAddressStatus to be of type string, got %T instead", value) 9463 } 9464 sv.Status = types.IpAddressStatus(jtv) 9465 } 9466 9467 case "StatusMessage": 9468 if value != nil { 9469 jtv, ok := value.(string) 9470 if !ok { 9471 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 9472 } 9473 sv.StatusMessage = ptr.String(jtv) 9474 } 9475 9476 case "SubnetId": 9477 if value != nil { 9478 jtv, ok := value.(string) 9479 if !ok { 9480 return fmt.Errorf("expected SubnetId to be of type string, got %T instead", value) 9481 } 9482 sv.SubnetId = ptr.String(jtv) 9483 } 9484 9485 default: 9486 _, _ = key, value 9487 9488 } 9489 } 9490 *v = sv 9491 return nil 9492} 9493 9494func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 9495 if v == nil { 9496 return fmt.Errorf("unexpected nil of type %T", v) 9497 } 9498 if value == nil { 9499 return nil 9500 } 9501 9502 shape, ok := value.(map[string]interface{}) 9503 if !ok { 9504 return fmt.Errorf("unexpected JSON type %v", value) 9505 } 9506 9507 var sv *types.LimitExceededException 9508 if *v == nil { 9509 sv = &types.LimitExceededException{} 9510 } else { 9511 sv = *v 9512 } 9513 9514 for key, value := range shape { 9515 switch key { 9516 case "Message": 9517 if value != nil { 9518 jtv, ok := value.(string) 9519 if !ok { 9520 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9521 } 9522 sv.Message = ptr.String(jtv) 9523 } 9524 9525 case "ResourceType": 9526 if value != nil { 9527 jtv, ok := value.(string) 9528 if !ok { 9529 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9530 } 9531 sv.ResourceType = ptr.String(jtv) 9532 } 9533 9534 default: 9535 _, _ = key, value 9536 9537 } 9538 } 9539 *v = sv 9540 return nil 9541} 9542 9543func awsAwsjson11_deserializeDocumentResolverDnssecConfig(v **types.ResolverDnssecConfig, value interface{}) error { 9544 if v == nil { 9545 return fmt.Errorf("unexpected nil of type %T", v) 9546 } 9547 if value == nil { 9548 return nil 9549 } 9550 9551 shape, ok := value.(map[string]interface{}) 9552 if !ok { 9553 return fmt.Errorf("unexpected JSON type %v", value) 9554 } 9555 9556 var sv *types.ResolverDnssecConfig 9557 if *v == nil { 9558 sv = &types.ResolverDnssecConfig{} 9559 } else { 9560 sv = *v 9561 } 9562 9563 for key, value := range shape { 9564 switch key { 9565 case "Id": 9566 if value != nil { 9567 jtv, ok := value.(string) 9568 if !ok { 9569 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 9570 } 9571 sv.Id = ptr.String(jtv) 9572 } 9573 9574 case "OwnerId": 9575 if value != nil { 9576 jtv, ok := value.(string) 9577 if !ok { 9578 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 9579 } 9580 sv.OwnerId = ptr.String(jtv) 9581 } 9582 9583 case "ResourceId": 9584 if value != nil { 9585 jtv, ok := value.(string) 9586 if !ok { 9587 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 9588 } 9589 sv.ResourceId = ptr.String(jtv) 9590 } 9591 9592 case "ValidationStatus": 9593 if value != nil { 9594 jtv, ok := value.(string) 9595 if !ok { 9596 return fmt.Errorf("expected ResolverDNSSECValidationStatus to be of type string, got %T instead", value) 9597 } 9598 sv.ValidationStatus = types.ResolverDNSSECValidationStatus(jtv) 9599 } 9600 9601 default: 9602 _, _ = key, value 9603 9604 } 9605 } 9606 *v = sv 9607 return nil 9608} 9609 9610func awsAwsjson11_deserializeDocumentResolverDnssecConfigList(v *[]types.ResolverDnssecConfig, value interface{}) error { 9611 if v == nil { 9612 return fmt.Errorf("unexpected nil of type %T", v) 9613 } 9614 if value == nil { 9615 return nil 9616 } 9617 9618 shape, ok := value.([]interface{}) 9619 if !ok { 9620 return fmt.Errorf("unexpected JSON type %v", value) 9621 } 9622 9623 var cv []types.ResolverDnssecConfig 9624 if *v == nil { 9625 cv = []types.ResolverDnssecConfig{} 9626 } else { 9627 cv = *v 9628 } 9629 9630 for _, value := range shape { 9631 var col types.ResolverDnssecConfig 9632 destAddr := &col 9633 if err := awsAwsjson11_deserializeDocumentResolverDnssecConfig(&destAddr, value); err != nil { 9634 return err 9635 } 9636 col = *destAddr 9637 cv = append(cv, col) 9638 9639 } 9640 *v = cv 9641 return nil 9642} 9643 9644func awsAwsjson11_deserializeDocumentResolverEndpoint(v **types.ResolverEndpoint, value interface{}) error { 9645 if v == nil { 9646 return fmt.Errorf("unexpected nil of type %T", v) 9647 } 9648 if value == nil { 9649 return nil 9650 } 9651 9652 shape, ok := value.(map[string]interface{}) 9653 if !ok { 9654 return fmt.Errorf("unexpected JSON type %v", value) 9655 } 9656 9657 var sv *types.ResolverEndpoint 9658 if *v == nil { 9659 sv = &types.ResolverEndpoint{} 9660 } else { 9661 sv = *v 9662 } 9663 9664 for key, value := range shape { 9665 switch key { 9666 case "Arn": 9667 if value != nil { 9668 jtv, ok := value.(string) 9669 if !ok { 9670 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 9671 } 9672 sv.Arn = ptr.String(jtv) 9673 } 9674 9675 case "CreationTime": 9676 if value != nil { 9677 jtv, ok := value.(string) 9678 if !ok { 9679 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 9680 } 9681 sv.CreationTime = ptr.String(jtv) 9682 } 9683 9684 case "CreatorRequestId": 9685 if value != nil { 9686 jtv, ok := value.(string) 9687 if !ok { 9688 return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value) 9689 } 9690 sv.CreatorRequestId = ptr.String(jtv) 9691 } 9692 9693 case "Direction": 9694 if value != nil { 9695 jtv, ok := value.(string) 9696 if !ok { 9697 return fmt.Errorf("expected ResolverEndpointDirection to be of type string, got %T instead", value) 9698 } 9699 sv.Direction = types.ResolverEndpointDirection(jtv) 9700 } 9701 9702 case "HostVPCId": 9703 if value != nil { 9704 jtv, ok := value.(string) 9705 if !ok { 9706 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 9707 } 9708 sv.HostVPCId = ptr.String(jtv) 9709 } 9710 9711 case "Id": 9712 if value != nil { 9713 jtv, ok := value.(string) 9714 if !ok { 9715 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 9716 } 9717 sv.Id = ptr.String(jtv) 9718 } 9719 9720 case "IpAddressCount": 9721 if value != nil { 9722 jtv, ok := value.(json.Number) 9723 if !ok { 9724 return fmt.Errorf("expected IpAddressCount to be json.Number, got %T instead", value) 9725 } 9726 i64, err := jtv.Int64() 9727 if err != nil { 9728 return err 9729 } 9730 sv.IpAddressCount = ptr.Int32(int32(i64)) 9731 } 9732 9733 case "ModificationTime": 9734 if value != nil { 9735 jtv, ok := value.(string) 9736 if !ok { 9737 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 9738 } 9739 sv.ModificationTime = ptr.String(jtv) 9740 } 9741 9742 case "Name": 9743 if value != nil { 9744 jtv, ok := value.(string) 9745 if !ok { 9746 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 9747 } 9748 sv.Name = ptr.String(jtv) 9749 } 9750 9751 case "SecurityGroupIds": 9752 if err := awsAwsjson11_deserializeDocumentSecurityGroupIds(&sv.SecurityGroupIds, value); err != nil { 9753 return err 9754 } 9755 9756 case "Status": 9757 if value != nil { 9758 jtv, ok := value.(string) 9759 if !ok { 9760 return fmt.Errorf("expected ResolverEndpointStatus to be of type string, got %T instead", value) 9761 } 9762 sv.Status = types.ResolverEndpointStatus(jtv) 9763 } 9764 9765 case "StatusMessage": 9766 if value != nil { 9767 jtv, ok := value.(string) 9768 if !ok { 9769 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 9770 } 9771 sv.StatusMessage = ptr.String(jtv) 9772 } 9773 9774 default: 9775 _, _ = key, value 9776 9777 } 9778 } 9779 *v = sv 9780 return nil 9781} 9782 9783func awsAwsjson11_deserializeDocumentResolverEndpoints(v *[]types.ResolverEndpoint, value interface{}) error { 9784 if v == nil { 9785 return fmt.Errorf("unexpected nil of type %T", v) 9786 } 9787 if value == nil { 9788 return nil 9789 } 9790 9791 shape, ok := value.([]interface{}) 9792 if !ok { 9793 return fmt.Errorf("unexpected JSON type %v", value) 9794 } 9795 9796 var cv []types.ResolverEndpoint 9797 if *v == nil { 9798 cv = []types.ResolverEndpoint{} 9799 } else { 9800 cv = *v 9801 } 9802 9803 for _, value := range shape { 9804 var col types.ResolverEndpoint 9805 destAddr := &col 9806 if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&destAddr, value); err != nil { 9807 return err 9808 } 9809 col = *destAddr 9810 cv = append(cv, col) 9811 9812 } 9813 *v = cv 9814 return nil 9815} 9816 9817func awsAwsjson11_deserializeDocumentResolverQueryLogConfig(v **types.ResolverQueryLogConfig, value interface{}) error { 9818 if v == nil { 9819 return fmt.Errorf("unexpected nil of type %T", v) 9820 } 9821 if value == nil { 9822 return nil 9823 } 9824 9825 shape, ok := value.(map[string]interface{}) 9826 if !ok { 9827 return fmt.Errorf("unexpected JSON type %v", value) 9828 } 9829 9830 var sv *types.ResolverQueryLogConfig 9831 if *v == nil { 9832 sv = &types.ResolverQueryLogConfig{} 9833 } else { 9834 sv = *v 9835 } 9836 9837 for key, value := range shape { 9838 switch key { 9839 case "Arn": 9840 if value != nil { 9841 jtv, ok := value.(string) 9842 if !ok { 9843 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 9844 } 9845 sv.Arn = ptr.String(jtv) 9846 } 9847 9848 case "AssociationCount": 9849 if value != nil { 9850 jtv, ok := value.(json.Number) 9851 if !ok { 9852 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 9853 } 9854 i64, err := jtv.Int64() 9855 if err != nil { 9856 return err 9857 } 9858 sv.AssociationCount = int32(i64) 9859 } 9860 9861 case "CreationTime": 9862 if value != nil { 9863 jtv, ok := value.(string) 9864 if !ok { 9865 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 9866 } 9867 sv.CreationTime = ptr.String(jtv) 9868 } 9869 9870 case "CreatorRequestId": 9871 if value != nil { 9872 jtv, ok := value.(string) 9873 if !ok { 9874 return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value) 9875 } 9876 sv.CreatorRequestId = ptr.String(jtv) 9877 } 9878 9879 case "DestinationArn": 9880 if value != nil { 9881 jtv, ok := value.(string) 9882 if !ok { 9883 return fmt.Errorf("expected DestinationArn to be of type string, got %T instead", value) 9884 } 9885 sv.DestinationArn = ptr.String(jtv) 9886 } 9887 9888 case "Id": 9889 if value != nil { 9890 jtv, ok := value.(string) 9891 if !ok { 9892 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 9893 } 9894 sv.Id = ptr.String(jtv) 9895 } 9896 9897 case "Name": 9898 if value != nil { 9899 jtv, ok := value.(string) 9900 if !ok { 9901 return fmt.Errorf("expected ResolverQueryLogConfigName to be of type string, got %T instead", value) 9902 } 9903 sv.Name = ptr.String(jtv) 9904 } 9905 9906 case "OwnerId": 9907 if value != nil { 9908 jtv, ok := value.(string) 9909 if !ok { 9910 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 9911 } 9912 sv.OwnerId = ptr.String(jtv) 9913 } 9914 9915 case "ShareStatus": 9916 if value != nil { 9917 jtv, ok := value.(string) 9918 if !ok { 9919 return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value) 9920 } 9921 sv.ShareStatus = types.ShareStatus(jtv) 9922 } 9923 9924 case "Status": 9925 if value != nil { 9926 jtv, ok := value.(string) 9927 if !ok { 9928 return fmt.Errorf("expected ResolverQueryLogConfigStatus to be of type string, got %T instead", value) 9929 } 9930 sv.Status = types.ResolverQueryLogConfigStatus(jtv) 9931 } 9932 9933 default: 9934 _, _ = key, value 9935 9936 } 9937 } 9938 *v = sv 9939 return nil 9940} 9941 9942func awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociation(v **types.ResolverQueryLogConfigAssociation, value interface{}) error { 9943 if v == nil { 9944 return fmt.Errorf("unexpected nil of type %T", v) 9945 } 9946 if value == nil { 9947 return nil 9948 } 9949 9950 shape, ok := value.(map[string]interface{}) 9951 if !ok { 9952 return fmt.Errorf("unexpected JSON type %v", value) 9953 } 9954 9955 var sv *types.ResolverQueryLogConfigAssociation 9956 if *v == nil { 9957 sv = &types.ResolverQueryLogConfigAssociation{} 9958 } else { 9959 sv = *v 9960 } 9961 9962 for key, value := range shape { 9963 switch key { 9964 case "CreationTime": 9965 if value != nil { 9966 jtv, ok := value.(string) 9967 if !ok { 9968 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 9969 } 9970 sv.CreationTime = ptr.String(jtv) 9971 } 9972 9973 case "Error": 9974 if value != nil { 9975 jtv, ok := value.(string) 9976 if !ok { 9977 return fmt.Errorf("expected ResolverQueryLogConfigAssociationError to be of type string, got %T instead", value) 9978 } 9979 sv.Error = types.ResolverQueryLogConfigAssociationError(jtv) 9980 } 9981 9982 case "ErrorMessage": 9983 if value != nil { 9984 jtv, ok := value.(string) 9985 if !ok { 9986 return fmt.Errorf("expected ResolverQueryLogConfigAssociationErrorMessage to be of type string, got %T instead", value) 9987 } 9988 sv.ErrorMessage = ptr.String(jtv) 9989 } 9990 9991 case "Id": 9992 if value != nil { 9993 jtv, ok := value.(string) 9994 if !ok { 9995 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 9996 } 9997 sv.Id = ptr.String(jtv) 9998 } 9999 10000 case "ResolverQueryLogConfigId": 10001 if value != nil { 10002 jtv, ok := value.(string) 10003 if !ok { 10004 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 10005 } 10006 sv.ResolverQueryLogConfigId = ptr.String(jtv) 10007 } 10008 10009 case "ResourceId": 10010 if value != nil { 10011 jtv, ok := value.(string) 10012 if !ok { 10013 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 10014 } 10015 sv.ResourceId = ptr.String(jtv) 10016 } 10017 10018 case "Status": 10019 if value != nil { 10020 jtv, ok := value.(string) 10021 if !ok { 10022 return fmt.Errorf("expected ResolverQueryLogConfigAssociationStatus to be of type string, got %T instead", value) 10023 } 10024 sv.Status = types.ResolverQueryLogConfigAssociationStatus(jtv) 10025 } 10026 10027 default: 10028 _, _ = key, value 10029 10030 } 10031 } 10032 *v = sv 10033 return nil 10034} 10035 10036func awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociationList(v *[]types.ResolverQueryLogConfigAssociation, value interface{}) error { 10037 if v == nil { 10038 return fmt.Errorf("unexpected nil of type %T", v) 10039 } 10040 if value == nil { 10041 return nil 10042 } 10043 10044 shape, ok := value.([]interface{}) 10045 if !ok { 10046 return fmt.Errorf("unexpected JSON type %v", value) 10047 } 10048 10049 var cv []types.ResolverQueryLogConfigAssociation 10050 if *v == nil { 10051 cv = []types.ResolverQueryLogConfigAssociation{} 10052 } else { 10053 cv = *v 10054 } 10055 10056 for _, value := range shape { 10057 var col types.ResolverQueryLogConfigAssociation 10058 destAddr := &col 10059 if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociation(&destAddr, value); err != nil { 10060 return err 10061 } 10062 col = *destAddr 10063 cv = append(cv, col) 10064 10065 } 10066 *v = cv 10067 return nil 10068} 10069 10070func awsAwsjson11_deserializeDocumentResolverQueryLogConfigList(v *[]types.ResolverQueryLogConfig, value interface{}) error { 10071 if v == nil { 10072 return fmt.Errorf("unexpected nil of type %T", v) 10073 } 10074 if value == nil { 10075 return nil 10076 } 10077 10078 shape, ok := value.([]interface{}) 10079 if !ok { 10080 return fmt.Errorf("unexpected JSON type %v", value) 10081 } 10082 10083 var cv []types.ResolverQueryLogConfig 10084 if *v == nil { 10085 cv = []types.ResolverQueryLogConfig{} 10086 } else { 10087 cv = *v 10088 } 10089 10090 for _, value := range shape { 10091 var col types.ResolverQueryLogConfig 10092 destAddr := &col 10093 if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfig(&destAddr, value); err != nil { 10094 return err 10095 } 10096 col = *destAddr 10097 cv = append(cv, col) 10098 10099 } 10100 *v = cv 10101 return nil 10102} 10103 10104func awsAwsjson11_deserializeDocumentResolverRule(v **types.ResolverRule, value interface{}) error { 10105 if v == nil { 10106 return fmt.Errorf("unexpected nil of type %T", v) 10107 } 10108 if value == nil { 10109 return nil 10110 } 10111 10112 shape, ok := value.(map[string]interface{}) 10113 if !ok { 10114 return fmt.Errorf("unexpected JSON type %v", value) 10115 } 10116 10117 var sv *types.ResolverRule 10118 if *v == nil { 10119 sv = &types.ResolverRule{} 10120 } else { 10121 sv = *v 10122 } 10123 10124 for key, value := range shape { 10125 switch key { 10126 case "Arn": 10127 if value != nil { 10128 jtv, ok := value.(string) 10129 if !ok { 10130 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10131 } 10132 sv.Arn = ptr.String(jtv) 10133 } 10134 10135 case "CreationTime": 10136 if value != nil { 10137 jtv, ok := value.(string) 10138 if !ok { 10139 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 10140 } 10141 sv.CreationTime = ptr.String(jtv) 10142 } 10143 10144 case "CreatorRequestId": 10145 if value != nil { 10146 jtv, ok := value.(string) 10147 if !ok { 10148 return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value) 10149 } 10150 sv.CreatorRequestId = ptr.String(jtv) 10151 } 10152 10153 case "DomainName": 10154 if value != nil { 10155 jtv, ok := value.(string) 10156 if !ok { 10157 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value) 10158 } 10159 sv.DomainName = ptr.String(jtv) 10160 } 10161 10162 case "Id": 10163 if value != nil { 10164 jtv, ok := value.(string) 10165 if !ok { 10166 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 10167 } 10168 sv.Id = ptr.String(jtv) 10169 } 10170 10171 case "ModificationTime": 10172 if value != nil { 10173 jtv, ok := value.(string) 10174 if !ok { 10175 return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value) 10176 } 10177 sv.ModificationTime = ptr.String(jtv) 10178 } 10179 10180 case "Name": 10181 if value != nil { 10182 jtv, ok := value.(string) 10183 if !ok { 10184 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 10185 } 10186 sv.Name = ptr.String(jtv) 10187 } 10188 10189 case "OwnerId": 10190 if value != nil { 10191 jtv, ok := value.(string) 10192 if !ok { 10193 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10194 } 10195 sv.OwnerId = ptr.String(jtv) 10196 } 10197 10198 case "ResolverEndpointId": 10199 if value != nil { 10200 jtv, ok := value.(string) 10201 if !ok { 10202 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 10203 } 10204 sv.ResolverEndpointId = ptr.String(jtv) 10205 } 10206 10207 case "RuleType": 10208 if value != nil { 10209 jtv, ok := value.(string) 10210 if !ok { 10211 return fmt.Errorf("expected RuleTypeOption to be of type string, got %T instead", value) 10212 } 10213 sv.RuleType = types.RuleTypeOption(jtv) 10214 } 10215 10216 case "ShareStatus": 10217 if value != nil { 10218 jtv, ok := value.(string) 10219 if !ok { 10220 return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value) 10221 } 10222 sv.ShareStatus = types.ShareStatus(jtv) 10223 } 10224 10225 case "Status": 10226 if value != nil { 10227 jtv, ok := value.(string) 10228 if !ok { 10229 return fmt.Errorf("expected ResolverRuleStatus to be of type string, got %T instead", value) 10230 } 10231 sv.Status = types.ResolverRuleStatus(jtv) 10232 } 10233 10234 case "StatusMessage": 10235 if value != nil { 10236 jtv, ok := value.(string) 10237 if !ok { 10238 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 10239 } 10240 sv.StatusMessage = ptr.String(jtv) 10241 } 10242 10243 case "TargetIps": 10244 if err := awsAwsjson11_deserializeDocumentTargetList(&sv.TargetIps, value); err != nil { 10245 return err 10246 } 10247 10248 default: 10249 _, _ = key, value 10250 10251 } 10252 } 10253 *v = sv 10254 return nil 10255} 10256 10257func awsAwsjson11_deserializeDocumentResolverRuleAssociation(v **types.ResolverRuleAssociation, value interface{}) error { 10258 if v == nil { 10259 return fmt.Errorf("unexpected nil of type %T", v) 10260 } 10261 if value == nil { 10262 return nil 10263 } 10264 10265 shape, ok := value.(map[string]interface{}) 10266 if !ok { 10267 return fmt.Errorf("unexpected JSON type %v", value) 10268 } 10269 10270 var sv *types.ResolverRuleAssociation 10271 if *v == nil { 10272 sv = &types.ResolverRuleAssociation{} 10273 } else { 10274 sv = *v 10275 } 10276 10277 for key, value := range shape { 10278 switch key { 10279 case "Id": 10280 if value != nil { 10281 jtv, ok := value.(string) 10282 if !ok { 10283 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 10284 } 10285 sv.Id = ptr.String(jtv) 10286 } 10287 10288 case "Name": 10289 if value != nil { 10290 jtv, ok := value.(string) 10291 if !ok { 10292 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 10293 } 10294 sv.Name = ptr.String(jtv) 10295 } 10296 10297 case "ResolverRuleId": 10298 if value != nil { 10299 jtv, ok := value.(string) 10300 if !ok { 10301 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 10302 } 10303 sv.ResolverRuleId = ptr.String(jtv) 10304 } 10305 10306 case "Status": 10307 if value != nil { 10308 jtv, ok := value.(string) 10309 if !ok { 10310 return fmt.Errorf("expected ResolverRuleAssociationStatus to be of type string, got %T instead", value) 10311 } 10312 sv.Status = types.ResolverRuleAssociationStatus(jtv) 10313 } 10314 10315 case "StatusMessage": 10316 if value != nil { 10317 jtv, ok := value.(string) 10318 if !ok { 10319 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 10320 } 10321 sv.StatusMessage = ptr.String(jtv) 10322 } 10323 10324 case "VPCId": 10325 if value != nil { 10326 jtv, ok := value.(string) 10327 if !ok { 10328 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 10329 } 10330 sv.VPCId = ptr.String(jtv) 10331 } 10332 10333 default: 10334 _, _ = key, value 10335 10336 } 10337 } 10338 *v = sv 10339 return nil 10340} 10341 10342func awsAwsjson11_deserializeDocumentResolverRuleAssociations(v *[]types.ResolverRuleAssociation, value interface{}) error { 10343 if v == nil { 10344 return fmt.Errorf("unexpected nil of type %T", v) 10345 } 10346 if value == nil { 10347 return nil 10348 } 10349 10350 shape, ok := value.([]interface{}) 10351 if !ok { 10352 return fmt.Errorf("unexpected JSON type %v", value) 10353 } 10354 10355 var cv []types.ResolverRuleAssociation 10356 if *v == nil { 10357 cv = []types.ResolverRuleAssociation{} 10358 } else { 10359 cv = *v 10360 } 10361 10362 for _, value := range shape { 10363 var col types.ResolverRuleAssociation 10364 destAddr := &col 10365 if err := awsAwsjson11_deserializeDocumentResolverRuleAssociation(&destAddr, value); err != nil { 10366 return err 10367 } 10368 col = *destAddr 10369 cv = append(cv, col) 10370 10371 } 10372 *v = cv 10373 return nil 10374} 10375 10376func awsAwsjson11_deserializeDocumentResolverRules(v *[]types.ResolverRule, value interface{}) error { 10377 if v == nil { 10378 return fmt.Errorf("unexpected nil of type %T", v) 10379 } 10380 if value == nil { 10381 return nil 10382 } 10383 10384 shape, ok := value.([]interface{}) 10385 if !ok { 10386 return fmt.Errorf("unexpected JSON type %v", value) 10387 } 10388 10389 var cv []types.ResolverRule 10390 if *v == nil { 10391 cv = []types.ResolverRule{} 10392 } else { 10393 cv = *v 10394 } 10395 10396 for _, value := range shape { 10397 var col types.ResolverRule 10398 destAddr := &col 10399 if err := awsAwsjson11_deserializeDocumentResolverRule(&destAddr, value); err != nil { 10400 return err 10401 } 10402 col = *destAddr 10403 cv = append(cv, col) 10404 10405 } 10406 *v = cv 10407 return nil 10408} 10409 10410func awsAwsjson11_deserializeDocumentResourceExistsException(v **types.ResourceExistsException, value interface{}) error { 10411 if v == nil { 10412 return fmt.Errorf("unexpected nil of type %T", v) 10413 } 10414 if value == nil { 10415 return nil 10416 } 10417 10418 shape, ok := value.(map[string]interface{}) 10419 if !ok { 10420 return fmt.Errorf("unexpected JSON type %v", value) 10421 } 10422 10423 var sv *types.ResourceExistsException 10424 if *v == nil { 10425 sv = &types.ResourceExistsException{} 10426 } else { 10427 sv = *v 10428 } 10429 10430 for key, value := range shape { 10431 switch key { 10432 case "Message": 10433 if value != nil { 10434 jtv, ok := value.(string) 10435 if !ok { 10436 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10437 } 10438 sv.Message = ptr.String(jtv) 10439 } 10440 10441 case "ResourceType": 10442 if value != nil { 10443 jtv, ok := value.(string) 10444 if !ok { 10445 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10446 } 10447 sv.ResourceType = ptr.String(jtv) 10448 } 10449 10450 default: 10451 _, _ = key, value 10452 10453 } 10454 } 10455 *v = sv 10456 return nil 10457} 10458 10459func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 10460 if v == nil { 10461 return fmt.Errorf("unexpected nil of type %T", v) 10462 } 10463 if value == nil { 10464 return nil 10465 } 10466 10467 shape, ok := value.(map[string]interface{}) 10468 if !ok { 10469 return fmt.Errorf("unexpected JSON type %v", value) 10470 } 10471 10472 var sv *types.ResourceInUseException 10473 if *v == nil { 10474 sv = &types.ResourceInUseException{} 10475 } else { 10476 sv = *v 10477 } 10478 10479 for key, value := range shape { 10480 switch key { 10481 case "Message": 10482 if value != nil { 10483 jtv, ok := value.(string) 10484 if !ok { 10485 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10486 } 10487 sv.Message = ptr.String(jtv) 10488 } 10489 10490 case "ResourceType": 10491 if value != nil { 10492 jtv, ok := value.(string) 10493 if !ok { 10494 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10495 } 10496 sv.ResourceType = ptr.String(jtv) 10497 } 10498 10499 default: 10500 _, _ = key, value 10501 10502 } 10503 } 10504 *v = sv 10505 return nil 10506} 10507 10508func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 10509 if v == nil { 10510 return fmt.Errorf("unexpected nil of type %T", v) 10511 } 10512 if value == nil { 10513 return nil 10514 } 10515 10516 shape, ok := value.(map[string]interface{}) 10517 if !ok { 10518 return fmt.Errorf("unexpected JSON type %v", value) 10519 } 10520 10521 var sv *types.ResourceNotFoundException 10522 if *v == nil { 10523 sv = &types.ResourceNotFoundException{} 10524 } else { 10525 sv = *v 10526 } 10527 10528 for key, value := range shape { 10529 switch key { 10530 case "Message": 10531 if value != nil { 10532 jtv, ok := value.(string) 10533 if !ok { 10534 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10535 } 10536 sv.Message = ptr.String(jtv) 10537 } 10538 10539 case "ResourceType": 10540 if value != nil { 10541 jtv, ok := value.(string) 10542 if !ok { 10543 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10544 } 10545 sv.ResourceType = ptr.String(jtv) 10546 } 10547 10548 default: 10549 _, _ = key, value 10550 10551 } 10552 } 10553 *v = sv 10554 return nil 10555} 10556 10557func awsAwsjson11_deserializeDocumentResourceUnavailableException(v **types.ResourceUnavailableException, value interface{}) error { 10558 if v == nil { 10559 return fmt.Errorf("unexpected nil of type %T", v) 10560 } 10561 if value == nil { 10562 return nil 10563 } 10564 10565 shape, ok := value.(map[string]interface{}) 10566 if !ok { 10567 return fmt.Errorf("unexpected JSON type %v", value) 10568 } 10569 10570 var sv *types.ResourceUnavailableException 10571 if *v == nil { 10572 sv = &types.ResourceUnavailableException{} 10573 } else { 10574 sv = *v 10575 } 10576 10577 for key, value := range shape { 10578 switch key { 10579 case "Message": 10580 if value != nil { 10581 jtv, ok := value.(string) 10582 if !ok { 10583 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10584 } 10585 sv.Message = ptr.String(jtv) 10586 } 10587 10588 case "ResourceType": 10589 if value != nil { 10590 jtv, ok := value.(string) 10591 if !ok { 10592 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10593 } 10594 sv.ResourceType = ptr.String(jtv) 10595 } 10596 10597 default: 10598 _, _ = key, value 10599 10600 } 10601 } 10602 *v = sv 10603 return nil 10604} 10605 10606func awsAwsjson11_deserializeDocumentSecurityGroupIds(v *[]string, value interface{}) error { 10607 if v == nil { 10608 return fmt.Errorf("unexpected nil of type %T", v) 10609 } 10610 if value == nil { 10611 return nil 10612 } 10613 10614 shape, ok := value.([]interface{}) 10615 if !ok { 10616 return fmt.Errorf("unexpected JSON type %v", value) 10617 } 10618 10619 var cv []string 10620 if *v == nil { 10621 cv = []string{} 10622 } else { 10623 cv = *v 10624 } 10625 10626 for _, value := range shape { 10627 var col string 10628 if value != nil { 10629 jtv, ok := value.(string) 10630 if !ok { 10631 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 10632 } 10633 col = jtv 10634 } 10635 cv = append(cv, col) 10636 10637 } 10638 *v = cv 10639 return nil 10640} 10641 10642func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 10643 if v == nil { 10644 return fmt.Errorf("unexpected nil of type %T", v) 10645 } 10646 if value == nil { 10647 return nil 10648 } 10649 10650 shape, ok := value.(map[string]interface{}) 10651 if !ok { 10652 return fmt.Errorf("unexpected JSON type %v", value) 10653 } 10654 10655 var sv *types.Tag 10656 if *v == nil { 10657 sv = &types.Tag{} 10658 } else { 10659 sv = *v 10660 } 10661 10662 for key, value := range shape { 10663 switch key { 10664 case "Key": 10665 if value != nil { 10666 jtv, ok := value.(string) 10667 if !ok { 10668 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 10669 } 10670 sv.Key = ptr.String(jtv) 10671 } 10672 10673 case "Value": 10674 if value != nil { 10675 jtv, ok := value.(string) 10676 if !ok { 10677 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 10678 } 10679 sv.Value = ptr.String(jtv) 10680 } 10681 10682 default: 10683 _, _ = key, value 10684 10685 } 10686 } 10687 *v = sv 10688 return nil 10689} 10690 10691func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 10692 if v == nil { 10693 return fmt.Errorf("unexpected nil of type %T", v) 10694 } 10695 if value == nil { 10696 return nil 10697 } 10698 10699 shape, ok := value.([]interface{}) 10700 if !ok { 10701 return fmt.Errorf("unexpected JSON type %v", value) 10702 } 10703 10704 var cv []types.Tag 10705 if *v == nil { 10706 cv = []types.Tag{} 10707 } else { 10708 cv = *v 10709 } 10710 10711 for _, value := range shape { 10712 var col types.Tag 10713 destAddr := &col 10714 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 10715 return err 10716 } 10717 col = *destAddr 10718 cv = append(cv, col) 10719 10720 } 10721 *v = cv 10722 return nil 10723} 10724 10725func awsAwsjson11_deserializeDocumentTargetAddress(v **types.TargetAddress, value interface{}) error { 10726 if v == nil { 10727 return fmt.Errorf("unexpected nil of type %T", v) 10728 } 10729 if value == nil { 10730 return nil 10731 } 10732 10733 shape, ok := value.(map[string]interface{}) 10734 if !ok { 10735 return fmt.Errorf("unexpected JSON type %v", value) 10736 } 10737 10738 var sv *types.TargetAddress 10739 if *v == nil { 10740 sv = &types.TargetAddress{} 10741 } else { 10742 sv = *v 10743 } 10744 10745 for key, value := range shape { 10746 switch key { 10747 case "Ip": 10748 if value != nil { 10749 jtv, ok := value.(string) 10750 if !ok { 10751 return fmt.Errorf("expected Ip to be of type string, got %T instead", value) 10752 } 10753 sv.Ip = ptr.String(jtv) 10754 } 10755 10756 case "Port": 10757 if value != nil { 10758 jtv, ok := value.(json.Number) 10759 if !ok { 10760 return fmt.Errorf("expected Port to be json.Number, got %T instead", value) 10761 } 10762 i64, err := jtv.Int64() 10763 if err != nil { 10764 return err 10765 } 10766 sv.Port = ptr.Int32(int32(i64)) 10767 } 10768 10769 default: 10770 _, _ = key, value 10771 10772 } 10773 } 10774 *v = sv 10775 return nil 10776} 10777 10778func awsAwsjson11_deserializeDocumentTargetList(v *[]types.TargetAddress, value interface{}) error { 10779 if v == nil { 10780 return fmt.Errorf("unexpected nil of type %T", v) 10781 } 10782 if value == nil { 10783 return nil 10784 } 10785 10786 shape, ok := value.([]interface{}) 10787 if !ok { 10788 return fmt.Errorf("unexpected JSON type %v", value) 10789 } 10790 10791 var cv []types.TargetAddress 10792 if *v == nil { 10793 cv = []types.TargetAddress{} 10794 } else { 10795 cv = *v 10796 } 10797 10798 for _, value := range shape { 10799 var col types.TargetAddress 10800 destAddr := &col 10801 if err := awsAwsjson11_deserializeDocumentTargetAddress(&destAddr, value); err != nil { 10802 return err 10803 } 10804 col = *destAddr 10805 cv = append(cv, col) 10806 10807 } 10808 *v = cv 10809 return nil 10810} 10811 10812func awsAwsjson11_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { 10813 if v == nil { 10814 return fmt.Errorf("unexpected nil of type %T", v) 10815 } 10816 if value == nil { 10817 return nil 10818 } 10819 10820 shape, ok := value.(map[string]interface{}) 10821 if !ok { 10822 return fmt.Errorf("unexpected JSON type %v", value) 10823 } 10824 10825 var sv *types.ThrottlingException 10826 if *v == nil { 10827 sv = &types.ThrottlingException{} 10828 } else { 10829 sv = *v 10830 } 10831 10832 for key, value := range shape { 10833 switch key { 10834 case "Message": 10835 if value != nil { 10836 jtv, ok := value.(string) 10837 if !ok { 10838 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10839 } 10840 sv.Message = ptr.String(jtv) 10841 } 10842 10843 default: 10844 _, _ = key, value 10845 10846 } 10847 } 10848 *v = sv 10849 return nil 10850} 10851 10852func awsAwsjson11_deserializeDocumentUnknownResourceException(v **types.UnknownResourceException, value interface{}) error { 10853 if v == nil { 10854 return fmt.Errorf("unexpected nil of type %T", v) 10855 } 10856 if value == nil { 10857 return nil 10858 } 10859 10860 shape, ok := value.(map[string]interface{}) 10861 if !ok { 10862 return fmt.Errorf("unexpected JSON type %v", value) 10863 } 10864 10865 var sv *types.UnknownResourceException 10866 if *v == nil { 10867 sv = &types.UnknownResourceException{} 10868 } else { 10869 sv = *v 10870 } 10871 10872 for key, value := range shape { 10873 switch key { 10874 case "Message": 10875 if value != nil { 10876 jtv, ok := value.(string) 10877 if !ok { 10878 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10879 } 10880 sv.Message = ptr.String(jtv) 10881 } 10882 10883 default: 10884 _, _ = key, value 10885 10886 } 10887 } 10888 *v = sv 10889 return nil 10890} 10891 10892func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { 10893 if v == nil { 10894 return fmt.Errorf("unexpected nil of type %T", v) 10895 } 10896 if value == nil { 10897 return nil 10898 } 10899 10900 shape, ok := value.(map[string]interface{}) 10901 if !ok { 10902 return fmt.Errorf("unexpected JSON type %v", value) 10903 } 10904 10905 var sv *types.ValidationException 10906 if *v == nil { 10907 sv = &types.ValidationException{} 10908 } else { 10909 sv = *v 10910 } 10911 10912 for key, value := range shape { 10913 switch key { 10914 case "Message": 10915 if value != nil { 10916 jtv, ok := value.(string) 10917 if !ok { 10918 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10919 } 10920 sv.Message = ptr.String(jtv) 10921 } 10922 10923 default: 10924 _, _ = key, value 10925 10926 } 10927 } 10928 *v = sv 10929 return nil 10930} 10931 10932func awsAwsjson11_deserializeOpDocumentAssociateFirewallRuleGroupOutput(v **AssociateFirewallRuleGroupOutput, value interface{}) error { 10933 if v == nil { 10934 return fmt.Errorf("unexpected nil of type %T", v) 10935 } 10936 if value == nil { 10937 return nil 10938 } 10939 10940 shape, ok := value.(map[string]interface{}) 10941 if !ok { 10942 return fmt.Errorf("unexpected JSON type %v", value) 10943 } 10944 10945 var sv *AssociateFirewallRuleGroupOutput 10946 if *v == nil { 10947 sv = &AssociateFirewallRuleGroupOutput{} 10948 } else { 10949 sv = *v 10950 } 10951 10952 for key, value := range shape { 10953 switch key { 10954 case "FirewallRuleGroupAssociation": 10955 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(&sv.FirewallRuleGroupAssociation, value); err != nil { 10956 return err 10957 } 10958 10959 default: 10960 _, _ = key, value 10961 10962 } 10963 } 10964 *v = sv 10965 return nil 10966} 10967 10968func awsAwsjson11_deserializeOpDocumentAssociateResolverEndpointIpAddressOutput(v **AssociateResolverEndpointIpAddressOutput, value interface{}) error { 10969 if v == nil { 10970 return fmt.Errorf("unexpected nil of type %T", v) 10971 } 10972 if value == nil { 10973 return nil 10974 } 10975 10976 shape, ok := value.(map[string]interface{}) 10977 if !ok { 10978 return fmt.Errorf("unexpected JSON type %v", value) 10979 } 10980 10981 var sv *AssociateResolverEndpointIpAddressOutput 10982 if *v == nil { 10983 sv = &AssociateResolverEndpointIpAddressOutput{} 10984 } else { 10985 sv = *v 10986 } 10987 10988 for key, value := range shape { 10989 switch key { 10990 case "ResolverEndpoint": 10991 if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil { 10992 return err 10993 } 10994 10995 default: 10996 _, _ = key, value 10997 10998 } 10999 } 11000 *v = sv 11001 return nil 11002} 11003 11004func awsAwsjson11_deserializeOpDocumentAssociateResolverQueryLogConfigOutput(v **AssociateResolverQueryLogConfigOutput, value interface{}) error { 11005 if v == nil { 11006 return fmt.Errorf("unexpected nil of type %T", v) 11007 } 11008 if value == nil { 11009 return nil 11010 } 11011 11012 shape, ok := value.(map[string]interface{}) 11013 if !ok { 11014 return fmt.Errorf("unexpected JSON type %v", value) 11015 } 11016 11017 var sv *AssociateResolverQueryLogConfigOutput 11018 if *v == nil { 11019 sv = &AssociateResolverQueryLogConfigOutput{} 11020 } else { 11021 sv = *v 11022 } 11023 11024 for key, value := range shape { 11025 switch key { 11026 case "ResolverQueryLogConfigAssociation": 11027 if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociation(&sv.ResolverQueryLogConfigAssociation, value); err != nil { 11028 return err 11029 } 11030 11031 default: 11032 _, _ = key, value 11033 11034 } 11035 } 11036 *v = sv 11037 return nil 11038} 11039 11040func awsAwsjson11_deserializeOpDocumentAssociateResolverRuleOutput(v **AssociateResolverRuleOutput, value interface{}) error { 11041 if v == nil { 11042 return fmt.Errorf("unexpected nil of type %T", v) 11043 } 11044 if value == nil { 11045 return nil 11046 } 11047 11048 shape, ok := value.(map[string]interface{}) 11049 if !ok { 11050 return fmt.Errorf("unexpected JSON type %v", value) 11051 } 11052 11053 var sv *AssociateResolverRuleOutput 11054 if *v == nil { 11055 sv = &AssociateResolverRuleOutput{} 11056 } else { 11057 sv = *v 11058 } 11059 11060 for key, value := range shape { 11061 switch key { 11062 case "ResolverRuleAssociation": 11063 if err := awsAwsjson11_deserializeDocumentResolverRuleAssociation(&sv.ResolverRuleAssociation, value); err != nil { 11064 return err 11065 } 11066 11067 default: 11068 _, _ = key, value 11069 11070 } 11071 } 11072 *v = sv 11073 return nil 11074} 11075 11076func awsAwsjson11_deserializeOpDocumentCreateFirewallDomainListOutput(v **CreateFirewallDomainListOutput, value interface{}) error { 11077 if v == nil { 11078 return fmt.Errorf("unexpected nil of type %T", v) 11079 } 11080 if value == nil { 11081 return nil 11082 } 11083 11084 shape, ok := value.(map[string]interface{}) 11085 if !ok { 11086 return fmt.Errorf("unexpected JSON type %v", value) 11087 } 11088 11089 var sv *CreateFirewallDomainListOutput 11090 if *v == nil { 11091 sv = &CreateFirewallDomainListOutput{} 11092 } else { 11093 sv = *v 11094 } 11095 11096 for key, value := range shape { 11097 switch key { 11098 case "FirewallDomainList": 11099 if err := awsAwsjson11_deserializeDocumentFirewallDomainList(&sv.FirewallDomainList, value); err != nil { 11100 return err 11101 } 11102 11103 default: 11104 _, _ = key, value 11105 11106 } 11107 } 11108 *v = sv 11109 return nil 11110} 11111 11112func awsAwsjson11_deserializeOpDocumentCreateFirewallRuleGroupOutput(v **CreateFirewallRuleGroupOutput, value interface{}) error { 11113 if v == nil { 11114 return fmt.Errorf("unexpected nil of type %T", v) 11115 } 11116 if value == nil { 11117 return nil 11118 } 11119 11120 shape, ok := value.(map[string]interface{}) 11121 if !ok { 11122 return fmt.Errorf("unexpected JSON type %v", value) 11123 } 11124 11125 var sv *CreateFirewallRuleGroupOutput 11126 if *v == nil { 11127 sv = &CreateFirewallRuleGroupOutput{} 11128 } else { 11129 sv = *v 11130 } 11131 11132 for key, value := range shape { 11133 switch key { 11134 case "FirewallRuleGroup": 11135 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroup(&sv.FirewallRuleGroup, value); err != nil { 11136 return err 11137 } 11138 11139 default: 11140 _, _ = key, value 11141 11142 } 11143 } 11144 *v = sv 11145 return nil 11146} 11147 11148func awsAwsjson11_deserializeOpDocumentCreateFirewallRuleOutput(v **CreateFirewallRuleOutput, value interface{}) error { 11149 if v == nil { 11150 return fmt.Errorf("unexpected nil of type %T", v) 11151 } 11152 if value == nil { 11153 return nil 11154 } 11155 11156 shape, ok := value.(map[string]interface{}) 11157 if !ok { 11158 return fmt.Errorf("unexpected JSON type %v", value) 11159 } 11160 11161 var sv *CreateFirewallRuleOutput 11162 if *v == nil { 11163 sv = &CreateFirewallRuleOutput{} 11164 } else { 11165 sv = *v 11166 } 11167 11168 for key, value := range shape { 11169 switch key { 11170 case "FirewallRule": 11171 if err := awsAwsjson11_deserializeDocumentFirewallRule(&sv.FirewallRule, value); err != nil { 11172 return err 11173 } 11174 11175 default: 11176 _, _ = key, value 11177 11178 } 11179 } 11180 *v = sv 11181 return nil 11182} 11183 11184func awsAwsjson11_deserializeOpDocumentCreateResolverEndpointOutput(v **CreateResolverEndpointOutput, value interface{}) error { 11185 if v == nil { 11186 return fmt.Errorf("unexpected nil of type %T", v) 11187 } 11188 if value == nil { 11189 return nil 11190 } 11191 11192 shape, ok := value.(map[string]interface{}) 11193 if !ok { 11194 return fmt.Errorf("unexpected JSON type %v", value) 11195 } 11196 11197 var sv *CreateResolverEndpointOutput 11198 if *v == nil { 11199 sv = &CreateResolverEndpointOutput{} 11200 } else { 11201 sv = *v 11202 } 11203 11204 for key, value := range shape { 11205 switch key { 11206 case "ResolverEndpoint": 11207 if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil { 11208 return err 11209 } 11210 11211 default: 11212 _, _ = key, value 11213 11214 } 11215 } 11216 *v = sv 11217 return nil 11218} 11219 11220func awsAwsjson11_deserializeOpDocumentCreateResolverQueryLogConfigOutput(v **CreateResolverQueryLogConfigOutput, value interface{}) error { 11221 if v == nil { 11222 return fmt.Errorf("unexpected nil of type %T", v) 11223 } 11224 if value == nil { 11225 return nil 11226 } 11227 11228 shape, ok := value.(map[string]interface{}) 11229 if !ok { 11230 return fmt.Errorf("unexpected JSON type %v", value) 11231 } 11232 11233 var sv *CreateResolverQueryLogConfigOutput 11234 if *v == nil { 11235 sv = &CreateResolverQueryLogConfigOutput{} 11236 } else { 11237 sv = *v 11238 } 11239 11240 for key, value := range shape { 11241 switch key { 11242 case "ResolverQueryLogConfig": 11243 if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfig(&sv.ResolverQueryLogConfig, value); err != nil { 11244 return err 11245 } 11246 11247 default: 11248 _, _ = key, value 11249 11250 } 11251 } 11252 *v = sv 11253 return nil 11254} 11255 11256func awsAwsjson11_deserializeOpDocumentCreateResolverRuleOutput(v **CreateResolverRuleOutput, value interface{}) error { 11257 if v == nil { 11258 return fmt.Errorf("unexpected nil of type %T", v) 11259 } 11260 if value == nil { 11261 return nil 11262 } 11263 11264 shape, ok := value.(map[string]interface{}) 11265 if !ok { 11266 return fmt.Errorf("unexpected JSON type %v", value) 11267 } 11268 11269 var sv *CreateResolverRuleOutput 11270 if *v == nil { 11271 sv = &CreateResolverRuleOutput{} 11272 } else { 11273 sv = *v 11274 } 11275 11276 for key, value := range shape { 11277 switch key { 11278 case "ResolverRule": 11279 if err := awsAwsjson11_deserializeDocumentResolverRule(&sv.ResolverRule, value); err != nil { 11280 return err 11281 } 11282 11283 default: 11284 _, _ = key, value 11285 11286 } 11287 } 11288 *v = sv 11289 return nil 11290} 11291 11292func awsAwsjson11_deserializeOpDocumentDeleteFirewallDomainListOutput(v **DeleteFirewallDomainListOutput, value interface{}) error { 11293 if v == nil { 11294 return fmt.Errorf("unexpected nil of type %T", v) 11295 } 11296 if value == nil { 11297 return nil 11298 } 11299 11300 shape, ok := value.(map[string]interface{}) 11301 if !ok { 11302 return fmt.Errorf("unexpected JSON type %v", value) 11303 } 11304 11305 var sv *DeleteFirewallDomainListOutput 11306 if *v == nil { 11307 sv = &DeleteFirewallDomainListOutput{} 11308 } else { 11309 sv = *v 11310 } 11311 11312 for key, value := range shape { 11313 switch key { 11314 case "FirewallDomainList": 11315 if err := awsAwsjson11_deserializeDocumentFirewallDomainList(&sv.FirewallDomainList, value); err != nil { 11316 return err 11317 } 11318 11319 default: 11320 _, _ = key, value 11321 11322 } 11323 } 11324 *v = sv 11325 return nil 11326} 11327 11328func awsAwsjson11_deserializeOpDocumentDeleteFirewallRuleGroupOutput(v **DeleteFirewallRuleGroupOutput, value interface{}) error { 11329 if v == nil { 11330 return fmt.Errorf("unexpected nil of type %T", v) 11331 } 11332 if value == nil { 11333 return nil 11334 } 11335 11336 shape, ok := value.(map[string]interface{}) 11337 if !ok { 11338 return fmt.Errorf("unexpected JSON type %v", value) 11339 } 11340 11341 var sv *DeleteFirewallRuleGroupOutput 11342 if *v == nil { 11343 sv = &DeleteFirewallRuleGroupOutput{} 11344 } else { 11345 sv = *v 11346 } 11347 11348 for key, value := range shape { 11349 switch key { 11350 case "FirewallRuleGroup": 11351 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroup(&sv.FirewallRuleGroup, value); err != nil { 11352 return err 11353 } 11354 11355 default: 11356 _, _ = key, value 11357 11358 } 11359 } 11360 *v = sv 11361 return nil 11362} 11363 11364func awsAwsjson11_deserializeOpDocumentDeleteFirewallRuleOutput(v **DeleteFirewallRuleOutput, value interface{}) error { 11365 if v == nil { 11366 return fmt.Errorf("unexpected nil of type %T", v) 11367 } 11368 if value == nil { 11369 return nil 11370 } 11371 11372 shape, ok := value.(map[string]interface{}) 11373 if !ok { 11374 return fmt.Errorf("unexpected JSON type %v", value) 11375 } 11376 11377 var sv *DeleteFirewallRuleOutput 11378 if *v == nil { 11379 sv = &DeleteFirewallRuleOutput{} 11380 } else { 11381 sv = *v 11382 } 11383 11384 for key, value := range shape { 11385 switch key { 11386 case "FirewallRule": 11387 if err := awsAwsjson11_deserializeDocumentFirewallRule(&sv.FirewallRule, value); err != nil { 11388 return err 11389 } 11390 11391 default: 11392 _, _ = key, value 11393 11394 } 11395 } 11396 *v = sv 11397 return nil 11398} 11399 11400func awsAwsjson11_deserializeOpDocumentDeleteResolverEndpointOutput(v **DeleteResolverEndpointOutput, value interface{}) error { 11401 if v == nil { 11402 return fmt.Errorf("unexpected nil of type %T", v) 11403 } 11404 if value == nil { 11405 return nil 11406 } 11407 11408 shape, ok := value.(map[string]interface{}) 11409 if !ok { 11410 return fmt.Errorf("unexpected JSON type %v", value) 11411 } 11412 11413 var sv *DeleteResolverEndpointOutput 11414 if *v == nil { 11415 sv = &DeleteResolverEndpointOutput{} 11416 } else { 11417 sv = *v 11418 } 11419 11420 for key, value := range shape { 11421 switch key { 11422 case "ResolverEndpoint": 11423 if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil { 11424 return err 11425 } 11426 11427 default: 11428 _, _ = key, value 11429 11430 } 11431 } 11432 *v = sv 11433 return nil 11434} 11435 11436func awsAwsjson11_deserializeOpDocumentDeleteResolverQueryLogConfigOutput(v **DeleteResolverQueryLogConfigOutput, value interface{}) error { 11437 if v == nil { 11438 return fmt.Errorf("unexpected nil of type %T", v) 11439 } 11440 if value == nil { 11441 return nil 11442 } 11443 11444 shape, ok := value.(map[string]interface{}) 11445 if !ok { 11446 return fmt.Errorf("unexpected JSON type %v", value) 11447 } 11448 11449 var sv *DeleteResolverQueryLogConfigOutput 11450 if *v == nil { 11451 sv = &DeleteResolverQueryLogConfigOutput{} 11452 } else { 11453 sv = *v 11454 } 11455 11456 for key, value := range shape { 11457 switch key { 11458 case "ResolverQueryLogConfig": 11459 if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfig(&sv.ResolverQueryLogConfig, value); err != nil { 11460 return err 11461 } 11462 11463 default: 11464 _, _ = key, value 11465 11466 } 11467 } 11468 *v = sv 11469 return nil 11470} 11471 11472func awsAwsjson11_deserializeOpDocumentDeleteResolverRuleOutput(v **DeleteResolverRuleOutput, value interface{}) error { 11473 if v == nil { 11474 return fmt.Errorf("unexpected nil of type %T", v) 11475 } 11476 if value == nil { 11477 return nil 11478 } 11479 11480 shape, ok := value.(map[string]interface{}) 11481 if !ok { 11482 return fmt.Errorf("unexpected JSON type %v", value) 11483 } 11484 11485 var sv *DeleteResolverRuleOutput 11486 if *v == nil { 11487 sv = &DeleteResolverRuleOutput{} 11488 } else { 11489 sv = *v 11490 } 11491 11492 for key, value := range shape { 11493 switch key { 11494 case "ResolverRule": 11495 if err := awsAwsjson11_deserializeDocumentResolverRule(&sv.ResolverRule, value); err != nil { 11496 return err 11497 } 11498 11499 default: 11500 _, _ = key, value 11501 11502 } 11503 } 11504 *v = sv 11505 return nil 11506} 11507 11508func awsAwsjson11_deserializeOpDocumentDisassociateFirewallRuleGroupOutput(v **DisassociateFirewallRuleGroupOutput, value interface{}) error { 11509 if v == nil { 11510 return fmt.Errorf("unexpected nil of type %T", v) 11511 } 11512 if value == nil { 11513 return nil 11514 } 11515 11516 shape, ok := value.(map[string]interface{}) 11517 if !ok { 11518 return fmt.Errorf("unexpected JSON type %v", value) 11519 } 11520 11521 var sv *DisassociateFirewallRuleGroupOutput 11522 if *v == nil { 11523 sv = &DisassociateFirewallRuleGroupOutput{} 11524 } else { 11525 sv = *v 11526 } 11527 11528 for key, value := range shape { 11529 switch key { 11530 case "FirewallRuleGroupAssociation": 11531 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(&sv.FirewallRuleGroupAssociation, value); err != nil { 11532 return err 11533 } 11534 11535 default: 11536 _, _ = key, value 11537 11538 } 11539 } 11540 *v = sv 11541 return nil 11542} 11543 11544func awsAwsjson11_deserializeOpDocumentDisassociateResolverEndpointIpAddressOutput(v **DisassociateResolverEndpointIpAddressOutput, value interface{}) error { 11545 if v == nil { 11546 return fmt.Errorf("unexpected nil of type %T", v) 11547 } 11548 if value == nil { 11549 return nil 11550 } 11551 11552 shape, ok := value.(map[string]interface{}) 11553 if !ok { 11554 return fmt.Errorf("unexpected JSON type %v", value) 11555 } 11556 11557 var sv *DisassociateResolverEndpointIpAddressOutput 11558 if *v == nil { 11559 sv = &DisassociateResolverEndpointIpAddressOutput{} 11560 } else { 11561 sv = *v 11562 } 11563 11564 for key, value := range shape { 11565 switch key { 11566 case "ResolverEndpoint": 11567 if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil { 11568 return err 11569 } 11570 11571 default: 11572 _, _ = key, value 11573 11574 } 11575 } 11576 *v = sv 11577 return nil 11578} 11579 11580func awsAwsjson11_deserializeOpDocumentDisassociateResolverQueryLogConfigOutput(v **DisassociateResolverQueryLogConfigOutput, value interface{}) error { 11581 if v == nil { 11582 return fmt.Errorf("unexpected nil of type %T", v) 11583 } 11584 if value == nil { 11585 return nil 11586 } 11587 11588 shape, ok := value.(map[string]interface{}) 11589 if !ok { 11590 return fmt.Errorf("unexpected JSON type %v", value) 11591 } 11592 11593 var sv *DisassociateResolverQueryLogConfigOutput 11594 if *v == nil { 11595 sv = &DisassociateResolverQueryLogConfigOutput{} 11596 } else { 11597 sv = *v 11598 } 11599 11600 for key, value := range shape { 11601 switch key { 11602 case "ResolverQueryLogConfigAssociation": 11603 if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociation(&sv.ResolverQueryLogConfigAssociation, value); err != nil { 11604 return err 11605 } 11606 11607 default: 11608 _, _ = key, value 11609 11610 } 11611 } 11612 *v = sv 11613 return nil 11614} 11615 11616func awsAwsjson11_deserializeOpDocumentDisassociateResolverRuleOutput(v **DisassociateResolverRuleOutput, value interface{}) error { 11617 if v == nil { 11618 return fmt.Errorf("unexpected nil of type %T", v) 11619 } 11620 if value == nil { 11621 return nil 11622 } 11623 11624 shape, ok := value.(map[string]interface{}) 11625 if !ok { 11626 return fmt.Errorf("unexpected JSON type %v", value) 11627 } 11628 11629 var sv *DisassociateResolverRuleOutput 11630 if *v == nil { 11631 sv = &DisassociateResolverRuleOutput{} 11632 } else { 11633 sv = *v 11634 } 11635 11636 for key, value := range shape { 11637 switch key { 11638 case "ResolverRuleAssociation": 11639 if err := awsAwsjson11_deserializeDocumentResolverRuleAssociation(&sv.ResolverRuleAssociation, value); err != nil { 11640 return err 11641 } 11642 11643 default: 11644 _, _ = key, value 11645 11646 } 11647 } 11648 *v = sv 11649 return nil 11650} 11651 11652func awsAwsjson11_deserializeOpDocumentGetFirewallConfigOutput(v **GetFirewallConfigOutput, value interface{}) error { 11653 if v == nil { 11654 return fmt.Errorf("unexpected nil of type %T", v) 11655 } 11656 if value == nil { 11657 return nil 11658 } 11659 11660 shape, ok := value.(map[string]interface{}) 11661 if !ok { 11662 return fmt.Errorf("unexpected JSON type %v", value) 11663 } 11664 11665 var sv *GetFirewallConfigOutput 11666 if *v == nil { 11667 sv = &GetFirewallConfigOutput{} 11668 } else { 11669 sv = *v 11670 } 11671 11672 for key, value := range shape { 11673 switch key { 11674 case "FirewallConfig": 11675 if err := awsAwsjson11_deserializeDocumentFirewallConfig(&sv.FirewallConfig, value); err != nil { 11676 return err 11677 } 11678 11679 default: 11680 _, _ = key, value 11681 11682 } 11683 } 11684 *v = sv 11685 return nil 11686} 11687 11688func awsAwsjson11_deserializeOpDocumentGetFirewallDomainListOutput(v **GetFirewallDomainListOutput, value interface{}) error { 11689 if v == nil { 11690 return fmt.Errorf("unexpected nil of type %T", v) 11691 } 11692 if value == nil { 11693 return nil 11694 } 11695 11696 shape, ok := value.(map[string]interface{}) 11697 if !ok { 11698 return fmt.Errorf("unexpected JSON type %v", value) 11699 } 11700 11701 var sv *GetFirewallDomainListOutput 11702 if *v == nil { 11703 sv = &GetFirewallDomainListOutput{} 11704 } else { 11705 sv = *v 11706 } 11707 11708 for key, value := range shape { 11709 switch key { 11710 case "FirewallDomainList": 11711 if err := awsAwsjson11_deserializeDocumentFirewallDomainList(&sv.FirewallDomainList, value); err != nil { 11712 return err 11713 } 11714 11715 default: 11716 _, _ = key, value 11717 11718 } 11719 } 11720 *v = sv 11721 return nil 11722} 11723 11724func awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupAssociationOutput(v **GetFirewallRuleGroupAssociationOutput, value interface{}) error { 11725 if v == nil { 11726 return fmt.Errorf("unexpected nil of type %T", v) 11727 } 11728 if value == nil { 11729 return nil 11730 } 11731 11732 shape, ok := value.(map[string]interface{}) 11733 if !ok { 11734 return fmt.Errorf("unexpected JSON type %v", value) 11735 } 11736 11737 var sv *GetFirewallRuleGroupAssociationOutput 11738 if *v == nil { 11739 sv = &GetFirewallRuleGroupAssociationOutput{} 11740 } else { 11741 sv = *v 11742 } 11743 11744 for key, value := range shape { 11745 switch key { 11746 case "FirewallRuleGroupAssociation": 11747 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(&sv.FirewallRuleGroupAssociation, value); err != nil { 11748 return err 11749 } 11750 11751 default: 11752 _, _ = key, value 11753 11754 } 11755 } 11756 *v = sv 11757 return nil 11758} 11759 11760func awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupOutput(v **GetFirewallRuleGroupOutput, value interface{}) error { 11761 if v == nil { 11762 return fmt.Errorf("unexpected nil of type %T", v) 11763 } 11764 if value == nil { 11765 return nil 11766 } 11767 11768 shape, ok := value.(map[string]interface{}) 11769 if !ok { 11770 return fmt.Errorf("unexpected JSON type %v", value) 11771 } 11772 11773 var sv *GetFirewallRuleGroupOutput 11774 if *v == nil { 11775 sv = &GetFirewallRuleGroupOutput{} 11776 } else { 11777 sv = *v 11778 } 11779 11780 for key, value := range shape { 11781 switch key { 11782 case "FirewallRuleGroup": 11783 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroup(&sv.FirewallRuleGroup, value); err != nil { 11784 return err 11785 } 11786 11787 default: 11788 _, _ = key, value 11789 11790 } 11791 } 11792 *v = sv 11793 return nil 11794} 11795 11796func awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupPolicyOutput(v **GetFirewallRuleGroupPolicyOutput, value interface{}) error { 11797 if v == nil { 11798 return fmt.Errorf("unexpected nil of type %T", v) 11799 } 11800 if value == nil { 11801 return nil 11802 } 11803 11804 shape, ok := value.(map[string]interface{}) 11805 if !ok { 11806 return fmt.Errorf("unexpected JSON type %v", value) 11807 } 11808 11809 var sv *GetFirewallRuleGroupPolicyOutput 11810 if *v == nil { 11811 sv = &GetFirewallRuleGroupPolicyOutput{} 11812 } else { 11813 sv = *v 11814 } 11815 11816 for key, value := range shape { 11817 switch key { 11818 case "FirewallRuleGroupPolicy": 11819 if value != nil { 11820 jtv, ok := value.(string) 11821 if !ok { 11822 return fmt.Errorf("expected FirewallRuleGroupPolicy to be of type string, got %T instead", value) 11823 } 11824 sv.FirewallRuleGroupPolicy = ptr.String(jtv) 11825 } 11826 11827 default: 11828 _, _ = key, value 11829 11830 } 11831 } 11832 *v = sv 11833 return nil 11834} 11835 11836func awsAwsjson11_deserializeOpDocumentGetResolverDnssecConfigOutput(v **GetResolverDnssecConfigOutput, value interface{}) error { 11837 if v == nil { 11838 return fmt.Errorf("unexpected nil of type %T", v) 11839 } 11840 if value == nil { 11841 return nil 11842 } 11843 11844 shape, ok := value.(map[string]interface{}) 11845 if !ok { 11846 return fmt.Errorf("unexpected JSON type %v", value) 11847 } 11848 11849 var sv *GetResolverDnssecConfigOutput 11850 if *v == nil { 11851 sv = &GetResolverDnssecConfigOutput{} 11852 } else { 11853 sv = *v 11854 } 11855 11856 for key, value := range shape { 11857 switch key { 11858 case "ResolverDNSSECConfig": 11859 if err := awsAwsjson11_deserializeDocumentResolverDnssecConfig(&sv.ResolverDNSSECConfig, value); err != nil { 11860 return err 11861 } 11862 11863 default: 11864 _, _ = key, value 11865 11866 } 11867 } 11868 *v = sv 11869 return nil 11870} 11871 11872func awsAwsjson11_deserializeOpDocumentGetResolverEndpointOutput(v **GetResolverEndpointOutput, value interface{}) error { 11873 if v == nil { 11874 return fmt.Errorf("unexpected nil of type %T", v) 11875 } 11876 if value == nil { 11877 return nil 11878 } 11879 11880 shape, ok := value.(map[string]interface{}) 11881 if !ok { 11882 return fmt.Errorf("unexpected JSON type %v", value) 11883 } 11884 11885 var sv *GetResolverEndpointOutput 11886 if *v == nil { 11887 sv = &GetResolverEndpointOutput{} 11888 } else { 11889 sv = *v 11890 } 11891 11892 for key, value := range shape { 11893 switch key { 11894 case "ResolverEndpoint": 11895 if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil { 11896 return err 11897 } 11898 11899 default: 11900 _, _ = key, value 11901 11902 } 11903 } 11904 *v = sv 11905 return nil 11906} 11907 11908func awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigAssociationOutput(v **GetResolverQueryLogConfigAssociationOutput, value interface{}) error { 11909 if v == nil { 11910 return fmt.Errorf("unexpected nil of type %T", v) 11911 } 11912 if value == nil { 11913 return nil 11914 } 11915 11916 shape, ok := value.(map[string]interface{}) 11917 if !ok { 11918 return fmt.Errorf("unexpected JSON type %v", value) 11919 } 11920 11921 var sv *GetResolverQueryLogConfigAssociationOutput 11922 if *v == nil { 11923 sv = &GetResolverQueryLogConfigAssociationOutput{} 11924 } else { 11925 sv = *v 11926 } 11927 11928 for key, value := range shape { 11929 switch key { 11930 case "ResolverQueryLogConfigAssociation": 11931 if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociation(&sv.ResolverQueryLogConfigAssociation, value); err != nil { 11932 return err 11933 } 11934 11935 default: 11936 _, _ = key, value 11937 11938 } 11939 } 11940 *v = sv 11941 return nil 11942} 11943 11944func awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigOutput(v **GetResolverQueryLogConfigOutput, value interface{}) error { 11945 if v == nil { 11946 return fmt.Errorf("unexpected nil of type %T", v) 11947 } 11948 if value == nil { 11949 return nil 11950 } 11951 11952 shape, ok := value.(map[string]interface{}) 11953 if !ok { 11954 return fmt.Errorf("unexpected JSON type %v", value) 11955 } 11956 11957 var sv *GetResolverQueryLogConfigOutput 11958 if *v == nil { 11959 sv = &GetResolverQueryLogConfigOutput{} 11960 } else { 11961 sv = *v 11962 } 11963 11964 for key, value := range shape { 11965 switch key { 11966 case "ResolverQueryLogConfig": 11967 if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfig(&sv.ResolverQueryLogConfig, value); err != nil { 11968 return err 11969 } 11970 11971 default: 11972 _, _ = key, value 11973 11974 } 11975 } 11976 *v = sv 11977 return nil 11978} 11979 11980func awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigPolicyOutput(v **GetResolverQueryLogConfigPolicyOutput, value interface{}) error { 11981 if v == nil { 11982 return fmt.Errorf("unexpected nil of type %T", v) 11983 } 11984 if value == nil { 11985 return nil 11986 } 11987 11988 shape, ok := value.(map[string]interface{}) 11989 if !ok { 11990 return fmt.Errorf("unexpected JSON type %v", value) 11991 } 11992 11993 var sv *GetResolverQueryLogConfigPolicyOutput 11994 if *v == nil { 11995 sv = &GetResolverQueryLogConfigPolicyOutput{} 11996 } else { 11997 sv = *v 11998 } 11999 12000 for key, value := range shape { 12001 switch key { 12002 case "ResolverQueryLogConfigPolicy": 12003 if value != nil { 12004 jtv, ok := value.(string) 12005 if !ok { 12006 return fmt.Errorf("expected ResolverQueryLogConfigPolicy to be of type string, got %T instead", value) 12007 } 12008 sv.ResolverQueryLogConfigPolicy = ptr.String(jtv) 12009 } 12010 12011 default: 12012 _, _ = key, value 12013 12014 } 12015 } 12016 *v = sv 12017 return nil 12018} 12019 12020func awsAwsjson11_deserializeOpDocumentGetResolverRuleAssociationOutput(v **GetResolverRuleAssociationOutput, value interface{}) error { 12021 if v == nil { 12022 return fmt.Errorf("unexpected nil of type %T", v) 12023 } 12024 if value == nil { 12025 return nil 12026 } 12027 12028 shape, ok := value.(map[string]interface{}) 12029 if !ok { 12030 return fmt.Errorf("unexpected JSON type %v", value) 12031 } 12032 12033 var sv *GetResolverRuleAssociationOutput 12034 if *v == nil { 12035 sv = &GetResolverRuleAssociationOutput{} 12036 } else { 12037 sv = *v 12038 } 12039 12040 for key, value := range shape { 12041 switch key { 12042 case "ResolverRuleAssociation": 12043 if err := awsAwsjson11_deserializeDocumentResolverRuleAssociation(&sv.ResolverRuleAssociation, value); err != nil { 12044 return err 12045 } 12046 12047 default: 12048 _, _ = key, value 12049 12050 } 12051 } 12052 *v = sv 12053 return nil 12054} 12055 12056func awsAwsjson11_deserializeOpDocumentGetResolverRuleOutput(v **GetResolverRuleOutput, value interface{}) error { 12057 if v == nil { 12058 return fmt.Errorf("unexpected nil of type %T", v) 12059 } 12060 if value == nil { 12061 return nil 12062 } 12063 12064 shape, ok := value.(map[string]interface{}) 12065 if !ok { 12066 return fmt.Errorf("unexpected JSON type %v", value) 12067 } 12068 12069 var sv *GetResolverRuleOutput 12070 if *v == nil { 12071 sv = &GetResolverRuleOutput{} 12072 } else { 12073 sv = *v 12074 } 12075 12076 for key, value := range shape { 12077 switch key { 12078 case "ResolverRule": 12079 if err := awsAwsjson11_deserializeDocumentResolverRule(&sv.ResolverRule, value); err != nil { 12080 return err 12081 } 12082 12083 default: 12084 _, _ = key, value 12085 12086 } 12087 } 12088 *v = sv 12089 return nil 12090} 12091 12092func awsAwsjson11_deserializeOpDocumentGetResolverRulePolicyOutput(v **GetResolverRulePolicyOutput, value interface{}) error { 12093 if v == nil { 12094 return fmt.Errorf("unexpected nil of type %T", v) 12095 } 12096 if value == nil { 12097 return nil 12098 } 12099 12100 shape, ok := value.(map[string]interface{}) 12101 if !ok { 12102 return fmt.Errorf("unexpected JSON type %v", value) 12103 } 12104 12105 var sv *GetResolverRulePolicyOutput 12106 if *v == nil { 12107 sv = &GetResolverRulePolicyOutput{} 12108 } else { 12109 sv = *v 12110 } 12111 12112 for key, value := range shape { 12113 switch key { 12114 case "ResolverRulePolicy": 12115 if value != nil { 12116 jtv, ok := value.(string) 12117 if !ok { 12118 return fmt.Errorf("expected ResolverRulePolicy to be of type string, got %T instead", value) 12119 } 12120 sv.ResolverRulePolicy = ptr.String(jtv) 12121 } 12122 12123 default: 12124 _, _ = key, value 12125 12126 } 12127 } 12128 *v = sv 12129 return nil 12130} 12131 12132func awsAwsjson11_deserializeOpDocumentImportFirewallDomainsOutput(v **ImportFirewallDomainsOutput, value interface{}) error { 12133 if v == nil { 12134 return fmt.Errorf("unexpected nil of type %T", v) 12135 } 12136 if value == nil { 12137 return nil 12138 } 12139 12140 shape, ok := value.(map[string]interface{}) 12141 if !ok { 12142 return fmt.Errorf("unexpected JSON type %v", value) 12143 } 12144 12145 var sv *ImportFirewallDomainsOutput 12146 if *v == nil { 12147 sv = &ImportFirewallDomainsOutput{} 12148 } else { 12149 sv = *v 12150 } 12151 12152 for key, value := range shape { 12153 switch key { 12154 case "Id": 12155 if value != nil { 12156 jtv, ok := value.(string) 12157 if !ok { 12158 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 12159 } 12160 sv.Id = ptr.String(jtv) 12161 } 12162 12163 case "Name": 12164 if value != nil { 12165 jtv, ok := value.(string) 12166 if !ok { 12167 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 12168 } 12169 sv.Name = ptr.String(jtv) 12170 } 12171 12172 case "Status": 12173 if value != nil { 12174 jtv, ok := value.(string) 12175 if !ok { 12176 return fmt.Errorf("expected FirewallDomainListStatus to be of type string, got %T instead", value) 12177 } 12178 sv.Status = types.FirewallDomainListStatus(jtv) 12179 } 12180 12181 case "StatusMessage": 12182 if value != nil { 12183 jtv, ok := value.(string) 12184 if !ok { 12185 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 12186 } 12187 sv.StatusMessage = ptr.String(jtv) 12188 } 12189 12190 default: 12191 _, _ = key, value 12192 12193 } 12194 } 12195 *v = sv 12196 return nil 12197} 12198 12199func awsAwsjson11_deserializeOpDocumentListFirewallConfigsOutput(v **ListFirewallConfigsOutput, value interface{}) error { 12200 if v == nil { 12201 return fmt.Errorf("unexpected nil of type %T", v) 12202 } 12203 if value == nil { 12204 return nil 12205 } 12206 12207 shape, ok := value.(map[string]interface{}) 12208 if !ok { 12209 return fmt.Errorf("unexpected JSON type %v", value) 12210 } 12211 12212 var sv *ListFirewallConfigsOutput 12213 if *v == nil { 12214 sv = &ListFirewallConfigsOutput{} 12215 } else { 12216 sv = *v 12217 } 12218 12219 for key, value := range shape { 12220 switch key { 12221 case "FirewallConfigs": 12222 if err := awsAwsjson11_deserializeDocumentFirewallConfigList(&sv.FirewallConfigs, value); err != nil { 12223 return err 12224 } 12225 12226 case "NextToken": 12227 if value != nil { 12228 jtv, ok := value.(string) 12229 if !ok { 12230 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12231 } 12232 sv.NextToken = ptr.String(jtv) 12233 } 12234 12235 default: 12236 _, _ = key, value 12237 12238 } 12239 } 12240 *v = sv 12241 return nil 12242} 12243 12244func awsAwsjson11_deserializeOpDocumentListFirewallDomainListsOutput(v **ListFirewallDomainListsOutput, value interface{}) error { 12245 if v == nil { 12246 return fmt.Errorf("unexpected nil of type %T", v) 12247 } 12248 if value == nil { 12249 return nil 12250 } 12251 12252 shape, ok := value.(map[string]interface{}) 12253 if !ok { 12254 return fmt.Errorf("unexpected JSON type %v", value) 12255 } 12256 12257 var sv *ListFirewallDomainListsOutput 12258 if *v == nil { 12259 sv = &ListFirewallDomainListsOutput{} 12260 } else { 12261 sv = *v 12262 } 12263 12264 for key, value := range shape { 12265 switch key { 12266 case "FirewallDomainLists": 12267 if err := awsAwsjson11_deserializeDocumentFirewallDomainListMetadataList(&sv.FirewallDomainLists, value); err != nil { 12268 return err 12269 } 12270 12271 case "NextToken": 12272 if value != nil { 12273 jtv, ok := value.(string) 12274 if !ok { 12275 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12276 } 12277 sv.NextToken = ptr.String(jtv) 12278 } 12279 12280 default: 12281 _, _ = key, value 12282 12283 } 12284 } 12285 *v = sv 12286 return nil 12287} 12288 12289func awsAwsjson11_deserializeOpDocumentListFirewallDomainsOutput(v **ListFirewallDomainsOutput, value interface{}) error { 12290 if v == nil { 12291 return fmt.Errorf("unexpected nil of type %T", v) 12292 } 12293 if value == nil { 12294 return nil 12295 } 12296 12297 shape, ok := value.(map[string]interface{}) 12298 if !ok { 12299 return fmt.Errorf("unexpected JSON type %v", value) 12300 } 12301 12302 var sv *ListFirewallDomainsOutput 12303 if *v == nil { 12304 sv = &ListFirewallDomainsOutput{} 12305 } else { 12306 sv = *v 12307 } 12308 12309 for key, value := range shape { 12310 switch key { 12311 case "Domains": 12312 if err := awsAwsjson11_deserializeDocumentFirewallDomains(&sv.Domains, value); err != nil { 12313 return err 12314 } 12315 12316 case "NextToken": 12317 if value != nil { 12318 jtv, ok := value.(string) 12319 if !ok { 12320 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12321 } 12322 sv.NextToken = ptr.String(jtv) 12323 } 12324 12325 default: 12326 _, _ = key, value 12327 12328 } 12329 } 12330 *v = sv 12331 return nil 12332} 12333 12334func awsAwsjson11_deserializeOpDocumentListFirewallRuleGroupAssociationsOutput(v **ListFirewallRuleGroupAssociationsOutput, value interface{}) error { 12335 if v == nil { 12336 return fmt.Errorf("unexpected nil of type %T", v) 12337 } 12338 if value == nil { 12339 return nil 12340 } 12341 12342 shape, ok := value.(map[string]interface{}) 12343 if !ok { 12344 return fmt.Errorf("unexpected JSON type %v", value) 12345 } 12346 12347 var sv *ListFirewallRuleGroupAssociationsOutput 12348 if *v == nil { 12349 sv = &ListFirewallRuleGroupAssociationsOutput{} 12350 } else { 12351 sv = *v 12352 } 12353 12354 for key, value := range shape { 12355 switch key { 12356 case "FirewallRuleGroupAssociations": 12357 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociations(&sv.FirewallRuleGroupAssociations, value); err != nil { 12358 return err 12359 } 12360 12361 case "NextToken": 12362 if value != nil { 12363 jtv, ok := value.(string) 12364 if !ok { 12365 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12366 } 12367 sv.NextToken = ptr.String(jtv) 12368 } 12369 12370 default: 12371 _, _ = key, value 12372 12373 } 12374 } 12375 *v = sv 12376 return nil 12377} 12378 12379func awsAwsjson11_deserializeOpDocumentListFirewallRuleGroupsOutput(v **ListFirewallRuleGroupsOutput, value interface{}) error { 12380 if v == nil { 12381 return fmt.Errorf("unexpected nil of type %T", v) 12382 } 12383 if value == nil { 12384 return nil 12385 } 12386 12387 shape, ok := value.(map[string]interface{}) 12388 if !ok { 12389 return fmt.Errorf("unexpected JSON type %v", value) 12390 } 12391 12392 var sv *ListFirewallRuleGroupsOutput 12393 if *v == nil { 12394 sv = &ListFirewallRuleGroupsOutput{} 12395 } else { 12396 sv = *v 12397 } 12398 12399 for key, value := range shape { 12400 switch key { 12401 case "FirewallRuleGroups": 12402 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupMetadataList(&sv.FirewallRuleGroups, value); err != nil { 12403 return err 12404 } 12405 12406 case "NextToken": 12407 if value != nil { 12408 jtv, ok := value.(string) 12409 if !ok { 12410 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12411 } 12412 sv.NextToken = ptr.String(jtv) 12413 } 12414 12415 default: 12416 _, _ = key, value 12417 12418 } 12419 } 12420 *v = sv 12421 return nil 12422} 12423 12424func awsAwsjson11_deserializeOpDocumentListFirewallRulesOutput(v **ListFirewallRulesOutput, value interface{}) error { 12425 if v == nil { 12426 return fmt.Errorf("unexpected nil of type %T", v) 12427 } 12428 if value == nil { 12429 return nil 12430 } 12431 12432 shape, ok := value.(map[string]interface{}) 12433 if !ok { 12434 return fmt.Errorf("unexpected JSON type %v", value) 12435 } 12436 12437 var sv *ListFirewallRulesOutput 12438 if *v == nil { 12439 sv = &ListFirewallRulesOutput{} 12440 } else { 12441 sv = *v 12442 } 12443 12444 for key, value := range shape { 12445 switch key { 12446 case "FirewallRules": 12447 if err := awsAwsjson11_deserializeDocumentFirewallRules(&sv.FirewallRules, value); err != nil { 12448 return err 12449 } 12450 12451 case "NextToken": 12452 if value != nil { 12453 jtv, ok := value.(string) 12454 if !ok { 12455 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12456 } 12457 sv.NextToken = ptr.String(jtv) 12458 } 12459 12460 default: 12461 _, _ = key, value 12462 12463 } 12464 } 12465 *v = sv 12466 return nil 12467} 12468 12469func awsAwsjson11_deserializeOpDocumentListResolverDnssecConfigsOutput(v **ListResolverDnssecConfigsOutput, value interface{}) error { 12470 if v == nil { 12471 return fmt.Errorf("unexpected nil of type %T", v) 12472 } 12473 if value == nil { 12474 return nil 12475 } 12476 12477 shape, ok := value.(map[string]interface{}) 12478 if !ok { 12479 return fmt.Errorf("unexpected JSON type %v", value) 12480 } 12481 12482 var sv *ListResolverDnssecConfigsOutput 12483 if *v == nil { 12484 sv = &ListResolverDnssecConfigsOutput{} 12485 } else { 12486 sv = *v 12487 } 12488 12489 for key, value := range shape { 12490 switch key { 12491 case "NextToken": 12492 if value != nil { 12493 jtv, ok := value.(string) 12494 if !ok { 12495 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12496 } 12497 sv.NextToken = ptr.String(jtv) 12498 } 12499 12500 case "ResolverDnssecConfigs": 12501 if err := awsAwsjson11_deserializeDocumentResolverDnssecConfigList(&sv.ResolverDnssecConfigs, value); err != nil { 12502 return err 12503 } 12504 12505 default: 12506 _, _ = key, value 12507 12508 } 12509 } 12510 *v = sv 12511 return nil 12512} 12513 12514func awsAwsjson11_deserializeOpDocumentListResolverEndpointIpAddressesOutput(v **ListResolverEndpointIpAddressesOutput, value interface{}) error { 12515 if v == nil { 12516 return fmt.Errorf("unexpected nil of type %T", v) 12517 } 12518 if value == nil { 12519 return nil 12520 } 12521 12522 shape, ok := value.(map[string]interface{}) 12523 if !ok { 12524 return fmt.Errorf("unexpected JSON type %v", value) 12525 } 12526 12527 var sv *ListResolverEndpointIpAddressesOutput 12528 if *v == nil { 12529 sv = &ListResolverEndpointIpAddressesOutput{} 12530 } else { 12531 sv = *v 12532 } 12533 12534 for key, value := range shape { 12535 switch key { 12536 case "IpAddresses": 12537 if err := awsAwsjson11_deserializeDocumentIpAddressesResponse(&sv.IpAddresses, value); err != nil { 12538 return err 12539 } 12540 12541 case "MaxResults": 12542 if value != nil { 12543 jtv, ok := value.(json.Number) 12544 if !ok { 12545 return fmt.Errorf("expected MaxResults to be json.Number, got %T instead", value) 12546 } 12547 i64, err := jtv.Int64() 12548 if err != nil { 12549 return err 12550 } 12551 sv.MaxResults = ptr.Int32(int32(i64)) 12552 } 12553 12554 case "NextToken": 12555 if value != nil { 12556 jtv, ok := value.(string) 12557 if !ok { 12558 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12559 } 12560 sv.NextToken = ptr.String(jtv) 12561 } 12562 12563 default: 12564 _, _ = key, value 12565 12566 } 12567 } 12568 *v = sv 12569 return nil 12570} 12571 12572func awsAwsjson11_deserializeOpDocumentListResolverEndpointsOutput(v **ListResolverEndpointsOutput, value interface{}) error { 12573 if v == nil { 12574 return fmt.Errorf("unexpected nil of type %T", v) 12575 } 12576 if value == nil { 12577 return nil 12578 } 12579 12580 shape, ok := value.(map[string]interface{}) 12581 if !ok { 12582 return fmt.Errorf("unexpected JSON type %v", value) 12583 } 12584 12585 var sv *ListResolverEndpointsOutput 12586 if *v == nil { 12587 sv = &ListResolverEndpointsOutput{} 12588 } else { 12589 sv = *v 12590 } 12591 12592 for key, value := range shape { 12593 switch key { 12594 case "MaxResults": 12595 if value != nil { 12596 jtv, ok := value.(json.Number) 12597 if !ok { 12598 return fmt.Errorf("expected MaxResults to be json.Number, got %T instead", value) 12599 } 12600 i64, err := jtv.Int64() 12601 if err != nil { 12602 return err 12603 } 12604 sv.MaxResults = ptr.Int32(int32(i64)) 12605 } 12606 12607 case "NextToken": 12608 if value != nil { 12609 jtv, ok := value.(string) 12610 if !ok { 12611 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12612 } 12613 sv.NextToken = ptr.String(jtv) 12614 } 12615 12616 case "ResolverEndpoints": 12617 if err := awsAwsjson11_deserializeDocumentResolverEndpoints(&sv.ResolverEndpoints, value); err != nil { 12618 return err 12619 } 12620 12621 default: 12622 _, _ = key, value 12623 12624 } 12625 } 12626 *v = sv 12627 return nil 12628} 12629 12630func awsAwsjson11_deserializeOpDocumentListResolverQueryLogConfigAssociationsOutput(v **ListResolverQueryLogConfigAssociationsOutput, value interface{}) error { 12631 if v == nil { 12632 return fmt.Errorf("unexpected nil of type %T", v) 12633 } 12634 if value == nil { 12635 return nil 12636 } 12637 12638 shape, ok := value.(map[string]interface{}) 12639 if !ok { 12640 return fmt.Errorf("unexpected JSON type %v", value) 12641 } 12642 12643 var sv *ListResolverQueryLogConfigAssociationsOutput 12644 if *v == nil { 12645 sv = &ListResolverQueryLogConfigAssociationsOutput{} 12646 } else { 12647 sv = *v 12648 } 12649 12650 for key, value := range shape { 12651 switch key { 12652 case "NextToken": 12653 if value != nil { 12654 jtv, ok := value.(string) 12655 if !ok { 12656 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12657 } 12658 sv.NextToken = ptr.String(jtv) 12659 } 12660 12661 case "ResolverQueryLogConfigAssociations": 12662 if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociationList(&sv.ResolverQueryLogConfigAssociations, value); err != nil { 12663 return err 12664 } 12665 12666 case "TotalCount": 12667 if value != nil { 12668 jtv, ok := value.(json.Number) 12669 if !ok { 12670 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 12671 } 12672 i64, err := jtv.Int64() 12673 if err != nil { 12674 return err 12675 } 12676 sv.TotalCount = int32(i64) 12677 } 12678 12679 case "TotalFilteredCount": 12680 if value != nil { 12681 jtv, ok := value.(json.Number) 12682 if !ok { 12683 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 12684 } 12685 i64, err := jtv.Int64() 12686 if err != nil { 12687 return err 12688 } 12689 sv.TotalFilteredCount = int32(i64) 12690 } 12691 12692 default: 12693 _, _ = key, value 12694 12695 } 12696 } 12697 *v = sv 12698 return nil 12699} 12700 12701func awsAwsjson11_deserializeOpDocumentListResolverQueryLogConfigsOutput(v **ListResolverQueryLogConfigsOutput, value interface{}) error { 12702 if v == nil { 12703 return fmt.Errorf("unexpected nil of type %T", v) 12704 } 12705 if value == nil { 12706 return nil 12707 } 12708 12709 shape, ok := value.(map[string]interface{}) 12710 if !ok { 12711 return fmt.Errorf("unexpected JSON type %v", value) 12712 } 12713 12714 var sv *ListResolverQueryLogConfigsOutput 12715 if *v == nil { 12716 sv = &ListResolverQueryLogConfigsOutput{} 12717 } else { 12718 sv = *v 12719 } 12720 12721 for key, value := range shape { 12722 switch key { 12723 case "NextToken": 12724 if value != nil { 12725 jtv, ok := value.(string) 12726 if !ok { 12727 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12728 } 12729 sv.NextToken = ptr.String(jtv) 12730 } 12731 12732 case "ResolverQueryLogConfigs": 12733 if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigList(&sv.ResolverQueryLogConfigs, value); err != nil { 12734 return err 12735 } 12736 12737 case "TotalCount": 12738 if value != nil { 12739 jtv, ok := value.(json.Number) 12740 if !ok { 12741 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 12742 } 12743 i64, err := jtv.Int64() 12744 if err != nil { 12745 return err 12746 } 12747 sv.TotalCount = int32(i64) 12748 } 12749 12750 case "TotalFilteredCount": 12751 if value != nil { 12752 jtv, ok := value.(json.Number) 12753 if !ok { 12754 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 12755 } 12756 i64, err := jtv.Int64() 12757 if err != nil { 12758 return err 12759 } 12760 sv.TotalFilteredCount = int32(i64) 12761 } 12762 12763 default: 12764 _, _ = key, value 12765 12766 } 12767 } 12768 *v = sv 12769 return nil 12770} 12771 12772func awsAwsjson11_deserializeOpDocumentListResolverRuleAssociationsOutput(v **ListResolverRuleAssociationsOutput, value interface{}) error { 12773 if v == nil { 12774 return fmt.Errorf("unexpected nil of type %T", v) 12775 } 12776 if value == nil { 12777 return nil 12778 } 12779 12780 shape, ok := value.(map[string]interface{}) 12781 if !ok { 12782 return fmt.Errorf("unexpected JSON type %v", value) 12783 } 12784 12785 var sv *ListResolverRuleAssociationsOutput 12786 if *v == nil { 12787 sv = &ListResolverRuleAssociationsOutput{} 12788 } else { 12789 sv = *v 12790 } 12791 12792 for key, value := range shape { 12793 switch key { 12794 case "MaxResults": 12795 if value != nil { 12796 jtv, ok := value.(json.Number) 12797 if !ok { 12798 return fmt.Errorf("expected MaxResults to be json.Number, got %T instead", value) 12799 } 12800 i64, err := jtv.Int64() 12801 if err != nil { 12802 return err 12803 } 12804 sv.MaxResults = ptr.Int32(int32(i64)) 12805 } 12806 12807 case "NextToken": 12808 if value != nil { 12809 jtv, ok := value.(string) 12810 if !ok { 12811 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12812 } 12813 sv.NextToken = ptr.String(jtv) 12814 } 12815 12816 case "ResolverRuleAssociations": 12817 if err := awsAwsjson11_deserializeDocumentResolverRuleAssociations(&sv.ResolverRuleAssociations, value); err != nil { 12818 return err 12819 } 12820 12821 default: 12822 _, _ = key, value 12823 12824 } 12825 } 12826 *v = sv 12827 return nil 12828} 12829 12830func awsAwsjson11_deserializeOpDocumentListResolverRulesOutput(v **ListResolverRulesOutput, value interface{}) error { 12831 if v == nil { 12832 return fmt.Errorf("unexpected nil of type %T", v) 12833 } 12834 if value == nil { 12835 return nil 12836 } 12837 12838 shape, ok := value.(map[string]interface{}) 12839 if !ok { 12840 return fmt.Errorf("unexpected JSON type %v", value) 12841 } 12842 12843 var sv *ListResolverRulesOutput 12844 if *v == nil { 12845 sv = &ListResolverRulesOutput{} 12846 } else { 12847 sv = *v 12848 } 12849 12850 for key, value := range shape { 12851 switch key { 12852 case "MaxResults": 12853 if value != nil { 12854 jtv, ok := value.(json.Number) 12855 if !ok { 12856 return fmt.Errorf("expected MaxResults to be json.Number, got %T instead", value) 12857 } 12858 i64, err := jtv.Int64() 12859 if err != nil { 12860 return err 12861 } 12862 sv.MaxResults = ptr.Int32(int32(i64)) 12863 } 12864 12865 case "NextToken": 12866 if value != nil { 12867 jtv, ok := value.(string) 12868 if !ok { 12869 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12870 } 12871 sv.NextToken = ptr.String(jtv) 12872 } 12873 12874 case "ResolverRules": 12875 if err := awsAwsjson11_deserializeDocumentResolverRules(&sv.ResolverRules, value); err != nil { 12876 return err 12877 } 12878 12879 default: 12880 _, _ = key, value 12881 12882 } 12883 } 12884 *v = sv 12885 return nil 12886} 12887 12888func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 12889 if v == nil { 12890 return fmt.Errorf("unexpected nil of type %T", v) 12891 } 12892 if value == nil { 12893 return nil 12894 } 12895 12896 shape, ok := value.(map[string]interface{}) 12897 if !ok { 12898 return fmt.Errorf("unexpected JSON type %v", value) 12899 } 12900 12901 var sv *ListTagsForResourceOutput 12902 if *v == nil { 12903 sv = &ListTagsForResourceOutput{} 12904 } else { 12905 sv = *v 12906 } 12907 12908 for key, value := range shape { 12909 switch key { 12910 case "NextToken": 12911 if value != nil { 12912 jtv, ok := value.(string) 12913 if !ok { 12914 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12915 } 12916 sv.NextToken = ptr.String(jtv) 12917 } 12918 12919 case "Tags": 12920 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 12921 return err 12922 } 12923 12924 default: 12925 _, _ = key, value 12926 12927 } 12928 } 12929 *v = sv 12930 return nil 12931} 12932 12933func awsAwsjson11_deserializeOpDocumentPutFirewallRuleGroupPolicyOutput(v **PutFirewallRuleGroupPolicyOutput, value interface{}) error { 12934 if v == nil { 12935 return fmt.Errorf("unexpected nil of type %T", v) 12936 } 12937 if value == nil { 12938 return nil 12939 } 12940 12941 shape, ok := value.(map[string]interface{}) 12942 if !ok { 12943 return fmt.Errorf("unexpected JSON type %v", value) 12944 } 12945 12946 var sv *PutFirewallRuleGroupPolicyOutput 12947 if *v == nil { 12948 sv = &PutFirewallRuleGroupPolicyOutput{} 12949 } else { 12950 sv = *v 12951 } 12952 12953 for key, value := range shape { 12954 switch key { 12955 case "ReturnValue": 12956 if value != nil { 12957 jtv, ok := value.(bool) 12958 if !ok { 12959 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 12960 } 12961 sv.ReturnValue = jtv 12962 } 12963 12964 default: 12965 _, _ = key, value 12966 12967 } 12968 } 12969 *v = sv 12970 return nil 12971} 12972 12973func awsAwsjson11_deserializeOpDocumentPutResolverQueryLogConfigPolicyOutput(v **PutResolverQueryLogConfigPolicyOutput, value interface{}) error { 12974 if v == nil { 12975 return fmt.Errorf("unexpected nil of type %T", v) 12976 } 12977 if value == nil { 12978 return nil 12979 } 12980 12981 shape, ok := value.(map[string]interface{}) 12982 if !ok { 12983 return fmt.Errorf("unexpected JSON type %v", value) 12984 } 12985 12986 var sv *PutResolverQueryLogConfigPolicyOutput 12987 if *v == nil { 12988 sv = &PutResolverQueryLogConfigPolicyOutput{} 12989 } else { 12990 sv = *v 12991 } 12992 12993 for key, value := range shape { 12994 switch key { 12995 case "ReturnValue": 12996 if value != nil { 12997 jtv, ok := value.(bool) 12998 if !ok { 12999 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 13000 } 13001 sv.ReturnValue = jtv 13002 } 13003 13004 default: 13005 _, _ = key, value 13006 13007 } 13008 } 13009 *v = sv 13010 return nil 13011} 13012 13013func awsAwsjson11_deserializeOpDocumentPutResolverRulePolicyOutput(v **PutResolverRulePolicyOutput, value interface{}) error { 13014 if v == nil { 13015 return fmt.Errorf("unexpected nil of type %T", v) 13016 } 13017 if value == nil { 13018 return nil 13019 } 13020 13021 shape, ok := value.(map[string]interface{}) 13022 if !ok { 13023 return fmt.Errorf("unexpected JSON type %v", value) 13024 } 13025 13026 var sv *PutResolverRulePolicyOutput 13027 if *v == nil { 13028 sv = &PutResolverRulePolicyOutput{} 13029 } else { 13030 sv = *v 13031 } 13032 13033 for key, value := range shape { 13034 switch key { 13035 case "ReturnValue": 13036 if value != nil { 13037 jtv, ok := value.(bool) 13038 if !ok { 13039 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 13040 } 13041 sv.ReturnValue = jtv 13042 } 13043 13044 default: 13045 _, _ = key, value 13046 13047 } 13048 } 13049 *v = sv 13050 return nil 13051} 13052 13053func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 13054 if v == nil { 13055 return fmt.Errorf("unexpected nil of type %T", v) 13056 } 13057 if value == nil { 13058 return nil 13059 } 13060 13061 shape, ok := value.(map[string]interface{}) 13062 if !ok { 13063 return fmt.Errorf("unexpected JSON type %v", value) 13064 } 13065 13066 var sv *TagResourceOutput 13067 if *v == nil { 13068 sv = &TagResourceOutput{} 13069 } else { 13070 sv = *v 13071 } 13072 13073 for key, value := range shape { 13074 switch key { 13075 default: 13076 _, _ = key, value 13077 13078 } 13079 } 13080 *v = sv 13081 return nil 13082} 13083 13084func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 13085 if v == nil { 13086 return fmt.Errorf("unexpected nil of type %T", v) 13087 } 13088 if value == nil { 13089 return nil 13090 } 13091 13092 shape, ok := value.(map[string]interface{}) 13093 if !ok { 13094 return fmt.Errorf("unexpected JSON type %v", value) 13095 } 13096 13097 var sv *UntagResourceOutput 13098 if *v == nil { 13099 sv = &UntagResourceOutput{} 13100 } else { 13101 sv = *v 13102 } 13103 13104 for key, value := range shape { 13105 switch key { 13106 default: 13107 _, _ = key, value 13108 13109 } 13110 } 13111 *v = sv 13112 return nil 13113} 13114 13115func awsAwsjson11_deserializeOpDocumentUpdateFirewallConfigOutput(v **UpdateFirewallConfigOutput, value interface{}) error { 13116 if v == nil { 13117 return fmt.Errorf("unexpected nil of type %T", v) 13118 } 13119 if value == nil { 13120 return nil 13121 } 13122 13123 shape, ok := value.(map[string]interface{}) 13124 if !ok { 13125 return fmt.Errorf("unexpected JSON type %v", value) 13126 } 13127 13128 var sv *UpdateFirewallConfigOutput 13129 if *v == nil { 13130 sv = &UpdateFirewallConfigOutput{} 13131 } else { 13132 sv = *v 13133 } 13134 13135 for key, value := range shape { 13136 switch key { 13137 case "FirewallConfig": 13138 if err := awsAwsjson11_deserializeDocumentFirewallConfig(&sv.FirewallConfig, value); err != nil { 13139 return err 13140 } 13141 13142 default: 13143 _, _ = key, value 13144 13145 } 13146 } 13147 *v = sv 13148 return nil 13149} 13150 13151func awsAwsjson11_deserializeOpDocumentUpdateFirewallDomainsOutput(v **UpdateFirewallDomainsOutput, value interface{}) error { 13152 if v == nil { 13153 return fmt.Errorf("unexpected nil of type %T", v) 13154 } 13155 if value == nil { 13156 return nil 13157 } 13158 13159 shape, ok := value.(map[string]interface{}) 13160 if !ok { 13161 return fmt.Errorf("unexpected JSON type %v", value) 13162 } 13163 13164 var sv *UpdateFirewallDomainsOutput 13165 if *v == nil { 13166 sv = &UpdateFirewallDomainsOutput{} 13167 } else { 13168 sv = *v 13169 } 13170 13171 for key, value := range shape { 13172 switch key { 13173 case "Id": 13174 if value != nil { 13175 jtv, ok := value.(string) 13176 if !ok { 13177 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 13178 } 13179 sv.Id = ptr.String(jtv) 13180 } 13181 13182 case "Name": 13183 if value != nil { 13184 jtv, ok := value.(string) 13185 if !ok { 13186 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 13187 } 13188 sv.Name = ptr.String(jtv) 13189 } 13190 13191 case "Status": 13192 if value != nil { 13193 jtv, ok := value.(string) 13194 if !ok { 13195 return fmt.Errorf("expected FirewallDomainListStatus to be of type string, got %T instead", value) 13196 } 13197 sv.Status = types.FirewallDomainListStatus(jtv) 13198 } 13199 13200 case "StatusMessage": 13201 if value != nil { 13202 jtv, ok := value.(string) 13203 if !ok { 13204 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 13205 } 13206 sv.StatusMessage = ptr.String(jtv) 13207 } 13208 13209 default: 13210 _, _ = key, value 13211 13212 } 13213 } 13214 *v = sv 13215 return nil 13216} 13217 13218func awsAwsjson11_deserializeOpDocumentUpdateFirewallRuleGroupAssociationOutput(v **UpdateFirewallRuleGroupAssociationOutput, value interface{}) error { 13219 if v == nil { 13220 return fmt.Errorf("unexpected nil of type %T", v) 13221 } 13222 if value == nil { 13223 return nil 13224 } 13225 13226 shape, ok := value.(map[string]interface{}) 13227 if !ok { 13228 return fmt.Errorf("unexpected JSON type %v", value) 13229 } 13230 13231 var sv *UpdateFirewallRuleGroupAssociationOutput 13232 if *v == nil { 13233 sv = &UpdateFirewallRuleGroupAssociationOutput{} 13234 } else { 13235 sv = *v 13236 } 13237 13238 for key, value := range shape { 13239 switch key { 13240 case "FirewallRuleGroupAssociation": 13241 if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(&sv.FirewallRuleGroupAssociation, value); err != nil { 13242 return err 13243 } 13244 13245 default: 13246 _, _ = key, value 13247 13248 } 13249 } 13250 *v = sv 13251 return nil 13252} 13253 13254func awsAwsjson11_deserializeOpDocumentUpdateFirewallRuleOutput(v **UpdateFirewallRuleOutput, value interface{}) error { 13255 if v == nil { 13256 return fmt.Errorf("unexpected nil of type %T", v) 13257 } 13258 if value == nil { 13259 return nil 13260 } 13261 13262 shape, ok := value.(map[string]interface{}) 13263 if !ok { 13264 return fmt.Errorf("unexpected JSON type %v", value) 13265 } 13266 13267 var sv *UpdateFirewallRuleOutput 13268 if *v == nil { 13269 sv = &UpdateFirewallRuleOutput{} 13270 } else { 13271 sv = *v 13272 } 13273 13274 for key, value := range shape { 13275 switch key { 13276 case "FirewallRule": 13277 if err := awsAwsjson11_deserializeDocumentFirewallRule(&sv.FirewallRule, value); err != nil { 13278 return err 13279 } 13280 13281 default: 13282 _, _ = key, value 13283 13284 } 13285 } 13286 *v = sv 13287 return nil 13288} 13289 13290func awsAwsjson11_deserializeOpDocumentUpdateResolverDnssecConfigOutput(v **UpdateResolverDnssecConfigOutput, value interface{}) error { 13291 if v == nil { 13292 return fmt.Errorf("unexpected nil of type %T", v) 13293 } 13294 if value == nil { 13295 return nil 13296 } 13297 13298 shape, ok := value.(map[string]interface{}) 13299 if !ok { 13300 return fmt.Errorf("unexpected JSON type %v", value) 13301 } 13302 13303 var sv *UpdateResolverDnssecConfigOutput 13304 if *v == nil { 13305 sv = &UpdateResolverDnssecConfigOutput{} 13306 } else { 13307 sv = *v 13308 } 13309 13310 for key, value := range shape { 13311 switch key { 13312 case "ResolverDNSSECConfig": 13313 if err := awsAwsjson11_deserializeDocumentResolverDnssecConfig(&sv.ResolverDNSSECConfig, value); err != nil { 13314 return err 13315 } 13316 13317 default: 13318 _, _ = key, value 13319 13320 } 13321 } 13322 *v = sv 13323 return nil 13324} 13325 13326func awsAwsjson11_deserializeOpDocumentUpdateResolverEndpointOutput(v **UpdateResolverEndpointOutput, value interface{}) error { 13327 if v == nil { 13328 return fmt.Errorf("unexpected nil of type %T", v) 13329 } 13330 if value == nil { 13331 return nil 13332 } 13333 13334 shape, ok := value.(map[string]interface{}) 13335 if !ok { 13336 return fmt.Errorf("unexpected JSON type %v", value) 13337 } 13338 13339 var sv *UpdateResolverEndpointOutput 13340 if *v == nil { 13341 sv = &UpdateResolverEndpointOutput{} 13342 } else { 13343 sv = *v 13344 } 13345 13346 for key, value := range shape { 13347 switch key { 13348 case "ResolverEndpoint": 13349 if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil { 13350 return err 13351 } 13352 13353 default: 13354 _, _ = key, value 13355 13356 } 13357 } 13358 *v = sv 13359 return nil 13360} 13361 13362func awsAwsjson11_deserializeOpDocumentUpdateResolverRuleOutput(v **UpdateResolverRuleOutput, value interface{}) error { 13363 if v == nil { 13364 return fmt.Errorf("unexpected nil of type %T", v) 13365 } 13366 if value == nil { 13367 return nil 13368 } 13369 13370 shape, ok := value.(map[string]interface{}) 13371 if !ok { 13372 return fmt.Errorf("unexpected JSON type %v", value) 13373 } 13374 13375 var sv *UpdateResolverRuleOutput 13376 if *v == nil { 13377 sv = &UpdateResolverRuleOutput{} 13378 } else { 13379 sv = *v 13380 } 13381 13382 for key, value := range shape { 13383 switch key { 13384 case "ResolverRule": 13385 if err := awsAwsjson11_deserializeDocumentResolverRule(&sv.ResolverRule, value); err != nil { 13386 return err 13387 } 13388 13389 default: 13390 _, _ = key, value 13391 13392 } 13393 } 13394 *v = sv 13395 return nil 13396} 13397