1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package cloudwatchlogs 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/cloudwatchlogs/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 "io/ioutil" 19 "strings" 20) 21 22type awsAwsjson11_deserializeOpAssociateKmsKey struct { 23} 24 25func (*awsAwsjson11_deserializeOpAssociateKmsKey) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpAssociateKmsKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsAwsjson11_deserializeOpErrorAssociateKmsKey(response, &metadata) 44 } 45 output := &AssociateKmsKeyOutput{} 46 out.Result = output 47 48 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 49 return out, metadata, &smithy.DeserializationError{ 50 Err: fmt.Errorf("failed to discard response body, %w", err), 51 } 52 } 53 54 return out, metadata, err 55} 56 57func awsAwsjson11_deserializeOpErrorAssociateKmsKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 58 var errorBuffer bytes.Buffer 59 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 60 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 61 } 62 errorBody := bytes.NewReader(errorBuffer.Bytes()) 63 64 errorCode := "UnknownError" 65 errorMessage := errorCode 66 67 code := response.Header.Get("X-Amzn-ErrorType") 68 if len(code) != 0 { 69 errorCode = restjson.SanitizeErrorCode(code) 70 } 71 72 var buff [1024]byte 73 ringBuffer := smithyio.NewRingBuffer(buff[:]) 74 75 body := io.TeeReader(errorBody, ringBuffer) 76 decoder := json.NewDecoder(body) 77 decoder.UseNumber() 78 code, message, err := restjson.GetErrorInfo(decoder) 79 if err != nil { 80 var snapshot bytes.Buffer 81 io.Copy(&snapshot, ringBuffer) 82 err = &smithy.DeserializationError{ 83 Err: fmt.Errorf("failed to decode response body, %w", err), 84 Snapshot: snapshot.Bytes(), 85 } 86 return err 87 } 88 89 errorBody.Seek(0, io.SeekStart) 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 if len(message) != 0 { 94 errorMessage = message 95 } 96 97 switch { 98 case strings.EqualFold("InvalidParameterException", errorCode): 99 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 100 101 case strings.EqualFold("OperationAbortedException", errorCode): 102 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 103 104 case strings.EqualFold("ResourceNotFoundException", errorCode): 105 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 106 107 case strings.EqualFold("ServiceUnavailableException", errorCode): 108 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 109 110 default: 111 genericError := &smithy.GenericAPIError{ 112 Code: errorCode, 113 Message: errorMessage, 114 } 115 return genericError 116 117 } 118} 119 120type awsAwsjson11_deserializeOpCancelExportTask struct { 121} 122 123func (*awsAwsjson11_deserializeOpCancelExportTask) ID() string { 124 return "OperationDeserializer" 125} 126 127func (m *awsAwsjson11_deserializeOpCancelExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 128 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 129) { 130 out, metadata, err = next.HandleDeserialize(ctx, in) 131 if err != nil { 132 return out, metadata, err 133 } 134 135 response, ok := out.RawResponse.(*smithyhttp.Response) 136 if !ok { 137 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 138 } 139 140 if response.StatusCode < 200 || response.StatusCode >= 300 { 141 return out, metadata, awsAwsjson11_deserializeOpErrorCancelExportTask(response, &metadata) 142 } 143 output := &CancelExportTaskOutput{} 144 out.Result = output 145 146 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 147 return out, metadata, &smithy.DeserializationError{ 148 Err: fmt.Errorf("failed to discard response body, %w", err), 149 } 150 } 151 152 return out, metadata, err 153} 154 155func awsAwsjson11_deserializeOpErrorCancelExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 156 var errorBuffer bytes.Buffer 157 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 158 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 159 } 160 errorBody := bytes.NewReader(errorBuffer.Bytes()) 161 162 errorCode := "UnknownError" 163 errorMessage := errorCode 164 165 code := response.Header.Get("X-Amzn-ErrorType") 166 if len(code) != 0 { 167 errorCode = restjson.SanitizeErrorCode(code) 168 } 169 170 var buff [1024]byte 171 ringBuffer := smithyio.NewRingBuffer(buff[:]) 172 173 body := io.TeeReader(errorBody, ringBuffer) 174 decoder := json.NewDecoder(body) 175 decoder.UseNumber() 176 code, message, err := restjson.GetErrorInfo(decoder) 177 if err != nil { 178 var snapshot bytes.Buffer 179 io.Copy(&snapshot, ringBuffer) 180 err = &smithy.DeserializationError{ 181 Err: fmt.Errorf("failed to decode response body, %w", err), 182 Snapshot: snapshot.Bytes(), 183 } 184 return err 185 } 186 187 errorBody.Seek(0, io.SeekStart) 188 if len(code) != 0 { 189 errorCode = restjson.SanitizeErrorCode(code) 190 } 191 if len(message) != 0 { 192 errorMessage = message 193 } 194 195 switch { 196 case strings.EqualFold("InvalidOperationException", errorCode): 197 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 198 199 case strings.EqualFold("InvalidParameterException", errorCode): 200 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 201 202 case strings.EqualFold("ResourceNotFoundException", errorCode): 203 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 204 205 case strings.EqualFold("ServiceUnavailableException", errorCode): 206 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 207 208 default: 209 genericError := &smithy.GenericAPIError{ 210 Code: errorCode, 211 Message: errorMessage, 212 } 213 return genericError 214 215 } 216} 217 218type awsAwsjson11_deserializeOpCreateExportTask struct { 219} 220 221func (*awsAwsjson11_deserializeOpCreateExportTask) ID() string { 222 return "OperationDeserializer" 223} 224 225func (m *awsAwsjson11_deserializeOpCreateExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 226 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 227) { 228 out, metadata, err = next.HandleDeserialize(ctx, in) 229 if err != nil { 230 return out, metadata, err 231 } 232 233 response, ok := out.RawResponse.(*smithyhttp.Response) 234 if !ok { 235 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 236 } 237 238 if response.StatusCode < 200 || response.StatusCode >= 300 { 239 return out, metadata, awsAwsjson11_deserializeOpErrorCreateExportTask(response, &metadata) 240 } 241 output := &CreateExportTaskOutput{} 242 out.Result = output 243 244 var buff [1024]byte 245 ringBuffer := smithyio.NewRingBuffer(buff[:]) 246 247 body := io.TeeReader(response.Body, ringBuffer) 248 decoder := json.NewDecoder(body) 249 decoder.UseNumber() 250 var shape interface{} 251 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 252 var snapshot bytes.Buffer 253 io.Copy(&snapshot, ringBuffer) 254 err = &smithy.DeserializationError{ 255 Err: fmt.Errorf("failed to decode response body, %w", err), 256 Snapshot: snapshot.Bytes(), 257 } 258 return out, metadata, err 259 } 260 261 err = awsAwsjson11_deserializeOpDocumentCreateExportTaskOutput(&output, shape) 262 if err != nil { 263 var snapshot bytes.Buffer 264 io.Copy(&snapshot, ringBuffer) 265 err = &smithy.DeserializationError{ 266 Err: fmt.Errorf("failed to decode response body, %w", err), 267 Snapshot: snapshot.Bytes(), 268 } 269 return out, metadata, err 270 } 271 272 return out, metadata, err 273} 274 275func awsAwsjson11_deserializeOpErrorCreateExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 276 var errorBuffer bytes.Buffer 277 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 278 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 279 } 280 errorBody := bytes.NewReader(errorBuffer.Bytes()) 281 282 errorCode := "UnknownError" 283 errorMessage := errorCode 284 285 code := response.Header.Get("X-Amzn-ErrorType") 286 if len(code) != 0 { 287 errorCode = restjson.SanitizeErrorCode(code) 288 } 289 290 var buff [1024]byte 291 ringBuffer := smithyio.NewRingBuffer(buff[:]) 292 293 body := io.TeeReader(errorBody, ringBuffer) 294 decoder := json.NewDecoder(body) 295 decoder.UseNumber() 296 code, message, err := restjson.GetErrorInfo(decoder) 297 if err != nil { 298 var snapshot bytes.Buffer 299 io.Copy(&snapshot, ringBuffer) 300 err = &smithy.DeserializationError{ 301 Err: fmt.Errorf("failed to decode response body, %w", err), 302 Snapshot: snapshot.Bytes(), 303 } 304 return err 305 } 306 307 errorBody.Seek(0, io.SeekStart) 308 if len(code) != 0 { 309 errorCode = restjson.SanitizeErrorCode(code) 310 } 311 if len(message) != 0 { 312 errorMessage = message 313 } 314 315 switch { 316 case strings.EqualFold("InvalidParameterException", errorCode): 317 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 318 319 case strings.EqualFold("LimitExceededException", errorCode): 320 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 321 322 case strings.EqualFold("OperationAbortedException", errorCode): 323 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 324 325 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 326 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 327 328 case strings.EqualFold("ResourceNotFoundException", errorCode): 329 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 330 331 case strings.EqualFold("ServiceUnavailableException", errorCode): 332 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 333 334 default: 335 genericError := &smithy.GenericAPIError{ 336 Code: errorCode, 337 Message: errorMessage, 338 } 339 return genericError 340 341 } 342} 343 344type awsAwsjson11_deserializeOpCreateLogGroup struct { 345} 346 347func (*awsAwsjson11_deserializeOpCreateLogGroup) ID() string { 348 return "OperationDeserializer" 349} 350 351func (m *awsAwsjson11_deserializeOpCreateLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 352 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 353) { 354 out, metadata, err = next.HandleDeserialize(ctx, in) 355 if err != nil { 356 return out, metadata, err 357 } 358 359 response, ok := out.RawResponse.(*smithyhttp.Response) 360 if !ok { 361 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 362 } 363 364 if response.StatusCode < 200 || response.StatusCode >= 300 { 365 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLogGroup(response, &metadata) 366 } 367 output := &CreateLogGroupOutput{} 368 out.Result = output 369 370 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 371 return out, metadata, &smithy.DeserializationError{ 372 Err: fmt.Errorf("failed to discard response body, %w", err), 373 } 374 } 375 376 return out, metadata, err 377} 378 379func awsAwsjson11_deserializeOpErrorCreateLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 380 var errorBuffer bytes.Buffer 381 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 382 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 383 } 384 errorBody := bytes.NewReader(errorBuffer.Bytes()) 385 386 errorCode := "UnknownError" 387 errorMessage := errorCode 388 389 code := response.Header.Get("X-Amzn-ErrorType") 390 if len(code) != 0 { 391 errorCode = restjson.SanitizeErrorCode(code) 392 } 393 394 var buff [1024]byte 395 ringBuffer := smithyio.NewRingBuffer(buff[:]) 396 397 body := io.TeeReader(errorBody, ringBuffer) 398 decoder := json.NewDecoder(body) 399 decoder.UseNumber() 400 code, message, err := restjson.GetErrorInfo(decoder) 401 if err != nil { 402 var snapshot bytes.Buffer 403 io.Copy(&snapshot, ringBuffer) 404 err = &smithy.DeserializationError{ 405 Err: fmt.Errorf("failed to decode response body, %w", err), 406 Snapshot: snapshot.Bytes(), 407 } 408 return err 409 } 410 411 errorBody.Seek(0, io.SeekStart) 412 if len(code) != 0 { 413 errorCode = restjson.SanitizeErrorCode(code) 414 } 415 if len(message) != 0 { 416 errorMessage = message 417 } 418 419 switch { 420 case strings.EqualFold("InvalidParameterException", errorCode): 421 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 422 423 case strings.EqualFold("LimitExceededException", errorCode): 424 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 425 426 case strings.EqualFold("OperationAbortedException", errorCode): 427 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 428 429 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 430 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 431 432 case strings.EqualFold("ServiceUnavailableException", errorCode): 433 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 434 435 default: 436 genericError := &smithy.GenericAPIError{ 437 Code: errorCode, 438 Message: errorMessage, 439 } 440 return genericError 441 442 } 443} 444 445type awsAwsjson11_deserializeOpCreateLogStream struct { 446} 447 448func (*awsAwsjson11_deserializeOpCreateLogStream) ID() string { 449 return "OperationDeserializer" 450} 451 452func (m *awsAwsjson11_deserializeOpCreateLogStream) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 453 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 454) { 455 out, metadata, err = next.HandleDeserialize(ctx, in) 456 if err != nil { 457 return out, metadata, err 458 } 459 460 response, ok := out.RawResponse.(*smithyhttp.Response) 461 if !ok { 462 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 463 } 464 465 if response.StatusCode < 200 || response.StatusCode >= 300 { 466 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLogStream(response, &metadata) 467 } 468 output := &CreateLogStreamOutput{} 469 out.Result = output 470 471 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 472 return out, metadata, &smithy.DeserializationError{ 473 Err: fmt.Errorf("failed to discard response body, %w", err), 474 } 475 } 476 477 return out, metadata, err 478} 479 480func awsAwsjson11_deserializeOpErrorCreateLogStream(response *smithyhttp.Response, metadata *middleware.Metadata) error { 481 var errorBuffer bytes.Buffer 482 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 483 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 484 } 485 errorBody := bytes.NewReader(errorBuffer.Bytes()) 486 487 errorCode := "UnknownError" 488 errorMessage := errorCode 489 490 code := response.Header.Get("X-Amzn-ErrorType") 491 if len(code) != 0 { 492 errorCode = restjson.SanitizeErrorCode(code) 493 } 494 495 var buff [1024]byte 496 ringBuffer := smithyio.NewRingBuffer(buff[:]) 497 498 body := io.TeeReader(errorBody, ringBuffer) 499 decoder := json.NewDecoder(body) 500 decoder.UseNumber() 501 code, message, err := restjson.GetErrorInfo(decoder) 502 if err != nil { 503 var snapshot bytes.Buffer 504 io.Copy(&snapshot, ringBuffer) 505 err = &smithy.DeserializationError{ 506 Err: fmt.Errorf("failed to decode response body, %w", err), 507 Snapshot: snapshot.Bytes(), 508 } 509 return err 510 } 511 512 errorBody.Seek(0, io.SeekStart) 513 if len(code) != 0 { 514 errorCode = restjson.SanitizeErrorCode(code) 515 } 516 if len(message) != 0 { 517 errorMessage = message 518 } 519 520 switch { 521 case strings.EqualFold("InvalidParameterException", errorCode): 522 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 523 524 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 525 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 526 527 case strings.EqualFold("ResourceNotFoundException", errorCode): 528 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 529 530 case strings.EqualFold("ServiceUnavailableException", errorCode): 531 return awsAwsjson11_deserializeErrorServiceUnavailableException(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_deserializeOpDeleteDestination struct { 544} 545 546func (*awsAwsjson11_deserializeOpDeleteDestination) ID() string { 547 return "OperationDeserializer" 548} 549 550func (m *awsAwsjson11_deserializeOpDeleteDestination) 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_deserializeOpErrorDeleteDestination(response, &metadata) 565 } 566 output := &DeleteDestinationOutput{} 567 out.Result = output 568 569 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 570 return out, metadata, &smithy.DeserializationError{ 571 Err: fmt.Errorf("failed to discard response body, %w", err), 572 } 573 } 574 575 return out, metadata, err 576} 577 578func awsAwsjson11_deserializeOpErrorDeleteDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { 579 var errorBuffer bytes.Buffer 580 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 581 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 582 } 583 errorBody := bytes.NewReader(errorBuffer.Bytes()) 584 585 errorCode := "UnknownError" 586 errorMessage := errorCode 587 588 code := response.Header.Get("X-Amzn-ErrorType") 589 if len(code) != 0 { 590 errorCode = restjson.SanitizeErrorCode(code) 591 } 592 593 var buff [1024]byte 594 ringBuffer := smithyio.NewRingBuffer(buff[:]) 595 596 body := io.TeeReader(errorBody, ringBuffer) 597 decoder := json.NewDecoder(body) 598 decoder.UseNumber() 599 code, message, err := restjson.GetErrorInfo(decoder) 600 if err != nil { 601 var snapshot bytes.Buffer 602 io.Copy(&snapshot, ringBuffer) 603 err = &smithy.DeserializationError{ 604 Err: fmt.Errorf("failed to decode response body, %w", err), 605 Snapshot: snapshot.Bytes(), 606 } 607 return err 608 } 609 610 errorBody.Seek(0, io.SeekStart) 611 if len(code) != 0 { 612 errorCode = restjson.SanitizeErrorCode(code) 613 } 614 if len(message) != 0 { 615 errorMessage = message 616 } 617 618 switch { 619 case strings.EqualFold("InvalidParameterException", errorCode): 620 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 621 622 case strings.EqualFold("OperationAbortedException", errorCode): 623 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 624 625 case strings.EqualFold("ResourceNotFoundException", errorCode): 626 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 627 628 case strings.EqualFold("ServiceUnavailableException", errorCode): 629 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 630 631 default: 632 genericError := &smithy.GenericAPIError{ 633 Code: errorCode, 634 Message: errorMessage, 635 } 636 return genericError 637 638 } 639} 640 641type awsAwsjson11_deserializeOpDeleteLogGroup struct { 642} 643 644func (*awsAwsjson11_deserializeOpDeleteLogGroup) ID() string { 645 return "OperationDeserializer" 646} 647 648func (m *awsAwsjson11_deserializeOpDeleteLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 649 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 650) { 651 out, metadata, err = next.HandleDeserialize(ctx, in) 652 if err != nil { 653 return out, metadata, err 654 } 655 656 response, ok := out.RawResponse.(*smithyhttp.Response) 657 if !ok { 658 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 659 } 660 661 if response.StatusCode < 200 || response.StatusCode >= 300 { 662 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLogGroup(response, &metadata) 663 } 664 output := &DeleteLogGroupOutput{} 665 out.Result = output 666 667 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 668 return out, metadata, &smithy.DeserializationError{ 669 Err: fmt.Errorf("failed to discard response body, %w", err), 670 } 671 } 672 673 return out, metadata, err 674} 675 676func awsAwsjson11_deserializeOpErrorDeleteLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 677 var errorBuffer bytes.Buffer 678 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 679 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 680 } 681 errorBody := bytes.NewReader(errorBuffer.Bytes()) 682 683 errorCode := "UnknownError" 684 errorMessage := errorCode 685 686 code := response.Header.Get("X-Amzn-ErrorType") 687 if len(code) != 0 { 688 errorCode = restjson.SanitizeErrorCode(code) 689 } 690 691 var buff [1024]byte 692 ringBuffer := smithyio.NewRingBuffer(buff[:]) 693 694 body := io.TeeReader(errorBody, ringBuffer) 695 decoder := json.NewDecoder(body) 696 decoder.UseNumber() 697 code, message, err := restjson.GetErrorInfo(decoder) 698 if err != nil { 699 var snapshot bytes.Buffer 700 io.Copy(&snapshot, ringBuffer) 701 err = &smithy.DeserializationError{ 702 Err: fmt.Errorf("failed to decode response body, %w", err), 703 Snapshot: snapshot.Bytes(), 704 } 705 return err 706 } 707 708 errorBody.Seek(0, io.SeekStart) 709 if len(code) != 0 { 710 errorCode = restjson.SanitizeErrorCode(code) 711 } 712 if len(message) != 0 { 713 errorMessage = message 714 } 715 716 switch { 717 case strings.EqualFold("InvalidParameterException", errorCode): 718 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 719 720 case strings.EqualFold("OperationAbortedException", errorCode): 721 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 722 723 case strings.EqualFold("ResourceNotFoundException", errorCode): 724 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 725 726 case strings.EqualFold("ServiceUnavailableException", errorCode): 727 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 728 729 default: 730 genericError := &smithy.GenericAPIError{ 731 Code: errorCode, 732 Message: errorMessage, 733 } 734 return genericError 735 736 } 737} 738 739type awsAwsjson11_deserializeOpDeleteLogStream struct { 740} 741 742func (*awsAwsjson11_deserializeOpDeleteLogStream) ID() string { 743 return "OperationDeserializer" 744} 745 746func (m *awsAwsjson11_deserializeOpDeleteLogStream) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 747 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 748) { 749 out, metadata, err = next.HandleDeserialize(ctx, in) 750 if err != nil { 751 return out, metadata, err 752 } 753 754 response, ok := out.RawResponse.(*smithyhttp.Response) 755 if !ok { 756 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 757 } 758 759 if response.StatusCode < 200 || response.StatusCode >= 300 { 760 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLogStream(response, &metadata) 761 } 762 output := &DeleteLogStreamOutput{} 763 out.Result = output 764 765 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 766 return out, metadata, &smithy.DeserializationError{ 767 Err: fmt.Errorf("failed to discard response body, %w", err), 768 } 769 } 770 771 return out, metadata, err 772} 773 774func awsAwsjson11_deserializeOpErrorDeleteLogStream(response *smithyhttp.Response, metadata *middleware.Metadata) error { 775 var errorBuffer bytes.Buffer 776 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 777 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 778 } 779 errorBody := bytes.NewReader(errorBuffer.Bytes()) 780 781 errorCode := "UnknownError" 782 errorMessage := errorCode 783 784 code := response.Header.Get("X-Amzn-ErrorType") 785 if len(code) != 0 { 786 errorCode = restjson.SanitizeErrorCode(code) 787 } 788 789 var buff [1024]byte 790 ringBuffer := smithyio.NewRingBuffer(buff[:]) 791 792 body := io.TeeReader(errorBody, ringBuffer) 793 decoder := json.NewDecoder(body) 794 decoder.UseNumber() 795 code, message, err := restjson.GetErrorInfo(decoder) 796 if err != nil { 797 var snapshot bytes.Buffer 798 io.Copy(&snapshot, ringBuffer) 799 err = &smithy.DeserializationError{ 800 Err: fmt.Errorf("failed to decode response body, %w", err), 801 Snapshot: snapshot.Bytes(), 802 } 803 return err 804 } 805 806 errorBody.Seek(0, io.SeekStart) 807 if len(code) != 0 { 808 errorCode = restjson.SanitizeErrorCode(code) 809 } 810 if len(message) != 0 { 811 errorMessage = message 812 } 813 814 switch { 815 case strings.EqualFold("InvalidParameterException", errorCode): 816 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 817 818 case strings.EqualFold("OperationAbortedException", errorCode): 819 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 820 821 case strings.EqualFold("ResourceNotFoundException", errorCode): 822 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 823 824 case strings.EqualFold("ServiceUnavailableException", errorCode): 825 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 826 827 default: 828 genericError := &smithy.GenericAPIError{ 829 Code: errorCode, 830 Message: errorMessage, 831 } 832 return genericError 833 834 } 835} 836 837type awsAwsjson11_deserializeOpDeleteMetricFilter struct { 838} 839 840func (*awsAwsjson11_deserializeOpDeleteMetricFilter) ID() string { 841 return "OperationDeserializer" 842} 843 844func (m *awsAwsjson11_deserializeOpDeleteMetricFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 845 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 846) { 847 out, metadata, err = next.HandleDeserialize(ctx, in) 848 if err != nil { 849 return out, metadata, err 850 } 851 852 response, ok := out.RawResponse.(*smithyhttp.Response) 853 if !ok { 854 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 855 } 856 857 if response.StatusCode < 200 || response.StatusCode >= 300 { 858 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteMetricFilter(response, &metadata) 859 } 860 output := &DeleteMetricFilterOutput{} 861 out.Result = output 862 863 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 864 return out, metadata, &smithy.DeserializationError{ 865 Err: fmt.Errorf("failed to discard response body, %w", err), 866 } 867 } 868 869 return out, metadata, err 870} 871 872func awsAwsjson11_deserializeOpErrorDeleteMetricFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 873 var errorBuffer bytes.Buffer 874 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 875 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 876 } 877 errorBody := bytes.NewReader(errorBuffer.Bytes()) 878 879 errorCode := "UnknownError" 880 errorMessage := errorCode 881 882 code := response.Header.Get("X-Amzn-ErrorType") 883 if len(code) != 0 { 884 errorCode = restjson.SanitizeErrorCode(code) 885 } 886 887 var buff [1024]byte 888 ringBuffer := smithyio.NewRingBuffer(buff[:]) 889 890 body := io.TeeReader(errorBody, ringBuffer) 891 decoder := json.NewDecoder(body) 892 decoder.UseNumber() 893 code, message, err := restjson.GetErrorInfo(decoder) 894 if err != nil { 895 var snapshot bytes.Buffer 896 io.Copy(&snapshot, ringBuffer) 897 err = &smithy.DeserializationError{ 898 Err: fmt.Errorf("failed to decode response body, %w", err), 899 Snapshot: snapshot.Bytes(), 900 } 901 return err 902 } 903 904 errorBody.Seek(0, io.SeekStart) 905 if len(code) != 0 { 906 errorCode = restjson.SanitizeErrorCode(code) 907 } 908 if len(message) != 0 { 909 errorMessage = message 910 } 911 912 switch { 913 case strings.EqualFold("InvalidParameterException", errorCode): 914 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 915 916 case strings.EqualFold("OperationAbortedException", errorCode): 917 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 918 919 case strings.EqualFold("ResourceNotFoundException", errorCode): 920 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 921 922 case strings.EqualFold("ServiceUnavailableException", errorCode): 923 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 924 925 default: 926 genericError := &smithy.GenericAPIError{ 927 Code: errorCode, 928 Message: errorMessage, 929 } 930 return genericError 931 932 } 933} 934 935type awsAwsjson11_deserializeOpDeleteQueryDefinition struct { 936} 937 938func (*awsAwsjson11_deserializeOpDeleteQueryDefinition) ID() string { 939 return "OperationDeserializer" 940} 941 942func (m *awsAwsjson11_deserializeOpDeleteQueryDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 943 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 944) { 945 out, metadata, err = next.HandleDeserialize(ctx, in) 946 if err != nil { 947 return out, metadata, err 948 } 949 950 response, ok := out.RawResponse.(*smithyhttp.Response) 951 if !ok { 952 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 953 } 954 955 if response.StatusCode < 200 || response.StatusCode >= 300 { 956 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteQueryDefinition(response, &metadata) 957 } 958 output := &DeleteQueryDefinitionOutput{} 959 out.Result = output 960 961 var buff [1024]byte 962 ringBuffer := smithyio.NewRingBuffer(buff[:]) 963 964 body := io.TeeReader(response.Body, ringBuffer) 965 decoder := json.NewDecoder(body) 966 decoder.UseNumber() 967 var shape interface{} 968 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 969 var snapshot bytes.Buffer 970 io.Copy(&snapshot, ringBuffer) 971 err = &smithy.DeserializationError{ 972 Err: fmt.Errorf("failed to decode response body, %w", err), 973 Snapshot: snapshot.Bytes(), 974 } 975 return out, metadata, err 976 } 977 978 err = awsAwsjson11_deserializeOpDocumentDeleteQueryDefinitionOutput(&output, shape) 979 if err != nil { 980 var snapshot bytes.Buffer 981 io.Copy(&snapshot, ringBuffer) 982 err = &smithy.DeserializationError{ 983 Err: fmt.Errorf("failed to decode response body, %w", err), 984 Snapshot: snapshot.Bytes(), 985 } 986 return out, metadata, err 987 } 988 989 return out, metadata, err 990} 991 992func awsAwsjson11_deserializeOpErrorDeleteQueryDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 993 var errorBuffer bytes.Buffer 994 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 995 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 996 } 997 errorBody := bytes.NewReader(errorBuffer.Bytes()) 998 999 errorCode := "UnknownError" 1000 errorMessage := errorCode 1001 1002 code := response.Header.Get("X-Amzn-ErrorType") 1003 if len(code) != 0 { 1004 errorCode = restjson.SanitizeErrorCode(code) 1005 } 1006 1007 var buff [1024]byte 1008 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1009 1010 body := io.TeeReader(errorBody, ringBuffer) 1011 decoder := json.NewDecoder(body) 1012 decoder.UseNumber() 1013 code, message, err := restjson.GetErrorInfo(decoder) 1014 if err != nil { 1015 var snapshot bytes.Buffer 1016 io.Copy(&snapshot, ringBuffer) 1017 err = &smithy.DeserializationError{ 1018 Err: fmt.Errorf("failed to decode response body, %w", err), 1019 Snapshot: snapshot.Bytes(), 1020 } 1021 return err 1022 } 1023 1024 errorBody.Seek(0, io.SeekStart) 1025 if len(code) != 0 { 1026 errorCode = restjson.SanitizeErrorCode(code) 1027 } 1028 if len(message) != 0 { 1029 errorMessage = message 1030 } 1031 1032 switch { 1033 case strings.EqualFold("InvalidParameterException", errorCode): 1034 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1035 1036 case strings.EqualFold("ResourceNotFoundException", errorCode): 1037 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1038 1039 case strings.EqualFold("ServiceUnavailableException", errorCode): 1040 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1041 1042 default: 1043 genericError := &smithy.GenericAPIError{ 1044 Code: errorCode, 1045 Message: errorMessage, 1046 } 1047 return genericError 1048 1049 } 1050} 1051 1052type awsAwsjson11_deserializeOpDeleteResourcePolicy struct { 1053} 1054 1055func (*awsAwsjson11_deserializeOpDeleteResourcePolicy) ID() string { 1056 return "OperationDeserializer" 1057} 1058 1059func (m *awsAwsjson11_deserializeOpDeleteResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1060 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1061) { 1062 out, metadata, err = next.HandleDeserialize(ctx, in) 1063 if err != nil { 1064 return out, metadata, err 1065 } 1066 1067 response, ok := out.RawResponse.(*smithyhttp.Response) 1068 if !ok { 1069 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1070 } 1071 1072 if response.StatusCode < 200 || response.StatusCode >= 300 { 1073 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response, &metadata) 1074 } 1075 output := &DeleteResourcePolicyOutput{} 1076 out.Result = output 1077 1078 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1079 return out, metadata, &smithy.DeserializationError{ 1080 Err: fmt.Errorf("failed to discard response body, %w", err), 1081 } 1082 } 1083 1084 return out, metadata, err 1085} 1086 1087func awsAwsjson11_deserializeOpErrorDeleteResourcePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1088 var errorBuffer bytes.Buffer 1089 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1090 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1091 } 1092 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1093 1094 errorCode := "UnknownError" 1095 errorMessage := errorCode 1096 1097 code := response.Header.Get("X-Amzn-ErrorType") 1098 if len(code) != 0 { 1099 errorCode = restjson.SanitizeErrorCode(code) 1100 } 1101 1102 var buff [1024]byte 1103 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1104 1105 body := io.TeeReader(errorBody, ringBuffer) 1106 decoder := json.NewDecoder(body) 1107 decoder.UseNumber() 1108 code, message, err := restjson.GetErrorInfo(decoder) 1109 if err != nil { 1110 var snapshot bytes.Buffer 1111 io.Copy(&snapshot, ringBuffer) 1112 err = &smithy.DeserializationError{ 1113 Err: fmt.Errorf("failed to decode response body, %w", err), 1114 Snapshot: snapshot.Bytes(), 1115 } 1116 return err 1117 } 1118 1119 errorBody.Seek(0, io.SeekStart) 1120 if len(code) != 0 { 1121 errorCode = restjson.SanitizeErrorCode(code) 1122 } 1123 if len(message) != 0 { 1124 errorMessage = message 1125 } 1126 1127 switch { 1128 case strings.EqualFold("InvalidParameterException", errorCode): 1129 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1130 1131 case strings.EqualFold("ResourceNotFoundException", errorCode): 1132 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1133 1134 case strings.EqualFold("ServiceUnavailableException", errorCode): 1135 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1136 1137 default: 1138 genericError := &smithy.GenericAPIError{ 1139 Code: errorCode, 1140 Message: errorMessage, 1141 } 1142 return genericError 1143 1144 } 1145} 1146 1147type awsAwsjson11_deserializeOpDeleteRetentionPolicy struct { 1148} 1149 1150func (*awsAwsjson11_deserializeOpDeleteRetentionPolicy) ID() string { 1151 return "OperationDeserializer" 1152} 1153 1154func (m *awsAwsjson11_deserializeOpDeleteRetentionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1155 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1156) { 1157 out, metadata, err = next.HandleDeserialize(ctx, in) 1158 if err != nil { 1159 return out, metadata, err 1160 } 1161 1162 response, ok := out.RawResponse.(*smithyhttp.Response) 1163 if !ok { 1164 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1165 } 1166 1167 if response.StatusCode < 200 || response.StatusCode >= 300 { 1168 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRetentionPolicy(response, &metadata) 1169 } 1170 output := &DeleteRetentionPolicyOutput{} 1171 out.Result = output 1172 1173 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1174 return out, metadata, &smithy.DeserializationError{ 1175 Err: fmt.Errorf("failed to discard response body, %w", err), 1176 } 1177 } 1178 1179 return out, metadata, err 1180} 1181 1182func awsAwsjson11_deserializeOpErrorDeleteRetentionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1183 var errorBuffer bytes.Buffer 1184 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1185 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1186 } 1187 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1188 1189 errorCode := "UnknownError" 1190 errorMessage := errorCode 1191 1192 code := response.Header.Get("X-Amzn-ErrorType") 1193 if len(code) != 0 { 1194 errorCode = restjson.SanitizeErrorCode(code) 1195 } 1196 1197 var buff [1024]byte 1198 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1199 1200 body := io.TeeReader(errorBody, ringBuffer) 1201 decoder := json.NewDecoder(body) 1202 decoder.UseNumber() 1203 code, message, err := restjson.GetErrorInfo(decoder) 1204 if err != nil { 1205 var snapshot bytes.Buffer 1206 io.Copy(&snapshot, ringBuffer) 1207 err = &smithy.DeserializationError{ 1208 Err: fmt.Errorf("failed to decode response body, %w", err), 1209 Snapshot: snapshot.Bytes(), 1210 } 1211 return err 1212 } 1213 1214 errorBody.Seek(0, io.SeekStart) 1215 if len(code) != 0 { 1216 errorCode = restjson.SanitizeErrorCode(code) 1217 } 1218 if len(message) != 0 { 1219 errorMessage = message 1220 } 1221 1222 switch { 1223 case strings.EqualFold("InvalidParameterException", errorCode): 1224 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1225 1226 case strings.EqualFold("OperationAbortedException", errorCode): 1227 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 1228 1229 case strings.EqualFold("ResourceNotFoundException", errorCode): 1230 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1231 1232 case strings.EqualFold("ServiceUnavailableException", errorCode): 1233 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1234 1235 default: 1236 genericError := &smithy.GenericAPIError{ 1237 Code: errorCode, 1238 Message: errorMessage, 1239 } 1240 return genericError 1241 1242 } 1243} 1244 1245type awsAwsjson11_deserializeOpDeleteSubscriptionFilter struct { 1246} 1247 1248func (*awsAwsjson11_deserializeOpDeleteSubscriptionFilter) ID() string { 1249 return "OperationDeserializer" 1250} 1251 1252func (m *awsAwsjson11_deserializeOpDeleteSubscriptionFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1253 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1254) { 1255 out, metadata, err = next.HandleDeserialize(ctx, in) 1256 if err != nil { 1257 return out, metadata, err 1258 } 1259 1260 response, ok := out.RawResponse.(*smithyhttp.Response) 1261 if !ok { 1262 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1263 } 1264 1265 if response.StatusCode < 200 || response.StatusCode >= 300 { 1266 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteSubscriptionFilter(response, &metadata) 1267 } 1268 output := &DeleteSubscriptionFilterOutput{} 1269 out.Result = output 1270 1271 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1272 return out, metadata, &smithy.DeserializationError{ 1273 Err: fmt.Errorf("failed to discard response body, %w", err), 1274 } 1275 } 1276 1277 return out, metadata, err 1278} 1279 1280func awsAwsjson11_deserializeOpErrorDeleteSubscriptionFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1281 var errorBuffer bytes.Buffer 1282 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1283 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1284 } 1285 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1286 1287 errorCode := "UnknownError" 1288 errorMessage := errorCode 1289 1290 code := response.Header.Get("X-Amzn-ErrorType") 1291 if len(code) != 0 { 1292 errorCode = restjson.SanitizeErrorCode(code) 1293 } 1294 1295 var buff [1024]byte 1296 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1297 1298 body := io.TeeReader(errorBody, ringBuffer) 1299 decoder := json.NewDecoder(body) 1300 decoder.UseNumber() 1301 code, message, err := restjson.GetErrorInfo(decoder) 1302 if err != nil { 1303 var snapshot bytes.Buffer 1304 io.Copy(&snapshot, ringBuffer) 1305 err = &smithy.DeserializationError{ 1306 Err: fmt.Errorf("failed to decode response body, %w", err), 1307 Snapshot: snapshot.Bytes(), 1308 } 1309 return err 1310 } 1311 1312 errorBody.Seek(0, io.SeekStart) 1313 if len(code) != 0 { 1314 errorCode = restjson.SanitizeErrorCode(code) 1315 } 1316 if len(message) != 0 { 1317 errorMessage = message 1318 } 1319 1320 switch { 1321 case strings.EqualFold("InvalidParameterException", errorCode): 1322 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1323 1324 case strings.EqualFold("OperationAbortedException", errorCode): 1325 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 1326 1327 case strings.EqualFold("ResourceNotFoundException", errorCode): 1328 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1329 1330 case strings.EqualFold("ServiceUnavailableException", errorCode): 1331 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1332 1333 default: 1334 genericError := &smithy.GenericAPIError{ 1335 Code: errorCode, 1336 Message: errorMessage, 1337 } 1338 return genericError 1339 1340 } 1341} 1342 1343type awsAwsjson11_deserializeOpDescribeDestinations struct { 1344} 1345 1346func (*awsAwsjson11_deserializeOpDescribeDestinations) ID() string { 1347 return "OperationDeserializer" 1348} 1349 1350func (m *awsAwsjson11_deserializeOpDescribeDestinations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1351 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1352) { 1353 out, metadata, err = next.HandleDeserialize(ctx, in) 1354 if err != nil { 1355 return out, metadata, err 1356 } 1357 1358 response, ok := out.RawResponse.(*smithyhttp.Response) 1359 if !ok { 1360 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1361 } 1362 1363 if response.StatusCode < 200 || response.StatusCode >= 300 { 1364 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDestinations(response, &metadata) 1365 } 1366 output := &DescribeDestinationsOutput{} 1367 out.Result = output 1368 1369 var buff [1024]byte 1370 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1371 1372 body := io.TeeReader(response.Body, ringBuffer) 1373 decoder := json.NewDecoder(body) 1374 decoder.UseNumber() 1375 var shape interface{} 1376 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1377 var snapshot bytes.Buffer 1378 io.Copy(&snapshot, ringBuffer) 1379 err = &smithy.DeserializationError{ 1380 Err: fmt.Errorf("failed to decode response body, %w", err), 1381 Snapshot: snapshot.Bytes(), 1382 } 1383 return out, metadata, err 1384 } 1385 1386 err = awsAwsjson11_deserializeOpDocumentDescribeDestinationsOutput(&output, shape) 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 out, metadata, err 1395 } 1396 1397 return out, metadata, err 1398} 1399 1400func awsAwsjson11_deserializeOpErrorDescribeDestinations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1401 var errorBuffer bytes.Buffer 1402 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1403 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1404 } 1405 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1406 1407 errorCode := "UnknownError" 1408 errorMessage := errorCode 1409 1410 code := response.Header.Get("X-Amzn-ErrorType") 1411 if len(code) != 0 { 1412 errorCode = restjson.SanitizeErrorCode(code) 1413 } 1414 1415 var buff [1024]byte 1416 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1417 1418 body := io.TeeReader(errorBody, ringBuffer) 1419 decoder := json.NewDecoder(body) 1420 decoder.UseNumber() 1421 code, message, err := restjson.GetErrorInfo(decoder) 1422 if err != nil { 1423 var snapshot bytes.Buffer 1424 io.Copy(&snapshot, ringBuffer) 1425 err = &smithy.DeserializationError{ 1426 Err: fmt.Errorf("failed to decode response body, %w", err), 1427 Snapshot: snapshot.Bytes(), 1428 } 1429 return err 1430 } 1431 1432 errorBody.Seek(0, io.SeekStart) 1433 if len(code) != 0 { 1434 errorCode = restjson.SanitizeErrorCode(code) 1435 } 1436 if len(message) != 0 { 1437 errorMessage = message 1438 } 1439 1440 switch { 1441 case strings.EqualFold("InvalidParameterException", errorCode): 1442 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1443 1444 case strings.EqualFold("ServiceUnavailableException", errorCode): 1445 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1446 1447 default: 1448 genericError := &smithy.GenericAPIError{ 1449 Code: errorCode, 1450 Message: errorMessage, 1451 } 1452 return genericError 1453 1454 } 1455} 1456 1457type awsAwsjson11_deserializeOpDescribeExportTasks struct { 1458} 1459 1460func (*awsAwsjson11_deserializeOpDescribeExportTasks) ID() string { 1461 return "OperationDeserializer" 1462} 1463 1464func (m *awsAwsjson11_deserializeOpDescribeExportTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1465 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1466) { 1467 out, metadata, err = next.HandleDeserialize(ctx, in) 1468 if err != nil { 1469 return out, metadata, err 1470 } 1471 1472 response, ok := out.RawResponse.(*smithyhttp.Response) 1473 if !ok { 1474 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1475 } 1476 1477 if response.StatusCode < 200 || response.StatusCode >= 300 { 1478 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeExportTasks(response, &metadata) 1479 } 1480 output := &DescribeExportTasksOutput{} 1481 out.Result = output 1482 1483 var buff [1024]byte 1484 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1485 1486 body := io.TeeReader(response.Body, ringBuffer) 1487 decoder := json.NewDecoder(body) 1488 decoder.UseNumber() 1489 var shape interface{} 1490 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1491 var snapshot bytes.Buffer 1492 io.Copy(&snapshot, ringBuffer) 1493 err = &smithy.DeserializationError{ 1494 Err: fmt.Errorf("failed to decode response body, %w", err), 1495 Snapshot: snapshot.Bytes(), 1496 } 1497 return out, metadata, err 1498 } 1499 1500 err = awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(&output, shape) 1501 if err != nil { 1502 var snapshot bytes.Buffer 1503 io.Copy(&snapshot, ringBuffer) 1504 err = &smithy.DeserializationError{ 1505 Err: fmt.Errorf("failed to decode response body, %w", err), 1506 Snapshot: snapshot.Bytes(), 1507 } 1508 return out, metadata, err 1509 } 1510 1511 return out, metadata, err 1512} 1513 1514func awsAwsjson11_deserializeOpErrorDescribeExportTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1515 var errorBuffer bytes.Buffer 1516 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1517 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1518 } 1519 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1520 1521 errorCode := "UnknownError" 1522 errorMessage := errorCode 1523 1524 code := response.Header.Get("X-Amzn-ErrorType") 1525 if len(code) != 0 { 1526 errorCode = restjson.SanitizeErrorCode(code) 1527 } 1528 1529 var buff [1024]byte 1530 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1531 1532 body := io.TeeReader(errorBody, ringBuffer) 1533 decoder := json.NewDecoder(body) 1534 decoder.UseNumber() 1535 code, message, err := restjson.GetErrorInfo(decoder) 1536 if err != nil { 1537 var snapshot bytes.Buffer 1538 io.Copy(&snapshot, ringBuffer) 1539 err = &smithy.DeserializationError{ 1540 Err: fmt.Errorf("failed to decode response body, %w", err), 1541 Snapshot: snapshot.Bytes(), 1542 } 1543 return err 1544 } 1545 1546 errorBody.Seek(0, io.SeekStart) 1547 if len(code) != 0 { 1548 errorCode = restjson.SanitizeErrorCode(code) 1549 } 1550 if len(message) != 0 { 1551 errorMessage = message 1552 } 1553 1554 switch { 1555 case strings.EqualFold("InvalidParameterException", errorCode): 1556 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1557 1558 case strings.EqualFold("ServiceUnavailableException", errorCode): 1559 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1560 1561 default: 1562 genericError := &smithy.GenericAPIError{ 1563 Code: errorCode, 1564 Message: errorMessage, 1565 } 1566 return genericError 1567 1568 } 1569} 1570 1571type awsAwsjson11_deserializeOpDescribeLogGroups struct { 1572} 1573 1574func (*awsAwsjson11_deserializeOpDescribeLogGroups) ID() string { 1575 return "OperationDeserializer" 1576} 1577 1578func (m *awsAwsjson11_deserializeOpDescribeLogGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1579 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1580) { 1581 out, metadata, err = next.HandleDeserialize(ctx, in) 1582 if err != nil { 1583 return out, metadata, err 1584 } 1585 1586 response, ok := out.RawResponse.(*smithyhttp.Response) 1587 if !ok { 1588 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1589 } 1590 1591 if response.StatusCode < 200 || response.StatusCode >= 300 { 1592 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLogGroups(response, &metadata) 1593 } 1594 output := &DescribeLogGroupsOutput{} 1595 out.Result = output 1596 1597 var buff [1024]byte 1598 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1599 1600 body := io.TeeReader(response.Body, ringBuffer) 1601 decoder := json.NewDecoder(body) 1602 decoder.UseNumber() 1603 var shape interface{} 1604 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1605 var snapshot bytes.Buffer 1606 io.Copy(&snapshot, ringBuffer) 1607 err = &smithy.DeserializationError{ 1608 Err: fmt.Errorf("failed to decode response body, %w", err), 1609 Snapshot: snapshot.Bytes(), 1610 } 1611 return out, metadata, err 1612 } 1613 1614 err = awsAwsjson11_deserializeOpDocumentDescribeLogGroupsOutput(&output, shape) 1615 if err != nil { 1616 var snapshot bytes.Buffer 1617 io.Copy(&snapshot, ringBuffer) 1618 err = &smithy.DeserializationError{ 1619 Err: fmt.Errorf("failed to decode response body, %w", err), 1620 Snapshot: snapshot.Bytes(), 1621 } 1622 return out, metadata, err 1623 } 1624 1625 return out, metadata, err 1626} 1627 1628func awsAwsjson11_deserializeOpErrorDescribeLogGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1629 var errorBuffer bytes.Buffer 1630 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1631 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1632 } 1633 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1634 1635 errorCode := "UnknownError" 1636 errorMessage := errorCode 1637 1638 code := response.Header.Get("X-Amzn-ErrorType") 1639 if len(code) != 0 { 1640 errorCode = restjson.SanitizeErrorCode(code) 1641 } 1642 1643 var buff [1024]byte 1644 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1645 1646 body := io.TeeReader(errorBody, ringBuffer) 1647 decoder := json.NewDecoder(body) 1648 decoder.UseNumber() 1649 code, message, err := restjson.GetErrorInfo(decoder) 1650 if err != nil { 1651 var snapshot bytes.Buffer 1652 io.Copy(&snapshot, ringBuffer) 1653 err = &smithy.DeserializationError{ 1654 Err: fmt.Errorf("failed to decode response body, %w", err), 1655 Snapshot: snapshot.Bytes(), 1656 } 1657 return err 1658 } 1659 1660 errorBody.Seek(0, io.SeekStart) 1661 if len(code) != 0 { 1662 errorCode = restjson.SanitizeErrorCode(code) 1663 } 1664 if len(message) != 0 { 1665 errorMessage = message 1666 } 1667 1668 switch { 1669 case strings.EqualFold("InvalidParameterException", errorCode): 1670 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1671 1672 case strings.EqualFold("ServiceUnavailableException", errorCode): 1673 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1674 1675 default: 1676 genericError := &smithy.GenericAPIError{ 1677 Code: errorCode, 1678 Message: errorMessage, 1679 } 1680 return genericError 1681 1682 } 1683} 1684 1685type awsAwsjson11_deserializeOpDescribeLogStreams struct { 1686} 1687 1688func (*awsAwsjson11_deserializeOpDescribeLogStreams) ID() string { 1689 return "OperationDeserializer" 1690} 1691 1692func (m *awsAwsjson11_deserializeOpDescribeLogStreams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1693 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1694) { 1695 out, metadata, err = next.HandleDeserialize(ctx, in) 1696 if err != nil { 1697 return out, metadata, err 1698 } 1699 1700 response, ok := out.RawResponse.(*smithyhttp.Response) 1701 if !ok { 1702 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1703 } 1704 1705 if response.StatusCode < 200 || response.StatusCode >= 300 { 1706 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLogStreams(response, &metadata) 1707 } 1708 output := &DescribeLogStreamsOutput{} 1709 out.Result = output 1710 1711 var buff [1024]byte 1712 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1713 1714 body := io.TeeReader(response.Body, ringBuffer) 1715 decoder := json.NewDecoder(body) 1716 decoder.UseNumber() 1717 var shape interface{} 1718 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1719 var snapshot bytes.Buffer 1720 io.Copy(&snapshot, ringBuffer) 1721 err = &smithy.DeserializationError{ 1722 Err: fmt.Errorf("failed to decode response body, %w", err), 1723 Snapshot: snapshot.Bytes(), 1724 } 1725 return out, metadata, err 1726 } 1727 1728 err = awsAwsjson11_deserializeOpDocumentDescribeLogStreamsOutput(&output, shape) 1729 if err != nil { 1730 var snapshot bytes.Buffer 1731 io.Copy(&snapshot, ringBuffer) 1732 err = &smithy.DeserializationError{ 1733 Err: fmt.Errorf("failed to decode response body, %w", err), 1734 Snapshot: snapshot.Bytes(), 1735 } 1736 return out, metadata, err 1737 } 1738 1739 return out, metadata, err 1740} 1741 1742func awsAwsjson11_deserializeOpErrorDescribeLogStreams(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1743 var errorBuffer bytes.Buffer 1744 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1745 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1746 } 1747 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1748 1749 errorCode := "UnknownError" 1750 errorMessage := errorCode 1751 1752 code := response.Header.Get("X-Amzn-ErrorType") 1753 if len(code) != 0 { 1754 errorCode = restjson.SanitizeErrorCode(code) 1755 } 1756 1757 var buff [1024]byte 1758 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1759 1760 body := io.TeeReader(errorBody, ringBuffer) 1761 decoder := json.NewDecoder(body) 1762 decoder.UseNumber() 1763 code, message, err := restjson.GetErrorInfo(decoder) 1764 if err != nil { 1765 var snapshot bytes.Buffer 1766 io.Copy(&snapshot, ringBuffer) 1767 err = &smithy.DeserializationError{ 1768 Err: fmt.Errorf("failed to decode response body, %w", err), 1769 Snapshot: snapshot.Bytes(), 1770 } 1771 return err 1772 } 1773 1774 errorBody.Seek(0, io.SeekStart) 1775 if len(code) != 0 { 1776 errorCode = restjson.SanitizeErrorCode(code) 1777 } 1778 if len(message) != 0 { 1779 errorMessage = message 1780 } 1781 1782 switch { 1783 case strings.EqualFold("InvalidParameterException", errorCode): 1784 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1785 1786 case strings.EqualFold("ResourceNotFoundException", errorCode): 1787 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1788 1789 case strings.EqualFold("ServiceUnavailableException", errorCode): 1790 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1791 1792 default: 1793 genericError := &smithy.GenericAPIError{ 1794 Code: errorCode, 1795 Message: errorMessage, 1796 } 1797 return genericError 1798 1799 } 1800} 1801 1802type awsAwsjson11_deserializeOpDescribeMetricFilters struct { 1803} 1804 1805func (*awsAwsjson11_deserializeOpDescribeMetricFilters) ID() string { 1806 return "OperationDeserializer" 1807} 1808 1809func (m *awsAwsjson11_deserializeOpDescribeMetricFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1810 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1811) { 1812 out, metadata, err = next.HandleDeserialize(ctx, in) 1813 if err != nil { 1814 return out, metadata, err 1815 } 1816 1817 response, ok := out.RawResponse.(*smithyhttp.Response) 1818 if !ok { 1819 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1820 } 1821 1822 if response.StatusCode < 200 || response.StatusCode >= 300 { 1823 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeMetricFilters(response, &metadata) 1824 } 1825 output := &DescribeMetricFiltersOutput{} 1826 out.Result = output 1827 1828 var buff [1024]byte 1829 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1830 1831 body := io.TeeReader(response.Body, ringBuffer) 1832 decoder := json.NewDecoder(body) 1833 decoder.UseNumber() 1834 var shape interface{} 1835 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1836 var snapshot bytes.Buffer 1837 io.Copy(&snapshot, ringBuffer) 1838 err = &smithy.DeserializationError{ 1839 Err: fmt.Errorf("failed to decode response body, %w", err), 1840 Snapshot: snapshot.Bytes(), 1841 } 1842 return out, metadata, err 1843 } 1844 1845 err = awsAwsjson11_deserializeOpDocumentDescribeMetricFiltersOutput(&output, shape) 1846 if err != nil { 1847 var snapshot bytes.Buffer 1848 io.Copy(&snapshot, ringBuffer) 1849 err = &smithy.DeserializationError{ 1850 Err: fmt.Errorf("failed to decode response body, %w", err), 1851 Snapshot: snapshot.Bytes(), 1852 } 1853 return out, metadata, err 1854 } 1855 1856 return out, metadata, err 1857} 1858 1859func awsAwsjson11_deserializeOpErrorDescribeMetricFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1860 var errorBuffer bytes.Buffer 1861 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1862 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1863 } 1864 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1865 1866 errorCode := "UnknownError" 1867 errorMessage := errorCode 1868 1869 code := response.Header.Get("X-Amzn-ErrorType") 1870 if len(code) != 0 { 1871 errorCode = restjson.SanitizeErrorCode(code) 1872 } 1873 1874 var buff [1024]byte 1875 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1876 1877 body := io.TeeReader(errorBody, ringBuffer) 1878 decoder := json.NewDecoder(body) 1879 decoder.UseNumber() 1880 code, message, err := restjson.GetErrorInfo(decoder) 1881 if err != nil { 1882 var snapshot bytes.Buffer 1883 io.Copy(&snapshot, ringBuffer) 1884 err = &smithy.DeserializationError{ 1885 Err: fmt.Errorf("failed to decode response body, %w", err), 1886 Snapshot: snapshot.Bytes(), 1887 } 1888 return err 1889 } 1890 1891 errorBody.Seek(0, io.SeekStart) 1892 if len(code) != 0 { 1893 errorCode = restjson.SanitizeErrorCode(code) 1894 } 1895 if len(message) != 0 { 1896 errorMessage = message 1897 } 1898 1899 switch { 1900 case strings.EqualFold("InvalidParameterException", errorCode): 1901 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1902 1903 case strings.EqualFold("ResourceNotFoundException", errorCode): 1904 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1905 1906 case strings.EqualFold("ServiceUnavailableException", errorCode): 1907 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1908 1909 default: 1910 genericError := &smithy.GenericAPIError{ 1911 Code: errorCode, 1912 Message: errorMessage, 1913 } 1914 return genericError 1915 1916 } 1917} 1918 1919type awsAwsjson11_deserializeOpDescribeQueries struct { 1920} 1921 1922func (*awsAwsjson11_deserializeOpDescribeQueries) ID() string { 1923 return "OperationDeserializer" 1924} 1925 1926func (m *awsAwsjson11_deserializeOpDescribeQueries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1927 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1928) { 1929 out, metadata, err = next.HandleDeserialize(ctx, in) 1930 if err != nil { 1931 return out, metadata, err 1932 } 1933 1934 response, ok := out.RawResponse.(*smithyhttp.Response) 1935 if !ok { 1936 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1937 } 1938 1939 if response.StatusCode < 200 || response.StatusCode >= 300 { 1940 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeQueries(response, &metadata) 1941 } 1942 output := &DescribeQueriesOutput{} 1943 out.Result = output 1944 1945 var buff [1024]byte 1946 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1947 1948 body := io.TeeReader(response.Body, ringBuffer) 1949 decoder := json.NewDecoder(body) 1950 decoder.UseNumber() 1951 var shape interface{} 1952 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1953 var snapshot bytes.Buffer 1954 io.Copy(&snapshot, ringBuffer) 1955 err = &smithy.DeserializationError{ 1956 Err: fmt.Errorf("failed to decode response body, %w", err), 1957 Snapshot: snapshot.Bytes(), 1958 } 1959 return out, metadata, err 1960 } 1961 1962 err = awsAwsjson11_deserializeOpDocumentDescribeQueriesOutput(&output, shape) 1963 if err != nil { 1964 var snapshot bytes.Buffer 1965 io.Copy(&snapshot, ringBuffer) 1966 err = &smithy.DeserializationError{ 1967 Err: fmt.Errorf("failed to decode response body, %w", err), 1968 Snapshot: snapshot.Bytes(), 1969 } 1970 return out, metadata, err 1971 } 1972 1973 return out, metadata, err 1974} 1975 1976func awsAwsjson11_deserializeOpErrorDescribeQueries(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1977 var errorBuffer bytes.Buffer 1978 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1979 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1980 } 1981 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1982 1983 errorCode := "UnknownError" 1984 errorMessage := errorCode 1985 1986 code := response.Header.Get("X-Amzn-ErrorType") 1987 if len(code) != 0 { 1988 errorCode = restjson.SanitizeErrorCode(code) 1989 } 1990 1991 var buff [1024]byte 1992 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1993 1994 body := io.TeeReader(errorBody, ringBuffer) 1995 decoder := json.NewDecoder(body) 1996 decoder.UseNumber() 1997 code, message, err := restjson.GetErrorInfo(decoder) 1998 if err != nil { 1999 var snapshot bytes.Buffer 2000 io.Copy(&snapshot, ringBuffer) 2001 err = &smithy.DeserializationError{ 2002 Err: fmt.Errorf("failed to decode response body, %w", err), 2003 Snapshot: snapshot.Bytes(), 2004 } 2005 return err 2006 } 2007 2008 errorBody.Seek(0, io.SeekStart) 2009 if len(code) != 0 { 2010 errorCode = restjson.SanitizeErrorCode(code) 2011 } 2012 if len(message) != 0 { 2013 errorMessage = message 2014 } 2015 2016 switch { 2017 case strings.EqualFold("InvalidParameterException", errorCode): 2018 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2019 2020 case strings.EqualFold("ResourceNotFoundException", errorCode): 2021 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2022 2023 case strings.EqualFold("ServiceUnavailableException", errorCode): 2024 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2025 2026 default: 2027 genericError := &smithy.GenericAPIError{ 2028 Code: errorCode, 2029 Message: errorMessage, 2030 } 2031 return genericError 2032 2033 } 2034} 2035 2036type awsAwsjson11_deserializeOpDescribeQueryDefinitions struct { 2037} 2038 2039func (*awsAwsjson11_deserializeOpDescribeQueryDefinitions) ID() string { 2040 return "OperationDeserializer" 2041} 2042 2043func (m *awsAwsjson11_deserializeOpDescribeQueryDefinitions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2044 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2045) { 2046 out, metadata, err = next.HandleDeserialize(ctx, in) 2047 if err != nil { 2048 return out, metadata, err 2049 } 2050 2051 response, ok := out.RawResponse.(*smithyhttp.Response) 2052 if !ok { 2053 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2054 } 2055 2056 if response.StatusCode < 200 || response.StatusCode >= 300 { 2057 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeQueryDefinitions(response, &metadata) 2058 } 2059 output := &DescribeQueryDefinitionsOutput{} 2060 out.Result = output 2061 2062 var buff [1024]byte 2063 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2064 2065 body := io.TeeReader(response.Body, ringBuffer) 2066 decoder := json.NewDecoder(body) 2067 decoder.UseNumber() 2068 var shape interface{} 2069 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2070 var snapshot bytes.Buffer 2071 io.Copy(&snapshot, ringBuffer) 2072 err = &smithy.DeserializationError{ 2073 Err: fmt.Errorf("failed to decode response body, %w", err), 2074 Snapshot: snapshot.Bytes(), 2075 } 2076 return out, metadata, err 2077 } 2078 2079 err = awsAwsjson11_deserializeOpDocumentDescribeQueryDefinitionsOutput(&output, shape) 2080 if err != nil { 2081 var snapshot bytes.Buffer 2082 io.Copy(&snapshot, ringBuffer) 2083 err = &smithy.DeserializationError{ 2084 Err: fmt.Errorf("failed to decode response body, %w", err), 2085 Snapshot: snapshot.Bytes(), 2086 } 2087 return out, metadata, err 2088 } 2089 2090 return out, metadata, err 2091} 2092 2093func awsAwsjson11_deserializeOpErrorDescribeQueryDefinitions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2094 var errorBuffer bytes.Buffer 2095 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2096 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2097 } 2098 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2099 2100 errorCode := "UnknownError" 2101 errorMessage := errorCode 2102 2103 code := response.Header.Get("X-Amzn-ErrorType") 2104 if len(code) != 0 { 2105 errorCode = restjson.SanitizeErrorCode(code) 2106 } 2107 2108 var buff [1024]byte 2109 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2110 2111 body := io.TeeReader(errorBody, ringBuffer) 2112 decoder := json.NewDecoder(body) 2113 decoder.UseNumber() 2114 code, message, err := restjson.GetErrorInfo(decoder) 2115 if err != nil { 2116 var snapshot bytes.Buffer 2117 io.Copy(&snapshot, ringBuffer) 2118 err = &smithy.DeserializationError{ 2119 Err: fmt.Errorf("failed to decode response body, %w", err), 2120 Snapshot: snapshot.Bytes(), 2121 } 2122 return err 2123 } 2124 2125 errorBody.Seek(0, io.SeekStart) 2126 if len(code) != 0 { 2127 errorCode = restjson.SanitizeErrorCode(code) 2128 } 2129 if len(message) != 0 { 2130 errorMessage = message 2131 } 2132 2133 switch { 2134 case strings.EqualFold("InvalidParameterException", errorCode): 2135 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2136 2137 case strings.EqualFold("ServiceUnavailableException", errorCode): 2138 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2139 2140 default: 2141 genericError := &smithy.GenericAPIError{ 2142 Code: errorCode, 2143 Message: errorMessage, 2144 } 2145 return genericError 2146 2147 } 2148} 2149 2150type awsAwsjson11_deserializeOpDescribeResourcePolicies struct { 2151} 2152 2153func (*awsAwsjson11_deserializeOpDescribeResourcePolicies) ID() string { 2154 return "OperationDeserializer" 2155} 2156 2157func (m *awsAwsjson11_deserializeOpDescribeResourcePolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2158 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2159) { 2160 out, metadata, err = next.HandleDeserialize(ctx, in) 2161 if err != nil { 2162 return out, metadata, err 2163 } 2164 2165 response, ok := out.RawResponse.(*smithyhttp.Response) 2166 if !ok { 2167 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2168 } 2169 2170 if response.StatusCode < 200 || response.StatusCode >= 300 { 2171 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeResourcePolicies(response, &metadata) 2172 } 2173 output := &DescribeResourcePoliciesOutput{} 2174 out.Result = output 2175 2176 var buff [1024]byte 2177 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2178 2179 body := io.TeeReader(response.Body, ringBuffer) 2180 decoder := json.NewDecoder(body) 2181 decoder.UseNumber() 2182 var shape interface{} 2183 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2184 var snapshot bytes.Buffer 2185 io.Copy(&snapshot, ringBuffer) 2186 err = &smithy.DeserializationError{ 2187 Err: fmt.Errorf("failed to decode response body, %w", err), 2188 Snapshot: snapshot.Bytes(), 2189 } 2190 return out, metadata, err 2191 } 2192 2193 err = awsAwsjson11_deserializeOpDocumentDescribeResourcePoliciesOutput(&output, shape) 2194 if err != nil { 2195 var snapshot bytes.Buffer 2196 io.Copy(&snapshot, ringBuffer) 2197 err = &smithy.DeserializationError{ 2198 Err: fmt.Errorf("failed to decode response body, %w", err), 2199 Snapshot: snapshot.Bytes(), 2200 } 2201 return out, metadata, err 2202 } 2203 2204 return out, metadata, err 2205} 2206 2207func awsAwsjson11_deserializeOpErrorDescribeResourcePolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2208 var errorBuffer bytes.Buffer 2209 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2210 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2211 } 2212 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2213 2214 errorCode := "UnknownError" 2215 errorMessage := errorCode 2216 2217 code := response.Header.Get("X-Amzn-ErrorType") 2218 if len(code) != 0 { 2219 errorCode = restjson.SanitizeErrorCode(code) 2220 } 2221 2222 var buff [1024]byte 2223 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2224 2225 body := io.TeeReader(errorBody, ringBuffer) 2226 decoder := json.NewDecoder(body) 2227 decoder.UseNumber() 2228 code, message, err := restjson.GetErrorInfo(decoder) 2229 if err != nil { 2230 var snapshot bytes.Buffer 2231 io.Copy(&snapshot, ringBuffer) 2232 err = &smithy.DeserializationError{ 2233 Err: fmt.Errorf("failed to decode response body, %w", err), 2234 Snapshot: snapshot.Bytes(), 2235 } 2236 return err 2237 } 2238 2239 errorBody.Seek(0, io.SeekStart) 2240 if len(code) != 0 { 2241 errorCode = restjson.SanitizeErrorCode(code) 2242 } 2243 if len(message) != 0 { 2244 errorMessage = message 2245 } 2246 2247 switch { 2248 case strings.EqualFold("InvalidParameterException", errorCode): 2249 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2250 2251 case strings.EqualFold("ServiceUnavailableException", errorCode): 2252 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2253 2254 default: 2255 genericError := &smithy.GenericAPIError{ 2256 Code: errorCode, 2257 Message: errorMessage, 2258 } 2259 return genericError 2260 2261 } 2262} 2263 2264type awsAwsjson11_deserializeOpDescribeSubscriptionFilters struct { 2265} 2266 2267func (*awsAwsjson11_deserializeOpDescribeSubscriptionFilters) ID() string { 2268 return "OperationDeserializer" 2269} 2270 2271func (m *awsAwsjson11_deserializeOpDescribeSubscriptionFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2272 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2273) { 2274 out, metadata, err = next.HandleDeserialize(ctx, in) 2275 if err != nil { 2276 return out, metadata, err 2277 } 2278 2279 response, ok := out.RawResponse.(*smithyhttp.Response) 2280 if !ok { 2281 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2282 } 2283 2284 if response.StatusCode < 200 || response.StatusCode >= 300 { 2285 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeSubscriptionFilters(response, &metadata) 2286 } 2287 output := &DescribeSubscriptionFiltersOutput{} 2288 out.Result = output 2289 2290 var buff [1024]byte 2291 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2292 2293 body := io.TeeReader(response.Body, ringBuffer) 2294 decoder := json.NewDecoder(body) 2295 decoder.UseNumber() 2296 var shape interface{} 2297 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2298 var snapshot bytes.Buffer 2299 io.Copy(&snapshot, ringBuffer) 2300 err = &smithy.DeserializationError{ 2301 Err: fmt.Errorf("failed to decode response body, %w", err), 2302 Snapshot: snapshot.Bytes(), 2303 } 2304 return out, metadata, err 2305 } 2306 2307 err = awsAwsjson11_deserializeOpDocumentDescribeSubscriptionFiltersOutput(&output, shape) 2308 if err != nil { 2309 var snapshot bytes.Buffer 2310 io.Copy(&snapshot, ringBuffer) 2311 err = &smithy.DeserializationError{ 2312 Err: fmt.Errorf("failed to decode response body, %w", err), 2313 Snapshot: snapshot.Bytes(), 2314 } 2315 return out, metadata, err 2316 } 2317 2318 return out, metadata, err 2319} 2320 2321func awsAwsjson11_deserializeOpErrorDescribeSubscriptionFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2322 var errorBuffer bytes.Buffer 2323 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2324 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2325 } 2326 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2327 2328 errorCode := "UnknownError" 2329 errorMessage := errorCode 2330 2331 code := response.Header.Get("X-Amzn-ErrorType") 2332 if len(code) != 0 { 2333 errorCode = restjson.SanitizeErrorCode(code) 2334 } 2335 2336 var buff [1024]byte 2337 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2338 2339 body := io.TeeReader(errorBody, ringBuffer) 2340 decoder := json.NewDecoder(body) 2341 decoder.UseNumber() 2342 code, message, err := restjson.GetErrorInfo(decoder) 2343 if err != nil { 2344 var snapshot bytes.Buffer 2345 io.Copy(&snapshot, ringBuffer) 2346 err = &smithy.DeserializationError{ 2347 Err: fmt.Errorf("failed to decode response body, %w", err), 2348 Snapshot: snapshot.Bytes(), 2349 } 2350 return err 2351 } 2352 2353 errorBody.Seek(0, io.SeekStart) 2354 if len(code) != 0 { 2355 errorCode = restjson.SanitizeErrorCode(code) 2356 } 2357 if len(message) != 0 { 2358 errorMessage = message 2359 } 2360 2361 switch { 2362 case strings.EqualFold("InvalidParameterException", errorCode): 2363 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2364 2365 case strings.EqualFold("ResourceNotFoundException", errorCode): 2366 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2367 2368 case strings.EqualFold("ServiceUnavailableException", errorCode): 2369 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2370 2371 default: 2372 genericError := &smithy.GenericAPIError{ 2373 Code: errorCode, 2374 Message: errorMessage, 2375 } 2376 return genericError 2377 2378 } 2379} 2380 2381type awsAwsjson11_deserializeOpDisassociateKmsKey struct { 2382} 2383 2384func (*awsAwsjson11_deserializeOpDisassociateKmsKey) ID() string { 2385 return "OperationDeserializer" 2386} 2387 2388func (m *awsAwsjson11_deserializeOpDisassociateKmsKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2389 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2390) { 2391 out, metadata, err = next.HandleDeserialize(ctx, in) 2392 if err != nil { 2393 return out, metadata, err 2394 } 2395 2396 response, ok := out.RawResponse.(*smithyhttp.Response) 2397 if !ok { 2398 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2399 } 2400 2401 if response.StatusCode < 200 || response.StatusCode >= 300 { 2402 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateKmsKey(response, &metadata) 2403 } 2404 output := &DisassociateKmsKeyOutput{} 2405 out.Result = output 2406 2407 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2408 return out, metadata, &smithy.DeserializationError{ 2409 Err: fmt.Errorf("failed to discard response body, %w", err), 2410 } 2411 } 2412 2413 return out, metadata, err 2414} 2415 2416func awsAwsjson11_deserializeOpErrorDisassociateKmsKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2417 var errorBuffer bytes.Buffer 2418 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2419 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2420 } 2421 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2422 2423 errorCode := "UnknownError" 2424 errorMessage := errorCode 2425 2426 code := response.Header.Get("X-Amzn-ErrorType") 2427 if len(code) != 0 { 2428 errorCode = restjson.SanitizeErrorCode(code) 2429 } 2430 2431 var buff [1024]byte 2432 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2433 2434 body := io.TeeReader(errorBody, ringBuffer) 2435 decoder := json.NewDecoder(body) 2436 decoder.UseNumber() 2437 code, message, err := restjson.GetErrorInfo(decoder) 2438 if err != nil { 2439 var snapshot bytes.Buffer 2440 io.Copy(&snapshot, ringBuffer) 2441 err = &smithy.DeserializationError{ 2442 Err: fmt.Errorf("failed to decode response body, %w", err), 2443 Snapshot: snapshot.Bytes(), 2444 } 2445 return err 2446 } 2447 2448 errorBody.Seek(0, io.SeekStart) 2449 if len(code) != 0 { 2450 errorCode = restjson.SanitizeErrorCode(code) 2451 } 2452 if len(message) != 0 { 2453 errorMessage = message 2454 } 2455 2456 switch { 2457 case strings.EqualFold("InvalidParameterException", errorCode): 2458 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2459 2460 case strings.EqualFold("OperationAbortedException", errorCode): 2461 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 2462 2463 case strings.EqualFold("ResourceNotFoundException", errorCode): 2464 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2465 2466 case strings.EqualFold("ServiceUnavailableException", errorCode): 2467 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2468 2469 default: 2470 genericError := &smithy.GenericAPIError{ 2471 Code: errorCode, 2472 Message: errorMessage, 2473 } 2474 return genericError 2475 2476 } 2477} 2478 2479type awsAwsjson11_deserializeOpFilterLogEvents struct { 2480} 2481 2482func (*awsAwsjson11_deserializeOpFilterLogEvents) ID() string { 2483 return "OperationDeserializer" 2484} 2485 2486func (m *awsAwsjson11_deserializeOpFilterLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2487 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2488) { 2489 out, metadata, err = next.HandleDeserialize(ctx, in) 2490 if err != nil { 2491 return out, metadata, err 2492 } 2493 2494 response, ok := out.RawResponse.(*smithyhttp.Response) 2495 if !ok { 2496 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2497 } 2498 2499 if response.StatusCode < 200 || response.StatusCode >= 300 { 2500 return out, metadata, awsAwsjson11_deserializeOpErrorFilterLogEvents(response, &metadata) 2501 } 2502 output := &FilterLogEventsOutput{} 2503 out.Result = output 2504 2505 var buff [1024]byte 2506 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2507 2508 body := io.TeeReader(response.Body, ringBuffer) 2509 decoder := json.NewDecoder(body) 2510 decoder.UseNumber() 2511 var shape interface{} 2512 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2513 var snapshot bytes.Buffer 2514 io.Copy(&snapshot, ringBuffer) 2515 err = &smithy.DeserializationError{ 2516 Err: fmt.Errorf("failed to decode response body, %w", err), 2517 Snapshot: snapshot.Bytes(), 2518 } 2519 return out, metadata, err 2520 } 2521 2522 err = awsAwsjson11_deserializeOpDocumentFilterLogEventsOutput(&output, shape) 2523 if err != nil { 2524 var snapshot bytes.Buffer 2525 io.Copy(&snapshot, ringBuffer) 2526 err = &smithy.DeserializationError{ 2527 Err: fmt.Errorf("failed to decode response body, %w", err), 2528 Snapshot: snapshot.Bytes(), 2529 } 2530 return out, metadata, err 2531 } 2532 2533 return out, metadata, err 2534} 2535 2536func awsAwsjson11_deserializeOpErrorFilterLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2537 var errorBuffer bytes.Buffer 2538 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2539 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2540 } 2541 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2542 2543 errorCode := "UnknownError" 2544 errorMessage := errorCode 2545 2546 code := response.Header.Get("X-Amzn-ErrorType") 2547 if len(code) != 0 { 2548 errorCode = restjson.SanitizeErrorCode(code) 2549 } 2550 2551 var buff [1024]byte 2552 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2553 2554 body := io.TeeReader(errorBody, ringBuffer) 2555 decoder := json.NewDecoder(body) 2556 decoder.UseNumber() 2557 code, message, err := restjson.GetErrorInfo(decoder) 2558 if err != nil { 2559 var snapshot bytes.Buffer 2560 io.Copy(&snapshot, ringBuffer) 2561 err = &smithy.DeserializationError{ 2562 Err: fmt.Errorf("failed to decode response body, %w", err), 2563 Snapshot: snapshot.Bytes(), 2564 } 2565 return err 2566 } 2567 2568 errorBody.Seek(0, io.SeekStart) 2569 if len(code) != 0 { 2570 errorCode = restjson.SanitizeErrorCode(code) 2571 } 2572 if len(message) != 0 { 2573 errorMessage = message 2574 } 2575 2576 switch { 2577 case strings.EqualFold("InvalidParameterException", errorCode): 2578 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2579 2580 case strings.EqualFold("ResourceNotFoundException", errorCode): 2581 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2582 2583 case strings.EqualFold("ServiceUnavailableException", errorCode): 2584 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2585 2586 default: 2587 genericError := &smithy.GenericAPIError{ 2588 Code: errorCode, 2589 Message: errorMessage, 2590 } 2591 return genericError 2592 2593 } 2594} 2595 2596type awsAwsjson11_deserializeOpGetLogEvents struct { 2597} 2598 2599func (*awsAwsjson11_deserializeOpGetLogEvents) ID() string { 2600 return "OperationDeserializer" 2601} 2602 2603func (m *awsAwsjson11_deserializeOpGetLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2604 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2605) { 2606 out, metadata, err = next.HandleDeserialize(ctx, in) 2607 if err != nil { 2608 return out, metadata, err 2609 } 2610 2611 response, ok := out.RawResponse.(*smithyhttp.Response) 2612 if !ok { 2613 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2614 } 2615 2616 if response.StatusCode < 200 || response.StatusCode >= 300 { 2617 return out, metadata, awsAwsjson11_deserializeOpErrorGetLogEvents(response, &metadata) 2618 } 2619 output := &GetLogEventsOutput{} 2620 out.Result = output 2621 2622 var buff [1024]byte 2623 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2624 2625 body := io.TeeReader(response.Body, ringBuffer) 2626 decoder := json.NewDecoder(body) 2627 decoder.UseNumber() 2628 var shape interface{} 2629 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2630 var snapshot bytes.Buffer 2631 io.Copy(&snapshot, ringBuffer) 2632 err = &smithy.DeserializationError{ 2633 Err: fmt.Errorf("failed to decode response body, %w", err), 2634 Snapshot: snapshot.Bytes(), 2635 } 2636 return out, metadata, err 2637 } 2638 2639 err = awsAwsjson11_deserializeOpDocumentGetLogEventsOutput(&output, shape) 2640 if err != nil { 2641 var snapshot bytes.Buffer 2642 io.Copy(&snapshot, ringBuffer) 2643 err = &smithy.DeserializationError{ 2644 Err: fmt.Errorf("failed to decode response body, %w", err), 2645 Snapshot: snapshot.Bytes(), 2646 } 2647 return out, metadata, err 2648 } 2649 2650 return out, metadata, err 2651} 2652 2653func awsAwsjson11_deserializeOpErrorGetLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2654 var errorBuffer bytes.Buffer 2655 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2656 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2657 } 2658 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2659 2660 errorCode := "UnknownError" 2661 errorMessage := errorCode 2662 2663 code := response.Header.Get("X-Amzn-ErrorType") 2664 if len(code) != 0 { 2665 errorCode = restjson.SanitizeErrorCode(code) 2666 } 2667 2668 var buff [1024]byte 2669 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2670 2671 body := io.TeeReader(errorBody, ringBuffer) 2672 decoder := json.NewDecoder(body) 2673 decoder.UseNumber() 2674 code, message, err := restjson.GetErrorInfo(decoder) 2675 if err != nil { 2676 var snapshot bytes.Buffer 2677 io.Copy(&snapshot, ringBuffer) 2678 err = &smithy.DeserializationError{ 2679 Err: fmt.Errorf("failed to decode response body, %w", err), 2680 Snapshot: snapshot.Bytes(), 2681 } 2682 return err 2683 } 2684 2685 errorBody.Seek(0, io.SeekStart) 2686 if len(code) != 0 { 2687 errorCode = restjson.SanitizeErrorCode(code) 2688 } 2689 if len(message) != 0 { 2690 errorMessage = message 2691 } 2692 2693 switch { 2694 case strings.EqualFold("InvalidParameterException", errorCode): 2695 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2696 2697 case strings.EqualFold("ResourceNotFoundException", errorCode): 2698 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2699 2700 case strings.EqualFold("ServiceUnavailableException", errorCode): 2701 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2702 2703 default: 2704 genericError := &smithy.GenericAPIError{ 2705 Code: errorCode, 2706 Message: errorMessage, 2707 } 2708 return genericError 2709 2710 } 2711} 2712 2713type awsAwsjson11_deserializeOpGetLogGroupFields struct { 2714} 2715 2716func (*awsAwsjson11_deserializeOpGetLogGroupFields) ID() string { 2717 return "OperationDeserializer" 2718} 2719 2720func (m *awsAwsjson11_deserializeOpGetLogGroupFields) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2721 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2722) { 2723 out, metadata, err = next.HandleDeserialize(ctx, in) 2724 if err != nil { 2725 return out, metadata, err 2726 } 2727 2728 response, ok := out.RawResponse.(*smithyhttp.Response) 2729 if !ok { 2730 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2731 } 2732 2733 if response.StatusCode < 200 || response.StatusCode >= 300 { 2734 return out, metadata, awsAwsjson11_deserializeOpErrorGetLogGroupFields(response, &metadata) 2735 } 2736 output := &GetLogGroupFieldsOutput{} 2737 out.Result = output 2738 2739 var buff [1024]byte 2740 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2741 2742 body := io.TeeReader(response.Body, ringBuffer) 2743 decoder := json.NewDecoder(body) 2744 decoder.UseNumber() 2745 var shape interface{} 2746 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2747 var snapshot bytes.Buffer 2748 io.Copy(&snapshot, ringBuffer) 2749 err = &smithy.DeserializationError{ 2750 Err: fmt.Errorf("failed to decode response body, %w", err), 2751 Snapshot: snapshot.Bytes(), 2752 } 2753 return out, metadata, err 2754 } 2755 2756 err = awsAwsjson11_deserializeOpDocumentGetLogGroupFieldsOutput(&output, shape) 2757 if err != nil { 2758 var snapshot bytes.Buffer 2759 io.Copy(&snapshot, ringBuffer) 2760 err = &smithy.DeserializationError{ 2761 Err: fmt.Errorf("failed to decode response body, %w", err), 2762 Snapshot: snapshot.Bytes(), 2763 } 2764 return out, metadata, err 2765 } 2766 2767 return out, metadata, err 2768} 2769 2770func awsAwsjson11_deserializeOpErrorGetLogGroupFields(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2771 var errorBuffer bytes.Buffer 2772 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2773 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2774 } 2775 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2776 2777 errorCode := "UnknownError" 2778 errorMessage := errorCode 2779 2780 code := response.Header.Get("X-Amzn-ErrorType") 2781 if len(code) != 0 { 2782 errorCode = restjson.SanitizeErrorCode(code) 2783 } 2784 2785 var buff [1024]byte 2786 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2787 2788 body := io.TeeReader(errorBody, ringBuffer) 2789 decoder := json.NewDecoder(body) 2790 decoder.UseNumber() 2791 code, message, err := restjson.GetErrorInfo(decoder) 2792 if err != nil { 2793 var snapshot bytes.Buffer 2794 io.Copy(&snapshot, ringBuffer) 2795 err = &smithy.DeserializationError{ 2796 Err: fmt.Errorf("failed to decode response body, %w", err), 2797 Snapshot: snapshot.Bytes(), 2798 } 2799 return err 2800 } 2801 2802 errorBody.Seek(0, io.SeekStart) 2803 if len(code) != 0 { 2804 errorCode = restjson.SanitizeErrorCode(code) 2805 } 2806 if len(message) != 0 { 2807 errorMessage = message 2808 } 2809 2810 switch { 2811 case strings.EqualFold("InvalidParameterException", errorCode): 2812 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2813 2814 case strings.EqualFold("LimitExceededException", errorCode): 2815 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2816 2817 case strings.EqualFold("ResourceNotFoundException", errorCode): 2818 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2819 2820 case strings.EqualFold("ServiceUnavailableException", errorCode): 2821 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2822 2823 default: 2824 genericError := &smithy.GenericAPIError{ 2825 Code: errorCode, 2826 Message: errorMessage, 2827 } 2828 return genericError 2829 2830 } 2831} 2832 2833type awsAwsjson11_deserializeOpGetLogRecord struct { 2834} 2835 2836func (*awsAwsjson11_deserializeOpGetLogRecord) ID() string { 2837 return "OperationDeserializer" 2838} 2839 2840func (m *awsAwsjson11_deserializeOpGetLogRecord) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2841 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2842) { 2843 out, metadata, err = next.HandleDeserialize(ctx, in) 2844 if err != nil { 2845 return out, metadata, err 2846 } 2847 2848 response, ok := out.RawResponse.(*smithyhttp.Response) 2849 if !ok { 2850 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2851 } 2852 2853 if response.StatusCode < 200 || response.StatusCode >= 300 { 2854 return out, metadata, awsAwsjson11_deserializeOpErrorGetLogRecord(response, &metadata) 2855 } 2856 output := &GetLogRecordOutput{} 2857 out.Result = output 2858 2859 var buff [1024]byte 2860 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2861 2862 body := io.TeeReader(response.Body, ringBuffer) 2863 decoder := json.NewDecoder(body) 2864 decoder.UseNumber() 2865 var shape interface{} 2866 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2867 var snapshot bytes.Buffer 2868 io.Copy(&snapshot, ringBuffer) 2869 err = &smithy.DeserializationError{ 2870 Err: fmt.Errorf("failed to decode response body, %w", err), 2871 Snapshot: snapshot.Bytes(), 2872 } 2873 return out, metadata, err 2874 } 2875 2876 err = awsAwsjson11_deserializeOpDocumentGetLogRecordOutput(&output, shape) 2877 if err != nil { 2878 var snapshot bytes.Buffer 2879 io.Copy(&snapshot, ringBuffer) 2880 err = &smithy.DeserializationError{ 2881 Err: fmt.Errorf("failed to decode response body, %w", err), 2882 Snapshot: snapshot.Bytes(), 2883 } 2884 return out, metadata, err 2885 } 2886 2887 return out, metadata, err 2888} 2889 2890func awsAwsjson11_deserializeOpErrorGetLogRecord(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2891 var errorBuffer bytes.Buffer 2892 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2893 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2894 } 2895 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2896 2897 errorCode := "UnknownError" 2898 errorMessage := errorCode 2899 2900 code := response.Header.Get("X-Amzn-ErrorType") 2901 if len(code) != 0 { 2902 errorCode = restjson.SanitizeErrorCode(code) 2903 } 2904 2905 var buff [1024]byte 2906 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2907 2908 body := io.TeeReader(errorBody, ringBuffer) 2909 decoder := json.NewDecoder(body) 2910 decoder.UseNumber() 2911 code, message, err := restjson.GetErrorInfo(decoder) 2912 if err != nil { 2913 var snapshot bytes.Buffer 2914 io.Copy(&snapshot, ringBuffer) 2915 err = &smithy.DeserializationError{ 2916 Err: fmt.Errorf("failed to decode response body, %w", err), 2917 Snapshot: snapshot.Bytes(), 2918 } 2919 return err 2920 } 2921 2922 errorBody.Seek(0, io.SeekStart) 2923 if len(code) != 0 { 2924 errorCode = restjson.SanitizeErrorCode(code) 2925 } 2926 if len(message) != 0 { 2927 errorMessage = message 2928 } 2929 2930 switch { 2931 case strings.EqualFold("InvalidParameterException", errorCode): 2932 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2933 2934 case strings.EqualFold("LimitExceededException", errorCode): 2935 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2936 2937 case strings.EqualFold("ResourceNotFoundException", errorCode): 2938 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2939 2940 case strings.EqualFold("ServiceUnavailableException", errorCode): 2941 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2942 2943 default: 2944 genericError := &smithy.GenericAPIError{ 2945 Code: errorCode, 2946 Message: errorMessage, 2947 } 2948 return genericError 2949 2950 } 2951} 2952 2953type awsAwsjson11_deserializeOpGetQueryResults struct { 2954} 2955 2956func (*awsAwsjson11_deserializeOpGetQueryResults) ID() string { 2957 return "OperationDeserializer" 2958} 2959 2960func (m *awsAwsjson11_deserializeOpGetQueryResults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2961 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2962) { 2963 out, metadata, err = next.HandleDeserialize(ctx, in) 2964 if err != nil { 2965 return out, metadata, err 2966 } 2967 2968 response, ok := out.RawResponse.(*smithyhttp.Response) 2969 if !ok { 2970 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2971 } 2972 2973 if response.StatusCode < 200 || response.StatusCode >= 300 { 2974 return out, metadata, awsAwsjson11_deserializeOpErrorGetQueryResults(response, &metadata) 2975 } 2976 output := &GetQueryResultsOutput{} 2977 out.Result = output 2978 2979 var buff [1024]byte 2980 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2981 2982 body := io.TeeReader(response.Body, ringBuffer) 2983 decoder := json.NewDecoder(body) 2984 decoder.UseNumber() 2985 var shape interface{} 2986 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2987 var snapshot bytes.Buffer 2988 io.Copy(&snapshot, ringBuffer) 2989 err = &smithy.DeserializationError{ 2990 Err: fmt.Errorf("failed to decode response body, %w", err), 2991 Snapshot: snapshot.Bytes(), 2992 } 2993 return out, metadata, err 2994 } 2995 2996 err = awsAwsjson11_deserializeOpDocumentGetQueryResultsOutput(&output, shape) 2997 if err != nil { 2998 var snapshot bytes.Buffer 2999 io.Copy(&snapshot, ringBuffer) 3000 err = &smithy.DeserializationError{ 3001 Err: fmt.Errorf("failed to decode response body, %w", err), 3002 Snapshot: snapshot.Bytes(), 3003 } 3004 return out, metadata, err 3005 } 3006 3007 return out, metadata, err 3008} 3009 3010func awsAwsjson11_deserializeOpErrorGetQueryResults(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3011 var errorBuffer bytes.Buffer 3012 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3013 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3014 } 3015 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3016 3017 errorCode := "UnknownError" 3018 errorMessage := errorCode 3019 3020 code := response.Header.Get("X-Amzn-ErrorType") 3021 if len(code) != 0 { 3022 errorCode = restjson.SanitizeErrorCode(code) 3023 } 3024 3025 var buff [1024]byte 3026 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3027 3028 body := io.TeeReader(errorBody, ringBuffer) 3029 decoder := json.NewDecoder(body) 3030 decoder.UseNumber() 3031 code, message, err := restjson.GetErrorInfo(decoder) 3032 if err != nil { 3033 var snapshot bytes.Buffer 3034 io.Copy(&snapshot, ringBuffer) 3035 err = &smithy.DeserializationError{ 3036 Err: fmt.Errorf("failed to decode response body, %w", err), 3037 Snapshot: snapshot.Bytes(), 3038 } 3039 return err 3040 } 3041 3042 errorBody.Seek(0, io.SeekStart) 3043 if len(code) != 0 { 3044 errorCode = restjson.SanitizeErrorCode(code) 3045 } 3046 if len(message) != 0 { 3047 errorMessage = message 3048 } 3049 3050 switch { 3051 case strings.EqualFold("InvalidParameterException", errorCode): 3052 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3053 3054 case strings.EqualFold("ResourceNotFoundException", errorCode): 3055 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3056 3057 case strings.EqualFold("ServiceUnavailableException", errorCode): 3058 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 3059 3060 default: 3061 genericError := &smithy.GenericAPIError{ 3062 Code: errorCode, 3063 Message: errorMessage, 3064 } 3065 return genericError 3066 3067 } 3068} 3069 3070type awsAwsjson11_deserializeOpListTagsLogGroup struct { 3071} 3072 3073func (*awsAwsjson11_deserializeOpListTagsLogGroup) ID() string { 3074 return "OperationDeserializer" 3075} 3076 3077func (m *awsAwsjson11_deserializeOpListTagsLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3078 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3079) { 3080 out, metadata, err = next.HandleDeserialize(ctx, in) 3081 if err != nil { 3082 return out, metadata, err 3083 } 3084 3085 response, ok := out.RawResponse.(*smithyhttp.Response) 3086 if !ok { 3087 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3088 } 3089 3090 if response.StatusCode < 200 || response.StatusCode >= 300 { 3091 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsLogGroup(response, &metadata) 3092 } 3093 output := &ListTagsLogGroupOutput{} 3094 out.Result = output 3095 3096 var buff [1024]byte 3097 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3098 3099 body := io.TeeReader(response.Body, ringBuffer) 3100 decoder := json.NewDecoder(body) 3101 decoder.UseNumber() 3102 var shape interface{} 3103 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3104 var snapshot bytes.Buffer 3105 io.Copy(&snapshot, ringBuffer) 3106 err = &smithy.DeserializationError{ 3107 Err: fmt.Errorf("failed to decode response body, %w", err), 3108 Snapshot: snapshot.Bytes(), 3109 } 3110 return out, metadata, err 3111 } 3112 3113 err = awsAwsjson11_deserializeOpDocumentListTagsLogGroupOutput(&output, shape) 3114 if err != nil { 3115 var snapshot bytes.Buffer 3116 io.Copy(&snapshot, ringBuffer) 3117 err = &smithy.DeserializationError{ 3118 Err: fmt.Errorf("failed to decode response body, %w", err), 3119 Snapshot: snapshot.Bytes(), 3120 } 3121 return out, metadata, err 3122 } 3123 3124 return out, metadata, err 3125} 3126 3127func awsAwsjson11_deserializeOpErrorListTagsLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3128 var errorBuffer bytes.Buffer 3129 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3130 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3131 } 3132 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3133 3134 errorCode := "UnknownError" 3135 errorMessage := errorCode 3136 3137 code := response.Header.Get("X-Amzn-ErrorType") 3138 if len(code) != 0 { 3139 errorCode = restjson.SanitizeErrorCode(code) 3140 } 3141 3142 var buff [1024]byte 3143 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3144 3145 body := io.TeeReader(errorBody, ringBuffer) 3146 decoder := json.NewDecoder(body) 3147 decoder.UseNumber() 3148 code, message, err := restjson.GetErrorInfo(decoder) 3149 if err != nil { 3150 var snapshot bytes.Buffer 3151 io.Copy(&snapshot, ringBuffer) 3152 err = &smithy.DeserializationError{ 3153 Err: fmt.Errorf("failed to decode response body, %w", err), 3154 Snapshot: snapshot.Bytes(), 3155 } 3156 return err 3157 } 3158 3159 errorBody.Seek(0, io.SeekStart) 3160 if len(code) != 0 { 3161 errorCode = restjson.SanitizeErrorCode(code) 3162 } 3163 if len(message) != 0 { 3164 errorMessage = message 3165 } 3166 3167 switch { 3168 case strings.EqualFold("ResourceNotFoundException", errorCode): 3169 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3170 3171 case strings.EqualFold("ServiceUnavailableException", errorCode): 3172 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 3173 3174 default: 3175 genericError := &smithy.GenericAPIError{ 3176 Code: errorCode, 3177 Message: errorMessage, 3178 } 3179 return genericError 3180 3181 } 3182} 3183 3184type awsAwsjson11_deserializeOpPutDestination struct { 3185} 3186 3187func (*awsAwsjson11_deserializeOpPutDestination) ID() string { 3188 return "OperationDeserializer" 3189} 3190 3191func (m *awsAwsjson11_deserializeOpPutDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3192 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3193) { 3194 out, metadata, err = next.HandleDeserialize(ctx, in) 3195 if err != nil { 3196 return out, metadata, err 3197 } 3198 3199 response, ok := out.RawResponse.(*smithyhttp.Response) 3200 if !ok { 3201 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3202 } 3203 3204 if response.StatusCode < 200 || response.StatusCode >= 300 { 3205 return out, metadata, awsAwsjson11_deserializeOpErrorPutDestination(response, &metadata) 3206 } 3207 output := &PutDestinationOutput{} 3208 out.Result = output 3209 3210 var buff [1024]byte 3211 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3212 3213 body := io.TeeReader(response.Body, ringBuffer) 3214 decoder := json.NewDecoder(body) 3215 decoder.UseNumber() 3216 var shape interface{} 3217 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3218 var snapshot bytes.Buffer 3219 io.Copy(&snapshot, ringBuffer) 3220 err = &smithy.DeserializationError{ 3221 Err: fmt.Errorf("failed to decode response body, %w", err), 3222 Snapshot: snapshot.Bytes(), 3223 } 3224 return out, metadata, err 3225 } 3226 3227 err = awsAwsjson11_deserializeOpDocumentPutDestinationOutput(&output, shape) 3228 if err != nil { 3229 var snapshot bytes.Buffer 3230 io.Copy(&snapshot, ringBuffer) 3231 err = &smithy.DeserializationError{ 3232 Err: fmt.Errorf("failed to decode response body, %w", err), 3233 Snapshot: snapshot.Bytes(), 3234 } 3235 return out, metadata, err 3236 } 3237 3238 return out, metadata, err 3239} 3240 3241func awsAwsjson11_deserializeOpErrorPutDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3242 var errorBuffer bytes.Buffer 3243 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3244 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3245 } 3246 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3247 3248 errorCode := "UnknownError" 3249 errorMessage := errorCode 3250 3251 code := response.Header.Get("X-Amzn-ErrorType") 3252 if len(code) != 0 { 3253 errorCode = restjson.SanitizeErrorCode(code) 3254 } 3255 3256 var buff [1024]byte 3257 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3258 3259 body := io.TeeReader(errorBody, ringBuffer) 3260 decoder := json.NewDecoder(body) 3261 decoder.UseNumber() 3262 code, message, err := restjson.GetErrorInfo(decoder) 3263 if err != nil { 3264 var snapshot bytes.Buffer 3265 io.Copy(&snapshot, ringBuffer) 3266 err = &smithy.DeserializationError{ 3267 Err: fmt.Errorf("failed to decode response body, %w", err), 3268 Snapshot: snapshot.Bytes(), 3269 } 3270 return err 3271 } 3272 3273 errorBody.Seek(0, io.SeekStart) 3274 if len(code) != 0 { 3275 errorCode = restjson.SanitizeErrorCode(code) 3276 } 3277 if len(message) != 0 { 3278 errorMessage = message 3279 } 3280 3281 switch { 3282 case strings.EqualFold("InvalidParameterException", errorCode): 3283 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3284 3285 case strings.EqualFold("OperationAbortedException", errorCode): 3286 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 3287 3288 case strings.EqualFold("ServiceUnavailableException", errorCode): 3289 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 3290 3291 default: 3292 genericError := &smithy.GenericAPIError{ 3293 Code: errorCode, 3294 Message: errorMessage, 3295 } 3296 return genericError 3297 3298 } 3299} 3300 3301type awsAwsjson11_deserializeOpPutDestinationPolicy struct { 3302} 3303 3304func (*awsAwsjson11_deserializeOpPutDestinationPolicy) ID() string { 3305 return "OperationDeserializer" 3306} 3307 3308func (m *awsAwsjson11_deserializeOpPutDestinationPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3309 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3310) { 3311 out, metadata, err = next.HandleDeserialize(ctx, in) 3312 if err != nil { 3313 return out, metadata, err 3314 } 3315 3316 response, ok := out.RawResponse.(*smithyhttp.Response) 3317 if !ok { 3318 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3319 } 3320 3321 if response.StatusCode < 200 || response.StatusCode >= 300 { 3322 return out, metadata, awsAwsjson11_deserializeOpErrorPutDestinationPolicy(response, &metadata) 3323 } 3324 output := &PutDestinationPolicyOutput{} 3325 out.Result = output 3326 3327 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3328 return out, metadata, &smithy.DeserializationError{ 3329 Err: fmt.Errorf("failed to discard response body, %w", err), 3330 } 3331 } 3332 3333 return out, metadata, err 3334} 3335 3336func awsAwsjson11_deserializeOpErrorPutDestinationPolicy(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("InvalidParameterException", errorCode): 3378 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3379 3380 case strings.EqualFold("OperationAbortedException", errorCode): 3381 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 3382 3383 case strings.EqualFold("ServiceUnavailableException", errorCode): 3384 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 3385 3386 default: 3387 genericError := &smithy.GenericAPIError{ 3388 Code: errorCode, 3389 Message: errorMessage, 3390 } 3391 return genericError 3392 3393 } 3394} 3395 3396type awsAwsjson11_deserializeOpPutLogEvents struct { 3397} 3398 3399func (*awsAwsjson11_deserializeOpPutLogEvents) ID() string { 3400 return "OperationDeserializer" 3401} 3402 3403func (m *awsAwsjson11_deserializeOpPutLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3404 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3405) { 3406 out, metadata, err = next.HandleDeserialize(ctx, in) 3407 if err != nil { 3408 return out, metadata, err 3409 } 3410 3411 response, ok := out.RawResponse.(*smithyhttp.Response) 3412 if !ok { 3413 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3414 } 3415 3416 if response.StatusCode < 200 || response.StatusCode >= 300 { 3417 return out, metadata, awsAwsjson11_deserializeOpErrorPutLogEvents(response, &metadata) 3418 } 3419 output := &PutLogEventsOutput{} 3420 out.Result = output 3421 3422 var buff [1024]byte 3423 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3424 3425 body := io.TeeReader(response.Body, ringBuffer) 3426 decoder := json.NewDecoder(body) 3427 decoder.UseNumber() 3428 var shape interface{} 3429 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3430 var snapshot bytes.Buffer 3431 io.Copy(&snapshot, ringBuffer) 3432 err = &smithy.DeserializationError{ 3433 Err: fmt.Errorf("failed to decode response body, %w", err), 3434 Snapshot: snapshot.Bytes(), 3435 } 3436 return out, metadata, err 3437 } 3438 3439 err = awsAwsjson11_deserializeOpDocumentPutLogEventsOutput(&output, shape) 3440 if err != nil { 3441 var snapshot bytes.Buffer 3442 io.Copy(&snapshot, ringBuffer) 3443 err = &smithy.DeserializationError{ 3444 Err: fmt.Errorf("failed to decode response body, %w", err), 3445 Snapshot: snapshot.Bytes(), 3446 } 3447 return out, metadata, err 3448 } 3449 3450 return out, metadata, err 3451} 3452 3453func awsAwsjson11_deserializeOpErrorPutLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3454 var errorBuffer bytes.Buffer 3455 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3456 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3457 } 3458 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3459 3460 errorCode := "UnknownError" 3461 errorMessage := errorCode 3462 3463 code := response.Header.Get("X-Amzn-ErrorType") 3464 if len(code) != 0 { 3465 errorCode = restjson.SanitizeErrorCode(code) 3466 } 3467 3468 var buff [1024]byte 3469 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3470 3471 body := io.TeeReader(errorBody, ringBuffer) 3472 decoder := json.NewDecoder(body) 3473 decoder.UseNumber() 3474 code, message, err := restjson.GetErrorInfo(decoder) 3475 if err != nil { 3476 var snapshot bytes.Buffer 3477 io.Copy(&snapshot, ringBuffer) 3478 err = &smithy.DeserializationError{ 3479 Err: fmt.Errorf("failed to decode response body, %w", err), 3480 Snapshot: snapshot.Bytes(), 3481 } 3482 return err 3483 } 3484 3485 errorBody.Seek(0, io.SeekStart) 3486 if len(code) != 0 { 3487 errorCode = restjson.SanitizeErrorCode(code) 3488 } 3489 if len(message) != 0 { 3490 errorMessage = message 3491 } 3492 3493 switch { 3494 case strings.EqualFold("DataAlreadyAcceptedException", errorCode): 3495 return awsAwsjson11_deserializeErrorDataAlreadyAcceptedException(response, errorBody) 3496 3497 case strings.EqualFold("InvalidParameterException", errorCode): 3498 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3499 3500 case strings.EqualFold("InvalidSequenceTokenException", errorCode): 3501 return awsAwsjson11_deserializeErrorInvalidSequenceTokenException(response, errorBody) 3502 3503 case strings.EqualFold("ResourceNotFoundException", errorCode): 3504 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3505 3506 case strings.EqualFold("ServiceUnavailableException", errorCode): 3507 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 3508 3509 case strings.EqualFold("UnrecognizedClientException", errorCode): 3510 return awsAwsjson11_deserializeErrorUnrecognizedClientException(response, errorBody) 3511 3512 default: 3513 genericError := &smithy.GenericAPIError{ 3514 Code: errorCode, 3515 Message: errorMessage, 3516 } 3517 return genericError 3518 3519 } 3520} 3521 3522type awsAwsjson11_deserializeOpPutMetricFilter struct { 3523} 3524 3525func (*awsAwsjson11_deserializeOpPutMetricFilter) ID() string { 3526 return "OperationDeserializer" 3527} 3528 3529func (m *awsAwsjson11_deserializeOpPutMetricFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3530 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3531) { 3532 out, metadata, err = next.HandleDeserialize(ctx, in) 3533 if err != nil { 3534 return out, metadata, err 3535 } 3536 3537 response, ok := out.RawResponse.(*smithyhttp.Response) 3538 if !ok { 3539 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3540 } 3541 3542 if response.StatusCode < 200 || response.StatusCode >= 300 { 3543 return out, metadata, awsAwsjson11_deserializeOpErrorPutMetricFilter(response, &metadata) 3544 } 3545 output := &PutMetricFilterOutput{} 3546 out.Result = output 3547 3548 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3549 return out, metadata, &smithy.DeserializationError{ 3550 Err: fmt.Errorf("failed to discard response body, %w", err), 3551 } 3552 } 3553 3554 return out, metadata, err 3555} 3556 3557func awsAwsjson11_deserializeOpErrorPutMetricFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3558 var errorBuffer bytes.Buffer 3559 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3560 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3561 } 3562 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3563 3564 errorCode := "UnknownError" 3565 errorMessage := errorCode 3566 3567 code := response.Header.Get("X-Amzn-ErrorType") 3568 if len(code) != 0 { 3569 errorCode = restjson.SanitizeErrorCode(code) 3570 } 3571 3572 var buff [1024]byte 3573 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3574 3575 body := io.TeeReader(errorBody, ringBuffer) 3576 decoder := json.NewDecoder(body) 3577 decoder.UseNumber() 3578 code, message, err := restjson.GetErrorInfo(decoder) 3579 if err != nil { 3580 var snapshot bytes.Buffer 3581 io.Copy(&snapshot, ringBuffer) 3582 err = &smithy.DeserializationError{ 3583 Err: fmt.Errorf("failed to decode response body, %w", err), 3584 Snapshot: snapshot.Bytes(), 3585 } 3586 return err 3587 } 3588 3589 errorBody.Seek(0, io.SeekStart) 3590 if len(code) != 0 { 3591 errorCode = restjson.SanitizeErrorCode(code) 3592 } 3593 if len(message) != 0 { 3594 errorMessage = message 3595 } 3596 3597 switch { 3598 case strings.EqualFold("InvalidParameterException", errorCode): 3599 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3600 3601 case strings.EqualFold("LimitExceededException", errorCode): 3602 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 3603 3604 case strings.EqualFold("OperationAbortedException", errorCode): 3605 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 3606 3607 case strings.EqualFold("ResourceNotFoundException", errorCode): 3608 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3609 3610 case strings.EqualFold("ServiceUnavailableException", errorCode): 3611 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 3612 3613 default: 3614 genericError := &smithy.GenericAPIError{ 3615 Code: errorCode, 3616 Message: errorMessage, 3617 } 3618 return genericError 3619 3620 } 3621} 3622 3623type awsAwsjson11_deserializeOpPutQueryDefinition struct { 3624} 3625 3626func (*awsAwsjson11_deserializeOpPutQueryDefinition) ID() string { 3627 return "OperationDeserializer" 3628} 3629 3630func (m *awsAwsjson11_deserializeOpPutQueryDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3631 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3632) { 3633 out, metadata, err = next.HandleDeserialize(ctx, in) 3634 if err != nil { 3635 return out, metadata, err 3636 } 3637 3638 response, ok := out.RawResponse.(*smithyhttp.Response) 3639 if !ok { 3640 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3641 } 3642 3643 if response.StatusCode < 200 || response.StatusCode >= 300 { 3644 return out, metadata, awsAwsjson11_deserializeOpErrorPutQueryDefinition(response, &metadata) 3645 } 3646 output := &PutQueryDefinitionOutput{} 3647 out.Result = output 3648 3649 var buff [1024]byte 3650 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3651 3652 body := io.TeeReader(response.Body, ringBuffer) 3653 decoder := json.NewDecoder(body) 3654 decoder.UseNumber() 3655 var shape interface{} 3656 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3657 var snapshot bytes.Buffer 3658 io.Copy(&snapshot, ringBuffer) 3659 err = &smithy.DeserializationError{ 3660 Err: fmt.Errorf("failed to decode response body, %w", err), 3661 Snapshot: snapshot.Bytes(), 3662 } 3663 return out, metadata, err 3664 } 3665 3666 err = awsAwsjson11_deserializeOpDocumentPutQueryDefinitionOutput(&output, shape) 3667 if err != nil { 3668 var snapshot bytes.Buffer 3669 io.Copy(&snapshot, ringBuffer) 3670 err = &smithy.DeserializationError{ 3671 Err: fmt.Errorf("failed to decode response body, %w", err), 3672 Snapshot: snapshot.Bytes(), 3673 } 3674 return out, metadata, err 3675 } 3676 3677 return out, metadata, err 3678} 3679 3680func awsAwsjson11_deserializeOpErrorPutQueryDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3681 var errorBuffer bytes.Buffer 3682 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3683 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3684 } 3685 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3686 3687 errorCode := "UnknownError" 3688 errorMessage := errorCode 3689 3690 code := response.Header.Get("X-Amzn-ErrorType") 3691 if len(code) != 0 { 3692 errorCode = restjson.SanitizeErrorCode(code) 3693 } 3694 3695 var buff [1024]byte 3696 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3697 3698 body := io.TeeReader(errorBody, ringBuffer) 3699 decoder := json.NewDecoder(body) 3700 decoder.UseNumber() 3701 code, message, err := restjson.GetErrorInfo(decoder) 3702 if err != nil { 3703 var snapshot bytes.Buffer 3704 io.Copy(&snapshot, ringBuffer) 3705 err = &smithy.DeserializationError{ 3706 Err: fmt.Errorf("failed to decode response body, %w", err), 3707 Snapshot: snapshot.Bytes(), 3708 } 3709 return err 3710 } 3711 3712 errorBody.Seek(0, io.SeekStart) 3713 if len(code) != 0 { 3714 errorCode = restjson.SanitizeErrorCode(code) 3715 } 3716 if len(message) != 0 { 3717 errorMessage = message 3718 } 3719 3720 switch { 3721 case strings.EqualFold("InvalidParameterException", errorCode): 3722 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3723 3724 case strings.EqualFold("ResourceNotFoundException", errorCode): 3725 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3726 3727 case strings.EqualFold("ServiceUnavailableException", errorCode): 3728 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 3729 3730 default: 3731 genericError := &smithy.GenericAPIError{ 3732 Code: errorCode, 3733 Message: errorMessage, 3734 } 3735 return genericError 3736 3737 } 3738} 3739 3740type awsAwsjson11_deserializeOpPutResourcePolicy struct { 3741} 3742 3743func (*awsAwsjson11_deserializeOpPutResourcePolicy) ID() string { 3744 return "OperationDeserializer" 3745} 3746 3747func (m *awsAwsjson11_deserializeOpPutResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3748 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3749) { 3750 out, metadata, err = next.HandleDeserialize(ctx, in) 3751 if err != nil { 3752 return out, metadata, err 3753 } 3754 3755 response, ok := out.RawResponse.(*smithyhttp.Response) 3756 if !ok { 3757 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3758 } 3759 3760 if response.StatusCode < 200 || response.StatusCode >= 300 { 3761 return out, metadata, awsAwsjson11_deserializeOpErrorPutResourcePolicy(response, &metadata) 3762 } 3763 output := &PutResourcePolicyOutput{} 3764 out.Result = output 3765 3766 var buff [1024]byte 3767 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3768 3769 body := io.TeeReader(response.Body, ringBuffer) 3770 decoder := json.NewDecoder(body) 3771 decoder.UseNumber() 3772 var shape interface{} 3773 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3774 var snapshot bytes.Buffer 3775 io.Copy(&snapshot, ringBuffer) 3776 err = &smithy.DeserializationError{ 3777 Err: fmt.Errorf("failed to decode response body, %w", err), 3778 Snapshot: snapshot.Bytes(), 3779 } 3780 return out, metadata, err 3781 } 3782 3783 err = awsAwsjson11_deserializeOpDocumentPutResourcePolicyOutput(&output, shape) 3784 if err != nil { 3785 var snapshot bytes.Buffer 3786 io.Copy(&snapshot, ringBuffer) 3787 err = &smithy.DeserializationError{ 3788 Err: fmt.Errorf("failed to decode response body, %w", err), 3789 Snapshot: snapshot.Bytes(), 3790 } 3791 return out, metadata, err 3792 } 3793 3794 return out, metadata, err 3795} 3796 3797func awsAwsjson11_deserializeOpErrorPutResourcePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3798 var errorBuffer bytes.Buffer 3799 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3800 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3801 } 3802 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3803 3804 errorCode := "UnknownError" 3805 errorMessage := errorCode 3806 3807 code := response.Header.Get("X-Amzn-ErrorType") 3808 if len(code) != 0 { 3809 errorCode = restjson.SanitizeErrorCode(code) 3810 } 3811 3812 var buff [1024]byte 3813 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3814 3815 body := io.TeeReader(errorBody, ringBuffer) 3816 decoder := json.NewDecoder(body) 3817 decoder.UseNumber() 3818 code, message, err := restjson.GetErrorInfo(decoder) 3819 if err != nil { 3820 var snapshot bytes.Buffer 3821 io.Copy(&snapshot, ringBuffer) 3822 err = &smithy.DeserializationError{ 3823 Err: fmt.Errorf("failed to decode response body, %w", err), 3824 Snapshot: snapshot.Bytes(), 3825 } 3826 return err 3827 } 3828 3829 errorBody.Seek(0, io.SeekStart) 3830 if len(code) != 0 { 3831 errorCode = restjson.SanitizeErrorCode(code) 3832 } 3833 if len(message) != 0 { 3834 errorMessage = message 3835 } 3836 3837 switch { 3838 case strings.EqualFold("InvalidParameterException", errorCode): 3839 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3840 3841 case strings.EqualFold("LimitExceededException", errorCode): 3842 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 3843 3844 case strings.EqualFold("ServiceUnavailableException", errorCode): 3845 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 3846 3847 default: 3848 genericError := &smithy.GenericAPIError{ 3849 Code: errorCode, 3850 Message: errorMessage, 3851 } 3852 return genericError 3853 3854 } 3855} 3856 3857type awsAwsjson11_deserializeOpPutRetentionPolicy struct { 3858} 3859 3860func (*awsAwsjson11_deserializeOpPutRetentionPolicy) ID() string { 3861 return "OperationDeserializer" 3862} 3863 3864func (m *awsAwsjson11_deserializeOpPutRetentionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3865 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3866) { 3867 out, metadata, err = next.HandleDeserialize(ctx, in) 3868 if err != nil { 3869 return out, metadata, err 3870 } 3871 3872 response, ok := out.RawResponse.(*smithyhttp.Response) 3873 if !ok { 3874 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3875 } 3876 3877 if response.StatusCode < 200 || response.StatusCode >= 300 { 3878 return out, metadata, awsAwsjson11_deserializeOpErrorPutRetentionPolicy(response, &metadata) 3879 } 3880 output := &PutRetentionPolicyOutput{} 3881 out.Result = output 3882 3883 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3884 return out, metadata, &smithy.DeserializationError{ 3885 Err: fmt.Errorf("failed to discard response body, %w", err), 3886 } 3887 } 3888 3889 return out, metadata, err 3890} 3891 3892func awsAwsjson11_deserializeOpErrorPutRetentionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3893 var errorBuffer bytes.Buffer 3894 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3895 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3896 } 3897 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3898 3899 errorCode := "UnknownError" 3900 errorMessage := errorCode 3901 3902 code := response.Header.Get("X-Amzn-ErrorType") 3903 if len(code) != 0 { 3904 errorCode = restjson.SanitizeErrorCode(code) 3905 } 3906 3907 var buff [1024]byte 3908 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3909 3910 body := io.TeeReader(errorBody, ringBuffer) 3911 decoder := json.NewDecoder(body) 3912 decoder.UseNumber() 3913 code, message, err := restjson.GetErrorInfo(decoder) 3914 if err != nil { 3915 var snapshot bytes.Buffer 3916 io.Copy(&snapshot, ringBuffer) 3917 err = &smithy.DeserializationError{ 3918 Err: fmt.Errorf("failed to decode response body, %w", err), 3919 Snapshot: snapshot.Bytes(), 3920 } 3921 return err 3922 } 3923 3924 errorBody.Seek(0, io.SeekStart) 3925 if len(code) != 0 { 3926 errorCode = restjson.SanitizeErrorCode(code) 3927 } 3928 if len(message) != 0 { 3929 errorMessage = message 3930 } 3931 3932 switch { 3933 case strings.EqualFold("InvalidParameterException", errorCode): 3934 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3935 3936 case strings.EqualFold("OperationAbortedException", errorCode): 3937 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 3938 3939 case strings.EqualFold("ResourceNotFoundException", errorCode): 3940 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3941 3942 case strings.EqualFold("ServiceUnavailableException", errorCode): 3943 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 3944 3945 default: 3946 genericError := &smithy.GenericAPIError{ 3947 Code: errorCode, 3948 Message: errorMessage, 3949 } 3950 return genericError 3951 3952 } 3953} 3954 3955type awsAwsjson11_deserializeOpPutSubscriptionFilter struct { 3956} 3957 3958func (*awsAwsjson11_deserializeOpPutSubscriptionFilter) ID() string { 3959 return "OperationDeserializer" 3960} 3961 3962func (m *awsAwsjson11_deserializeOpPutSubscriptionFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3963 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3964) { 3965 out, metadata, err = next.HandleDeserialize(ctx, in) 3966 if err != nil { 3967 return out, metadata, err 3968 } 3969 3970 response, ok := out.RawResponse.(*smithyhttp.Response) 3971 if !ok { 3972 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3973 } 3974 3975 if response.StatusCode < 200 || response.StatusCode >= 300 { 3976 return out, metadata, awsAwsjson11_deserializeOpErrorPutSubscriptionFilter(response, &metadata) 3977 } 3978 output := &PutSubscriptionFilterOutput{} 3979 out.Result = output 3980 3981 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3982 return out, metadata, &smithy.DeserializationError{ 3983 Err: fmt.Errorf("failed to discard response body, %w", err), 3984 } 3985 } 3986 3987 return out, metadata, err 3988} 3989 3990func awsAwsjson11_deserializeOpErrorPutSubscriptionFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3991 var errorBuffer bytes.Buffer 3992 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3993 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3994 } 3995 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3996 3997 errorCode := "UnknownError" 3998 errorMessage := errorCode 3999 4000 code := response.Header.Get("X-Amzn-ErrorType") 4001 if len(code) != 0 { 4002 errorCode = restjson.SanitizeErrorCode(code) 4003 } 4004 4005 var buff [1024]byte 4006 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4007 4008 body := io.TeeReader(errorBody, ringBuffer) 4009 decoder := json.NewDecoder(body) 4010 decoder.UseNumber() 4011 code, message, err := restjson.GetErrorInfo(decoder) 4012 if err != nil { 4013 var snapshot bytes.Buffer 4014 io.Copy(&snapshot, ringBuffer) 4015 err = &smithy.DeserializationError{ 4016 Err: fmt.Errorf("failed to decode response body, %w", err), 4017 Snapshot: snapshot.Bytes(), 4018 } 4019 return err 4020 } 4021 4022 errorBody.Seek(0, io.SeekStart) 4023 if len(code) != 0 { 4024 errorCode = restjson.SanitizeErrorCode(code) 4025 } 4026 if len(message) != 0 { 4027 errorMessage = message 4028 } 4029 4030 switch { 4031 case strings.EqualFold("InvalidParameterException", errorCode): 4032 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4033 4034 case strings.EqualFold("LimitExceededException", errorCode): 4035 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 4036 4037 case strings.EqualFold("OperationAbortedException", errorCode): 4038 return awsAwsjson11_deserializeErrorOperationAbortedException(response, errorBody) 4039 4040 case strings.EqualFold("ResourceNotFoundException", errorCode): 4041 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4042 4043 case strings.EqualFold("ServiceUnavailableException", errorCode): 4044 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 4045 4046 default: 4047 genericError := &smithy.GenericAPIError{ 4048 Code: errorCode, 4049 Message: errorMessage, 4050 } 4051 return genericError 4052 4053 } 4054} 4055 4056type awsAwsjson11_deserializeOpStartQuery struct { 4057} 4058 4059func (*awsAwsjson11_deserializeOpStartQuery) ID() string { 4060 return "OperationDeserializer" 4061} 4062 4063func (m *awsAwsjson11_deserializeOpStartQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4064 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4065) { 4066 out, metadata, err = next.HandleDeserialize(ctx, in) 4067 if err != nil { 4068 return out, metadata, err 4069 } 4070 4071 response, ok := out.RawResponse.(*smithyhttp.Response) 4072 if !ok { 4073 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4074 } 4075 4076 if response.StatusCode < 200 || response.StatusCode >= 300 { 4077 return out, metadata, awsAwsjson11_deserializeOpErrorStartQuery(response, &metadata) 4078 } 4079 output := &StartQueryOutput{} 4080 out.Result = output 4081 4082 var buff [1024]byte 4083 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4084 4085 body := io.TeeReader(response.Body, ringBuffer) 4086 decoder := json.NewDecoder(body) 4087 decoder.UseNumber() 4088 var shape interface{} 4089 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4090 var snapshot bytes.Buffer 4091 io.Copy(&snapshot, ringBuffer) 4092 err = &smithy.DeserializationError{ 4093 Err: fmt.Errorf("failed to decode response body, %w", err), 4094 Snapshot: snapshot.Bytes(), 4095 } 4096 return out, metadata, err 4097 } 4098 4099 err = awsAwsjson11_deserializeOpDocumentStartQueryOutput(&output, shape) 4100 if err != nil { 4101 var snapshot bytes.Buffer 4102 io.Copy(&snapshot, ringBuffer) 4103 err = &smithy.DeserializationError{ 4104 Err: fmt.Errorf("failed to decode response body, %w", err), 4105 Snapshot: snapshot.Bytes(), 4106 } 4107 return out, metadata, err 4108 } 4109 4110 return out, metadata, err 4111} 4112 4113func awsAwsjson11_deserializeOpErrorStartQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4114 var errorBuffer bytes.Buffer 4115 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4116 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4117 } 4118 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4119 4120 errorCode := "UnknownError" 4121 errorMessage := errorCode 4122 4123 code := response.Header.Get("X-Amzn-ErrorType") 4124 if len(code) != 0 { 4125 errorCode = restjson.SanitizeErrorCode(code) 4126 } 4127 4128 var buff [1024]byte 4129 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4130 4131 body := io.TeeReader(errorBody, ringBuffer) 4132 decoder := json.NewDecoder(body) 4133 decoder.UseNumber() 4134 code, message, err := restjson.GetErrorInfo(decoder) 4135 if err != nil { 4136 var snapshot bytes.Buffer 4137 io.Copy(&snapshot, ringBuffer) 4138 err = &smithy.DeserializationError{ 4139 Err: fmt.Errorf("failed to decode response body, %w", err), 4140 Snapshot: snapshot.Bytes(), 4141 } 4142 return err 4143 } 4144 4145 errorBody.Seek(0, io.SeekStart) 4146 if len(code) != 0 { 4147 errorCode = restjson.SanitizeErrorCode(code) 4148 } 4149 if len(message) != 0 { 4150 errorMessage = message 4151 } 4152 4153 switch { 4154 case strings.EqualFold("InvalidParameterException", errorCode): 4155 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4156 4157 case strings.EqualFold("LimitExceededException", errorCode): 4158 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 4159 4160 case strings.EqualFold("MalformedQueryException", errorCode): 4161 return awsAwsjson11_deserializeErrorMalformedQueryException(response, errorBody) 4162 4163 case strings.EqualFold("ResourceNotFoundException", errorCode): 4164 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4165 4166 case strings.EqualFold("ServiceUnavailableException", errorCode): 4167 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 4168 4169 default: 4170 genericError := &smithy.GenericAPIError{ 4171 Code: errorCode, 4172 Message: errorMessage, 4173 } 4174 return genericError 4175 4176 } 4177} 4178 4179type awsAwsjson11_deserializeOpStopQuery struct { 4180} 4181 4182func (*awsAwsjson11_deserializeOpStopQuery) ID() string { 4183 return "OperationDeserializer" 4184} 4185 4186func (m *awsAwsjson11_deserializeOpStopQuery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4187 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4188) { 4189 out, metadata, err = next.HandleDeserialize(ctx, in) 4190 if err != nil { 4191 return out, metadata, err 4192 } 4193 4194 response, ok := out.RawResponse.(*smithyhttp.Response) 4195 if !ok { 4196 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4197 } 4198 4199 if response.StatusCode < 200 || response.StatusCode >= 300 { 4200 return out, metadata, awsAwsjson11_deserializeOpErrorStopQuery(response, &metadata) 4201 } 4202 output := &StopQueryOutput{} 4203 out.Result = output 4204 4205 var buff [1024]byte 4206 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4207 4208 body := io.TeeReader(response.Body, ringBuffer) 4209 decoder := json.NewDecoder(body) 4210 decoder.UseNumber() 4211 var shape interface{} 4212 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4213 var snapshot bytes.Buffer 4214 io.Copy(&snapshot, ringBuffer) 4215 err = &smithy.DeserializationError{ 4216 Err: fmt.Errorf("failed to decode response body, %w", err), 4217 Snapshot: snapshot.Bytes(), 4218 } 4219 return out, metadata, err 4220 } 4221 4222 err = awsAwsjson11_deserializeOpDocumentStopQueryOutput(&output, shape) 4223 if err != nil { 4224 var snapshot bytes.Buffer 4225 io.Copy(&snapshot, ringBuffer) 4226 err = &smithy.DeserializationError{ 4227 Err: fmt.Errorf("failed to decode response body, %w", err), 4228 Snapshot: snapshot.Bytes(), 4229 } 4230 return out, metadata, err 4231 } 4232 4233 return out, metadata, err 4234} 4235 4236func awsAwsjson11_deserializeOpErrorStopQuery(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4237 var errorBuffer bytes.Buffer 4238 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4239 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4240 } 4241 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4242 4243 errorCode := "UnknownError" 4244 errorMessage := errorCode 4245 4246 code := response.Header.Get("X-Amzn-ErrorType") 4247 if len(code) != 0 { 4248 errorCode = restjson.SanitizeErrorCode(code) 4249 } 4250 4251 var buff [1024]byte 4252 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4253 4254 body := io.TeeReader(errorBody, ringBuffer) 4255 decoder := json.NewDecoder(body) 4256 decoder.UseNumber() 4257 code, message, err := restjson.GetErrorInfo(decoder) 4258 if err != nil { 4259 var snapshot bytes.Buffer 4260 io.Copy(&snapshot, ringBuffer) 4261 err = &smithy.DeserializationError{ 4262 Err: fmt.Errorf("failed to decode response body, %w", err), 4263 Snapshot: snapshot.Bytes(), 4264 } 4265 return err 4266 } 4267 4268 errorBody.Seek(0, io.SeekStart) 4269 if len(code) != 0 { 4270 errorCode = restjson.SanitizeErrorCode(code) 4271 } 4272 if len(message) != 0 { 4273 errorMessage = message 4274 } 4275 4276 switch { 4277 case strings.EqualFold("InvalidParameterException", errorCode): 4278 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4279 4280 case strings.EqualFold("ResourceNotFoundException", errorCode): 4281 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4282 4283 case strings.EqualFold("ServiceUnavailableException", errorCode): 4284 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 4285 4286 default: 4287 genericError := &smithy.GenericAPIError{ 4288 Code: errorCode, 4289 Message: errorMessage, 4290 } 4291 return genericError 4292 4293 } 4294} 4295 4296type awsAwsjson11_deserializeOpTagLogGroup struct { 4297} 4298 4299func (*awsAwsjson11_deserializeOpTagLogGroup) ID() string { 4300 return "OperationDeserializer" 4301} 4302 4303func (m *awsAwsjson11_deserializeOpTagLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4304 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4305) { 4306 out, metadata, err = next.HandleDeserialize(ctx, in) 4307 if err != nil { 4308 return out, metadata, err 4309 } 4310 4311 response, ok := out.RawResponse.(*smithyhttp.Response) 4312 if !ok { 4313 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4314 } 4315 4316 if response.StatusCode < 200 || response.StatusCode >= 300 { 4317 return out, metadata, awsAwsjson11_deserializeOpErrorTagLogGroup(response, &metadata) 4318 } 4319 output := &TagLogGroupOutput{} 4320 out.Result = output 4321 4322 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 4323 return out, metadata, &smithy.DeserializationError{ 4324 Err: fmt.Errorf("failed to discard response body, %w", err), 4325 } 4326 } 4327 4328 return out, metadata, err 4329} 4330 4331func awsAwsjson11_deserializeOpErrorTagLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4332 var errorBuffer bytes.Buffer 4333 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4334 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4335 } 4336 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4337 4338 errorCode := "UnknownError" 4339 errorMessage := errorCode 4340 4341 code := response.Header.Get("X-Amzn-ErrorType") 4342 if len(code) != 0 { 4343 errorCode = restjson.SanitizeErrorCode(code) 4344 } 4345 4346 var buff [1024]byte 4347 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4348 4349 body := io.TeeReader(errorBody, ringBuffer) 4350 decoder := json.NewDecoder(body) 4351 decoder.UseNumber() 4352 code, message, err := restjson.GetErrorInfo(decoder) 4353 if err != nil { 4354 var snapshot bytes.Buffer 4355 io.Copy(&snapshot, ringBuffer) 4356 err = &smithy.DeserializationError{ 4357 Err: fmt.Errorf("failed to decode response body, %w", err), 4358 Snapshot: snapshot.Bytes(), 4359 } 4360 return err 4361 } 4362 4363 errorBody.Seek(0, io.SeekStart) 4364 if len(code) != 0 { 4365 errorCode = restjson.SanitizeErrorCode(code) 4366 } 4367 if len(message) != 0 { 4368 errorMessage = message 4369 } 4370 4371 switch { 4372 case strings.EqualFold("InvalidParameterException", errorCode): 4373 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4374 4375 case strings.EqualFold("ResourceNotFoundException", errorCode): 4376 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4377 4378 default: 4379 genericError := &smithy.GenericAPIError{ 4380 Code: errorCode, 4381 Message: errorMessage, 4382 } 4383 return genericError 4384 4385 } 4386} 4387 4388type awsAwsjson11_deserializeOpTestMetricFilter struct { 4389} 4390 4391func (*awsAwsjson11_deserializeOpTestMetricFilter) ID() string { 4392 return "OperationDeserializer" 4393} 4394 4395func (m *awsAwsjson11_deserializeOpTestMetricFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4396 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4397) { 4398 out, metadata, err = next.HandleDeserialize(ctx, in) 4399 if err != nil { 4400 return out, metadata, err 4401 } 4402 4403 response, ok := out.RawResponse.(*smithyhttp.Response) 4404 if !ok { 4405 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4406 } 4407 4408 if response.StatusCode < 200 || response.StatusCode >= 300 { 4409 return out, metadata, awsAwsjson11_deserializeOpErrorTestMetricFilter(response, &metadata) 4410 } 4411 output := &TestMetricFilterOutput{} 4412 out.Result = output 4413 4414 var buff [1024]byte 4415 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4416 4417 body := io.TeeReader(response.Body, ringBuffer) 4418 decoder := json.NewDecoder(body) 4419 decoder.UseNumber() 4420 var shape interface{} 4421 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4422 var snapshot bytes.Buffer 4423 io.Copy(&snapshot, ringBuffer) 4424 err = &smithy.DeserializationError{ 4425 Err: fmt.Errorf("failed to decode response body, %w", err), 4426 Snapshot: snapshot.Bytes(), 4427 } 4428 return out, metadata, err 4429 } 4430 4431 err = awsAwsjson11_deserializeOpDocumentTestMetricFilterOutput(&output, shape) 4432 if err != nil { 4433 var snapshot bytes.Buffer 4434 io.Copy(&snapshot, ringBuffer) 4435 err = &smithy.DeserializationError{ 4436 Err: fmt.Errorf("failed to decode response body, %w", err), 4437 Snapshot: snapshot.Bytes(), 4438 } 4439 return out, metadata, err 4440 } 4441 4442 return out, metadata, err 4443} 4444 4445func awsAwsjson11_deserializeOpErrorTestMetricFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4446 var errorBuffer bytes.Buffer 4447 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4448 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4449 } 4450 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4451 4452 errorCode := "UnknownError" 4453 errorMessage := errorCode 4454 4455 code := response.Header.Get("X-Amzn-ErrorType") 4456 if len(code) != 0 { 4457 errorCode = restjson.SanitizeErrorCode(code) 4458 } 4459 4460 var buff [1024]byte 4461 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4462 4463 body := io.TeeReader(errorBody, ringBuffer) 4464 decoder := json.NewDecoder(body) 4465 decoder.UseNumber() 4466 code, message, err := restjson.GetErrorInfo(decoder) 4467 if err != nil { 4468 var snapshot bytes.Buffer 4469 io.Copy(&snapshot, ringBuffer) 4470 err = &smithy.DeserializationError{ 4471 Err: fmt.Errorf("failed to decode response body, %w", err), 4472 Snapshot: snapshot.Bytes(), 4473 } 4474 return err 4475 } 4476 4477 errorBody.Seek(0, io.SeekStart) 4478 if len(code) != 0 { 4479 errorCode = restjson.SanitizeErrorCode(code) 4480 } 4481 if len(message) != 0 { 4482 errorMessage = message 4483 } 4484 4485 switch { 4486 case strings.EqualFold("InvalidParameterException", errorCode): 4487 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4488 4489 case strings.EqualFold("ServiceUnavailableException", errorCode): 4490 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 4491 4492 default: 4493 genericError := &smithy.GenericAPIError{ 4494 Code: errorCode, 4495 Message: errorMessage, 4496 } 4497 return genericError 4498 4499 } 4500} 4501 4502type awsAwsjson11_deserializeOpUntagLogGroup struct { 4503} 4504 4505func (*awsAwsjson11_deserializeOpUntagLogGroup) ID() string { 4506 return "OperationDeserializer" 4507} 4508 4509func (m *awsAwsjson11_deserializeOpUntagLogGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4510 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4511) { 4512 out, metadata, err = next.HandleDeserialize(ctx, in) 4513 if err != nil { 4514 return out, metadata, err 4515 } 4516 4517 response, ok := out.RawResponse.(*smithyhttp.Response) 4518 if !ok { 4519 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4520 } 4521 4522 if response.StatusCode < 200 || response.StatusCode >= 300 { 4523 return out, metadata, awsAwsjson11_deserializeOpErrorUntagLogGroup(response, &metadata) 4524 } 4525 output := &UntagLogGroupOutput{} 4526 out.Result = output 4527 4528 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 4529 return out, metadata, &smithy.DeserializationError{ 4530 Err: fmt.Errorf("failed to discard response body, %w", err), 4531 } 4532 } 4533 4534 return out, metadata, err 4535} 4536 4537func awsAwsjson11_deserializeOpErrorUntagLogGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4538 var errorBuffer bytes.Buffer 4539 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4540 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4541 } 4542 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4543 4544 errorCode := "UnknownError" 4545 errorMessage := errorCode 4546 4547 code := response.Header.Get("X-Amzn-ErrorType") 4548 if len(code) != 0 { 4549 errorCode = restjson.SanitizeErrorCode(code) 4550 } 4551 4552 var buff [1024]byte 4553 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4554 4555 body := io.TeeReader(errorBody, ringBuffer) 4556 decoder := json.NewDecoder(body) 4557 decoder.UseNumber() 4558 code, message, err := restjson.GetErrorInfo(decoder) 4559 if err != nil { 4560 var snapshot bytes.Buffer 4561 io.Copy(&snapshot, ringBuffer) 4562 err = &smithy.DeserializationError{ 4563 Err: fmt.Errorf("failed to decode response body, %w", err), 4564 Snapshot: snapshot.Bytes(), 4565 } 4566 return err 4567 } 4568 4569 errorBody.Seek(0, io.SeekStart) 4570 if len(code) != 0 { 4571 errorCode = restjson.SanitizeErrorCode(code) 4572 } 4573 if len(message) != 0 { 4574 errorMessage = message 4575 } 4576 4577 switch { 4578 case strings.EqualFold("ResourceNotFoundException", errorCode): 4579 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4580 4581 default: 4582 genericError := &smithy.GenericAPIError{ 4583 Code: errorCode, 4584 Message: errorMessage, 4585 } 4586 return genericError 4587 4588 } 4589} 4590 4591func awsAwsjson11_deserializeErrorDataAlreadyAcceptedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4592 var buff [1024]byte 4593 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4594 4595 body := io.TeeReader(errorBody, ringBuffer) 4596 decoder := json.NewDecoder(body) 4597 decoder.UseNumber() 4598 var shape interface{} 4599 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4600 var snapshot bytes.Buffer 4601 io.Copy(&snapshot, ringBuffer) 4602 err = &smithy.DeserializationError{ 4603 Err: fmt.Errorf("failed to decode response body, %w", err), 4604 Snapshot: snapshot.Bytes(), 4605 } 4606 return err 4607 } 4608 4609 output := &types.DataAlreadyAcceptedException{} 4610 err := awsAwsjson11_deserializeDocumentDataAlreadyAcceptedException(&output, shape) 4611 4612 if err != nil { 4613 var snapshot bytes.Buffer 4614 io.Copy(&snapshot, ringBuffer) 4615 err = &smithy.DeserializationError{ 4616 Err: fmt.Errorf("failed to decode response body, %w", err), 4617 Snapshot: snapshot.Bytes(), 4618 } 4619 return err 4620 } 4621 4622 errorBody.Seek(0, io.SeekStart) 4623 return output 4624} 4625 4626func awsAwsjson11_deserializeErrorInvalidOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4627 var buff [1024]byte 4628 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4629 4630 body := io.TeeReader(errorBody, ringBuffer) 4631 decoder := json.NewDecoder(body) 4632 decoder.UseNumber() 4633 var shape interface{} 4634 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4635 var snapshot bytes.Buffer 4636 io.Copy(&snapshot, ringBuffer) 4637 err = &smithy.DeserializationError{ 4638 Err: fmt.Errorf("failed to decode response body, %w", err), 4639 Snapshot: snapshot.Bytes(), 4640 } 4641 return err 4642 } 4643 4644 output := &types.InvalidOperationException{} 4645 err := awsAwsjson11_deserializeDocumentInvalidOperationException(&output, shape) 4646 4647 if err != nil { 4648 var snapshot bytes.Buffer 4649 io.Copy(&snapshot, ringBuffer) 4650 err = &smithy.DeserializationError{ 4651 Err: fmt.Errorf("failed to decode response body, %w", err), 4652 Snapshot: snapshot.Bytes(), 4653 } 4654 return err 4655 } 4656 4657 errorBody.Seek(0, io.SeekStart) 4658 return output 4659} 4660 4661func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4662 var buff [1024]byte 4663 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4664 4665 body := io.TeeReader(errorBody, ringBuffer) 4666 decoder := json.NewDecoder(body) 4667 decoder.UseNumber() 4668 var shape interface{} 4669 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4670 var snapshot bytes.Buffer 4671 io.Copy(&snapshot, ringBuffer) 4672 err = &smithy.DeserializationError{ 4673 Err: fmt.Errorf("failed to decode response body, %w", err), 4674 Snapshot: snapshot.Bytes(), 4675 } 4676 return err 4677 } 4678 4679 output := &types.InvalidParameterException{} 4680 err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape) 4681 4682 if err != nil { 4683 var snapshot bytes.Buffer 4684 io.Copy(&snapshot, ringBuffer) 4685 err = &smithy.DeserializationError{ 4686 Err: fmt.Errorf("failed to decode response body, %w", err), 4687 Snapshot: snapshot.Bytes(), 4688 } 4689 return err 4690 } 4691 4692 errorBody.Seek(0, io.SeekStart) 4693 return output 4694} 4695 4696func awsAwsjson11_deserializeErrorInvalidSequenceTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4697 var buff [1024]byte 4698 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4699 4700 body := io.TeeReader(errorBody, ringBuffer) 4701 decoder := json.NewDecoder(body) 4702 decoder.UseNumber() 4703 var shape interface{} 4704 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4705 var snapshot bytes.Buffer 4706 io.Copy(&snapshot, ringBuffer) 4707 err = &smithy.DeserializationError{ 4708 Err: fmt.Errorf("failed to decode response body, %w", err), 4709 Snapshot: snapshot.Bytes(), 4710 } 4711 return err 4712 } 4713 4714 output := &types.InvalidSequenceTokenException{} 4715 err := awsAwsjson11_deserializeDocumentInvalidSequenceTokenException(&output, shape) 4716 4717 if err != nil { 4718 var snapshot bytes.Buffer 4719 io.Copy(&snapshot, ringBuffer) 4720 err = &smithy.DeserializationError{ 4721 Err: fmt.Errorf("failed to decode response body, %w", err), 4722 Snapshot: snapshot.Bytes(), 4723 } 4724 return err 4725 } 4726 4727 errorBody.Seek(0, io.SeekStart) 4728 return output 4729} 4730 4731func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4732 var buff [1024]byte 4733 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4734 4735 body := io.TeeReader(errorBody, ringBuffer) 4736 decoder := json.NewDecoder(body) 4737 decoder.UseNumber() 4738 var shape interface{} 4739 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4740 var snapshot bytes.Buffer 4741 io.Copy(&snapshot, ringBuffer) 4742 err = &smithy.DeserializationError{ 4743 Err: fmt.Errorf("failed to decode response body, %w", err), 4744 Snapshot: snapshot.Bytes(), 4745 } 4746 return err 4747 } 4748 4749 output := &types.LimitExceededException{} 4750 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 4751 4752 if err != nil { 4753 var snapshot bytes.Buffer 4754 io.Copy(&snapshot, ringBuffer) 4755 err = &smithy.DeserializationError{ 4756 Err: fmt.Errorf("failed to decode response body, %w", err), 4757 Snapshot: snapshot.Bytes(), 4758 } 4759 return err 4760 } 4761 4762 errorBody.Seek(0, io.SeekStart) 4763 return output 4764} 4765 4766func awsAwsjson11_deserializeErrorMalformedQueryException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4767 var buff [1024]byte 4768 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4769 4770 body := io.TeeReader(errorBody, ringBuffer) 4771 decoder := json.NewDecoder(body) 4772 decoder.UseNumber() 4773 var shape interface{} 4774 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4775 var snapshot bytes.Buffer 4776 io.Copy(&snapshot, ringBuffer) 4777 err = &smithy.DeserializationError{ 4778 Err: fmt.Errorf("failed to decode response body, %w", err), 4779 Snapshot: snapshot.Bytes(), 4780 } 4781 return err 4782 } 4783 4784 output := &types.MalformedQueryException{} 4785 err := awsAwsjson11_deserializeDocumentMalformedQueryException(&output, shape) 4786 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 err 4795 } 4796 4797 errorBody.Seek(0, io.SeekStart) 4798 return output 4799} 4800 4801func awsAwsjson11_deserializeErrorOperationAbortedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4802 var buff [1024]byte 4803 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4804 4805 body := io.TeeReader(errorBody, ringBuffer) 4806 decoder := json.NewDecoder(body) 4807 decoder.UseNumber() 4808 var shape interface{} 4809 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4810 var snapshot bytes.Buffer 4811 io.Copy(&snapshot, ringBuffer) 4812 err = &smithy.DeserializationError{ 4813 Err: fmt.Errorf("failed to decode response body, %w", err), 4814 Snapshot: snapshot.Bytes(), 4815 } 4816 return err 4817 } 4818 4819 output := &types.OperationAbortedException{} 4820 err := awsAwsjson11_deserializeDocumentOperationAbortedException(&output, shape) 4821 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 return output 4834} 4835 4836func awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4837 var buff [1024]byte 4838 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4839 4840 body := io.TeeReader(errorBody, ringBuffer) 4841 decoder := json.NewDecoder(body) 4842 decoder.UseNumber() 4843 var shape interface{} 4844 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4845 var snapshot bytes.Buffer 4846 io.Copy(&snapshot, ringBuffer) 4847 err = &smithy.DeserializationError{ 4848 Err: fmt.Errorf("failed to decode response body, %w", err), 4849 Snapshot: snapshot.Bytes(), 4850 } 4851 return err 4852 } 4853 4854 output := &types.ResourceAlreadyExistsException{} 4855 err := awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(&output, shape) 4856 4857 if err != nil { 4858 var snapshot bytes.Buffer 4859 io.Copy(&snapshot, ringBuffer) 4860 err = &smithy.DeserializationError{ 4861 Err: fmt.Errorf("failed to decode response body, %w", err), 4862 Snapshot: snapshot.Bytes(), 4863 } 4864 return err 4865 } 4866 4867 errorBody.Seek(0, io.SeekStart) 4868 return output 4869} 4870 4871func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4872 var buff [1024]byte 4873 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4874 4875 body := io.TeeReader(errorBody, ringBuffer) 4876 decoder := json.NewDecoder(body) 4877 decoder.UseNumber() 4878 var shape interface{} 4879 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4880 var snapshot bytes.Buffer 4881 io.Copy(&snapshot, ringBuffer) 4882 err = &smithy.DeserializationError{ 4883 Err: fmt.Errorf("failed to decode response body, %w", err), 4884 Snapshot: snapshot.Bytes(), 4885 } 4886 return err 4887 } 4888 4889 output := &types.ResourceNotFoundException{} 4890 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 4891 4892 if err != nil { 4893 var snapshot bytes.Buffer 4894 io.Copy(&snapshot, ringBuffer) 4895 err = &smithy.DeserializationError{ 4896 Err: fmt.Errorf("failed to decode response body, %w", err), 4897 Snapshot: snapshot.Bytes(), 4898 } 4899 return err 4900 } 4901 4902 errorBody.Seek(0, io.SeekStart) 4903 return output 4904} 4905 4906func awsAwsjson11_deserializeErrorServiceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4907 var buff [1024]byte 4908 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4909 4910 body := io.TeeReader(errorBody, ringBuffer) 4911 decoder := json.NewDecoder(body) 4912 decoder.UseNumber() 4913 var shape interface{} 4914 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4915 var snapshot bytes.Buffer 4916 io.Copy(&snapshot, ringBuffer) 4917 err = &smithy.DeserializationError{ 4918 Err: fmt.Errorf("failed to decode response body, %w", err), 4919 Snapshot: snapshot.Bytes(), 4920 } 4921 return err 4922 } 4923 4924 output := &types.ServiceUnavailableException{} 4925 err := awsAwsjson11_deserializeDocumentServiceUnavailableException(&output, shape) 4926 4927 if err != nil { 4928 var snapshot bytes.Buffer 4929 io.Copy(&snapshot, ringBuffer) 4930 err = &smithy.DeserializationError{ 4931 Err: fmt.Errorf("failed to decode response body, %w", err), 4932 Snapshot: snapshot.Bytes(), 4933 } 4934 return err 4935 } 4936 4937 errorBody.Seek(0, io.SeekStart) 4938 return output 4939} 4940 4941func awsAwsjson11_deserializeErrorUnrecognizedClientException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4942 var buff [1024]byte 4943 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4944 4945 body := io.TeeReader(errorBody, ringBuffer) 4946 decoder := json.NewDecoder(body) 4947 decoder.UseNumber() 4948 var shape interface{} 4949 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4950 var snapshot bytes.Buffer 4951 io.Copy(&snapshot, ringBuffer) 4952 err = &smithy.DeserializationError{ 4953 Err: fmt.Errorf("failed to decode response body, %w", err), 4954 Snapshot: snapshot.Bytes(), 4955 } 4956 return err 4957 } 4958 4959 output := &types.UnrecognizedClientException{} 4960 err := awsAwsjson11_deserializeDocumentUnrecognizedClientException(&output, shape) 4961 4962 if err != nil { 4963 var snapshot bytes.Buffer 4964 io.Copy(&snapshot, ringBuffer) 4965 err = &smithy.DeserializationError{ 4966 Err: fmt.Errorf("failed to decode response body, %w", err), 4967 Snapshot: snapshot.Bytes(), 4968 } 4969 return err 4970 } 4971 4972 errorBody.Seek(0, io.SeekStart) 4973 return output 4974} 4975 4976func awsAwsjson11_deserializeDocumentDataAlreadyAcceptedException(v **types.DataAlreadyAcceptedException, value interface{}) error { 4977 if v == nil { 4978 return fmt.Errorf("unexpected nil of type %T", v) 4979 } 4980 if value == nil { 4981 return nil 4982 } 4983 4984 shape, ok := value.(map[string]interface{}) 4985 if !ok { 4986 return fmt.Errorf("unexpected JSON type %v", value) 4987 } 4988 4989 var sv *types.DataAlreadyAcceptedException 4990 if *v == nil { 4991 sv = &types.DataAlreadyAcceptedException{} 4992 } else { 4993 sv = *v 4994 } 4995 4996 for key, value := range shape { 4997 switch key { 4998 case "expectedSequenceToken": 4999 if value != nil { 5000 jtv, ok := value.(string) 5001 if !ok { 5002 return fmt.Errorf("expected SequenceToken to be of type string, got %T instead", value) 5003 } 5004 sv.ExpectedSequenceToken = ptr.String(jtv) 5005 } 5006 5007 case "message": 5008 if value != nil { 5009 jtv, ok := value.(string) 5010 if !ok { 5011 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5012 } 5013 sv.Message = ptr.String(jtv) 5014 } 5015 5016 default: 5017 _, _ = key, value 5018 5019 } 5020 } 5021 *v = sv 5022 return nil 5023} 5024 5025func awsAwsjson11_deserializeDocumentDestination(v **types.Destination, value interface{}) error { 5026 if v == nil { 5027 return fmt.Errorf("unexpected nil of type %T", v) 5028 } 5029 if value == nil { 5030 return nil 5031 } 5032 5033 shape, ok := value.(map[string]interface{}) 5034 if !ok { 5035 return fmt.Errorf("unexpected JSON type %v", value) 5036 } 5037 5038 var sv *types.Destination 5039 if *v == nil { 5040 sv = &types.Destination{} 5041 } else { 5042 sv = *v 5043 } 5044 5045 for key, value := range shape { 5046 switch key { 5047 case "accessPolicy": 5048 if value != nil { 5049 jtv, ok := value.(string) 5050 if !ok { 5051 return fmt.Errorf("expected AccessPolicy to be of type string, got %T instead", value) 5052 } 5053 sv.AccessPolicy = ptr.String(jtv) 5054 } 5055 5056 case "arn": 5057 if value != nil { 5058 jtv, ok := value.(string) 5059 if !ok { 5060 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 5061 } 5062 sv.Arn = ptr.String(jtv) 5063 } 5064 5065 case "creationTime": 5066 if value != nil { 5067 jtv, ok := value.(json.Number) 5068 if !ok { 5069 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5070 } 5071 i64, err := jtv.Int64() 5072 if err != nil { 5073 return err 5074 } 5075 sv.CreationTime = ptr.Int64(i64) 5076 } 5077 5078 case "destinationName": 5079 if value != nil { 5080 jtv, ok := value.(string) 5081 if !ok { 5082 return fmt.Errorf("expected DestinationName to be of type string, got %T instead", value) 5083 } 5084 sv.DestinationName = ptr.String(jtv) 5085 } 5086 5087 case "roleArn": 5088 if value != nil { 5089 jtv, ok := value.(string) 5090 if !ok { 5091 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 5092 } 5093 sv.RoleArn = ptr.String(jtv) 5094 } 5095 5096 case "targetArn": 5097 if value != nil { 5098 jtv, ok := value.(string) 5099 if !ok { 5100 return fmt.Errorf("expected TargetArn to be of type string, got %T instead", value) 5101 } 5102 sv.TargetArn = ptr.String(jtv) 5103 } 5104 5105 default: 5106 _, _ = key, value 5107 5108 } 5109 } 5110 *v = sv 5111 return nil 5112} 5113 5114func awsAwsjson11_deserializeDocumentDestinations(v *[]types.Destination, value interface{}) error { 5115 if v == nil { 5116 return fmt.Errorf("unexpected nil of type %T", v) 5117 } 5118 if value == nil { 5119 return nil 5120 } 5121 5122 shape, ok := value.([]interface{}) 5123 if !ok { 5124 return fmt.Errorf("unexpected JSON type %v", value) 5125 } 5126 5127 var cv []types.Destination 5128 if *v == nil { 5129 cv = []types.Destination{} 5130 } else { 5131 cv = *v 5132 } 5133 5134 for _, value := range shape { 5135 var col types.Destination 5136 destAddr := &col 5137 if err := awsAwsjson11_deserializeDocumentDestination(&destAddr, value); err != nil { 5138 return err 5139 } 5140 col = *destAddr 5141 cv = append(cv, col) 5142 5143 } 5144 *v = cv 5145 return nil 5146} 5147 5148func awsAwsjson11_deserializeDocumentExportTask(v **types.ExportTask, value interface{}) error { 5149 if v == nil { 5150 return fmt.Errorf("unexpected nil of type %T", v) 5151 } 5152 if value == nil { 5153 return nil 5154 } 5155 5156 shape, ok := value.(map[string]interface{}) 5157 if !ok { 5158 return fmt.Errorf("unexpected JSON type %v", value) 5159 } 5160 5161 var sv *types.ExportTask 5162 if *v == nil { 5163 sv = &types.ExportTask{} 5164 } else { 5165 sv = *v 5166 } 5167 5168 for key, value := range shape { 5169 switch key { 5170 case "destination": 5171 if value != nil { 5172 jtv, ok := value.(string) 5173 if !ok { 5174 return fmt.Errorf("expected ExportDestinationBucket to be of type string, got %T instead", value) 5175 } 5176 sv.Destination = ptr.String(jtv) 5177 } 5178 5179 case "destinationPrefix": 5180 if value != nil { 5181 jtv, ok := value.(string) 5182 if !ok { 5183 return fmt.Errorf("expected ExportDestinationPrefix to be of type string, got %T instead", value) 5184 } 5185 sv.DestinationPrefix = ptr.String(jtv) 5186 } 5187 5188 case "executionInfo": 5189 if err := awsAwsjson11_deserializeDocumentExportTaskExecutionInfo(&sv.ExecutionInfo, value); err != nil { 5190 return err 5191 } 5192 5193 case "from": 5194 if value != nil { 5195 jtv, ok := value.(json.Number) 5196 if !ok { 5197 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5198 } 5199 i64, err := jtv.Int64() 5200 if err != nil { 5201 return err 5202 } 5203 sv.From = ptr.Int64(i64) 5204 } 5205 5206 case "logGroupName": 5207 if value != nil { 5208 jtv, ok := value.(string) 5209 if !ok { 5210 return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) 5211 } 5212 sv.LogGroupName = ptr.String(jtv) 5213 } 5214 5215 case "status": 5216 if err := awsAwsjson11_deserializeDocumentExportTaskStatus(&sv.Status, value); err != nil { 5217 return err 5218 } 5219 5220 case "taskId": 5221 if value != nil { 5222 jtv, ok := value.(string) 5223 if !ok { 5224 return fmt.Errorf("expected ExportTaskId to be of type string, got %T instead", value) 5225 } 5226 sv.TaskId = ptr.String(jtv) 5227 } 5228 5229 case "taskName": 5230 if value != nil { 5231 jtv, ok := value.(string) 5232 if !ok { 5233 return fmt.Errorf("expected ExportTaskName to be of type string, got %T instead", value) 5234 } 5235 sv.TaskName = ptr.String(jtv) 5236 } 5237 5238 case "to": 5239 if value != nil { 5240 jtv, ok := value.(json.Number) 5241 if !ok { 5242 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5243 } 5244 i64, err := jtv.Int64() 5245 if err != nil { 5246 return err 5247 } 5248 sv.To = ptr.Int64(i64) 5249 } 5250 5251 default: 5252 _, _ = key, value 5253 5254 } 5255 } 5256 *v = sv 5257 return nil 5258} 5259 5260func awsAwsjson11_deserializeDocumentExportTaskExecutionInfo(v **types.ExportTaskExecutionInfo, value interface{}) error { 5261 if v == nil { 5262 return fmt.Errorf("unexpected nil of type %T", v) 5263 } 5264 if value == nil { 5265 return nil 5266 } 5267 5268 shape, ok := value.(map[string]interface{}) 5269 if !ok { 5270 return fmt.Errorf("unexpected JSON type %v", value) 5271 } 5272 5273 var sv *types.ExportTaskExecutionInfo 5274 if *v == nil { 5275 sv = &types.ExportTaskExecutionInfo{} 5276 } else { 5277 sv = *v 5278 } 5279 5280 for key, value := range shape { 5281 switch key { 5282 case "completionTime": 5283 if value != nil { 5284 jtv, ok := value.(json.Number) 5285 if !ok { 5286 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5287 } 5288 i64, err := jtv.Int64() 5289 if err != nil { 5290 return err 5291 } 5292 sv.CompletionTime = ptr.Int64(i64) 5293 } 5294 5295 case "creationTime": 5296 if value != nil { 5297 jtv, ok := value.(json.Number) 5298 if !ok { 5299 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5300 } 5301 i64, err := jtv.Int64() 5302 if err != nil { 5303 return err 5304 } 5305 sv.CreationTime = ptr.Int64(i64) 5306 } 5307 5308 default: 5309 _, _ = key, value 5310 5311 } 5312 } 5313 *v = sv 5314 return nil 5315} 5316 5317func awsAwsjson11_deserializeDocumentExportTasks(v *[]types.ExportTask, value interface{}) error { 5318 if v == nil { 5319 return fmt.Errorf("unexpected nil of type %T", v) 5320 } 5321 if value == nil { 5322 return nil 5323 } 5324 5325 shape, ok := value.([]interface{}) 5326 if !ok { 5327 return fmt.Errorf("unexpected JSON type %v", value) 5328 } 5329 5330 var cv []types.ExportTask 5331 if *v == nil { 5332 cv = []types.ExportTask{} 5333 } else { 5334 cv = *v 5335 } 5336 5337 for _, value := range shape { 5338 var col types.ExportTask 5339 destAddr := &col 5340 if err := awsAwsjson11_deserializeDocumentExportTask(&destAddr, value); err != nil { 5341 return err 5342 } 5343 col = *destAddr 5344 cv = append(cv, col) 5345 5346 } 5347 *v = cv 5348 return nil 5349} 5350 5351func awsAwsjson11_deserializeDocumentExportTaskStatus(v **types.ExportTaskStatus, value interface{}) error { 5352 if v == nil { 5353 return fmt.Errorf("unexpected nil of type %T", v) 5354 } 5355 if value == nil { 5356 return nil 5357 } 5358 5359 shape, ok := value.(map[string]interface{}) 5360 if !ok { 5361 return fmt.Errorf("unexpected JSON type %v", value) 5362 } 5363 5364 var sv *types.ExportTaskStatus 5365 if *v == nil { 5366 sv = &types.ExportTaskStatus{} 5367 } else { 5368 sv = *v 5369 } 5370 5371 for key, value := range shape { 5372 switch key { 5373 case "code": 5374 if value != nil { 5375 jtv, ok := value.(string) 5376 if !ok { 5377 return fmt.Errorf("expected ExportTaskStatusCode to be of type string, got %T instead", value) 5378 } 5379 sv.Code = types.ExportTaskStatusCode(jtv) 5380 } 5381 5382 case "message": 5383 if value != nil { 5384 jtv, ok := value.(string) 5385 if !ok { 5386 return fmt.Errorf("expected ExportTaskStatusMessage to be of type string, got %T instead", value) 5387 } 5388 sv.Message = ptr.String(jtv) 5389 } 5390 5391 default: 5392 _, _ = key, value 5393 5394 } 5395 } 5396 *v = sv 5397 return nil 5398} 5399 5400func awsAwsjson11_deserializeDocumentExtractedValues(v *map[string]string, value interface{}) error { 5401 if v == nil { 5402 return fmt.Errorf("unexpected nil of type %T", v) 5403 } 5404 if value == nil { 5405 return nil 5406 } 5407 5408 shape, ok := value.(map[string]interface{}) 5409 if !ok { 5410 return fmt.Errorf("unexpected JSON type %v", value) 5411 } 5412 5413 var mv map[string]string 5414 if *v == nil { 5415 mv = map[string]string{} 5416 } else { 5417 mv = *v 5418 } 5419 5420 for key, value := range shape { 5421 var parsedVal string 5422 if value != nil { 5423 jtv, ok := value.(string) 5424 if !ok { 5425 return fmt.Errorf("expected Value to be of type string, got %T instead", value) 5426 } 5427 parsedVal = jtv 5428 } 5429 mv[key] = parsedVal 5430 5431 } 5432 *v = mv 5433 return nil 5434} 5435 5436func awsAwsjson11_deserializeDocumentFilteredLogEvent(v **types.FilteredLogEvent, value interface{}) error { 5437 if v == nil { 5438 return fmt.Errorf("unexpected nil of type %T", v) 5439 } 5440 if value == nil { 5441 return nil 5442 } 5443 5444 shape, ok := value.(map[string]interface{}) 5445 if !ok { 5446 return fmt.Errorf("unexpected JSON type %v", value) 5447 } 5448 5449 var sv *types.FilteredLogEvent 5450 if *v == nil { 5451 sv = &types.FilteredLogEvent{} 5452 } else { 5453 sv = *v 5454 } 5455 5456 for key, value := range shape { 5457 switch key { 5458 case "eventId": 5459 if value != nil { 5460 jtv, ok := value.(string) 5461 if !ok { 5462 return fmt.Errorf("expected EventId to be of type string, got %T instead", value) 5463 } 5464 sv.EventId = ptr.String(jtv) 5465 } 5466 5467 case "ingestionTime": 5468 if value != nil { 5469 jtv, ok := value.(json.Number) 5470 if !ok { 5471 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5472 } 5473 i64, err := jtv.Int64() 5474 if err != nil { 5475 return err 5476 } 5477 sv.IngestionTime = ptr.Int64(i64) 5478 } 5479 5480 case "logStreamName": 5481 if value != nil { 5482 jtv, ok := value.(string) 5483 if !ok { 5484 return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) 5485 } 5486 sv.LogStreamName = ptr.String(jtv) 5487 } 5488 5489 case "message": 5490 if value != nil { 5491 jtv, ok := value.(string) 5492 if !ok { 5493 return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) 5494 } 5495 sv.Message = ptr.String(jtv) 5496 } 5497 5498 case "timestamp": 5499 if value != nil { 5500 jtv, ok := value.(json.Number) 5501 if !ok { 5502 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5503 } 5504 i64, err := jtv.Int64() 5505 if err != nil { 5506 return err 5507 } 5508 sv.Timestamp = ptr.Int64(i64) 5509 } 5510 5511 default: 5512 _, _ = key, value 5513 5514 } 5515 } 5516 *v = sv 5517 return nil 5518} 5519 5520func awsAwsjson11_deserializeDocumentFilteredLogEvents(v *[]types.FilteredLogEvent, value interface{}) error { 5521 if v == nil { 5522 return fmt.Errorf("unexpected nil of type %T", v) 5523 } 5524 if value == nil { 5525 return nil 5526 } 5527 5528 shape, ok := value.([]interface{}) 5529 if !ok { 5530 return fmt.Errorf("unexpected JSON type %v", value) 5531 } 5532 5533 var cv []types.FilteredLogEvent 5534 if *v == nil { 5535 cv = []types.FilteredLogEvent{} 5536 } else { 5537 cv = *v 5538 } 5539 5540 for _, value := range shape { 5541 var col types.FilteredLogEvent 5542 destAddr := &col 5543 if err := awsAwsjson11_deserializeDocumentFilteredLogEvent(&destAddr, value); err != nil { 5544 return err 5545 } 5546 col = *destAddr 5547 cv = append(cv, col) 5548 5549 } 5550 *v = cv 5551 return nil 5552} 5553 5554func awsAwsjson11_deserializeDocumentInvalidOperationException(v **types.InvalidOperationException, value interface{}) error { 5555 if v == nil { 5556 return fmt.Errorf("unexpected nil of type %T", v) 5557 } 5558 if value == nil { 5559 return nil 5560 } 5561 5562 shape, ok := value.(map[string]interface{}) 5563 if !ok { 5564 return fmt.Errorf("unexpected JSON type %v", value) 5565 } 5566 5567 var sv *types.InvalidOperationException 5568 if *v == nil { 5569 sv = &types.InvalidOperationException{} 5570 } else { 5571 sv = *v 5572 } 5573 5574 for key, value := range shape { 5575 switch key { 5576 case "message": 5577 if value != nil { 5578 jtv, ok := value.(string) 5579 if !ok { 5580 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5581 } 5582 sv.Message = ptr.String(jtv) 5583 } 5584 5585 default: 5586 _, _ = key, value 5587 5588 } 5589 } 5590 *v = sv 5591 return nil 5592} 5593 5594func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error { 5595 if v == nil { 5596 return fmt.Errorf("unexpected nil of type %T", v) 5597 } 5598 if value == nil { 5599 return nil 5600 } 5601 5602 shape, ok := value.(map[string]interface{}) 5603 if !ok { 5604 return fmt.Errorf("unexpected JSON type %v", value) 5605 } 5606 5607 var sv *types.InvalidParameterException 5608 if *v == nil { 5609 sv = &types.InvalidParameterException{} 5610 } else { 5611 sv = *v 5612 } 5613 5614 for key, value := range shape { 5615 switch key { 5616 case "message": 5617 if value != nil { 5618 jtv, ok := value.(string) 5619 if !ok { 5620 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5621 } 5622 sv.Message = ptr.String(jtv) 5623 } 5624 5625 default: 5626 _, _ = key, value 5627 5628 } 5629 } 5630 *v = sv 5631 return nil 5632} 5633 5634func awsAwsjson11_deserializeDocumentInvalidSequenceTokenException(v **types.InvalidSequenceTokenException, value interface{}) error { 5635 if v == nil { 5636 return fmt.Errorf("unexpected nil of type %T", v) 5637 } 5638 if value == nil { 5639 return nil 5640 } 5641 5642 shape, ok := value.(map[string]interface{}) 5643 if !ok { 5644 return fmt.Errorf("unexpected JSON type %v", value) 5645 } 5646 5647 var sv *types.InvalidSequenceTokenException 5648 if *v == nil { 5649 sv = &types.InvalidSequenceTokenException{} 5650 } else { 5651 sv = *v 5652 } 5653 5654 for key, value := range shape { 5655 switch key { 5656 case "expectedSequenceToken": 5657 if value != nil { 5658 jtv, ok := value.(string) 5659 if !ok { 5660 return fmt.Errorf("expected SequenceToken to be of type string, got %T instead", value) 5661 } 5662 sv.ExpectedSequenceToken = ptr.String(jtv) 5663 } 5664 5665 case "message": 5666 if value != nil { 5667 jtv, ok := value.(string) 5668 if !ok { 5669 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5670 } 5671 sv.Message = ptr.String(jtv) 5672 } 5673 5674 default: 5675 _, _ = key, value 5676 5677 } 5678 } 5679 *v = sv 5680 return nil 5681} 5682 5683func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 5684 if v == nil { 5685 return fmt.Errorf("unexpected nil of type %T", v) 5686 } 5687 if value == nil { 5688 return nil 5689 } 5690 5691 shape, ok := value.(map[string]interface{}) 5692 if !ok { 5693 return fmt.Errorf("unexpected JSON type %v", value) 5694 } 5695 5696 var sv *types.LimitExceededException 5697 if *v == nil { 5698 sv = &types.LimitExceededException{} 5699 } else { 5700 sv = *v 5701 } 5702 5703 for key, value := range shape { 5704 switch key { 5705 case "message": 5706 if value != nil { 5707 jtv, ok := value.(string) 5708 if !ok { 5709 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5710 } 5711 sv.Message = ptr.String(jtv) 5712 } 5713 5714 default: 5715 _, _ = key, value 5716 5717 } 5718 } 5719 *v = sv 5720 return nil 5721} 5722 5723func awsAwsjson11_deserializeDocumentLogGroup(v **types.LogGroup, value interface{}) error { 5724 if v == nil { 5725 return fmt.Errorf("unexpected nil of type %T", v) 5726 } 5727 if value == nil { 5728 return nil 5729 } 5730 5731 shape, ok := value.(map[string]interface{}) 5732 if !ok { 5733 return fmt.Errorf("unexpected JSON type %v", value) 5734 } 5735 5736 var sv *types.LogGroup 5737 if *v == nil { 5738 sv = &types.LogGroup{} 5739 } else { 5740 sv = *v 5741 } 5742 5743 for key, value := range shape { 5744 switch key { 5745 case "arn": 5746 if value != nil { 5747 jtv, ok := value.(string) 5748 if !ok { 5749 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 5750 } 5751 sv.Arn = ptr.String(jtv) 5752 } 5753 5754 case "creationTime": 5755 if value != nil { 5756 jtv, ok := value.(json.Number) 5757 if !ok { 5758 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5759 } 5760 i64, err := jtv.Int64() 5761 if err != nil { 5762 return err 5763 } 5764 sv.CreationTime = ptr.Int64(i64) 5765 } 5766 5767 case "kmsKeyId": 5768 if value != nil { 5769 jtv, ok := value.(string) 5770 if !ok { 5771 return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) 5772 } 5773 sv.KmsKeyId = ptr.String(jtv) 5774 } 5775 5776 case "logGroupName": 5777 if value != nil { 5778 jtv, ok := value.(string) 5779 if !ok { 5780 return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) 5781 } 5782 sv.LogGroupName = ptr.String(jtv) 5783 } 5784 5785 case "metricFilterCount": 5786 if value != nil { 5787 jtv, ok := value.(json.Number) 5788 if !ok { 5789 return fmt.Errorf("expected FilterCount to be json.Number, got %T instead", value) 5790 } 5791 i64, err := jtv.Int64() 5792 if err != nil { 5793 return err 5794 } 5795 sv.MetricFilterCount = ptr.Int32(int32(i64)) 5796 } 5797 5798 case "retentionInDays": 5799 if value != nil { 5800 jtv, ok := value.(json.Number) 5801 if !ok { 5802 return fmt.Errorf("expected Days to be json.Number, got %T instead", value) 5803 } 5804 i64, err := jtv.Int64() 5805 if err != nil { 5806 return err 5807 } 5808 sv.RetentionInDays = ptr.Int32(int32(i64)) 5809 } 5810 5811 case "storedBytes": 5812 if value != nil { 5813 jtv, ok := value.(json.Number) 5814 if !ok { 5815 return fmt.Errorf("expected StoredBytes to be json.Number, got %T instead", value) 5816 } 5817 i64, err := jtv.Int64() 5818 if err != nil { 5819 return err 5820 } 5821 sv.StoredBytes = ptr.Int64(i64) 5822 } 5823 5824 default: 5825 _, _ = key, value 5826 5827 } 5828 } 5829 *v = sv 5830 return nil 5831} 5832 5833func awsAwsjson11_deserializeDocumentLogGroupField(v **types.LogGroupField, value interface{}) error { 5834 if v == nil { 5835 return fmt.Errorf("unexpected nil of type %T", v) 5836 } 5837 if value == nil { 5838 return nil 5839 } 5840 5841 shape, ok := value.(map[string]interface{}) 5842 if !ok { 5843 return fmt.Errorf("unexpected JSON type %v", value) 5844 } 5845 5846 var sv *types.LogGroupField 5847 if *v == nil { 5848 sv = &types.LogGroupField{} 5849 } else { 5850 sv = *v 5851 } 5852 5853 for key, value := range shape { 5854 switch key { 5855 case "name": 5856 if value != nil { 5857 jtv, ok := value.(string) 5858 if !ok { 5859 return fmt.Errorf("expected Field to be of type string, got %T instead", value) 5860 } 5861 sv.Name = ptr.String(jtv) 5862 } 5863 5864 case "percent": 5865 if value != nil { 5866 jtv, ok := value.(json.Number) 5867 if !ok { 5868 return fmt.Errorf("expected Percentage to be json.Number, got %T instead", value) 5869 } 5870 i64, err := jtv.Int64() 5871 if err != nil { 5872 return err 5873 } 5874 sv.Percent = int32(i64) 5875 } 5876 5877 default: 5878 _, _ = key, value 5879 5880 } 5881 } 5882 *v = sv 5883 return nil 5884} 5885 5886func awsAwsjson11_deserializeDocumentLogGroupFieldList(v *[]types.LogGroupField, value interface{}) error { 5887 if v == nil { 5888 return fmt.Errorf("unexpected nil of type %T", v) 5889 } 5890 if value == nil { 5891 return nil 5892 } 5893 5894 shape, ok := value.([]interface{}) 5895 if !ok { 5896 return fmt.Errorf("unexpected JSON type %v", value) 5897 } 5898 5899 var cv []types.LogGroupField 5900 if *v == nil { 5901 cv = []types.LogGroupField{} 5902 } else { 5903 cv = *v 5904 } 5905 5906 for _, value := range shape { 5907 var col types.LogGroupField 5908 destAddr := &col 5909 if err := awsAwsjson11_deserializeDocumentLogGroupField(&destAddr, value); err != nil { 5910 return err 5911 } 5912 col = *destAddr 5913 cv = append(cv, col) 5914 5915 } 5916 *v = cv 5917 return nil 5918} 5919 5920func awsAwsjson11_deserializeDocumentLogGroupNames(v *[]string, value interface{}) error { 5921 if v == nil { 5922 return fmt.Errorf("unexpected nil of type %T", v) 5923 } 5924 if value == nil { 5925 return nil 5926 } 5927 5928 shape, ok := value.([]interface{}) 5929 if !ok { 5930 return fmt.Errorf("unexpected JSON type %v", value) 5931 } 5932 5933 var cv []string 5934 if *v == nil { 5935 cv = []string{} 5936 } else { 5937 cv = *v 5938 } 5939 5940 for _, value := range shape { 5941 var col string 5942 if value != nil { 5943 jtv, ok := value.(string) 5944 if !ok { 5945 return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) 5946 } 5947 col = jtv 5948 } 5949 cv = append(cv, col) 5950 5951 } 5952 *v = cv 5953 return nil 5954} 5955 5956func awsAwsjson11_deserializeDocumentLogGroups(v *[]types.LogGroup, value interface{}) error { 5957 if v == nil { 5958 return fmt.Errorf("unexpected nil of type %T", v) 5959 } 5960 if value == nil { 5961 return nil 5962 } 5963 5964 shape, ok := value.([]interface{}) 5965 if !ok { 5966 return fmt.Errorf("unexpected JSON type %v", value) 5967 } 5968 5969 var cv []types.LogGroup 5970 if *v == nil { 5971 cv = []types.LogGroup{} 5972 } else { 5973 cv = *v 5974 } 5975 5976 for _, value := range shape { 5977 var col types.LogGroup 5978 destAddr := &col 5979 if err := awsAwsjson11_deserializeDocumentLogGroup(&destAddr, value); err != nil { 5980 return err 5981 } 5982 col = *destAddr 5983 cv = append(cv, col) 5984 5985 } 5986 *v = cv 5987 return nil 5988} 5989 5990func awsAwsjson11_deserializeDocumentLogRecord(v *map[string]string, value interface{}) error { 5991 if v == nil { 5992 return fmt.Errorf("unexpected nil of type %T", v) 5993 } 5994 if value == nil { 5995 return nil 5996 } 5997 5998 shape, ok := value.(map[string]interface{}) 5999 if !ok { 6000 return fmt.Errorf("unexpected JSON type %v", value) 6001 } 6002 6003 var mv map[string]string 6004 if *v == nil { 6005 mv = map[string]string{} 6006 } else { 6007 mv = *v 6008 } 6009 6010 for key, value := range shape { 6011 var parsedVal string 6012 if value != nil { 6013 jtv, ok := value.(string) 6014 if !ok { 6015 return fmt.Errorf("expected Value to be of type string, got %T instead", value) 6016 } 6017 parsedVal = jtv 6018 } 6019 mv[key] = parsedVal 6020 6021 } 6022 *v = mv 6023 return nil 6024} 6025 6026func awsAwsjson11_deserializeDocumentLogStream(v **types.LogStream, value interface{}) error { 6027 if v == nil { 6028 return fmt.Errorf("unexpected nil of type %T", v) 6029 } 6030 if value == nil { 6031 return nil 6032 } 6033 6034 shape, ok := value.(map[string]interface{}) 6035 if !ok { 6036 return fmt.Errorf("unexpected JSON type %v", value) 6037 } 6038 6039 var sv *types.LogStream 6040 if *v == nil { 6041 sv = &types.LogStream{} 6042 } else { 6043 sv = *v 6044 } 6045 6046 for key, value := range shape { 6047 switch key { 6048 case "arn": 6049 if value != nil { 6050 jtv, ok := value.(string) 6051 if !ok { 6052 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6053 } 6054 sv.Arn = ptr.String(jtv) 6055 } 6056 6057 case "creationTime": 6058 if value != nil { 6059 jtv, ok := value.(json.Number) 6060 if !ok { 6061 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6062 } 6063 i64, err := jtv.Int64() 6064 if err != nil { 6065 return err 6066 } 6067 sv.CreationTime = ptr.Int64(i64) 6068 } 6069 6070 case "firstEventTimestamp": 6071 if value != nil { 6072 jtv, ok := value.(json.Number) 6073 if !ok { 6074 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6075 } 6076 i64, err := jtv.Int64() 6077 if err != nil { 6078 return err 6079 } 6080 sv.FirstEventTimestamp = ptr.Int64(i64) 6081 } 6082 6083 case "lastEventTimestamp": 6084 if value != nil { 6085 jtv, ok := value.(json.Number) 6086 if !ok { 6087 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6088 } 6089 i64, err := jtv.Int64() 6090 if err != nil { 6091 return err 6092 } 6093 sv.LastEventTimestamp = ptr.Int64(i64) 6094 } 6095 6096 case "lastIngestionTime": 6097 if value != nil { 6098 jtv, ok := value.(json.Number) 6099 if !ok { 6100 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6101 } 6102 i64, err := jtv.Int64() 6103 if err != nil { 6104 return err 6105 } 6106 sv.LastIngestionTime = ptr.Int64(i64) 6107 } 6108 6109 case "logStreamName": 6110 if value != nil { 6111 jtv, ok := value.(string) 6112 if !ok { 6113 return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) 6114 } 6115 sv.LogStreamName = ptr.String(jtv) 6116 } 6117 6118 case "storedBytes": 6119 if value != nil { 6120 jtv, ok := value.(json.Number) 6121 if !ok { 6122 return fmt.Errorf("expected StoredBytes to be json.Number, got %T instead", value) 6123 } 6124 i64, err := jtv.Int64() 6125 if err != nil { 6126 return err 6127 } 6128 sv.StoredBytes = ptr.Int64(i64) 6129 } 6130 6131 case "uploadSequenceToken": 6132 if value != nil { 6133 jtv, ok := value.(string) 6134 if !ok { 6135 return fmt.Errorf("expected SequenceToken to be of type string, got %T instead", value) 6136 } 6137 sv.UploadSequenceToken = ptr.String(jtv) 6138 } 6139 6140 default: 6141 _, _ = key, value 6142 6143 } 6144 } 6145 *v = sv 6146 return nil 6147} 6148 6149func awsAwsjson11_deserializeDocumentLogStreams(v *[]types.LogStream, value interface{}) error { 6150 if v == nil { 6151 return fmt.Errorf("unexpected nil of type %T", v) 6152 } 6153 if value == nil { 6154 return nil 6155 } 6156 6157 shape, ok := value.([]interface{}) 6158 if !ok { 6159 return fmt.Errorf("unexpected JSON type %v", value) 6160 } 6161 6162 var cv []types.LogStream 6163 if *v == nil { 6164 cv = []types.LogStream{} 6165 } else { 6166 cv = *v 6167 } 6168 6169 for _, value := range shape { 6170 var col types.LogStream 6171 destAddr := &col 6172 if err := awsAwsjson11_deserializeDocumentLogStream(&destAddr, value); err != nil { 6173 return err 6174 } 6175 col = *destAddr 6176 cv = append(cv, col) 6177 6178 } 6179 *v = cv 6180 return nil 6181} 6182 6183func awsAwsjson11_deserializeDocumentMalformedQueryException(v **types.MalformedQueryException, value interface{}) error { 6184 if v == nil { 6185 return fmt.Errorf("unexpected nil of type %T", v) 6186 } 6187 if value == nil { 6188 return nil 6189 } 6190 6191 shape, ok := value.(map[string]interface{}) 6192 if !ok { 6193 return fmt.Errorf("unexpected JSON type %v", value) 6194 } 6195 6196 var sv *types.MalformedQueryException 6197 if *v == nil { 6198 sv = &types.MalformedQueryException{} 6199 } else { 6200 sv = *v 6201 } 6202 6203 for key, value := range shape { 6204 switch key { 6205 case "message": 6206 if value != nil { 6207 jtv, ok := value.(string) 6208 if !ok { 6209 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 6210 } 6211 sv.Message = ptr.String(jtv) 6212 } 6213 6214 case "queryCompileError": 6215 if err := awsAwsjson11_deserializeDocumentQueryCompileError(&sv.QueryCompileError, value); err != nil { 6216 return err 6217 } 6218 6219 default: 6220 _, _ = key, value 6221 6222 } 6223 } 6224 *v = sv 6225 return nil 6226} 6227 6228func awsAwsjson11_deserializeDocumentMetricFilter(v **types.MetricFilter, value interface{}) error { 6229 if v == nil { 6230 return fmt.Errorf("unexpected nil of type %T", v) 6231 } 6232 if value == nil { 6233 return nil 6234 } 6235 6236 shape, ok := value.(map[string]interface{}) 6237 if !ok { 6238 return fmt.Errorf("unexpected JSON type %v", value) 6239 } 6240 6241 var sv *types.MetricFilter 6242 if *v == nil { 6243 sv = &types.MetricFilter{} 6244 } else { 6245 sv = *v 6246 } 6247 6248 for key, value := range shape { 6249 switch key { 6250 case "creationTime": 6251 if value != nil { 6252 jtv, ok := value.(json.Number) 6253 if !ok { 6254 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6255 } 6256 i64, err := jtv.Int64() 6257 if err != nil { 6258 return err 6259 } 6260 sv.CreationTime = ptr.Int64(i64) 6261 } 6262 6263 case "filterName": 6264 if value != nil { 6265 jtv, ok := value.(string) 6266 if !ok { 6267 return fmt.Errorf("expected FilterName to be of type string, got %T instead", value) 6268 } 6269 sv.FilterName = ptr.String(jtv) 6270 } 6271 6272 case "filterPattern": 6273 if value != nil { 6274 jtv, ok := value.(string) 6275 if !ok { 6276 return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) 6277 } 6278 sv.FilterPattern = ptr.String(jtv) 6279 } 6280 6281 case "logGroupName": 6282 if value != nil { 6283 jtv, ok := value.(string) 6284 if !ok { 6285 return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) 6286 } 6287 sv.LogGroupName = ptr.String(jtv) 6288 } 6289 6290 case "metricTransformations": 6291 if err := awsAwsjson11_deserializeDocumentMetricTransformations(&sv.MetricTransformations, value); err != nil { 6292 return err 6293 } 6294 6295 default: 6296 _, _ = key, value 6297 6298 } 6299 } 6300 *v = sv 6301 return nil 6302} 6303 6304func awsAwsjson11_deserializeDocumentMetricFilterMatches(v *[]types.MetricFilterMatchRecord, value interface{}) error { 6305 if v == nil { 6306 return fmt.Errorf("unexpected nil of type %T", v) 6307 } 6308 if value == nil { 6309 return nil 6310 } 6311 6312 shape, ok := value.([]interface{}) 6313 if !ok { 6314 return fmt.Errorf("unexpected JSON type %v", value) 6315 } 6316 6317 var cv []types.MetricFilterMatchRecord 6318 if *v == nil { 6319 cv = []types.MetricFilterMatchRecord{} 6320 } else { 6321 cv = *v 6322 } 6323 6324 for _, value := range shape { 6325 var col types.MetricFilterMatchRecord 6326 destAddr := &col 6327 if err := awsAwsjson11_deserializeDocumentMetricFilterMatchRecord(&destAddr, value); err != nil { 6328 return err 6329 } 6330 col = *destAddr 6331 cv = append(cv, col) 6332 6333 } 6334 *v = cv 6335 return nil 6336} 6337 6338func awsAwsjson11_deserializeDocumentMetricFilterMatchRecord(v **types.MetricFilterMatchRecord, value interface{}) error { 6339 if v == nil { 6340 return fmt.Errorf("unexpected nil of type %T", v) 6341 } 6342 if value == nil { 6343 return nil 6344 } 6345 6346 shape, ok := value.(map[string]interface{}) 6347 if !ok { 6348 return fmt.Errorf("unexpected JSON type %v", value) 6349 } 6350 6351 var sv *types.MetricFilterMatchRecord 6352 if *v == nil { 6353 sv = &types.MetricFilterMatchRecord{} 6354 } else { 6355 sv = *v 6356 } 6357 6358 for key, value := range shape { 6359 switch key { 6360 case "eventMessage": 6361 if value != nil { 6362 jtv, ok := value.(string) 6363 if !ok { 6364 return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) 6365 } 6366 sv.EventMessage = ptr.String(jtv) 6367 } 6368 6369 case "eventNumber": 6370 if value != nil { 6371 jtv, ok := value.(json.Number) 6372 if !ok { 6373 return fmt.Errorf("expected EventNumber to be json.Number, got %T instead", value) 6374 } 6375 i64, err := jtv.Int64() 6376 if err != nil { 6377 return err 6378 } 6379 sv.EventNumber = i64 6380 } 6381 6382 case "extractedValues": 6383 if err := awsAwsjson11_deserializeDocumentExtractedValues(&sv.ExtractedValues, value); err != nil { 6384 return err 6385 } 6386 6387 default: 6388 _, _ = key, value 6389 6390 } 6391 } 6392 *v = sv 6393 return nil 6394} 6395 6396func awsAwsjson11_deserializeDocumentMetricFilters(v *[]types.MetricFilter, value interface{}) error { 6397 if v == nil { 6398 return fmt.Errorf("unexpected nil of type %T", v) 6399 } 6400 if value == nil { 6401 return nil 6402 } 6403 6404 shape, ok := value.([]interface{}) 6405 if !ok { 6406 return fmt.Errorf("unexpected JSON type %v", value) 6407 } 6408 6409 var cv []types.MetricFilter 6410 if *v == nil { 6411 cv = []types.MetricFilter{} 6412 } else { 6413 cv = *v 6414 } 6415 6416 for _, value := range shape { 6417 var col types.MetricFilter 6418 destAddr := &col 6419 if err := awsAwsjson11_deserializeDocumentMetricFilter(&destAddr, value); err != nil { 6420 return err 6421 } 6422 col = *destAddr 6423 cv = append(cv, col) 6424 6425 } 6426 *v = cv 6427 return nil 6428} 6429 6430func awsAwsjson11_deserializeDocumentMetricTransformation(v **types.MetricTransformation, value interface{}) error { 6431 if v == nil { 6432 return fmt.Errorf("unexpected nil of type %T", v) 6433 } 6434 if value == nil { 6435 return nil 6436 } 6437 6438 shape, ok := value.(map[string]interface{}) 6439 if !ok { 6440 return fmt.Errorf("unexpected JSON type %v", value) 6441 } 6442 6443 var sv *types.MetricTransformation 6444 if *v == nil { 6445 sv = &types.MetricTransformation{} 6446 } else { 6447 sv = *v 6448 } 6449 6450 for key, value := range shape { 6451 switch key { 6452 case "defaultValue": 6453 if value != nil { 6454 jtv, ok := value.(json.Number) 6455 if !ok { 6456 return fmt.Errorf("expected DefaultValue to be json.Number, got %T instead", value) 6457 } 6458 f64, err := jtv.Float64() 6459 if err != nil { 6460 return err 6461 } 6462 sv.DefaultValue = ptr.Float64(f64) 6463 } 6464 6465 case "metricName": 6466 if value != nil { 6467 jtv, ok := value.(string) 6468 if !ok { 6469 return fmt.Errorf("expected MetricName to be of type string, got %T instead", value) 6470 } 6471 sv.MetricName = ptr.String(jtv) 6472 } 6473 6474 case "metricNamespace": 6475 if value != nil { 6476 jtv, ok := value.(string) 6477 if !ok { 6478 return fmt.Errorf("expected MetricNamespace to be of type string, got %T instead", value) 6479 } 6480 sv.MetricNamespace = ptr.String(jtv) 6481 } 6482 6483 case "metricValue": 6484 if value != nil { 6485 jtv, ok := value.(string) 6486 if !ok { 6487 return fmt.Errorf("expected MetricValue to be of type string, got %T instead", value) 6488 } 6489 sv.MetricValue = ptr.String(jtv) 6490 } 6491 6492 default: 6493 _, _ = key, value 6494 6495 } 6496 } 6497 *v = sv 6498 return nil 6499} 6500 6501func awsAwsjson11_deserializeDocumentMetricTransformations(v *[]types.MetricTransformation, value interface{}) error { 6502 if v == nil { 6503 return fmt.Errorf("unexpected nil of type %T", v) 6504 } 6505 if value == nil { 6506 return nil 6507 } 6508 6509 shape, ok := value.([]interface{}) 6510 if !ok { 6511 return fmt.Errorf("unexpected JSON type %v", value) 6512 } 6513 6514 var cv []types.MetricTransformation 6515 if *v == nil { 6516 cv = []types.MetricTransformation{} 6517 } else { 6518 cv = *v 6519 } 6520 6521 for _, value := range shape { 6522 var col types.MetricTransformation 6523 destAddr := &col 6524 if err := awsAwsjson11_deserializeDocumentMetricTransformation(&destAddr, value); err != nil { 6525 return err 6526 } 6527 col = *destAddr 6528 cv = append(cv, col) 6529 6530 } 6531 *v = cv 6532 return nil 6533} 6534 6535func awsAwsjson11_deserializeDocumentOperationAbortedException(v **types.OperationAbortedException, value interface{}) error { 6536 if v == nil { 6537 return fmt.Errorf("unexpected nil of type %T", v) 6538 } 6539 if value == nil { 6540 return nil 6541 } 6542 6543 shape, ok := value.(map[string]interface{}) 6544 if !ok { 6545 return fmt.Errorf("unexpected JSON type %v", value) 6546 } 6547 6548 var sv *types.OperationAbortedException 6549 if *v == nil { 6550 sv = &types.OperationAbortedException{} 6551 } else { 6552 sv = *v 6553 } 6554 6555 for key, value := range shape { 6556 switch key { 6557 case "message": 6558 if value != nil { 6559 jtv, ok := value.(string) 6560 if !ok { 6561 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 6562 } 6563 sv.Message = ptr.String(jtv) 6564 } 6565 6566 default: 6567 _, _ = key, value 6568 6569 } 6570 } 6571 *v = sv 6572 return nil 6573} 6574 6575func awsAwsjson11_deserializeDocumentOutputLogEvent(v **types.OutputLogEvent, value interface{}) error { 6576 if v == nil { 6577 return fmt.Errorf("unexpected nil of type %T", v) 6578 } 6579 if value == nil { 6580 return nil 6581 } 6582 6583 shape, ok := value.(map[string]interface{}) 6584 if !ok { 6585 return fmt.Errorf("unexpected JSON type %v", value) 6586 } 6587 6588 var sv *types.OutputLogEvent 6589 if *v == nil { 6590 sv = &types.OutputLogEvent{} 6591 } else { 6592 sv = *v 6593 } 6594 6595 for key, value := range shape { 6596 switch key { 6597 case "ingestionTime": 6598 if value != nil { 6599 jtv, ok := value.(json.Number) 6600 if !ok { 6601 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6602 } 6603 i64, err := jtv.Int64() 6604 if err != nil { 6605 return err 6606 } 6607 sv.IngestionTime = ptr.Int64(i64) 6608 } 6609 6610 case "message": 6611 if value != nil { 6612 jtv, ok := value.(string) 6613 if !ok { 6614 return fmt.Errorf("expected EventMessage to be of type string, got %T instead", value) 6615 } 6616 sv.Message = ptr.String(jtv) 6617 } 6618 6619 case "timestamp": 6620 if value != nil { 6621 jtv, ok := value.(json.Number) 6622 if !ok { 6623 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6624 } 6625 i64, err := jtv.Int64() 6626 if err != nil { 6627 return err 6628 } 6629 sv.Timestamp = ptr.Int64(i64) 6630 } 6631 6632 default: 6633 _, _ = key, value 6634 6635 } 6636 } 6637 *v = sv 6638 return nil 6639} 6640 6641func awsAwsjson11_deserializeDocumentOutputLogEvents(v *[]types.OutputLogEvent, value interface{}) error { 6642 if v == nil { 6643 return fmt.Errorf("unexpected nil of type %T", v) 6644 } 6645 if value == nil { 6646 return nil 6647 } 6648 6649 shape, ok := value.([]interface{}) 6650 if !ok { 6651 return fmt.Errorf("unexpected JSON type %v", value) 6652 } 6653 6654 var cv []types.OutputLogEvent 6655 if *v == nil { 6656 cv = []types.OutputLogEvent{} 6657 } else { 6658 cv = *v 6659 } 6660 6661 for _, value := range shape { 6662 var col types.OutputLogEvent 6663 destAddr := &col 6664 if err := awsAwsjson11_deserializeDocumentOutputLogEvent(&destAddr, value); err != nil { 6665 return err 6666 } 6667 col = *destAddr 6668 cv = append(cv, col) 6669 6670 } 6671 *v = cv 6672 return nil 6673} 6674 6675func awsAwsjson11_deserializeDocumentQueryCompileError(v **types.QueryCompileError, value interface{}) error { 6676 if v == nil { 6677 return fmt.Errorf("unexpected nil of type %T", v) 6678 } 6679 if value == nil { 6680 return nil 6681 } 6682 6683 shape, ok := value.(map[string]interface{}) 6684 if !ok { 6685 return fmt.Errorf("unexpected JSON type %v", value) 6686 } 6687 6688 var sv *types.QueryCompileError 6689 if *v == nil { 6690 sv = &types.QueryCompileError{} 6691 } else { 6692 sv = *v 6693 } 6694 6695 for key, value := range shape { 6696 switch key { 6697 case "location": 6698 if err := awsAwsjson11_deserializeDocumentQueryCompileErrorLocation(&sv.Location, value); err != nil { 6699 return err 6700 } 6701 6702 case "message": 6703 if value != nil { 6704 jtv, ok := value.(string) 6705 if !ok { 6706 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 6707 } 6708 sv.Message = ptr.String(jtv) 6709 } 6710 6711 default: 6712 _, _ = key, value 6713 6714 } 6715 } 6716 *v = sv 6717 return nil 6718} 6719 6720func awsAwsjson11_deserializeDocumentQueryCompileErrorLocation(v **types.QueryCompileErrorLocation, value interface{}) error { 6721 if v == nil { 6722 return fmt.Errorf("unexpected nil of type %T", v) 6723 } 6724 if value == nil { 6725 return nil 6726 } 6727 6728 shape, ok := value.(map[string]interface{}) 6729 if !ok { 6730 return fmt.Errorf("unexpected JSON type %v", value) 6731 } 6732 6733 var sv *types.QueryCompileErrorLocation 6734 if *v == nil { 6735 sv = &types.QueryCompileErrorLocation{} 6736 } else { 6737 sv = *v 6738 } 6739 6740 for key, value := range shape { 6741 switch key { 6742 case "endCharOffset": 6743 if value != nil { 6744 jtv, ok := value.(json.Number) 6745 if !ok { 6746 return fmt.Errorf("expected QueryCharOffset to be json.Number, got %T instead", value) 6747 } 6748 i64, err := jtv.Int64() 6749 if err != nil { 6750 return err 6751 } 6752 sv.EndCharOffset = ptr.Int32(int32(i64)) 6753 } 6754 6755 case "startCharOffset": 6756 if value != nil { 6757 jtv, ok := value.(json.Number) 6758 if !ok { 6759 return fmt.Errorf("expected QueryCharOffset to be json.Number, got %T instead", value) 6760 } 6761 i64, err := jtv.Int64() 6762 if err != nil { 6763 return err 6764 } 6765 sv.StartCharOffset = ptr.Int32(int32(i64)) 6766 } 6767 6768 default: 6769 _, _ = key, value 6770 6771 } 6772 } 6773 *v = sv 6774 return nil 6775} 6776 6777func awsAwsjson11_deserializeDocumentQueryDefinition(v **types.QueryDefinition, value interface{}) error { 6778 if v == nil { 6779 return fmt.Errorf("unexpected nil of type %T", v) 6780 } 6781 if value == nil { 6782 return nil 6783 } 6784 6785 shape, ok := value.(map[string]interface{}) 6786 if !ok { 6787 return fmt.Errorf("unexpected JSON type %v", value) 6788 } 6789 6790 var sv *types.QueryDefinition 6791 if *v == nil { 6792 sv = &types.QueryDefinition{} 6793 } else { 6794 sv = *v 6795 } 6796 6797 for key, value := range shape { 6798 switch key { 6799 case "lastModified": 6800 if value != nil { 6801 jtv, ok := value.(json.Number) 6802 if !ok { 6803 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6804 } 6805 i64, err := jtv.Int64() 6806 if err != nil { 6807 return err 6808 } 6809 sv.LastModified = ptr.Int64(i64) 6810 } 6811 6812 case "logGroupNames": 6813 if err := awsAwsjson11_deserializeDocumentLogGroupNames(&sv.LogGroupNames, value); err != nil { 6814 return err 6815 } 6816 6817 case "name": 6818 if value != nil { 6819 jtv, ok := value.(string) 6820 if !ok { 6821 return fmt.Errorf("expected QueryDefinitionName to be of type string, got %T instead", value) 6822 } 6823 sv.Name = ptr.String(jtv) 6824 } 6825 6826 case "queryDefinitionId": 6827 if value != nil { 6828 jtv, ok := value.(string) 6829 if !ok { 6830 return fmt.Errorf("expected QueryId to be of type string, got %T instead", value) 6831 } 6832 sv.QueryDefinitionId = ptr.String(jtv) 6833 } 6834 6835 case "queryString": 6836 if value != nil { 6837 jtv, ok := value.(string) 6838 if !ok { 6839 return fmt.Errorf("expected QueryDefinitionString to be of type string, got %T instead", value) 6840 } 6841 sv.QueryString = ptr.String(jtv) 6842 } 6843 6844 default: 6845 _, _ = key, value 6846 6847 } 6848 } 6849 *v = sv 6850 return nil 6851} 6852 6853func awsAwsjson11_deserializeDocumentQueryDefinitionList(v *[]types.QueryDefinition, value interface{}) error { 6854 if v == nil { 6855 return fmt.Errorf("unexpected nil of type %T", v) 6856 } 6857 if value == nil { 6858 return nil 6859 } 6860 6861 shape, ok := value.([]interface{}) 6862 if !ok { 6863 return fmt.Errorf("unexpected JSON type %v", value) 6864 } 6865 6866 var cv []types.QueryDefinition 6867 if *v == nil { 6868 cv = []types.QueryDefinition{} 6869 } else { 6870 cv = *v 6871 } 6872 6873 for _, value := range shape { 6874 var col types.QueryDefinition 6875 destAddr := &col 6876 if err := awsAwsjson11_deserializeDocumentQueryDefinition(&destAddr, value); err != nil { 6877 return err 6878 } 6879 col = *destAddr 6880 cv = append(cv, col) 6881 6882 } 6883 *v = cv 6884 return nil 6885} 6886 6887func awsAwsjson11_deserializeDocumentQueryInfo(v **types.QueryInfo, value interface{}) error { 6888 if v == nil { 6889 return fmt.Errorf("unexpected nil of type %T", v) 6890 } 6891 if value == nil { 6892 return nil 6893 } 6894 6895 shape, ok := value.(map[string]interface{}) 6896 if !ok { 6897 return fmt.Errorf("unexpected JSON type %v", value) 6898 } 6899 6900 var sv *types.QueryInfo 6901 if *v == nil { 6902 sv = &types.QueryInfo{} 6903 } else { 6904 sv = *v 6905 } 6906 6907 for key, value := range shape { 6908 switch key { 6909 case "createTime": 6910 if value != nil { 6911 jtv, ok := value.(json.Number) 6912 if !ok { 6913 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6914 } 6915 i64, err := jtv.Int64() 6916 if err != nil { 6917 return err 6918 } 6919 sv.CreateTime = ptr.Int64(i64) 6920 } 6921 6922 case "logGroupName": 6923 if value != nil { 6924 jtv, ok := value.(string) 6925 if !ok { 6926 return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) 6927 } 6928 sv.LogGroupName = ptr.String(jtv) 6929 } 6930 6931 case "queryId": 6932 if value != nil { 6933 jtv, ok := value.(string) 6934 if !ok { 6935 return fmt.Errorf("expected QueryId to be of type string, got %T instead", value) 6936 } 6937 sv.QueryId = ptr.String(jtv) 6938 } 6939 6940 case "queryString": 6941 if value != nil { 6942 jtv, ok := value.(string) 6943 if !ok { 6944 return fmt.Errorf("expected QueryString to be of type string, got %T instead", value) 6945 } 6946 sv.QueryString = ptr.String(jtv) 6947 } 6948 6949 case "status": 6950 if value != nil { 6951 jtv, ok := value.(string) 6952 if !ok { 6953 return fmt.Errorf("expected QueryStatus to be of type string, got %T instead", value) 6954 } 6955 sv.Status = types.QueryStatus(jtv) 6956 } 6957 6958 default: 6959 _, _ = key, value 6960 6961 } 6962 } 6963 *v = sv 6964 return nil 6965} 6966 6967func awsAwsjson11_deserializeDocumentQueryInfoList(v *[]types.QueryInfo, value interface{}) error { 6968 if v == nil { 6969 return fmt.Errorf("unexpected nil of type %T", v) 6970 } 6971 if value == nil { 6972 return nil 6973 } 6974 6975 shape, ok := value.([]interface{}) 6976 if !ok { 6977 return fmt.Errorf("unexpected JSON type %v", value) 6978 } 6979 6980 var cv []types.QueryInfo 6981 if *v == nil { 6982 cv = []types.QueryInfo{} 6983 } else { 6984 cv = *v 6985 } 6986 6987 for _, value := range shape { 6988 var col types.QueryInfo 6989 destAddr := &col 6990 if err := awsAwsjson11_deserializeDocumentQueryInfo(&destAddr, value); err != nil { 6991 return err 6992 } 6993 col = *destAddr 6994 cv = append(cv, col) 6995 6996 } 6997 *v = cv 6998 return nil 6999} 7000 7001func awsAwsjson11_deserializeDocumentQueryResults(v *[][]types.ResultField, value interface{}) error { 7002 if v == nil { 7003 return fmt.Errorf("unexpected nil of type %T", v) 7004 } 7005 if value == nil { 7006 return nil 7007 } 7008 7009 shape, ok := value.([]interface{}) 7010 if !ok { 7011 return fmt.Errorf("unexpected JSON type %v", value) 7012 } 7013 7014 var cv [][]types.ResultField 7015 if *v == nil { 7016 cv = [][]types.ResultField{} 7017 } else { 7018 cv = *v 7019 } 7020 7021 for _, value := range shape { 7022 var col []types.ResultField 7023 if err := awsAwsjson11_deserializeDocumentResultRows(&col, value); err != nil { 7024 return err 7025 } 7026 cv = append(cv, col) 7027 7028 } 7029 *v = cv 7030 return nil 7031} 7032 7033func awsAwsjson11_deserializeDocumentQueryStatistics(v **types.QueryStatistics, value interface{}) error { 7034 if v == nil { 7035 return fmt.Errorf("unexpected nil of type %T", v) 7036 } 7037 if value == nil { 7038 return nil 7039 } 7040 7041 shape, ok := value.(map[string]interface{}) 7042 if !ok { 7043 return fmt.Errorf("unexpected JSON type %v", value) 7044 } 7045 7046 var sv *types.QueryStatistics 7047 if *v == nil { 7048 sv = &types.QueryStatistics{} 7049 } else { 7050 sv = *v 7051 } 7052 7053 for key, value := range shape { 7054 switch key { 7055 case "bytesScanned": 7056 if value != nil { 7057 jtv, ok := value.(json.Number) 7058 if !ok { 7059 return fmt.Errorf("expected StatsValue to be json.Number, got %T instead", value) 7060 } 7061 f64, err := jtv.Float64() 7062 if err != nil { 7063 return err 7064 } 7065 sv.BytesScanned = f64 7066 } 7067 7068 case "recordsMatched": 7069 if value != nil { 7070 jtv, ok := value.(json.Number) 7071 if !ok { 7072 return fmt.Errorf("expected StatsValue to be json.Number, got %T instead", value) 7073 } 7074 f64, err := jtv.Float64() 7075 if err != nil { 7076 return err 7077 } 7078 sv.RecordsMatched = f64 7079 } 7080 7081 case "recordsScanned": 7082 if value != nil { 7083 jtv, ok := value.(json.Number) 7084 if !ok { 7085 return fmt.Errorf("expected StatsValue to be json.Number, got %T instead", value) 7086 } 7087 f64, err := jtv.Float64() 7088 if err != nil { 7089 return err 7090 } 7091 sv.RecordsScanned = f64 7092 } 7093 7094 default: 7095 _, _ = key, value 7096 7097 } 7098 } 7099 *v = sv 7100 return nil 7101} 7102 7103func awsAwsjson11_deserializeDocumentRejectedLogEventsInfo(v **types.RejectedLogEventsInfo, value interface{}) error { 7104 if v == nil { 7105 return fmt.Errorf("unexpected nil of type %T", v) 7106 } 7107 if value == nil { 7108 return nil 7109 } 7110 7111 shape, ok := value.(map[string]interface{}) 7112 if !ok { 7113 return fmt.Errorf("unexpected JSON type %v", value) 7114 } 7115 7116 var sv *types.RejectedLogEventsInfo 7117 if *v == nil { 7118 sv = &types.RejectedLogEventsInfo{} 7119 } else { 7120 sv = *v 7121 } 7122 7123 for key, value := range shape { 7124 switch key { 7125 case "expiredLogEventEndIndex": 7126 if value != nil { 7127 jtv, ok := value.(json.Number) 7128 if !ok { 7129 return fmt.Errorf("expected LogEventIndex to be json.Number, got %T instead", value) 7130 } 7131 i64, err := jtv.Int64() 7132 if err != nil { 7133 return err 7134 } 7135 sv.ExpiredLogEventEndIndex = ptr.Int32(int32(i64)) 7136 } 7137 7138 case "tooNewLogEventStartIndex": 7139 if value != nil { 7140 jtv, ok := value.(json.Number) 7141 if !ok { 7142 return fmt.Errorf("expected LogEventIndex to be json.Number, got %T instead", value) 7143 } 7144 i64, err := jtv.Int64() 7145 if err != nil { 7146 return err 7147 } 7148 sv.TooNewLogEventStartIndex = ptr.Int32(int32(i64)) 7149 } 7150 7151 case "tooOldLogEventEndIndex": 7152 if value != nil { 7153 jtv, ok := value.(json.Number) 7154 if !ok { 7155 return fmt.Errorf("expected LogEventIndex to be json.Number, got %T instead", value) 7156 } 7157 i64, err := jtv.Int64() 7158 if err != nil { 7159 return err 7160 } 7161 sv.TooOldLogEventEndIndex = ptr.Int32(int32(i64)) 7162 } 7163 7164 default: 7165 _, _ = key, value 7166 7167 } 7168 } 7169 *v = sv 7170 return nil 7171} 7172 7173func awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(v **types.ResourceAlreadyExistsException, value interface{}) error { 7174 if v == nil { 7175 return fmt.Errorf("unexpected nil of type %T", v) 7176 } 7177 if value == nil { 7178 return nil 7179 } 7180 7181 shape, ok := value.(map[string]interface{}) 7182 if !ok { 7183 return fmt.Errorf("unexpected JSON type %v", value) 7184 } 7185 7186 var sv *types.ResourceAlreadyExistsException 7187 if *v == nil { 7188 sv = &types.ResourceAlreadyExistsException{} 7189 } else { 7190 sv = *v 7191 } 7192 7193 for key, value := range shape { 7194 switch key { 7195 case "message": 7196 if value != nil { 7197 jtv, ok := value.(string) 7198 if !ok { 7199 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7200 } 7201 sv.Message = ptr.String(jtv) 7202 } 7203 7204 default: 7205 _, _ = key, value 7206 7207 } 7208 } 7209 *v = sv 7210 return nil 7211} 7212 7213func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 7214 if v == nil { 7215 return fmt.Errorf("unexpected nil of type %T", v) 7216 } 7217 if value == nil { 7218 return nil 7219 } 7220 7221 shape, ok := value.(map[string]interface{}) 7222 if !ok { 7223 return fmt.Errorf("unexpected JSON type %v", value) 7224 } 7225 7226 var sv *types.ResourceNotFoundException 7227 if *v == nil { 7228 sv = &types.ResourceNotFoundException{} 7229 } else { 7230 sv = *v 7231 } 7232 7233 for key, value := range shape { 7234 switch key { 7235 case "message": 7236 if value != nil { 7237 jtv, ok := value.(string) 7238 if !ok { 7239 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7240 } 7241 sv.Message = ptr.String(jtv) 7242 } 7243 7244 default: 7245 _, _ = key, value 7246 7247 } 7248 } 7249 *v = sv 7250 return nil 7251} 7252 7253func awsAwsjson11_deserializeDocumentResourcePolicies(v *[]types.ResourcePolicy, value interface{}) error { 7254 if v == nil { 7255 return fmt.Errorf("unexpected nil of type %T", v) 7256 } 7257 if value == nil { 7258 return nil 7259 } 7260 7261 shape, ok := value.([]interface{}) 7262 if !ok { 7263 return fmt.Errorf("unexpected JSON type %v", value) 7264 } 7265 7266 var cv []types.ResourcePolicy 7267 if *v == nil { 7268 cv = []types.ResourcePolicy{} 7269 } else { 7270 cv = *v 7271 } 7272 7273 for _, value := range shape { 7274 var col types.ResourcePolicy 7275 destAddr := &col 7276 if err := awsAwsjson11_deserializeDocumentResourcePolicy(&destAddr, value); err != nil { 7277 return err 7278 } 7279 col = *destAddr 7280 cv = append(cv, col) 7281 7282 } 7283 *v = cv 7284 return nil 7285} 7286 7287func awsAwsjson11_deserializeDocumentResourcePolicy(v **types.ResourcePolicy, value interface{}) error { 7288 if v == nil { 7289 return fmt.Errorf("unexpected nil of type %T", v) 7290 } 7291 if value == nil { 7292 return nil 7293 } 7294 7295 shape, ok := value.(map[string]interface{}) 7296 if !ok { 7297 return fmt.Errorf("unexpected JSON type %v", value) 7298 } 7299 7300 var sv *types.ResourcePolicy 7301 if *v == nil { 7302 sv = &types.ResourcePolicy{} 7303 } else { 7304 sv = *v 7305 } 7306 7307 for key, value := range shape { 7308 switch key { 7309 case "lastUpdatedTime": 7310 if value != nil { 7311 jtv, ok := value.(json.Number) 7312 if !ok { 7313 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7314 } 7315 i64, err := jtv.Int64() 7316 if err != nil { 7317 return err 7318 } 7319 sv.LastUpdatedTime = ptr.Int64(i64) 7320 } 7321 7322 case "policyDocument": 7323 if value != nil { 7324 jtv, ok := value.(string) 7325 if !ok { 7326 return fmt.Errorf("expected PolicyDocument to be of type string, got %T instead", value) 7327 } 7328 sv.PolicyDocument = ptr.String(jtv) 7329 } 7330 7331 case "policyName": 7332 if value != nil { 7333 jtv, ok := value.(string) 7334 if !ok { 7335 return fmt.Errorf("expected PolicyName to be of type string, got %T instead", value) 7336 } 7337 sv.PolicyName = ptr.String(jtv) 7338 } 7339 7340 default: 7341 _, _ = key, value 7342 7343 } 7344 } 7345 *v = sv 7346 return nil 7347} 7348 7349func awsAwsjson11_deserializeDocumentResultField(v **types.ResultField, value interface{}) error { 7350 if v == nil { 7351 return fmt.Errorf("unexpected nil of type %T", v) 7352 } 7353 if value == nil { 7354 return nil 7355 } 7356 7357 shape, ok := value.(map[string]interface{}) 7358 if !ok { 7359 return fmt.Errorf("unexpected JSON type %v", value) 7360 } 7361 7362 var sv *types.ResultField 7363 if *v == nil { 7364 sv = &types.ResultField{} 7365 } else { 7366 sv = *v 7367 } 7368 7369 for key, value := range shape { 7370 switch key { 7371 case "field": 7372 if value != nil { 7373 jtv, ok := value.(string) 7374 if !ok { 7375 return fmt.Errorf("expected Field to be of type string, got %T instead", value) 7376 } 7377 sv.Field = ptr.String(jtv) 7378 } 7379 7380 case "value": 7381 if value != nil { 7382 jtv, ok := value.(string) 7383 if !ok { 7384 return fmt.Errorf("expected Value to be of type string, got %T instead", value) 7385 } 7386 sv.Value = ptr.String(jtv) 7387 } 7388 7389 default: 7390 _, _ = key, value 7391 7392 } 7393 } 7394 *v = sv 7395 return nil 7396} 7397 7398func awsAwsjson11_deserializeDocumentResultRows(v *[]types.ResultField, value interface{}) error { 7399 if v == nil { 7400 return fmt.Errorf("unexpected nil of type %T", v) 7401 } 7402 if value == nil { 7403 return nil 7404 } 7405 7406 shape, ok := value.([]interface{}) 7407 if !ok { 7408 return fmt.Errorf("unexpected JSON type %v", value) 7409 } 7410 7411 var cv []types.ResultField 7412 if *v == nil { 7413 cv = []types.ResultField{} 7414 } else { 7415 cv = *v 7416 } 7417 7418 for _, value := range shape { 7419 var col types.ResultField 7420 destAddr := &col 7421 if err := awsAwsjson11_deserializeDocumentResultField(&destAddr, value); err != nil { 7422 return err 7423 } 7424 col = *destAddr 7425 cv = append(cv, col) 7426 7427 } 7428 *v = cv 7429 return nil 7430} 7431 7432func awsAwsjson11_deserializeDocumentSearchedLogStream(v **types.SearchedLogStream, value interface{}) error { 7433 if v == nil { 7434 return fmt.Errorf("unexpected nil of type %T", v) 7435 } 7436 if value == nil { 7437 return nil 7438 } 7439 7440 shape, ok := value.(map[string]interface{}) 7441 if !ok { 7442 return fmt.Errorf("unexpected JSON type %v", value) 7443 } 7444 7445 var sv *types.SearchedLogStream 7446 if *v == nil { 7447 sv = &types.SearchedLogStream{} 7448 } else { 7449 sv = *v 7450 } 7451 7452 for key, value := range shape { 7453 switch key { 7454 case "logStreamName": 7455 if value != nil { 7456 jtv, ok := value.(string) 7457 if !ok { 7458 return fmt.Errorf("expected LogStreamName to be of type string, got %T instead", value) 7459 } 7460 sv.LogStreamName = ptr.String(jtv) 7461 } 7462 7463 case "searchedCompletely": 7464 if value != nil { 7465 jtv, ok := value.(bool) 7466 if !ok { 7467 return fmt.Errorf("expected LogStreamSearchedCompletely to be of type *bool, got %T instead", value) 7468 } 7469 sv.SearchedCompletely = ptr.Bool(jtv) 7470 } 7471 7472 default: 7473 _, _ = key, value 7474 7475 } 7476 } 7477 *v = sv 7478 return nil 7479} 7480 7481func awsAwsjson11_deserializeDocumentSearchedLogStreams(v *[]types.SearchedLogStream, value interface{}) error { 7482 if v == nil { 7483 return fmt.Errorf("unexpected nil of type %T", v) 7484 } 7485 if value == nil { 7486 return nil 7487 } 7488 7489 shape, ok := value.([]interface{}) 7490 if !ok { 7491 return fmt.Errorf("unexpected JSON type %v", value) 7492 } 7493 7494 var cv []types.SearchedLogStream 7495 if *v == nil { 7496 cv = []types.SearchedLogStream{} 7497 } else { 7498 cv = *v 7499 } 7500 7501 for _, value := range shape { 7502 var col types.SearchedLogStream 7503 destAddr := &col 7504 if err := awsAwsjson11_deserializeDocumentSearchedLogStream(&destAddr, value); err != nil { 7505 return err 7506 } 7507 col = *destAddr 7508 cv = append(cv, col) 7509 7510 } 7511 *v = cv 7512 return nil 7513} 7514 7515func awsAwsjson11_deserializeDocumentServiceUnavailableException(v **types.ServiceUnavailableException, value interface{}) error { 7516 if v == nil { 7517 return fmt.Errorf("unexpected nil of type %T", v) 7518 } 7519 if value == nil { 7520 return nil 7521 } 7522 7523 shape, ok := value.(map[string]interface{}) 7524 if !ok { 7525 return fmt.Errorf("unexpected JSON type %v", value) 7526 } 7527 7528 var sv *types.ServiceUnavailableException 7529 if *v == nil { 7530 sv = &types.ServiceUnavailableException{} 7531 } else { 7532 sv = *v 7533 } 7534 7535 for key, value := range shape { 7536 switch key { 7537 case "message": 7538 if value != nil { 7539 jtv, ok := value.(string) 7540 if !ok { 7541 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7542 } 7543 sv.Message = ptr.String(jtv) 7544 } 7545 7546 default: 7547 _, _ = key, value 7548 7549 } 7550 } 7551 *v = sv 7552 return nil 7553} 7554 7555func awsAwsjson11_deserializeDocumentSubscriptionFilter(v **types.SubscriptionFilter, value interface{}) error { 7556 if v == nil { 7557 return fmt.Errorf("unexpected nil of type %T", v) 7558 } 7559 if value == nil { 7560 return nil 7561 } 7562 7563 shape, ok := value.(map[string]interface{}) 7564 if !ok { 7565 return fmt.Errorf("unexpected JSON type %v", value) 7566 } 7567 7568 var sv *types.SubscriptionFilter 7569 if *v == nil { 7570 sv = &types.SubscriptionFilter{} 7571 } else { 7572 sv = *v 7573 } 7574 7575 for key, value := range shape { 7576 switch key { 7577 case "creationTime": 7578 if value != nil { 7579 jtv, ok := value.(json.Number) 7580 if !ok { 7581 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7582 } 7583 i64, err := jtv.Int64() 7584 if err != nil { 7585 return err 7586 } 7587 sv.CreationTime = ptr.Int64(i64) 7588 } 7589 7590 case "destinationArn": 7591 if value != nil { 7592 jtv, ok := value.(string) 7593 if !ok { 7594 return fmt.Errorf("expected DestinationArn to be of type string, got %T instead", value) 7595 } 7596 sv.DestinationArn = ptr.String(jtv) 7597 } 7598 7599 case "distribution": 7600 if value != nil { 7601 jtv, ok := value.(string) 7602 if !ok { 7603 return fmt.Errorf("expected Distribution to be of type string, got %T instead", value) 7604 } 7605 sv.Distribution = types.Distribution(jtv) 7606 } 7607 7608 case "filterName": 7609 if value != nil { 7610 jtv, ok := value.(string) 7611 if !ok { 7612 return fmt.Errorf("expected FilterName to be of type string, got %T instead", value) 7613 } 7614 sv.FilterName = ptr.String(jtv) 7615 } 7616 7617 case "filterPattern": 7618 if value != nil { 7619 jtv, ok := value.(string) 7620 if !ok { 7621 return fmt.Errorf("expected FilterPattern to be of type string, got %T instead", value) 7622 } 7623 sv.FilterPattern = ptr.String(jtv) 7624 } 7625 7626 case "logGroupName": 7627 if value != nil { 7628 jtv, ok := value.(string) 7629 if !ok { 7630 return fmt.Errorf("expected LogGroupName to be of type string, got %T instead", value) 7631 } 7632 sv.LogGroupName = ptr.String(jtv) 7633 } 7634 7635 case "roleArn": 7636 if value != nil { 7637 jtv, ok := value.(string) 7638 if !ok { 7639 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 7640 } 7641 sv.RoleArn = ptr.String(jtv) 7642 } 7643 7644 default: 7645 _, _ = key, value 7646 7647 } 7648 } 7649 *v = sv 7650 return nil 7651} 7652 7653func awsAwsjson11_deserializeDocumentSubscriptionFilters(v *[]types.SubscriptionFilter, value interface{}) error { 7654 if v == nil { 7655 return fmt.Errorf("unexpected nil of type %T", v) 7656 } 7657 if value == nil { 7658 return nil 7659 } 7660 7661 shape, ok := value.([]interface{}) 7662 if !ok { 7663 return fmt.Errorf("unexpected JSON type %v", value) 7664 } 7665 7666 var cv []types.SubscriptionFilter 7667 if *v == nil { 7668 cv = []types.SubscriptionFilter{} 7669 } else { 7670 cv = *v 7671 } 7672 7673 for _, value := range shape { 7674 var col types.SubscriptionFilter 7675 destAddr := &col 7676 if err := awsAwsjson11_deserializeDocumentSubscriptionFilter(&destAddr, value); err != nil { 7677 return err 7678 } 7679 col = *destAddr 7680 cv = append(cv, col) 7681 7682 } 7683 *v = cv 7684 return nil 7685} 7686 7687func awsAwsjson11_deserializeDocumentTags(v *map[string]string, value interface{}) error { 7688 if v == nil { 7689 return fmt.Errorf("unexpected nil of type %T", v) 7690 } 7691 if value == nil { 7692 return nil 7693 } 7694 7695 shape, ok := value.(map[string]interface{}) 7696 if !ok { 7697 return fmt.Errorf("unexpected JSON type %v", value) 7698 } 7699 7700 var mv map[string]string 7701 if *v == nil { 7702 mv = map[string]string{} 7703 } else { 7704 mv = *v 7705 } 7706 7707 for key, value := range shape { 7708 var parsedVal string 7709 if value != nil { 7710 jtv, ok := value.(string) 7711 if !ok { 7712 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 7713 } 7714 parsedVal = jtv 7715 } 7716 mv[key] = parsedVal 7717 7718 } 7719 *v = mv 7720 return nil 7721} 7722 7723func awsAwsjson11_deserializeDocumentUnrecognizedClientException(v **types.UnrecognizedClientException, value interface{}) error { 7724 if v == nil { 7725 return fmt.Errorf("unexpected nil of type %T", v) 7726 } 7727 if value == nil { 7728 return nil 7729 } 7730 7731 shape, ok := value.(map[string]interface{}) 7732 if !ok { 7733 return fmt.Errorf("unexpected JSON type %v", value) 7734 } 7735 7736 var sv *types.UnrecognizedClientException 7737 if *v == nil { 7738 sv = &types.UnrecognizedClientException{} 7739 } else { 7740 sv = *v 7741 } 7742 7743 for key, value := range shape { 7744 switch key { 7745 case "message": 7746 if value != nil { 7747 jtv, ok := value.(string) 7748 if !ok { 7749 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7750 } 7751 sv.Message = ptr.String(jtv) 7752 } 7753 7754 default: 7755 _, _ = key, value 7756 7757 } 7758 } 7759 *v = sv 7760 return nil 7761} 7762 7763func awsAwsjson11_deserializeOpDocumentCreateExportTaskOutput(v **CreateExportTaskOutput, value interface{}) error { 7764 if v == nil { 7765 return fmt.Errorf("unexpected nil of type %T", v) 7766 } 7767 if value == nil { 7768 return nil 7769 } 7770 7771 shape, ok := value.(map[string]interface{}) 7772 if !ok { 7773 return fmt.Errorf("unexpected JSON type %v", value) 7774 } 7775 7776 var sv *CreateExportTaskOutput 7777 if *v == nil { 7778 sv = &CreateExportTaskOutput{} 7779 } else { 7780 sv = *v 7781 } 7782 7783 for key, value := range shape { 7784 switch key { 7785 case "taskId": 7786 if value != nil { 7787 jtv, ok := value.(string) 7788 if !ok { 7789 return fmt.Errorf("expected ExportTaskId to be of type string, got %T instead", value) 7790 } 7791 sv.TaskId = ptr.String(jtv) 7792 } 7793 7794 default: 7795 _, _ = key, value 7796 7797 } 7798 } 7799 *v = sv 7800 return nil 7801} 7802 7803func awsAwsjson11_deserializeOpDocumentDeleteQueryDefinitionOutput(v **DeleteQueryDefinitionOutput, value interface{}) error { 7804 if v == nil { 7805 return fmt.Errorf("unexpected nil of type %T", v) 7806 } 7807 if value == nil { 7808 return nil 7809 } 7810 7811 shape, ok := value.(map[string]interface{}) 7812 if !ok { 7813 return fmt.Errorf("unexpected JSON type %v", value) 7814 } 7815 7816 var sv *DeleteQueryDefinitionOutput 7817 if *v == nil { 7818 sv = &DeleteQueryDefinitionOutput{} 7819 } else { 7820 sv = *v 7821 } 7822 7823 for key, value := range shape { 7824 switch key { 7825 case "success": 7826 if value != nil { 7827 jtv, ok := value.(bool) 7828 if !ok { 7829 return fmt.Errorf("expected Success to be of type *bool, got %T instead", value) 7830 } 7831 sv.Success = jtv 7832 } 7833 7834 default: 7835 _, _ = key, value 7836 7837 } 7838 } 7839 *v = sv 7840 return nil 7841} 7842 7843func awsAwsjson11_deserializeOpDocumentDescribeDestinationsOutput(v **DescribeDestinationsOutput, value interface{}) error { 7844 if v == nil { 7845 return fmt.Errorf("unexpected nil of type %T", v) 7846 } 7847 if value == nil { 7848 return nil 7849 } 7850 7851 shape, ok := value.(map[string]interface{}) 7852 if !ok { 7853 return fmt.Errorf("unexpected JSON type %v", value) 7854 } 7855 7856 var sv *DescribeDestinationsOutput 7857 if *v == nil { 7858 sv = &DescribeDestinationsOutput{} 7859 } else { 7860 sv = *v 7861 } 7862 7863 for key, value := range shape { 7864 switch key { 7865 case "destinations": 7866 if err := awsAwsjson11_deserializeDocumentDestinations(&sv.Destinations, value); err != nil { 7867 return err 7868 } 7869 7870 case "nextToken": 7871 if value != nil { 7872 jtv, ok := value.(string) 7873 if !ok { 7874 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7875 } 7876 sv.NextToken = ptr.String(jtv) 7877 } 7878 7879 default: 7880 _, _ = key, value 7881 7882 } 7883 } 7884 *v = sv 7885 return nil 7886} 7887 7888func awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExportTasksOutput, value interface{}) error { 7889 if v == nil { 7890 return fmt.Errorf("unexpected nil of type %T", v) 7891 } 7892 if value == nil { 7893 return nil 7894 } 7895 7896 shape, ok := value.(map[string]interface{}) 7897 if !ok { 7898 return fmt.Errorf("unexpected JSON type %v", value) 7899 } 7900 7901 var sv *DescribeExportTasksOutput 7902 if *v == nil { 7903 sv = &DescribeExportTasksOutput{} 7904 } else { 7905 sv = *v 7906 } 7907 7908 for key, value := range shape { 7909 switch key { 7910 case "exportTasks": 7911 if err := awsAwsjson11_deserializeDocumentExportTasks(&sv.ExportTasks, value); err != nil { 7912 return err 7913 } 7914 7915 case "nextToken": 7916 if value != nil { 7917 jtv, ok := value.(string) 7918 if !ok { 7919 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7920 } 7921 sv.NextToken = ptr.String(jtv) 7922 } 7923 7924 default: 7925 _, _ = key, value 7926 7927 } 7928 } 7929 *v = sv 7930 return nil 7931} 7932 7933func awsAwsjson11_deserializeOpDocumentDescribeLogGroupsOutput(v **DescribeLogGroupsOutput, value interface{}) error { 7934 if v == nil { 7935 return fmt.Errorf("unexpected nil of type %T", v) 7936 } 7937 if value == nil { 7938 return nil 7939 } 7940 7941 shape, ok := value.(map[string]interface{}) 7942 if !ok { 7943 return fmt.Errorf("unexpected JSON type %v", value) 7944 } 7945 7946 var sv *DescribeLogGroupsOutput 7947 if *v == nil { 7948 sv = &DescribeLogGroupsOutput{} 7949 } else { 7950 sv = *v 7951 } 7952 7953 for key, value := range shape { 7954 switch key { 7955 case "logGroups": 7956 if err := awsAwsjson11_deserializeDocumentLogGroups(&sv.LogGroups, value); err != nil { 7957 return err 7958 } 7959 7960 case "nextToken": 7961 if value != nil { 7962 jtv, ok := value.(string) 7963 if !ok { 7964 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7965 } 7966 sv.NextToken = ptr.String(jtv) 7967 } 7968 7969 default: 7970 _, _ = key, value 7971 7972 } 7973 } 7974 *v = sv 7975 return nil 7976} 7977 7978func awsAwsjson11_deserializeOpDocumentDescribeLogStreamsOutput(v **DescribeLogStreamsOutput, value interface{}) error { 7979 if v == nil { 7980 return fmt.Errorf("unexpected nil of type %T", v) 7981 } 7982 if value == nil { 7983 return nil 7984 } 7985 7986 shape, ok := value.(map[string]interface{}) 7987 if !ok { 7988 return fmt.Errorf("unexpected JSON type %v", value) 7989 } 7990 7991 var sv *DescribeLogStreamsOutput 7992 if *v == nil { 7993 sv = &DescribeLogStreamsOutput{} 7994 } else { 7995 sv = *v 7996 } 7997 7998 for key, value := range shape { 7999 switch key { 8000 case "logStreams": 8001 if err := awsAwsjson11_deserializeDocumentLogStreams(&sv.LogStreams, value); err != nil { 8002 return err 8003 } 8004 8005 case "nextToken": 8006 if value != nil { 8007 jtv, ok := value.(string) 8008 if !ok { 8009 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8010 } 8011 sv.NextToken = ptr.String(jtv) 8012 } 8013 8014 default: 8015 _, _ = key, value 8016 8017 } 8018 } 8019 *v = sv 8020 return nil 8021} 8022 8023func awsAwsjson11_deserializeOpDocumentDescribeMetricFiltersOutput(v **DescribeMetricFiltersOutput, value interface{}) error { 8024 if v == nil { 8025 return fmt.Errorf("unexpected nil of type %T", v) 8026 } 8027 if value == nil { 8028 return nil 8029 } 8030 8031 shape, ok := value.(map[string]interface{}) 8032 if !ok { 8033 return fmt.Errorf("unexpected JSON type %v", value) 8034 } 8035 8036 var sv *DescribeMetricFiltersOutput 8037 if *v == nil { 8038 sv = &DescribeMetricFiltersOutput{} 8039 } else { 8040 sv = *v 8041 } 8042 8043 for key, value := range shape { 8044 switch key { 8045 case "metricFilters": 8046 if err := awsAwsjson11_deserializeDocumentMetricFilters(&sv.MetricFilters, value); err != nil { 8047 return err 8048 } 8049 8050 case "nextToken": 8051 if value != nil { 8052 jtv, ok := value.(string) 8053 if !ok { 8054 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8055 } 8056 sv.NextToken = ptr.String(jtv) 8057 } 8058 8059 default: 8060 _, _ = key, value 8061 8062 } 8063 } 8064 *v = sv 8065 return nil 8066} 8067 8068func awsAwsjson11_deserializeOpDocumentDescribeQueriesOutput(v **DescribeQueriesOutput, value interface{}) error { 8069 if v == nil { 8070 return fmt.Errorf("unexpected nil of type %T", v) 8071 } 8072 if value == nil { 8073 return nil 8074 } 8075 8076 shape, ok := value.(map[string]interface{}) 8077 if !ok { 8078 return fmt.Errorf("unexpected JSON type %v", value) 8079 } 8080 8081 var sv *DescribeQueriesOutput 8082 if *v == nil { 8083 sv = &DescribeQueriesOutput{} 8084 } else { 8085 sv = *v 8086 } 8087 8088 for key, value := range shape { 8089 switch key { 8090 case "nextToken": 8091 if value != nil { 8092 jtv, ok := value.(string) 8093 if !ok { 8094 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8095 } 8096 sv.NextToken = ptr.String(jtv) 8097 } 8098 8099 case "queries": 8100 if err := awsAwsjson11_deserializeDocumentQueryInfoList(&sv.Queries, value); err != nil { 8101 return err 8102 } 8103 8104 default: 8105 _, _ = key, value 8106 8107 } 8108 } 8109 *v = sv 8110 return nil 8111} 8112 8113func awsAwsjson11_deserializeOpDocumentDescribeQueryDefinitionsOutput(v **DescribeQueryDefinitionsOutput, value interface{}) error { 8114 if v == nil { 8115 return fmt.Errorf("unexpected nil of type %T", v) 8116 } 8117 if value == nil { 8118 return nil 8119 } 8120 8121 shape, ok := value.(map[string]interface{}) 8122 if !ok { 8123 return fmt.Errorf("unexpected JSON type %v", value) 8124 } 8125 8126 var sv *DescribeQueryDefinitionsOutput 8127 if *v == nil { 8128 sv = &DescribeQueryDefinitionsOutput{} 8129 } else { 8130 sv = *v 8131 } 8132 8133 for key, value := range shape { 8134 switch key { 8135 case "nextToken": 8136 if value != nil { 8137 jtv, ok := value.(string) 8138 if !ok { 8139 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8140 } 8141 sv.NextToken = ptr.String(jtv) 8142 } 8143 8144 case "queryDefinitions": 8145 if err := awsAwsjson11_deserializeDocumentQueryDefinitionList(&sv.QueryDefinitions, value); err != nil { 8146 return err 8147 } 8148 8149 default: 8150 _, _ = key, value 8151 8152 } 8153 } 8154 *v = sv 8155 return nil 8156} 8157 8158func awsAwsjson11_deserializeOpDocumentDescribeResourcePoliciesOutput(v **DescribeResourcePoliciesOutput, value interface{}) error { 8159 if v == nil { 8160 return fmt.Errorf("unexpected nil of type %T", v) 8161 } 8162 if value == nil { 8163 return nil 8164 } 8165 8166 shape, ok := value.(map[string]interface{}) 8167 if !ok { 8168 return fmt.Errorf("unexpected JSON type %v", value) 8169 } 8170 8171 var sv *DescribeResourcePoliciesOutput 8172 if *v == nil { 8173 sv = &DescribeResourcePoliciesOutput{} 8174 } else { 8175 sv = *v 8176 } 8177 8178 for key, value := range shape { 8179 switch key { 8180 case "nextToken": 8181 if value != nil { 8182 jtv, ok := value.(string) 8183 if !ok { 8184 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8185 } 8186 sv.NextToken = ptr.String(jtv) 8187 } 8188 8189 case "resourcePolicies": 8190 if err := awsAwsjson11_deserializeDocumentResourcePolicies(&sv.ResourcePolicies, value); err != nil { 8191 return err 8192 } 8193 8194 default: 8195 _, _ = key, value 8196 8197 } 8198 } 8199 *v = sv 8200 return nil 8201} 8202 8203func awsAwsjson11_deserializeOpDocumentDescribeSubscriptionFiltersOutput(v **DescribeSubscriptionFiltersOutput, value interface{}) error { 8204 if v == nil { 8205 return fmt.Errorf("unexpected nil of type %T", v) 8206 } 8207 if value == nil { 8208 return nil 8209 } 8210 8211 shape, ok := value.(map[string]interface{}) 8212 if !ok { 8213 return fmt.Errorf("unexpected JSON type %v", value) 8214 } 8215 8216 var sv *DescribeSubscriptionFiltersOutput 8217 if *v == nil { 8218 sv = &DescribeSubscriptionFiltersOutput{} 8219 } else { 8220 sv = *v 8221 } 8222 8223 for key, value := range shape { 8224 switch key { 8225 case "nextToken": 8226 if value != nil { 8227 jtv, ok := value.(string) 8228 if !ok { 8229 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8230 } 8231 sv.NextToken = ptr.String(jtv) 8232 } 8233 8234 case "subscriptionFilters": 8235 if err := awsAwsjson11_deserializeDocumentSubscriptionFilters(&sv.SubscriptionFilters, value); err != nil { 8236 return err 8237 } 8238 8239 default: 8240 _, _ = key, value 8241 8242 } 8243 } 8244 *v = sv 8245 return nil 8246} 8247 8248func awsAwsjson11_deserializeOpDocumentFilterLogEventsOutput(v **FilterLogEventsOutput, value interface{}) error { 8249 if v == nil { 8250 return fmt.Errorf("unexpected nil of type %T", v) 8251 } 8252 if value == nil { 8253 return nil 8254 } 8255 8256 shape, ok := value.(map[string]interface{}) 8257 if !ok { 8258 return fmt.Errorf("unexpected JSON type %v", value) 8259 } 8260 8261 var sv *FilterLogEventsOutput 8262 if *v == nil { 8263 sv = &FilterLogEventsOutput{} 8264 } else { 8265 sv = *v 8266 } 8267 8268 for key, value := range shape { 8269 switch key { 8270 case "events": 8271 if err := awsAwsjson11_deserializeDocumentFilteredLogEvents(&sv.Events, value); err != nil { 8272 return err 8273 } 8274 8275 case "nextToken": 8276 if value != nil { 8277 jtv, ok := value.(string) 8278 if !ok { 8279 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8280 } 8281 sv.NextToken = ptr.String(jtv) 8282 } 8283 8284 case "searchedLogStreams": 8285 if err := awsAwsjson11_deserializeDocumentSearchedLogStreams(&sv.SearchedLogStreams, value); err != nil { 8286 return err 8287 } 8288 8289 default: 8290 _, _ = key, value 8291 8292 } 8293 } 8294 *v = sv 8295 return nil 8296} 8297 8298func awsAwsjson11_deserializeOpDocumentGetLogEventsOutput(v **GetLogEventsOutput, value interface{}) error { 8299 if v == nil { 8300 return fmt.Errorf("unexpected nil of type %T", v) 8301 } 8302 if value == nil { 8303 return nil 8304 } 8305 8306 shape, ok := value.(map[string]interface{}) 8307 if !ok { 8308 return fmt.Errorf("unexpected JSON type %v", value) 8309 } 8310 8311 var sv *GetLogEventsOutput 8312 if *v == nil { 8313 sv = &GetLogEventsOutput{} 8314 } else { 8315 sv = *v 8316 } 8317 8318 for key, value := range shape { 8319 switch key { 8320 case "events": 8321 if err := awsAwsjson11_deserializeDocumentOutputLogEvents(&sv.Events, value); err != nil { 8322 return err 8323 } 8324 8325 case "nextBackwardToken": 8326 if value != nil { 8327 jtv, ok := value.(string) 8328 if !ok { 8329 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8330 } 8331 sv.NextBackwardToken = ptr.String(jtv) 8332 } 8333 8334 case "nextForwardToken": 8335 if value != nil { 8336 jtv, ok := value.(string) 8337 if !ok { 8338 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8339 } 8340 sv.NextForwardToken = ptr.String(jtv) 8341 } 8342 8343 default: 8344 _, _ = key, value 8345 8346 } 8347 } 8348 *v = sv 8349 return nil 8350} 8351 8352func awsAwsjson11_deserializeOpDocumentGetLogGroupFieldsOutput(v **GetLogGroupFieldsOutput, value interface{}) error { 8353 if v == nil { 8354 return fmt.Errorf("unexpected nil of type %T", v) 8355 } 8356 if value == nil { 8357 return nil 8358 } 8359 8360 shape, ok := value.(map[string]interface{}) 8361 if !ok { 8362 return fmt.Errorf("unexpected JSON type %v", value) 8363 } 8364 8365 var sv *GetLogGroupFieldsOutput 8366 if *v == nil { 8367 sv = &GetLogGroupFieldsOutput{} 8368 } else { 8369 sv = *v 8370 } 8371 8372 for key, value := range shape { 8373 switch key { 8374 case "logGroupFields": 8375 if err := awsAwsjson11_deserializeDocumentLogGroupFieldList(&sv.LogGroupFields, value); err != nil { 8376 return err 8377 } 8378 8379 default: 8380 _, _ = key, value 8381 8382 } 8383 } 8384 *v = sv 8385 return nil 8386} 8387 8388func awsAwsjson11_deserializeOpDocumentGetLogRecordOutput(v **GetLogRecordOutput, value interface{}) error { 8389 if v == nil { 8390 return fmt.Errorf("unexpected nil of type %T", v) 8391 } 8392 if value == nil { 8393 return nil 8394 } 8395 8396 shape, ok := value.(map[string]interface{}) 8397 if !ok { 8398 return fmt.Errorf("unexpected JSON type %v", value) 8399 } 8400 8401 var sv *GetLogRecordOutput 8402 if *v == nil { 8403 sv = &GetLogRecordOutput{} 8404 } else { 8405 sv = *v 8406 } 8407 8408 for key, value := range shape { 8409 switch key { 8410 case "logRecord": 8411 if err := awsAwsjson11_deserializeDocumentLogRecord(&sv.LogRecord, value); err != nil { 8412 return err 8413 } 8414 8415 default: 8416 _, _ = key, value 8417 8418 } 8419 } 8420 *v = sv 8421 return nil 8422} 8423 8424func awsAwsjson11_deserializeOpDocumentGetQueryResultsOutput(v **GetQueryResultsOutput, value interface{}) error { 8425 if v == nil { 8426 return fmt.Errorf("unexpected nil of type %T", v) 8427 } 8428 if value == nil { 8429 return nil 8430 } 8431 8432 shape, ok := value.(map[string]interface{}) 8433 if !ok { 8434 return fmt.Errorf("unexpected JSON type %v", value) 8435 } 8436 8437 var sv *GetQueryResultsOutput 8438 if *v == nil { 8439 sv = &GetQueryResultsOutput{} 8440 } else { 8441 sv = *v 8442 } 8443 8444 for key, value := range shape { 8445 switch key { 8446 case "results": 8447 if err := awsAwsjson11_deserializeDocumentQueryResults(&sv.Results, value); err != nil { 8448 return err 8449 } 8450 8451 case "statistics": 8452 if err := awsAwsjson11_deserializeDocumentQueryStatistics(&sv.Statistics, value); err != nil { 8453 return err 8454 } 8455 8456 case "status": 8457 if value != nil { 8458 jtv, ok := value.(string) 8459 if !ok { 8460 return fmt.Errorf("expected QueryStatus to be of type string, got %T instead", value) 8461 } 8462 sv.Status = types.QueryStatus(jtv) 8463 } 8464 8465 default: 8466 _, _ = key, value 8467 8468 } 8469 } 8470 *v = sv 8471 return nil 8472} 8473 8474func awsAwsjson11_deserializeOpDocumentListTagsLogGroupOutput(v **ListTagsLogGroupOutput, value interface{}) error { 8475 if v == nil { 8476 return fmt.Errorf("unexpected nil of type %T", v) 8477 } 8478 if value == nil { 8479 return nil 8480 } 8481 8482 shape, ok := value.(map[string]interface{}) 8483 if !ok { 8484 return fmt.Errorf("unexpected JSON type %v", value) 8485 } 8486 8487 var sv *ListTagsLogGroupOutput 8488 if *v == nil { 8489 sv = &ListTagsLogGroupOutput{} 8490 } else { 8491 sv = *v 8492 } 8493 8494 for key, value := range shape { 8495 switch key { 8496 case "tags": 8497 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 8498 return err 8499 } 8500 8501 default: 8502 _, _ = key, value 8503 8504 } 8505 } 8506 *v = sv 8507 return nil 8508} 8509 8510func awsAwsjson11_deserializeOpDocumentPutDestinationOutput(v **PutDestinationOutput, value interface{}) error { 8511 if v == nil { 8512 return fmt.Errorf("unexpected nil of type %T", v) 8513 } 8514 if value == nil { 8515 return nil 8516 } 8517 8518 shape, ok := value.(map[string]interface{}) 8519 if !ok { 8520 return fmt.Errorf("unexpected JSON type %v", value) 8521 } 8522 8523 var sv *PutDestinationOutput 8524 if *v == nil { 8525 sv = &PutDestinationOutput{} 8526 } else { 8527 sv = *v 8528 } 8529 8530 for key, value := range shape { 8531 switch key { 8532 case "destination": 8533 if err := awsAwsjson11_deserializeDocumentDestination(&sv.Destination, value); err != nil { 8534 return err 8535 } 8536 8537 default: 8538 _, _ = key, value 8539 8540 } 8541 } 8542 *v = sv 8543 return nil 8544} 8545 8546func awsAwsjson11_deserializeOpDocumentPutLogEventsOutput(v **PutLogEventsOutput, value interface{}) error { 8547 if v == nil { 8548 return fmt.Errorf("unexpected nil of type %T", v) 8549 } 8550 if value == nil { 8551 return nil 8552 } 8553 8554 shape, ok := value.(map[string]interface{}) 8555 if !ok { 8556 return fmt.Errorf("unexpected JSON type %v", value) 8557 } 8558 8559 var sv *PutLogEventsOutput 8560 if *v == nil { 8561 sv = &PutLogEventsOutput{} 8562 } else { 8563 sv = *v 8564 } 8565 8566 for key, value := range shape { 8567 switch key { 8568 case "nextSequenceToken": 8569 if value != nil { 8570 jtv, ok := value.(string) 8571 if !ok { 8572 return fmt.Errorf("expected SequenceToken to be of type string, got %T instead", value) 8573 } 8574 sv.NextSequenceToken = ptr.String(jtv) 8575 } 8576 8577 case "rejectedLogEventsInfo": 8578 if err := awsAwsjson11_deserializeDocumentRejectedLogEventsInfo(&sv.RejectedLogEventsInfo, value); err != nil { 8579 return err 8580 } 8581 8582 default: 8583 _, _ = key, value 8584 8585 } 8586 } 8587 *v = sv 8588 return nil 8589} 8590 8591func awsAwsjson11_deserializeOpDocumentPutQueryDefinitionOutput(v **PutQueryDefinitionOutput, value interface{}) error { 8592 if v == nil { 8593 return fmt.Errorf("unexpected nil of type %T", v) 8594 } 8595 if value == nil { 8596 return nil 8597 } 8598 8599 shape, ok := value.(map[string]interface{}) 8600 if !ok { 8601 return fmt.Errorf("unexpected JSON type %v", value) 8602 } 8603 8604 var sv *PutQueryDefinitionOutput 8605 if *v == nil { 8606 sv = &PutQueryDefinitionOutput{} 8607 } else { 8608 sv = *v 8609 } 8610 8611 for key, value := range shape { 8612 switch key { 8613 case "queryDefinitionId": 8614 if value != nil { 8615 jtv, ok := value.(string) 8616 if !ok { 8617 return fmt.Errorf("expected QueryId to be of type string, got %T instead", value) 8618 } 8619 sv.QueryDefinitionId = ptr.String(jtv) 8620 } 8621 8622 default: 8623 _, _ = key, value 8624 8625 } 8626 } 8627 *v = sv 8628 return nil 8629} 8630 8631func awsAwsjson11_deserializeOpDocumentPutResourcePolicyOutput(v **PutResourcePolicyOutput, value interface{}) error { 8632 if v == nil { 8633 return fmt.Errorf("unexpected nil of type %T", v) 8634 } 8635 if value == nil { 8636 return nil 8637 } 8638 8639 shape, ok := value.(map[string]interface{}) 8640 if !ok { 8641 return fmt.Errorf("unexpected JSON type %v", value) 8642 } 8643 8644 var sv *PutResourcePolicyOutput 8645 if *v == nil { 8646 sv = &PutResourcePolicyOutput{} 8647 } else { 8648 sv = *v 8649 } 8650 8651 for key, value := range shape { 8652 switch key { 8653 case "resourcePolicy": 8654 if err := awsAwsjson11_deserializeDocumentResourcePolicy(&sv.ResourcePolicy, value); err != nil { 8655 return err 8656 } 8657 8658 default: 8659 _, _ = key, value 8660 8661 } 8662 } 8663 *v = sv 8664 return nil 8665} 8666 8667func awsAwsjson11_deserializeOpDocumentStartQueryOutput(v **StartQueryOutput, value interface{}) error { 8668 if v == nil { 8669 return fmt.Errorf("unexpected nil of type %T", v) 8670 } 8671 if value == nil { 8672 return nil 8673 } 8674 8675 shape, ok := value.(map[string]interface{}) 8676 if !ok { 8677 return fmt.Errorf("unexpected JSON type %v", value) 8678 } 8679 8680 var sv *StartQueryOutput 8681 if *v == nil { 8682 sv = &StartQueryOutput{} 8683 } else { 8684 sv = *v 8685 } 8686 8687 for key, value := range shape { 8688 switch key { 8689 case "queryId": 8690 if value != nil { 8691 jtv, ok := value.(string) 8692 if !ok { 8693 return fmt.Errorf("expected QueryId to be of type string, got %T instead", value) 8694 } 8695 sv.QueryId = ptr.String(jtv) 8696 } 8697 8698 default: 8699 _, _ = key, value 8700 8701 } 8702 } 8703 *v = sv 8704 return nil 8705} 8706 8707func awsAwsjson11_deserializeOpDocumentStopQueryOutput(v **StopQueryOutput, value interface{}) error { 8708 if v == nil { 8709 return fmt.Errorf("unexpected nil of type %T", v) 8710 } 8711 if value == nil { 8712 return nil 8713 } 8714 8715 shape, ok := value.(map[string]interface{}) 8716 if !ok { 8717 return fmt.Errorf("unexpected JSON type %v", value) 8718 } 8719 8720 var sv *StopQueryOutput 8721 if *v == nil { 8722 sv = &StopQueryOutput{} 8723 } else { 8724 sv = *v 8725 } 8726 8727 for key, value := range shape { 8728 switch key { 8729 case "success": 8730 if value != nil { 8731 jtv, ok := value.(bool) 8732 if !ok { 8733 return fmt.Errorf("expected Success to be of type *bool, got %T instead", value) 8734 } 8735 sv.Success = jtv 8736 } 8737 8738 default: 8739 _, _ = key, value 8740 8741 } 8742 } 8743 *v = sv 8744 return nil 8745} 8746 8747func awsAwsjson11_deserializeOpDocumentTestMetricFilterOutput(v **TestMetricFilterOutput, value interface{}) error { 8748 if v == nil { 8749 return fmt.Errorf("unexpected nil of type %T", v) 8750 } 8751 if value == nil { 8752 return nil 8753 } 8754 8755 shape, ok := value.(map[string]interface{}) 8756 if !ok { 8757 return fmt.Errorf("unexpected JSON type %v", value) 8758 } 8759 8760 var sv *TestMetricFilterOutput 8761 if *v == nil { 8762 sv = &TestMetricFilterOutput{} 8763 } else { 8764 sv = *v 8765 } 8766 8767 for key, value := range shape { 8768 switch key { 8769 case "matches": 8770 if err := awsAwsjson11_deserializeDocumentMetricFilterMatches(&sv.Matches, value); err != nil { 8771 return err 8772 } 8773 8774 default: 8775 _, _ = key, value 8776 8777 } 8778 } 8779 *v = sv 8780 return nil 8781} 8782