1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package neptune 4 5import ( 6 "bytes" 7 "context" 8 "encoding/xml" 9 "fmt" 10 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" 11 awsxml "github.com/aws/aws-sdk-go-v2/aws/protocol/xml" 12 "github.com/aws/aws-sdk-go-v2/service/neptune/types" 13 smithy "github.com/aws/smithy-go" 14 smithyxml "github.com/aws/smithy-go/encoding/xml" 15 smithyio "github.com/aws/smithy-go/io" 16 "github.com/aws/smithy-go/middleware" 17 "github.com/aws/smithy-go/ptr" 18 smithytime "github.com/aws/smithy-go/time" 19 smithyhttp "github.com/aws/smithy-go/transport/http" 20 "io" 21 "io/ioutil" 22 "strconv" 23 "strings" 24) 25 26type awsAwsquery_deserializeOpAddRoleToDBCluster struct { 27} 28 29func (*awsAwsquery_deserializeOpAddRoleToDBCluster) ID() string { 30 return "OperationDeserializer" 31} 32 33func (m *awsAwsquery_deserializeOpAddRoleToDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 34 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 35) { 36 out, metadata, err = next.HandleDeserialize(ctx, in) 37 if err != nil { 38 return out, metadata, err 39 } 40 41 response, ok := out.RawResponse.(*smithyhttp.Response) 42 if !ok { 43 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 44 } 45 46 if response.StatusCode < 200 || response.StatusCode >= 300 { 47 return out, metadata, awsAwsquery_deserializeOpErrorAddRoleToDBCluster(response, &metadata) 48 } 49 output := &AddRoleToDBClusterOutput{} 50 out.Result = output 51 52 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 53 return out, metadata, &smithy.DeserializationError{ 54 Err: fmt.Errorf("failed to discard response body, %w", err), 55 } 56 } 57 58 return out, metadata, err 59} 60 61func awsAwsquery_deserializeOpErrorAddRoleToDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 62 var errorBuffer bytes.Buffer 63 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 64 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 65 } 66 errorBody := bytes.NewReader(errorBuffer.Bytes()) 67 68 errorCode := "UnknownError" 69 errorMessage := errorCode 70 71 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 72 if err != nil { 73 return err 74 } 75 if reqID := errorComponents.RequestID; len(reqID) != 0 { 76 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 77 } 78 if len(errorComponents.Code) != 0 { 79 errorCode = errorComponents.Code 80 } 81 if len(errorComponents.Message) != 0 { 82 errorMessage = errorComponents.Message 83 } 84 errorBody.Seek(0, io.SeekStart) 85 switch { 86 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 87 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 88 89 case strings.EqualFold("DBClusterRoleAlreadyExistsFault", errorCode): 90 return awsAwsquery_deserializeErrorDBClusterRoleAlreadyExistsFault(response, errorBody) 91 92 case strings.EqualFold("DBClusterRoleQuotaExceededFault", errorCode): 93 return awsAwsquery_deserializeErrorDBClusterRoleQuotaExceededFault(response, errorBody) 94 95 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 96 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 97 98 default: 99 genericError := &smithy.GenericAPIError{ 100 Code: errorCode, 101 Message: errorMessage, 102 } 103 return genericError 104 105 } 106} 107 108type awsAwsquery_deserializeOpAddSourceIdentifierToSubscription struct { 109} 110 111func (*awsAwsquery_deserializeOpAddSourceIdentifierToSubscription) ID() string { 112 return "OperationDeserializer" 113} 114 115func (m *awsAwsquery_deserializeOpAddSourceIdentifierToSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 116 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 117) { 118 out, metadata, err = next.HandleDeserialize(ctx, in) 119 if err != nil { 120 return out, metadata, err 121 } 122 123 response, ok := out.RawResponse.(*smithyhttp.Response) 124 if !ok { 125 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 126 } 127 128 if response.StatusCode < 200 || response.StatusCode >= 300 { 129 return out, metadata, awsAwsquery_deserializeOpErrorAddSourceIdentifierToSubscription(response, &metadata) 130 } 131 output := &AddSourceIdentifierToSubscriptionOutput{} 132 out.Result = output 133 134 var buff [1024]byte 135 ringBuffer := smithyio.NewRingBuffer(buff[:]) 136 body := io.TeeReader(response.Body, ringBuffer) 137 rootDecoder := xml.NewDecoder(body) 138 t, err := smithyxml.FetchRootElement(rootDecoder) 139 if err == io.EOF { 140 return out, metadata, nil 141 } 142 if err != nil { 143 var snapshot bytes.Buffer 144 io.Copy(&snapshot, ringBuffer) 145 return out, metadata, &smithy.DeserializationError{ 146 Err: fmt.Errorf("failed to decode response body, %w", err), 147 Snapshot: snapshot.Bytes(), 148 } 149 } 150 151 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 152 t, err = decoder.GetElement("AddSourceIdentifierToSubscriptionResult") 153 if err != nil { 154 var snapshot bytes.Buffer 155 io.Copy(&snapshot, ringBuffer) 156 err = &smithy.DeserializationError{ 157 Err: fmt.Errorf("failed to decode response body, %w", err), 158 Snapshot: snapshot.Bytes(), 159 } 160 return out, metadata, err 161 } 162 163 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 164 err = awsAwsquery_deserializeOpDocumentAddSourceIdentifierToSubscriptionOutput(&output, decoder) 165 if err != nil { 166 var snapshot bytes.Buffer 167 io.Copy(&snapshot, ringBuffer) 168 err = &smithy.DeserializationError{ 169 Err: fmt.Errorf("failed to decode response body, %w", err), 170 Snapshot: snapshot.Bytes(), 171 } 172 return out, metadata, err 173 } 174 175 return out, metadata, err 176} 177 178func awsAwsquery_deserializeOpErrorAddSourceIdentifierToSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 179 var errorBuffer bytes.Buffer 180 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 181 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 182 } 183 errorBody := bytes.NewReader(errorBuffer.Bytes()) 184 185 errorCode := "UnknownError" 186 errorMessage := errorCode 187 188 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 189 if err != nil { 190 return err 191 } 192 if reqID := errorComponents.RequestID; len(reqID) != 0 { 193 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 194 } 195 if len(errorComponents.Code) != 0 { 196 errorCode = errorComponents.Code 197 } 198 if len(errorComponents.Message) != 0 { 199 errorMessage = errorComponents.Message 200 } 201 errorBody.Seek(0, io.SeekStart) 202 switch { 203 case strings.EqualFold("SourceNotFoundFault", errorCode): 204 return awsAwsquery_deserializeErrorSourceNotFoundFault(response, errorBody) 205 206 case strings.EqualFold("SubscriptionNotFoundFault", errorCode): 207 return awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response, errorBody) 208 209 default: 210 genericError := &smithy.GenericAPIError{ 211 Code: errorCode, 212 Message: errorMessage, 213 } 214 return genericError 215 216 } 217} 218 219type awsAwsquery_deserializeOpAddTagsToResource struct { 220} 221 222func (*awsAwsquery_deserializeOpAddTagsToResource) ID() string { 223 return "OperationDeserializer" 224} 225 226func (m *awsAwsquery_deserializeOpAddTagsToResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 227 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 228) { 229 out, metadata, err = next.HandleDeserialize(ctx, in) 230 if err != nil { 231 return out, metadata, err 232 } 233 234 response, ok := out.RawResponse.(*smithyhttp.Response) 235 if !ok { 236 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 237 } 238 239 if response.StatusCode < 200 || response.StatusCode >= 300 { 240 return out, metadata, awsAwsquery_deserializeOpErrorAddTagsToResource(response, &metadata) 241 } 242 output := &AddTagsToResourceOutput{} 243 out.Result = output 244 245 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 246 return out, metadata, &smithy.DeserializationError{ 247 Err: fmt.Errorf("failed to discard response body, %w", err), 248 } 249 } 250 251 return out, metadata, err 252} 253 254func awsAwsquery_deserializeOpErrorAddTagsToResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 255 var errorBuffer bytes.Buffer 256 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 257 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 258 } 259 errorBody := bytes.NewReader(errorBuffer.Bytes()) 260 261 errorCode := "UnknownError" 262 errorMessage := errorCode 263 264 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 265 if err != nil { 266 return err 267 } 268 if reqID := errorComponents.RequestID; len(reqID) != 0 { 269 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 270 } 271 if len(errorComponents.Code) != 0 { 272 errorCode = errorComponents.Code 273 } 274 if len(errorComponents.Message) != 0 { 275 errorMessage = errorComponents.Message 276 } 277 errorBody.Seek(0, io.SeekStart) 278 switch { 279 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 280 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 281 282 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 283 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 284 285 case strings.EqualFold("DBSnapshotNotFoundFault", errorCode): 286 return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) 287 288 default: 289 genericError := &smithy.GenericAPIError{ 290 Code: errorCode, 291 Message: errorMessage, 292 } 293 return genericError 294 295 } 296} 297 298type awsAwsquery_deserializeOpApplyPendingMaintenanceAction struct { 299} 300 301func (*awsAwsquery_deserializeOpApplyPendingMaintenanceAction) ID() string { 302 return "OperationDeserializer" 303} 304 305func (m *awsAwsquery_deserializeOpApplyPendingMaintenanceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 306 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 307) { 308 out, metadata, err = next.HandleDeserialize(ctx, in) 309 if err != nil { 310 return out, metadata, err 311 } 312 313 response, ok := out.RawResponse.(*smithyhttp.Response) 314 if !ok { 315 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 316 } 317 318 if response.StatusCode < 200 || response.StatusCode >= 300 { 319 return out, metadata, awsAwsquery_deserializeOpErrorApplyPendingMaintenanceAction(response, &metadata) 320 } 321 output := &ApplyPendingMaintenanceActionOutput{} 322 out.Result = output 323 324 var buff [1024]byte 325 ringBuffer := smithyio.NewRingBuffer(buff[:]) 326 body := io.TeeReader(response.Body, ringBuffer) 327 rootDecoder := xml.NewDecoder(body) 328 t, err := smithyxml.FetchRootElement(rootDecoder) 329 if err == io.EOF { 330 return out, metadata, nil 331 } 332 if err != nil { 333 var snapshot bytes.Buffer 334 io.Copy(&snapshot, ringBuffer) 335 return out, metadata, &smithy.DeserializationError{ 336 Err: fmt.Errorf("failed to decode response body, %w", err), 337 Snapshot: snapshot.Bytes(), 338 } 339 } 340 341 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 342 t, err = decoder.GetElement("ApplyPendingMaintenanceActionResult") 343 if err != nil { 344 var snapshot bytes.Buffer 345 io.Copy(&snapshot, ringBuffer) 346 err = &smithy.DeserializationError{ 347 Err: fmt.Errorf("failed to decode response body, %w", err), 348 Snapshot: snapshot.Bytes(), 349 } 350 return out, metadata, err 351 } 352 353 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 354 err = awsAwsquery_deserializeOpDocumentApplyPendingMaintenanceActionOutput(&output, decoder) 355 if err != nil { 356 var snapshot bytes.Buffer 357 io.Copy(&snapshot, ringBuffer) 358 err = &smithy.DeserializationError{ 359 Err: fmt.Errorf("failed to decode response body, %w", err), 360 Snapshot: snapshot.Bytes(), 361 } 362 return out, metadata, err 363 } 364 365 return out, metadata, err 366} 367 368func awsAwsquery_deserializeOpErrorApplyPendingMaintenanceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 369 var errorBuffer bytes.Buffer 370 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 371 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 372 } 373 errorBody := bytes.NewReader(errorBuffer.Bytes()) 374 375 errorCode := "UnknownError" 376 errorMessage := errorCode 377 378 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 379 if err != nil { 380 return err 381 } 382 if reqID := errorComponents.RequestID; len(reqID) != 0 { 383 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 384 } 385 if len(errorComponents.Code) != 0 { 386 errorCode = errorComponents.Code 387 } 388 if len(errorComponents.Message) != 0 { 389 errorMessage = errorComponents.Message 390 } 391 errorBody.Seek(0, io.SeekStart) 392 switch { 393 case strings.EqualFold("ResourceNotFoundFault", errorCode): 394 return awsAwsquery_deserializeErrorResourceNotFoundFault(response, errorBody) 395 396 default: 397 genericError := &smithy.GenericAPIError{ 398 Code: errorCode, 399 Message: errorMessage, 400 } 401 return genericError 402 403 } 404} 405 406type awsAwsquery_deserializeOpCopyDBClusterParameterGroup struct { 407} 408 409func (*awsAwsquery_deserializeOpCopyDBClusterParameterGroup) ID() string { 410 return "OperationDeserializer" 411} 412 413func (m *awsAwsquery_deserializeOpCopyDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 414 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 415) { 416 out, metadata, err = next.HandleDeserialize(ctx, in) 417 if err != nil { 418 return out, metadata, err 419 } 420 421 response, ok := out.RawResponse.(*smithyhttp.Response) 422 if !ok { 423 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 424 } 425 426 if response.StatusCode < 200 || response.StatusCode >= 300 { 427 return out, metadata, awsAwsquery_deserializeOpErrorCopyDBClusterParameterGroup(response, &metadata) 428 } 429 output := &CopyDBClusterParameterGroupOutput{} 430 out.Result = output 431 432 var buff [1024]byte 433 ringBuffer := smithyio.NewRingBuffer(buff[:]) 434 body := io.TeeReader(response.Body, ringBuffer) 435 rootDecoder := xml.NewDecoder(body) 436 t, err := smithyxml.FetchRootElement(rootDecoder) 437 if err == io.EOF { 438 return out, metadata, nil 439 } 440 if err != nil { 441 var snapshot bytes.Buffer 442 io.Copy(&snapshot, ringBuffer) 443 return out, metadata, &smithy.DeserializationError{ 444 Err: fmt.Errorf("failed to decode response body, %w", err), 445 Snapshot: snapshot.Bytes(), 446 } 447 } 448 449 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 450 t, err = decoder.GetElement("CopyDBClusterParameterGroupResult") 451 if err != nil { 452 var snapshot bytes.Buffer 453 io.Copy(&snapshot, ringBuffer) 454 err = &smithy.DeserializationError{ 455 Err: fmt.Errorf("failed to decode response body, %w", err), 456 Snapshot: snapshot.Bytes(), 457 } 458 return out, metadata, err 459 } 460 461 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 462 err = awsAwsquery_deserializeOpDocumentCopyDBClusterParameterGroupOutput(&output, decoder) 463 if err != nil { 464 var snapshot bytes.Buffer 465 io.Copy(&snapshot, ringBuffer) 466 err = &smithy.DeserializationError{ 467 Err: fmt.Errorf("failed to decode response body, %w", err), 468 Snapshot: snapshot.Bytes(), 469 } 470 return out, metadata, err 471 } 472 473 return out, metadata, err 474} 475 476func awsAwsquery_deserializeOpErrorCopyDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 477 var errorBuffer bytes.Buffer 478 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 479 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 480 } 481 errorBody := bytes.NewReader(errorBuffer.Bytes()) 482 483 errorCode := "UnknownError" 484 errorMessage := errorCode 485 486 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 487 if err != nil { 488 return err 489 } 490 if reqID := errorComponents.RequestID; len(reqID) != 0 { 491 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 492 } 493 if len(errorComponents.Code) != 0 { 494 errorCode = errorComponents.Code 495 } 496 if len(errorComponents.Message) != 0 { 497 errorMessage = errorComponents.Message 498 } 499 errorBody.Seek(0, io.SeekStart) 500 switch { 501 case strings.EqualFold("DBParameterGroupAlreadyExistsFault", errorCode): 502 return awsAwsquery_deserializeErrorDBParameterGroupAlreadyExistsFault(response, errorBody) 503 504 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 505 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 506 507 case strings.EqualFold("DBParameterGroupQuotaExceededFault", errorCode): 508 return awsAwsquery_deserializeErrorDBParameterGroupQuotaExceededFault(response, errorBody) 509 510 default: 511 genericError := &smithy.GenericAPIError{ 512 Code: errorCode, 513 Message: errorMessage, 514 } 515 return genericError 516 517 } 518} 519 520type awsAwsquery_deserializeOpCopyDBClusterSnapshot struct { 521} 522 523func (*awsAwsquery_deserializeOpCopyDBClusterSnapshot) ID() string { 524 return "OperationDeserializer" 525} 526 527func (m *awsAwsquery_deserializeOpCopyDBClusterSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 528 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 529) { 530 out, metadata, err = next.HandleDeserialize(ctx, in) 531 if err != nil { 532 return out, metadata, err 533 } 534 535 response, ok := out.RawResponse.(*smithyhttp.Response) 536 if !ok { 537 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 538 } 539 540 if response.StatusCode < 200 || response.StatusCode >= 300 { 541 return out, metadata, awsAwsquery_deserializeOpErrorCopyDBClusterSnapshot(response, &metadata) 542 } 543 output := &CopyDBClusterSnapshotOutput{} 544 out.Result = output 545 546 var buff [1024]byte 547 ringBuffer := smithyio.NewRingBuffer(buff[:]) 548 body := io.TeeReader(response.Body, ringBuffer) 549 rootDecoder := xml.NewDecoder(body) 550 t, err := smithyxml.FetchRootElement(rootDecoder) 551 if err == io.EOF { 552 return out, metadata, nil 553 } 554 if err != nil { 555 var snapshot bytes.Buffer 556 io.Copy(&snapshot, ringBuffer) 557 return out, metadata, &smithy.DeserializationError{ 558 Err: fmt.Errorf("failed to decode response body, %w", err), 559 Snapshot: snapshot.Bytes(), 560 } 561 } 562 563 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 564 t, err = decoder.GetElement("CopyDBClusterSnapshotResult") 565 if err != nil { 566 var snapshot bytes.Buffer 567 io.Copy(&snapshot, ringBuffer) 568 err = &smithy.DeserializationError{ 569 Err: fmt.Errorf("failed to decode response body, %w", err), 570 Snapshot: snapshot.Bytes(), 571 } 572 return out, metadata, err 573 } 574 575 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 576 err = awsAwsquery_deserializeOpDocumentCopyDBClusterSnapshotOutput(&output, decoder) 577 if err != nil { 578 var snapshot bytes.Buffer 579 io.Copy(&snapshot, ringBuffer) 580 err = &smithy.DeserializationError{ 581 Err: fmt.Errorf("failed to decode response body, %w", err), 582 Snapshot: snapshot.Bytes(), 583 } 584 return out, metadata, err 585 } 586 587 return out, metadata, err 588} 589 590func awsAwsquery_deserializeOpErrorCopyDBClusterSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { 591 var errorBuffer bytes.Buffer 592 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 593 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 594 } 595 errorBody := bytes.NewReader(errorBuffer.Bytes()) 596 597 errorCode := "UnknownError" 598 errorMessage := errorCode 599 600 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 601 if err != nil { 602 return err 603 } 604 if reqID := errorComponents.RequestID; len(reqID) != 0 { 605 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 606 } 607 if len(errorComponents.Code) != 0 { 608 errorCode = errorComponents.Code 609 } 610 if len(errorComponents.Message) != 0 { 611 errorMessage = errorComponents.Message 612 } 613 errorBody.Seek(0, io.SeekStart) 614 switch { 615 case strings.EqualFold("DBClusterSnapshotAlreadyExistsFault", errorCode): 616 return awsAwsquery_deserializeErrorDBClusterSnapshotAlreadyExistsFault(response, errorBody) 617 618 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 619 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 620 621 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 622 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 623 624 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 625 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 626 627 case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): 628 return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) 629 630 case strings.EqualFold("SnapshotQuotaExceededFault", errorCode): 631 return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody) 632 633 default: 634 genericError := &smithy.GenericAPIError{ 635 Code: errorCode, 636 Message: errorMessage, 637 } 638 return genericError 639 640 } 641} 642 643type awsAwsquery_deserializeOpCopyDBParameterGroup struct { 644} 645 646func (*awsAwsquery_deserializeOpCopyDBParameterGroup) ID() string { 647 return "OperationDeserializer" 648} 649 650func (m *awsAwsquery_deserializeOpCopyDBParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 651 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 652) { 653 out, metadata, err = next.HandleDeserialize(ctx, in) 654 if err != nil { 655 return out, metadata, err 656 } 657 658 response, ok := out.RawResponse.(*smithyhttp.Response) 659 if !ok { 660 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 661 } 662 663 if response.StatusCode < 200 || response.StatusCode >= 300 { 664 return out, metadata, awsAwsquery_deserializeOpErrorCopyDBParameterGroup(response, &metadata) 665 } 666 output := &CopyDBParameterGroupOutput{} 667 out.Result = output 668 669 var buff [1024]byte 670 ringBuffer := smithyio.NewRingBuffer(buff[:]) 671 body := io.TeeReader(response.Body, ringBuffer) 672 rootDecoder := xml.NewDecoder(body) 673 t, err := smithyxml.FetchRootElement(rootDecoder) 674 if err == io.EOF { 675 return out, metadata, nil 676 } 677 if err != nil { 678 var snapshot bytes.Buffer 679 io.Copy(&snapshot, ringBuffer) 680 return out, metadata, &smithy.DeserializationError{ 681 Err: fmt.Errorf("failed to decode response body, %w", err), 682 Snapshot: snapshot.Bytes(), 683 } 684 } 685 686 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 687 t, err = decoder.GetElement("CopyDBParameterGroupResult") 688 if err != nil { 689 var snapshot bytes.Buffer 690 io.Copy(&snapshot, ringBuffer) 691 err = &smithy.DeserializationError{ 692 Err: fmt.Errorf("failed to decode response body, %w", err), 693 Snapshot: snapshot.Bytes(), 694 } 695 return out, metadata, err 696 } 697 698 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 699 err = awsAwsquery_deserializeOpDocumentCopyDBParameterGroupOutput(&output, decoder) 700 if err != nil { 701 var snapshot bytes.Buffer 702 io.Copy(&snapshot, ringBuffer) 703 err = &smithy.DeserializationError{ 704 Err: fmt.Errorf("failed to decode response body, %w", err), 705 Snapshot: snapshot.Bytes(), 706 } 707 return out, metadata, err 708 } 709 710 return out, metadata, err 711} 712 713func awsAwsquery_deserializeOpErrorCopyDBParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 714 var errorBuffer bytes.Buffer 715 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 716 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 717 } 718 errorBody := bytes.NewReader(errorBuffer.Bytes()) 719 720 errorCode := "UnknownError" 721 errorMessage := errorCode 722 723 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 724 if err != nil { 725 return err 726 } 727 if reqID := errorComponents.RequestID; len(reqID) != 0 { 728 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 729 } 730 if len(errorComponents.Code) != 0 { 731 errorCode = errorComponents.Code 732 } 733 if len(errorComponents.Message) != 0 { 734 errorMessage = errorComponents.Message 735 } 736 errorBody.Seek(0, io.SeekStart) 737 switch { 738 case strings.EqualFold("DBParameterGroupAlreadyExistsFault", errorCode): 739 return awsAwsquery_deserializeErrorDBParameterGroupAlreadyExistsFault(response, errorBody) 740 741 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 742 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 743 744 case strings.EqualFold("DBParameterGroupQuotaExceededFault", errorCode): 745 return awsAwsquery_deserializeErrorDBParameterGroupQuotaExceededFault(response, errorBody) 746 747 default: 748 genericError := &smithy.GenericAPIError{ 749 Code: errorCode, 750 Message: errorMessage, 751 } 752 return genericError 753 754 } 755} 756 757type awsAwsquery_deserializeOpCreateDBCluster struct { 758} 759 760func (*awsAwsquery_deserializeOpCreateDBCluster) ID() string { 761 return "OperationDeserializer" 762} 763 764func (m *awsAwsquery_deserializeOpCreateDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 765 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 766) { 767 out, metadata, err = next.HandleDeserialize(ctx, in) 768 if err != nil { 769 return out, metadata, err 770 } 771 772 response, ok := out.RawResponse.(*smithyhttp.Response) 773 if !ok { 774 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 775 } 776 777 if response.StatusCode < 200 || response.StatusCode >= 300 { 778 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBCluster(response, &metadata) 779 } 780 output := &CreateDBClusterOutput{} 781 out.Result = output 782 783 var buff [1024]byte 784 ringBuffer := smithyio.NewRingBuffer(buff[:]) 785 body := io.TeeReader(response.Body, ringBuffer) 786 rootDecoder := xml.NewDecoder(body) 787 t, err := smithyxml.FetchRootElement(rootDecoder) 788 if err == io.EOF { 789 return out, metadata, nil 790 } 791 if err != nil { 792 var snapshot bytes.Buffer 793 io.Copy(&snapshot, ringBuffer) 794 return out, metadata, &smithy.DeserializationError{ 795 Err: fmt.Errorf("failed to decode response body, %w", err), 796 Snapshot: snapshot.Bytes(), 797 } 798 } 799 800 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 801 t, err = decoder.GetElement("CreateDBClusterResult") 802 if err != nil { 803 var snapshot bytes.Buffer 804 io.Copy(&snapshot, ringBuffer) 805 err = &smithy.DeserializationError{ 806 Err: fmt.Errorf("failed to decode response body, %w", err), 807 Snapshot: snapshot.Bytes(), 808 } 809 return out, metadata, err 810 } 811 812 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 813 err = awsAwsquery_deserializeOpDocumentCreateDBClusterOutput(&output, decoder) 814 if err != nil { 815 var snapshot bytes.Buffer 816 io.Copy(&snapshot, ringBuffer) 817 err = &smithy.DeserializationError{ 818 Err: fmt.Errorf("failed to decode response body, %w", err), 819 Snapshot: snapshot.Bytes(), 820 } 821 return out, metadata, err 822 } 823 824 return out, metadata, err 825} 826 827func awsAwsquery_deserializeOpErrorCreateDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 828 var errorBuffer bytes.Buffer 829 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 830 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 831 } 832 errorBody := bytes.NewReader(errorBuffer.Bytes()) 833 834 errorCode := "UnknownError" 835 errorMessage := errorCode 836 837 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 838 if err != nil { 839 return err 840 } 841 if reqID := errorComponents.RequestID; len(reqID) != 0 { 842 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 843 } 844 if len(errorComponents.Code) != 0 { 845 errorCode = errorComponents.Code 846 } 847 if len(errorComponents.Message) != 0 { 848 errorMessage = errorComponents.Message 849 } 850 errorBody.Seek(0, io.SeekStart) 851 switch { 852 case strings.EqualFold("DBClusterAlreadyExistsFault", errorCode): 853 return awsAwsquery_deserializeErrorDBClusterAlreadyExistsFault(response, errorBody) 854 855 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 856 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 857 858 case strings.EqualFold("DBClusterParameterGroupNotFoundFault", errorCode): 859 return awsAwsquery_deserializeErrorDBClusterParameterGroupNotFoundFault(response, errorBody) 860 861 case strings.EqualFold("DBClusterQuotaExceededFault", errorCode): 862 return awsAwsquery_deserializeErrorDBClusterQuotaExceededFault(response, errorBody) 863 864 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 865 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 866 867 case strings.EqualFold("DBSubnetGroupDoesNotCoverEnoughAZs", errorCode): 868 return awsAwsquery_deserializeErrorDBSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) 869 870 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 871 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 872 873 case strings.EqualFold("InsufficientStorageClusterCapacityFault", errorCode): 874 return awsAwsquery_deserializeErrorInsufficientStorageClusterCapacityFault(response, errorBody) 875 876 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 877 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 878 879 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 880 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 881 882 case strings.EqualFold("InvalidDBSubnetGroupStateFault", errorCode): 883 return awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response, errorBody) 884 885 case strings.EqualFold("InvalidSubnet", errorCode): 886 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 887 888 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 889 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 890 891 case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): 892 return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) 893 894 case strings.EqualFold("StorageQuotaExceededFault", errorCode): 895 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 896 897 default: 898 genericError := &smithy.GenericAPIError{ 899 Code: errorCode, 900 Message: errorMessage, 901 } 902 return genericError 903 904 } 905} 906 907type awsAwsquery_deserializeOpCreateDBClusterEndpoint struct { 908} 909 910func (*awsAwsquery_deserializeOpCreateDBClusterEndpoint) ID() string { 911 return "OperationDeserializer" 912} 913 914func (m *awsAwsquery_deserializeOpCreateDBClusterEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 915 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 916) { 917 out, metadata, err = next.HandleDeserialize(ctx, in) 918 if err != nil { 919 return out, metadata, err 920 } 921 922 response, ok := out.RawResponse.(*smithyhttp.Response) 923 if !ok { 924 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 925 } 926 927 if response.StatusCode < 200 || response.StatusCode >= 300 { 928 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBClusterEndpoint(response, &metadata) 929 } 930 output := &CreateDBClusterEndpointOutput{} 931 out.Result = output 932 933 var buff [1024]byte 934 ringBuffer := smithyio.NewRingBuffer(buff[:]) 935 body := io.TeeReader(response.Body, ringBuffer) 936 rootDecoder := xml.NewDecoder(body) 937 t, err := smithyxml.FetchRootElement(rootDecoder) 938 if err == io.EOF { 939 return out, metadata, nil 940 } 941 if err != nil { 942 var snapshot bytes.Buffer 943 io.Copy(&snapshot, ringBuffer) 944 return out, metadata, &smithy.DeserializationError{ 945 Err: fmt.Errorf("failed to decode response body, %w", err), 946 Snapshot: snapshot.Bytes(), 947 } 948 } 949 950 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 951 t, err = decoder.GetElement("CreateDBClusterEndpointResult") 952 if err != nil { 953 var snapshot bytes.Buffer 954 io.Copy(&snapshot, ringBuffer) 955 err = &smithy.DeserializationError{ 956 Err: fmt.Errorf("failed to decode response body, %w", err), 957 Snapshot: snapshot.Bytes(), 958 } 959 return out, metadata, err 960 } 961 962 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 963 err = awsAwsquery_deserializeOpDocumentCreateDBClusterEndpointOutput(&output, decoder) 964 if err != nil { 965 var snapshot bytes.Buffer 966 io.Copy(&snapshot, ringBuffer) 967 err = &smithy.DeserializationError{ 968 Err: fmt.Errorf("failed to decode response body, %w", err), 969 Snapshot: snapshot.Bytes(), 970 } 971 return out, metadata, err 972 } 973 974 return out, metadata, err 975} 976 977func awsAwsquery_deserializeOpErrorCreateDBClusterEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 978 var errorBuffer bytes.Buffer 979 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 980 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 981 } 982 errorBody := bytes.NewReader(errorBuffer.Bytes()) 983 984 errorCode := "UnknownError" 985 errorMessage := errorCode 986 987 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 988 if err != nil { 989 return err 990 } 991 if reqID := errorComponents.RequestID; len(reqID) != 0 { 992 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 993 } 994 if len(errorComponents.Code) != 0 { 995 errorCode = errorComponents.Code 996 } 997 if len(errorComponents.Message) != 0 { 998 errorMessage = errorComponents.Message 999 } 1000 errorBody.Seek(0, io.SeekStart) 1001 switch { 1002 case strings.EqualFold("DBClusterEndpointAlreadyExistsFault", errorCode): 1003 return awsAwsquery_deserializeErrorDBClusterEndpointAlreadyExistsFault(response, errorBody) 1004 1005 case strings.EqualFold("DBClusterEndpointQuotaExceededFault", errorCode): 1006 return awsAwsquery_deserializeErrorDBClusterEndpointQuotaExceededFault(response, errorBody) 1007 1008 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 1009 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 1010 1011 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 1012 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 1013 1014 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 1015 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 1016 1017 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 1018 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 1019 1020 default: 1021 genericError := &smithy.GenericAPIError{ 1022 Code: errorCode, 1023 Message: errorMessage, 1024 } 1025 return genericError 1026 1027 } 1028} 1029 1030type awsAwsquery_deserializeOpCreateDBClusterParameterGroup struct { 1031} 1032 1033func (*awsAwsquery_deserializeOpCreateDBClusterParameterGroup) ID() string { 1034 return "OperationDeserializer" 1035} 1036 1037func (m *awsAwsquery_deserializeOpCreateDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1038 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1039) { 1040 out, metadata, err = next.HandleDeserialize(ctx, in) 1041 if err != nil { 1042 return out, metadata, err 1043 } 1044 1045 response, ok := out.RawResponse.(*smithyhttp.Response) 1046 if !ok { 1047 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1048 } 1049 1050 if response.StatusCode < 200 || response.StatusCode >= 300 { 1051 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBClusterParameterGroup(response, &metadata) 1052 } 1053 output := &CreateDBClusterParameterGroupOutput{} 1054 out.Result = output 1055 1056 var buff [1024]byte 1057 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1058 body := io.TeeReader(response.Body, ringBuffer) 1059 rootDecoder := xml.NewDecoder(body) 1060 t, err := smithyxml.FetchRootElement(rootDecoder) 1061 if err == io.EOF { 1062 return out, metadata, nil 1063 } 1064 if err != nil { 1065 var snapshot bytes.Buffer 1066 io.Copy(&snapshot, ringBuffer) 1067 return out, metadata, &smithy.DeserializationError{ 1068 Err: fmt.Errorf("failed to decode response body, %w", err), 1069 Snapshot: snapshot.Bytes(), 1070 } 1071 } 1072 1073 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1074 t, err = decoder.GetElement("CreateDBClusterParameterGroupResult") 1075 if err != nil { 1076 var snapshot bytes.Buffer 1077 io.Copy(&snapshot, ringBuffer) 1078 err = &smithy.DeserializationError{ 1079 Err: fmt.Errorf("failed to decode response body, %w", err), 1080 Snapshot: snapshot.Bytes(), 1081 } 1082 return out, metadata, err 1083 } 1084 1085 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1086 err = awsAwsquery_deserializeOpDocumentCreateDBClusterParameterGroupOutput(&output, decoder) 1087 if err != nil { 1088 var snapshot bytes.Buffer 1089 io.Copy(&snapshot, ringBuffer) 1090 err = &smithy.DeserializationError{ 1091 Err: fmt.Errorf("failed to decode response body, %w", err), 1092 Snapshot: snapshot.Bytes(), 1093 } 1094 return out, metadata, err 1095 } 1096 1097 return out, metadata, err 1098} 1099 1100func awsAwsquery_deserializeOpErrorCreateDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1101 var errorBuffer bytes.Buffer 1102 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1103 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1104 } 1105 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1106 1107 errorCode := "UnknownError" 1108 errorMessage := errorCode 1109 1110 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1111 if err != nil { 1112 return err 1113 } 1114 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1115 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1116 } 1117 if len(errorComponents.Code) != 0 { 1118 errorCode = errorComponents.Code 1119 } 1120 if len(errorComponents.Message) != 0 { 1121 errorMessage = errorComponents.Message 1122 } 1123 errorBody.Seek(0, io.SeekStart) 1124 switch { 1125 case strings.EqualFold("DBParameterGroupAlreadyExistsFault", errorCode): 1126 return awsAwsquery_deserializeErrorDBParameterGroupAlreadyExistsFault(response, errorBody) 1127 1128 case strings.EqualFold("DBParameterGroupQuotaExceededFault", errorCode): 1129 return awsAwsquery_deserializeErrorDBParameterGroupQuotaExceededFault(response, errorBody) 1130 1131 default: 1132 genericError := &smithy.GenericAPIError{ 1133 Code: errorCode, 1134 Message: errorMessage, 1135 } 1136 return genericError 1137 1138 } 1139} 1140 1141type awsAwsquery_deserializeOpCreateDBClusterSnapshot struct { 1142} 1143 1144func (*awsAwsquery_deserializeOpCreateDBClusterSnapshot) ID() string { 1145 return "OperationDeserializer" 1146} 1147 1148func (m *awsAwsquery_deserializeOpCreateDBClusterSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1149 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1150) { 1151 out, metadata, err = next.HandleDeserialize(ctx, in) 1152 if err != nil { 1153 return out, metadata, err 1154 } 1155 1156 response, ok := out.RawResponse.(*smithyhttp.Response) 1157 if !ok { 1158 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1159 } 1160 1161 if response.StatusCode < 200 || response.StatusCode >= 300 { 1162 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBClusterSnapshot(response, &metadata) 1163 } 1164 output := &CreateDBClusterSnapshotOutput{} 1165 out.Result = output 1166 1167 var buff [1024]byte 1168 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1169 body := io.TeeReader(response.Body, ringBuffer) 1170 rootDecoder := xml.NewDecoder(body) 1171 t, err := smithyxml.FetchRootElement(rootDecoder) 1172 if err == io.EOF { 1173 return out, metadata, nil 1174 } 1175 if err != nil { 1176 var snapshot bytes.Buffer 1177 io.Copy(&snapshot, ringBuffer) 1178 return out, metadata, &smithy.DeserializationError{ 1179 Err: fmt.Errorf("failed to decode response body, %w", err), 1180 Snapshot: snapshot.Bytes(), 1181 } 1182 } 1183 1184 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1185 t, err = decoder.GetElement("CreateDBClusterSnapshotResult") 1186 if err != nil { 1187 var snapshot bytes.Buffer 1188 io.Copy(&snapshot, ringBuffer) 1189 err = &smithy.DeserializationError{ 1190 Err: fmt.Errorf("failed to decode response body, %w", err), 1191 Snapshot: snapshot.Bytes(), 1192 } 1193 return out, metadata, err 1194 } 1195 1196 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1197 err = awsAwsquery_deserializeOpDocumentCreateDBClusterSnapshotOutput(&output, decoder) 1198 if err != nil { 1199 var snapshot bytes.Buffer 1200 io.Copy(&snapshot, ringBuffer) 1201 err = &smithy.DeserializationError{ 1202 Err: fmt.Errorf("failed to decode response body, %w", err), 1203 Snapshot: snapshot.Bytes(), 1204 } 1205 return out, metadata, err 1206 } 1207 1208 return out, metadata, err 1209} 1210 1211func awsAwsquery_deserializeOpErrorCreateDBClusterSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1212 var errorBuffer bytes.Buffer 1213 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1214 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1215 } 1216 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1217 1218 errorCode := "UnknownError" 1219 errorMessage := errorCode 1220 1221 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1222 if err != nil { 1223 return err 1224 } 1225 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1226 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1227 } 1228 if len(errorComponents.Code) != 0 { 1229 errorCode = errorComponents.Code 1230 } 1231 if len(errorComponents.Message) != 0 { 1232 errorMessage = errorComponents.Message 1233 } 1234 errorBody.Seek(0, io.SeekStart) 1235 switch { 1236 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 1237 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 1238 1239 case strings.EqualFold("DBClusterSnapshotAlreadyExistsFault", errorCode): 1240 return awsAwsquery_deserializeErrorDBClusterSnapshotAlreadyExistsFault(response, errorBody) 1241 1242 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 1243 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 1244 1245 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 1246 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 1247 1248 case strings.EqualFold("SnapshotQuotaExceededFault", errorCode): 1249 return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody) 1250 1251 default: 1252 genericError := &smithy.GenericAPIError{ 1253 Code: errorCode, 1254 Message: errorMessage, 1255 } 1256 return genericError 1257 1258 } 1259} 1260 1261type awsAwsquery_deserializeOpCreateDBInstance struct { 1262} 1263 1264func (*awsAwsquery_deserializeOpCreateDBInstance) ID() string { 1265 return "OperationDeserializer" 1266} 1267 1268func (m *awsAwsquery_deserializeOpCreateDBInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1269 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1270) { 1271 out, metadata, err = next.HandleDeserialize(ctx, in) 1272 if err != nil { 1273 return out, metadata, err 1274 } 1275 1276 response, ok := out.RawResponse.(*smithyhttp.Response) 1277 if !ok { 1278 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1279 } 1280 1281 if response.StatusCode < 200 || response.StatusCode >= 300 { 1282 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBInstance(response, &metadata) 1283 } 1284 output := &CreateDBInstanceOutput{} 1285 out.Result = output 1286 1287 var buff [1024]byte 1288 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1289 body := io.TeeReader(response.Body, ringBuffer) 1290 rootDecoder := xml.NewDecoder(body) 1291 t, err := smithyxml.FetchRootElement(rootDecoder) 1292 if err == io.EOF { 1293 return out, metadata, nil 1294 } 1295 if err != nil { 1296 var snapshot bytes.Buffer 1297 io.Copy(&snapshot, ringBuffer) 1298 return out, metadata, &smithy.DeserializationError{ 1299 Err: fmt.Errorf("failed to decode response body, %w", err), 1300 Snapshot: snapshot.Bytes(), 1301 } 1302 } 1303 1304 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1305 t, err = decoder.GetElement("CreateDBInstanceResult") 1306 if err != nil { 1307 var snapshot bytes.Buffer 1308 io.Copy(&snapshot, ringBuffer) 1309 err = &smithy.DeserializationError{ 1310 Err: fmt.Errorf("failed to decode response body, %w", err), 1311 Snapshot: snapshot.Bytes(), 1312 } 1313 return out, metadata, err 1314 } 1315 1316 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1317 err = awsAwsquery_deserializeOpDocumentCreateDBInstanceOutput(&output, decoder) 1318 if err != nil { 1319 var snapshot bytes.Buffer 1320 io.Copy(&snapshot, ringBuffer) 1321 err = &smithy.DeserializationError{ 1322 Err: fmt.Errorf("failed to decode response body, %w", err), 1323 Snapshot: snapshot.Bytes(), 1324 } 1325 return out, metadata, err 1326 } 1327 1328 return out, metadata, err 1329} 1330 1331func awsAwsquery_deserializeOpErrorCreateDBInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1332 var errorBuffer bytes.Buffer 1333 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1334 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1335 } 1336 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1337 1338 errorCode := "UnknownError" 1339 errorMessage := errorCode 1340 1341 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1342 if err != nil { 1343 return err 1344 } 1345 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1346 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1347 } 1348 if len(errorComponents.Code) != 0 { 1349 errorCode = errorComponents.Code 1350 } 1351 if len(errorComponents.Message) != 0 { 1352 errorMessage = errorComponents.Message 1353 } 1354 errorBody.Seek(0, io.SeekStart) 1355 switch { 1356 case strings.EqualFold("AuthorizationNotFoundFault", errorCode): 1357 return awsAwsquery_deserializeErrorAuthorizationNotFoundFault(response, errorBody) 1358 1359 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 1360 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 1361 1362 case strings.EqualFold("DBInstanceAlreadyExistsFault", errorCode): 1363 return awsAwsquery_deserializeErrorDBInstanceAlreadyExistsFault(response, errorBody) 1364 1365 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 1366 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 1367 1368 case strings.EqualFold("DBSecurityGroupNotFoundFault", errorCode): 1369 return awsAwsquery_deserializeErrorDBSecurityGroupNotFoundFault(response, errorBody) 1370 1371 case strings.EqualFold("DBSubnetGroupDoesNotCoverEnoughAZs", errorCode): 1372 return awsAwsquery_deserializeErrorDBSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) 1373 1374 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 1375 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 1376 1377 case strings.EqualFold("DomainNotFoundFault", errorCode): 1378 return awsAwsquery_deserializeErrorDomainNotFoundFault(response, errorBody) 1379 1380 case strings.EqualFold("InstanceQuotaExceededFault", errorCode): 1381 return awsAwsquery_deserializeErrorInstanceQuotaExceededFault(response, errorBody) 1382 1383 case strings.EqualFold("InsufficientDBInstanceCapacityFault", errorCode): 1384 return awsAwsquery_deserializeErrorInsufficientDBInstanceCapacityFault(response, errorBody) 1385 1386 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 1387 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 1388 1389 case strings.EqualFold("InvalidSubnet", errorCode): 1390 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 1391 1392 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 1393 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 1394 1395 case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): 1396 return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) 1397 1398 case strings.EqualFold("OptionGroupNotFoundFault", errorCode): 1399 return awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response, errorBody) 1400 1401 case strings.EqualFold("ProvisionedIopsNotAvailableInAZFault", errorCode): 1402 return awsAwsquery_deserializeErrorProvisionedIopsNotAvailableInAZFault(response, errorBody) 1403 1404 case strings.EqualFold("StorageQuotaExceededFault", errorCode): 1405 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 1406 1407 case strings.EqualFold("StorageTypeNotSupportedFault", errorCode): 1408 return awsAwsquery_deserializeErrorStorageTypeNotSupportedFault(response, errorBody) 1409 1410 default: 1411 genericError := &smithy.GenericAPIError{ 1412 Code: errorCode, 1413 Message: errorMessage, 1414 } 1415 return genericError 1416 1417 } 1418} 1419 1420type awsAwsquery_deserializeOpCreateDBParameterGroup struct { 1421} 1422 1423func (*awsAwsquery_deserializeOpCreateDBParameterGroup) ID() string { 1424 return "OperationDeserializer" 1425} 1426 1427func (m *awsAwsquery_deserializeOpCreateDBParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1428 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1429) { 1430 out, metadata, err = next.HandleDeserialize(ctx, in) 1431 if err != nil { 1432 return out, metadata, err 1433 } 1434 1435 response, ok := out.RawResponse.(*smithyhttp.Response) 1436 if !ok { 1437 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1438 } 1439 1440 if response.StatusCode < 200 || response.StatusCode >= 300 { 1441 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBParameterGroup(response, &metadata) 1442 } 1443 output := &CreateDBParameterGroupOutput{} 1444 out.Result = output 1445 1446 var buff [1024]byte 1447 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1448 body := io.TeeReader(response.Body, ringBuffer) 1449 rootDecoder := xml.NewDecoder(body) 1450 t, err := smithyxml.FetchRootElement(rootDecoder) 1451 if err == io.EOF { 1452 return out, metadata, nil 1453 } 1454 if err != nil { 1455 var snapshot bytes.Buffer 1456 io.Copy(&snapshot, ringBuffer) 1457 return out, metadata, &smithy.DeserializationError{ 1458 Err: fmt.Errorf("failed to decode response body, %w", err), 1459 Snapshot: snapshot.Bytes(), 1460 } 1461 } 1462 1463 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1464 t, err = decoder.GetElement("CreateDBParameterGroupResult") 1465 if err != nil { 1466 var snapshot bytes.Buffer 1467 io.Copy(&snapshot, ringBuffer) 1468 err = &smithy.DeserializationError{ 1469 Err: fmt.Errorf("failed to decode response body, %w", err), 1470 Snapshot: snapshot.Bytes(), 1471 } 1472 return out, metadata, err 1473 } 1474 1475 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1476 err = awsAwsquery_deserializeOpDocumentCreateDBParameterGroupOutput(&output, decoder) 1477 if err != nil { 1478 var snapshot bytes.Buffer 1479 io.Copy(&snapshot, ringBuffer) 1480 err = &smithy.DeserializationError{ 1481 Err: fmt.Errorf("failed to decode response body, %w", err), 1482 Snapshot: snapshot.Bytes(), 1483 } 1484 return out, metadata, err 1485 } 1486 1487 return out, metadata, err 1488} 1489 1490func awsAwsquery_deserializeOpErrorCreateDBParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1491 var errorBuffer bytes.Buffer 1492 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1493 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1494 } 1495 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1496 1497 errorCode := "UnknownError" 1498 errorMessage := errorCode 1499 1500 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1501 if err != nil { 1502 return err 1503 } 1504 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1505 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1506 } 1507 if len(errorComponents.Code) != 0 { 1508 errorCode = errorComponents.Code 1509 } 1510 if len(errorComponents.Message) != 0 { 1511 errorMessage = errorComponents.Message 1512 } 1513 errorBody.Seek(0, io.SeekStart) 1514 switch { 1515 case strings.EqualFold("DBParameterGroupAlreadyExistsFault", errorCode): 1516 return awsAwsquery_deserializeErrorDBParameterGroupAlreadyExistsFault(response, errorBody) 1517 1518 case strings.EqualFold("DBParameterGroupQuotaExceededFault", errorCode): 1519 return awsAwsquery_deserializeErrorDBParameterGroupQuotaExceededFault(response, errorBody) 1520 1521 default: 1522 genericError := &smithy.GenericAPIError{ 1523 Code: errorCode, 1524 Message: errorMessage, 1525 } 1526 return genericError 1527 1528 } 1529} 1530 1531type awsAwsquery_deserializeOpCreateDBSubnetGroup struct { 1532} 1533 1534func (*awsAwsquery_deserializeOpCreateDBSubnetGroup) ID() string { 1535 return "OperationDeserializer" 1536} 1537 1538func (m *awsAwsquery_deserializeOpCreateDBSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1539 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1540) { 1541 out, metadata, err = next.HandleDeserialize(ctx, in) 1542 if err != nil { 1543 return out, metadata, err 1544 } 1545 1546 response, ok := out.RawResponse.(*smithyhttp.Response) 1547 if !ok { 1548 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1549 } 1550 1551 if response.StatusCode < 200 || response.StatusCode >= 300 { 1552 return out, metadata, awsAwsquery_deserializeOpErrorCreateDBSubnetGroup(response, &metadata) 1553 } 1554 output := &CreateDBSubnetGroupOutput{} 1555 out.Result = output 1556 1557 var buff [1024]byte 1558 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1559 body := io.TeeReader(response.Body, ringBuffer) 1560 rootDecoder := xml.NewDecoder(body) 1561 t, err := smithyxml.FetchRootElement(rootDecoder) 1562 if err == io.EOF { 1563 return out, metadata, nil 1564 } 1565 if err != nil { 1566 var snapshot bytes.Buffer 1567 io.Copy(&snapshot, ringBuffer) 1568 return out, metadata, &smithy.DeserializationError{ 1569 Err: fmt.Errorf("failed to decode response body, %w", err), 1570 Snapshot: snapshot.Bytes(), 1571 } 1572 } 1573 1574 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1575 t, err = decoder.GetElement("CreateDBSubnetGroupResult") 1576 if err != nil { 1577 var snapshot bytes.Buffer 1578 io.Copy(&snapshot, ringBuffer) 1579 err = &smithy.DeserializationError{ 1580 Err: fmt.Errorf("failed to decode response body, %w", err), 1581 Snapshot: snapshot.Bytes(), 1582 } 1583 return out, metadata, err 1584 } 1585 1586 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1587 err = awsAwsquery_deserializeOpDocumentCreateDBSubnetGroupOutput(&output, decoder) 1588 if err != nil { 1589 var snapshot bytes.Buffer 1590 io.Copy(&snapshot, ringBuffer) 1591 err = &smithy.DeserializationError{ 1592 Err: fmt.Errorf("failed to decode response body, %w", err), 1593 Snapshot: snapshot.Bytes(), 1594 } 1595 return out, metadata, err 1596 } 1597 1598 return out, metadata, err 1599} 1600 1601func awsAwsquery_deserializeOpErrorCreateDBSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1602 var errorBuffer bytes.Buffer 1603 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1604 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1605 } 1606 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1607 1608 errorCode := "UnknownError" 1609 errorMessage := errorCode 1610 1611 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1612 if err != nil { 1613 return err 1614 } 1615 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1616 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1617 } 1618 if len(errorComponents.Code) != 0 { 1619 errorCode = errorComponents.Code 1620 } 1621 if len(errorComponents.Message) != 0 { 1622 errorMessage = errorComponents.Message 1623 } 1624 errorBody.Seek(0, io.SeekStart) 1625 switch { 1626 case strings.EqualFold("DBSubnetGroupAlreadyExistsFault", errorCode): 1627 return awsAwsquery_deserializeErrorDBSubnetGroupAlreadyExistsFault(response, errorBody) 1628 1629 case strings.EqualFold("DBSubnetGroupDoesNotCoverEnoughAZs", errorCode): 1630 return awsAwsquery_deserializeErrorDBSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) 1631 1632 case strings.EqualFold("DBSubnetGroupQuotaExceededFault", errorCode): 1633 return awsAwsquery_deserializeErrorDBSubnetGroupQuotaExceededFault(response, errorBody) 1634 1635 case strings.EqualFold("DBSubnetQuotaExceededFault", errorCode): 1636 return awsAwsquery_deserializeErrorDBSubnetQuotaExceededFault(response, errorBody) 1637 1638 case strings.EqualFold("InvalidSubnet", errorCode): 1639 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 1640 1641 default: 1642 genericError := &smithy.GenericAPIError{ 1643 Code: errorCode, 1644 Message: errorMessage, 1645 } 1646 return genericError 1647 1648 } 1649} 1650 1651type awsAwsquery_deserializeOpCreateEventSubscription struct { 1652} 1653 1654func (*awsAwsquery_deserializeOpCreateEventSubscription) ID() string { 1655 return "OperationDeserializer" 1656} 1657 1658func (m *awsAwsquery_deserializeOpCreateEventSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1659 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1660) { 1661 out, metadata, err = next.HandleDeserialize(ctx, in) 1662 if err != nil { 1663 return out, metadata, err 1664 } 1665 1666 response, ok := out.RawResponse.(*smithyhttp.Response) 1667 if !ok { 1668 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1669 } 1670 1671 if response.StatusCode < 200 || response.StatusCode >= 300 { 1672 return out, metadata, awsAwsquery_deserializeOpErrorCreateEventSubscription(response, &metadata) 1673 } 1674 output := &CreateEventSubscriptionOutput{} 1675 out.Result = output 1676 1677 var buff [1024]byte 1678 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1679 body := io.TeeReader(response.Body, ringBuffer) 1680 rootDecoder := xml.NewDecoder(body) 1681 t, err := smithyxml.FetchRootElement(rootDecoder) 1682 if err == io.EOF { 1683 return out, metadata, nil 1684 } 1685 if err != nil { 1686 var snapshot bytes.Buffer 1687 io.Copy(&snapshot, ringBuffer) 1688 return out, metadata, &smithy.DeserializationError{ 1689 Err: fmt.Errorf("failed to decode response body, %w", err), 1690 Snapshot: snapshot.Bytes(), 1691 } 1692 } 1693 1694 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1695 t, err = decoder.GetElement("CreateEventSubscriptionResult") 1696 if err != nil { 1697 var snapshot bytes.Buffer 1698 io.Copy(&snapshot, ringBuffer) 1699 err = &smithy.DeserializationError{ 1700 Err: fmt.Errorf("failed to decode response body, %w", err), 1701 Snapshot: snapshot.Bytes(), 1702 } 1703 return out, metadata, err 1704 } 1705 1706 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1707 err = awsAwsquery_deserializeOpDocumentCreateEventSubscriptionOutput(&output, decoder) 1708 if err != nil { 1709 var snapshot bytes.Buffer 1710 io.Copy(&snapshot, ringBuffer) 1711 err = &smithy.DeserializationError{ 1712 Err: fmt.Errorf("failed to decode response body, %w", err), 1713 Snapshot: snapshot.Bytes(), 1714 } 1715 return out, metadata, err 1716 } 1717 1718 return out, metadata, err 1719} 1720 1721func awsAwsquery_deserializeOpErrorCreateEventSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1722 var errorBuffer bytes.Buffer 1723 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1724 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1725 } 1726 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1727 1728 errorCode := "UnknownError" 1729 errorMessage := errorCode 1730 1731 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1732 if err != nil { 1733 return err 1734 } 1735 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1736 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1737 } 1738 if len(errorComponents.Code) != 0 { 1739 errorCode = errorComponents.Code 1740 } 1741 if len(errorComponents.Message) != 0 { 1742 errorMessage = errorComponents.Message 1743 } 1744 errorBody.Seek(0, io.SeekStart) 1745 switch { 1746 case strings.EqualFold("EventSubscriptionQuotaExceededFault", errorCode): 1747 return awsAwsquery_deserializeErrorEventSubscriptionQuotaExceededFault(response, errorBody) 1748 1749 case strings.EqualFold("SNSInvalidTopicFault", errorCode): 1750 return awsAwsquery_deserializeErrorSNSInvalidTopicFault(response, errorBody) 1751 1752 case strings.EqualFold("SNSNoAuthorizationFault", errorCode): 1753 return awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response, errorBody) 1754 1755 case strings.EqualFold("SNSTopicArnNotFoundFault", errorCode): 1756 return awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response, errorBody) 1757 1758 case strings.EqualFold("SourceNotFoundFault", errorCode): 1759 return awsAwsquery_deserializeErrorSourceNotFoundFault(response, errorBody) 1760 1761 case strings.EqualFold("SubscriptionAlreadyExistFault", errorCode): 1762 return awsAwsquery_deserializeErrorSubscriptionAlreadyExistFault(response, errorBody) 1763 1764 case strings.EqualFold("SubscriptionCategoryNotFoundFault", errorCode): 1765 return awsAwsquery_deserializeErrorSubscriptionCategoryNotFoundFault(response, errorBody) 1766 1767 default: 1768 genericError := &smithy.GenericAPIError{ 1769 Code: errorCode, 1770 Message: errorMessage, 1771 } 1772 return genericError 1773 1774 } 1775} 1776 1777type awsAwsquery_deserializeOpDeleteDBCluster struct { 1778} 1779 1780func (*awsAwsquery_deserializeOpDeleteDBCluster) ID() string { 1781 return "OperationDeserializer" 1782} 1783 1784func (m *awsAwsquery_deserializeOpDeleteDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1785 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1786) { 1787 out, metadata, err = next.HandleDeserialize(ctx, in) 1788 if err != nil { 1789 return out, metadata, err 1790 } 1791 1792 response, ok := out.RawResponse.(*smithyhttp.Response) 1793 if !ok { 1794 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1795 } 1796 1797 if response.StatusCode < 200 || response.StatusCode >= 300 { 1798 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBCluster(response, &metadata) 1799 } 1800 output := &DeleteDBClusterOutput{} 1801 out.Result = output 1802 1803 var buff [1024]byte 1804 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1805 body := io.TeeReader(response.Body, ringBuffer) 1806 rootDecoder := xml.NewDecoder(body) 1807 t, err := smithyxml.FetchRootElement(rootDecoder) 1808 if err == io.EOF { 1809 return out, metadata, nil 1810 } 1811 if err != nil { 1812 var snapshot bytes.Buffer 1813 io.Copy(&snapshot, ringBuffer) 1814 return out, metadata, &smithy.DeserializationError{ 1815 Err: fmt.Errorf("failed to decode response body, %w", err), 1816 Snapshot: snapshot.Bytes(), 1817 } 1818 } 1819 1820 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1821 t, err = decoder.GetElement("DeleteDBClusterResult") 1822 if err != nil { 1823 var snapshot bytes.Buffer 1824 io.Copy(&snapshot, ringBuffer) 1825 err = &smithy.DeserializationError{ 1826 Err: fmt.Errorf("failed to decode response body, %w", err), 1827 Snapshot: snapshot.Bytes(), 1828 } 1829 return out, metadata, err 1830 } 1831 1832 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1833 err = awsAwsquery_deserializeOpDocumentDeleteDBClusterOutput(&output, decoder) 1834 if err != nil { 1835 var snapshot bytes.Buffer 1836 io.Copy(&snapshot, ringBuffer) 1837 err = &smithy.DeserializationError{ 1838 Err: fmt.Errorf("failed to decode response body, %w", err), 1839 Snapshot: snapshot.Bytes(), 1840 } 1841 return out, metadata, err 1842 } 1843 1844 return out, metadata, err 1845} 1846 1847func awsAwsquery_deserializeOpErrorDeleteDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1848 var errorBuffer bytes.Buffer 1849 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1850 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1851 } 1852 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1853 1854 errorCode := "UnknownError" 1855 errorMessage := errorCode 1856 1857 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1858 if err != nil { 1859 return err 1860 } 1861 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1862 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1863 } 1864 if len(errorComponents.Code) != 0 { 1865 errorCode = errorComponents.Code 1866 } 1867 if len(errorComponents.Message) != 0 { 1868 errorMessage = errorComponents.Message 1869 } 1870 errorBody.Seek(0, io.SeekStart) 1871 switch { 1872 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 1873 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 1874 1875 case strings.EqualFold("DBClusterSnapshotAlreadyExistsFault", errorCode): 1876 return awsAwsquery_deserializeErrorDBClusterSnapshotAlreadyExistsFault(response, errorBody) 1877 1878 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 1879 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 1880 1881 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 1882 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 1883 1884 case strings.EqualFold("SnapshotQuotaExceededFault", errorCode): 1885 return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody) 1886 1887 default: 1888 genericError := &smithy.GenericAPIError{ 1889 Code: errorCode, 1890 Message: errorMessage, 1891 } 1892 return genericError 1893 1894 } 1895} 1896 1897type awsAwsquery_deserializeOpDeleteDBClusterEndpoint struct { 1898} 1899 1900func (*awsAwsquery_deserializeOpDeleteDBClusterEndpoint) ID() string { 1901 return "OperationDeserializer" 1902} 1903 1904func (m *awsAwsquery_deserializeOpDeleteDBClusterEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1905 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1906) { 1907 out, metadata, err = next.HandleDeserialize(ctx, in) 1908 if err != nil { 1909 return out, metadata, err 1910 } 1911 1912 response, ok := out.RawResponse.(*smithyhttp.Response) 1913 if !ok { 1914 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1915 } 1916 1917 if response.StatusCode < 200 || response.StatusCode >= 300 { 1918 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterEndpoint(response, &metadata) 1919 } 1920 output := &DeleteDBClusterEndpointOutput{} 1921 out.Result = output 1922 1923 var buff [1024]byte 1924 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1925 body := io.TeeReader(response.Body, ringBuffer) 1926 rootDecoder := xml.NewDecoder(body) 1927 t, err := smithyxml.FetchRootElement(rootDecoder) 1928 if err == io.EOF { 1929 return out, metadata, nil 1930 } 1931 if err != nil { 1932 var snapshot bytes.Buffer 1933 io.Copy(&snapshot, ringBuffer) 1934 return out, metadata, &smithy.DeserializationError{ 1935 Err: fmt.Errorf("failed to decode response body, %w", err), 1936 Snapshot: snapshot.Bytes(), 1937 } 1938 } 1939 1940 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1941 t, err = decoder.GetElement("DeleteDBClusterEndpointResult") 1942 if err != nil { 1943 var snapshot bytes.Buffer 1944 io.Copy(&snapshot, ringBuffer) 1945 err = &smithy.DeserializationError{ 1946 Err: fmt.Errorf("failed to decode response body, %w", err), 1947 Snapshot: snapshot.Bytes(), 1948 } 1949 return out, metadata, err 1950 } 1951 1952 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1953 err = awsAwsquery_deserializeOpDocumentDeleteDBClusterEndpointOutput(&output, decoder) 1954 if err != nil { 1955 var snapshot bytes.Buffer 1956 io.Copy(&snapshot, ringBuffer) 1957 err = &smithy.DeserializationError{ 1958 Err: fmt.Errorf("failed to decode response body, %w", err), 1959 Snapshot: snapshot.Bytes(), 1960 } 1961 return out, metadata, err 1962 } 1963 1964 return out, metadata, err 1965} 1966 1967func awsAwsquery_deserializeOpErrorDeleteDBClusterEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1968 var errorBuffer bytes.Buffer 1969 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1970 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1971 } 1972 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1973 1974 errorCode := "UnknownError" 1975 errorMessage := errorCode 1976 1977 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1978 if err != nil { 1979 return err 1980 } 1981 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1982 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1983 } 1984 if len(errorComponents.Code) != 0 { 1985 errorCode = errorComponents.Code 1986 } 1987 if len(errorComponents.Message) != 0 { 1988 errorMessage = errorComponents.Message 1989 } 1990 errorBody.Seek(0, io.SeekStart) 1991 switch { 1992 case strings.EqualFold("DBClusterEndpointNotFoundFault", errorCode): 1993 return awsAwsquery_deserializeErrorDBClusterEndpointNotFoundFault(response, errorBody) 1994 1995 case strings.EqualFold("InvalidDBClusterEndpointStateFault", errorCode): 1996 return awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response, errorBody) 1997 1998 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 1999 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 2000 2001 default: 2002 genericError := &smithy.GenericAPIError{ 2003 Code: errorCode, 2004 Message: errorMessage, 2005 } 2006 return genericError 2007 2008 } 2009} 2010 2011type awsAwsquery_deserializeOpDeleteDBClusterParameterGroup struct { 2012} 2013 2014func (*awsAwsquery_deserializeOpDeleteDBClusterParameterGroup) ID() string { 2015 return "OperationDeserializer" 2016} 2017 2018func (m *awsAwsquery_deserializeOpDeleteDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2019 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2020) { 2021 out, metadata, err = next.HandleDeserialize(ctx, in) 2022 if err != nil { 2023 return out, metadata, err 2024 } 2025 2026 response, ok := out.RawResponse.(*smithyhttp.Response) 2027 if !ok { 2028 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2029 } 2030 2031 if response.StatusCode < 200 || response.StatusCode >= 300 { 2032 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterParameterGroup(response, &metadata) 2033 } 2034 output := &DeleteDBClusterParameterGroupOutput{} 2035 out.Result = output 2036 2037 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2038 return out, metadata, &smithy.DeserializationError{ 2039 Err: fmt.Errorf("failed to discard response body, %w", err), 2040 } 2041 } 2042 2043 return out, metadata, err 2044} 2045 2046func awsAwsquery_deserializeOpErrorDeleteDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2047 var errorBuffer bytes.Buffer 2048 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2049 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2050 } 2051 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2052 2053 errorCode := "UnknownError" 2054 errorMessage := errorCode 2055 2056 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2057 if err != nil { 2058 return err 2059 } 2060 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2061 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2062 } 2063 if len(errorComponents.Code) != 0 { 2064 errorCode = errorComponents.Code 2065 } 2066 if len(errorComponents.Message) != 0 { 2067 errorMessage = errorComponents.Message 2068 } 2069 errorBody.Seek(0, io.SeekStart) 2070 switch { 2071 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 2072 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 2073 2074 case strings.EqualFold("InvalidDBParameterGroupStateFault", errorCode): 2075 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 2076 2077 default: 2078 genericError := &smithy.GenericAPIError{ 2079 Code: errorCode, 2080 Message: errorMessage, 2081 } 2082 return genericError 2083 2084 } 2085} 2086 2087type awsAwsquery_deserializeOpDeleteDBClusterSnapshot struct { 2088} 2089 2090func (*awsAwsquery_deserializeOpDeleteDBClusterSnapshot) ID() string { 2091 return "OperationDeserializer" 2092} 2093 2094func (m *awsAwsquery_deserializeOpDeleteDBClusterSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2095 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2096) { 2097 out, metadata, err = next.HandleDeserialize(ctx, in) 2098 if err != nil { 2099 return out, metadata, err 2100 } 2101 2102 response, ok := out.RawResponse.(*smithyhttp.Response) 2103 if !ok { 2104 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2105 } 2106 2107 if response.StatusCode < 200 || response.StatusCode >= 300 { 2108 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBClusterSnapshot(response, &metadata) 2109 } 2110 output := &DeleteDBClusterSnapshotOutput{} 2111 out.Result = output 2112 2113 var buff [1024]byte 2114 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2115 body := io.TeeReader(response.Body, ringBuffer) 2116 rootDecoder := xml.NewDecoder(body) 2117 t, err := smithyxml.FetchRootElement(rootDecoder) 2118 if err == io.EOF { 2119 return out, metadata, nil 2120 } 2121 if err != nil { 2122 var snapshot bytes.Buffer 2123 io.Copy(&snapshot, ringBuffer) 2124 return out, metadata, &smithy.DeserializationError{ 2125 Err: fmt.Errorf("failed to decode response body, %w", err), 2126 Snapshot: snapshot.Bytes(), 2127 } 2128 } 2129 2130 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2131 t, err = decoder.GetElement("DeleteDBClusterSnapshotResult") 2132 if err != nil { 2133 var snapshot bytes.Buffer 2134 io.Copy(&snapshot, ringBuffer) 2135 err = &smithy.DeserializationError{ 2136 Err: fmt.Errorf("failed to decode response body, %w", err), 2137 Snapshot: snapshot.Bytes(), 2138 } 2139 return out, metadata, err 2140 } 2141 2142 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2143 err = awsAwsquery_deserializeOpDocumentDeleteDBClusterSnapshotOutput(&output, decoder) 2144 if err != nil { 2145 var snapshot bytes.Buffer 2146 io.Copy(&snapshot, ringBuffer) 2147 err = &smithy.DeserializationError{ 2148 Err: fmt.Errorf("failed to decode response body, %w", err), 2149 Snapshot: snapshot.Bytes(), 2150 } 2151 return out, metadata, err 2152 } 2153 2154 return out, metadata, err 2155} 2156 2157func awsAwsquery_deserializeOpErrorDeleteDBClusterSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2158 var errorBuffer bytes.Buffer 2159 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2160 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2161 } 2162 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2163 2164 errorCode := "UnknownError" 2165 errorMessage := errorCode 2166 2167 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2168 if err != nil { 2169 return err 2170 } 2171 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2172 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2173 } 2174 if len(errorComponents.Code) != 0 { 2175 errorCode = errorComponents.Code 2176 } 2177 if len(errorComponents.Message) != 0 { 2178 errorMessage = errorComponents.Message 2179 } 2180 errorBody.Seek(0, io.SeekStart) 2181 switch { 2182 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 2183 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 2184 2185 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 2186 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 2187 2188 default: 2189 genericError := &smithy.GenericAPIError{ 2190 Code: errorCode, 2191 Message: errorMessage, 2192 } 2193 return genericError 2194 2195 } 2196} 2197 2198type awsAwsquery_deserializeOpDeleteDBInstance struct { 2199} 2200 2201func (*awsAwsquery_deserializeOpDeleteDBInstance) ID() string { 2202 return "OperationDeserializer" 2203} 2204 2205func (m *awsAwsquery_deserializeOpDeleteDBInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2206 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2207) { 2208 out, metadata, err = next.HandleDeserialize(ctx, in) 2209 if err != nil { 2210 return out, metadata, err 2211 } 2212 2213 response, ok := out.RawResponse.(*smithyhttp.Response) 2214 if !ok { 2215 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2216 } 2217 2218 if response.StatusCode < 200 || response.StatusCode >= 300 { 2219 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBInstance(response, &metadata) 2220 } 2221 output := &DeleteDBInstanceOutput{} 2222 out.Result = output 2223 2224 var buff [1024]byte 2225 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2226 body := io.TeeReader(response.Body, ringBuffer) 2227 rootDecoder := xml.NewDecoder(body) 2228 t, err := smithyxml.FetchRootElement(rootDecoder) 2229 if err == io.EOF { 2230 return out, metadata, nil 2231 } 2232 if err != nil { 2233 var snapshot bytes.Buffer 2234 io.Copy(&snapshot, ringBuffer) 2235 return out, metadata, &smithy.DeserializationError{ 2236 Err: fmt.Errorf("failed to decode response body, %w", err), 2237 Snapshot: snapshot.Bytes(), 2238 } 2239 } 2240 2241 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2242 t, err = decoder.GetElement("DeleteDBInstanceResult") 2243 if err != nil { 2244 var snapshot bytes.Buffer 2245 io.Copy(&snapshot, ringBuffer) 2246 err = &smithy.DeserializationError{ 2247 Err: fmt.Errorf("failed to decode response body, %w", err), 2248 Snapshot: snapshot.Bytes(), 2249 } 2250 return out, metadata, err 2251 } 2252 2253 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2254 err = awsAwsquery_deserializeOpDocumentDeleteDBInstanceOutput(&output, decoder) 2255 if err != nil { 2256 var snapshot bytes.Buffer 2257 io.Copy(&snapshot, ringBuffer) 2258 err = &smithy.DeserializationError{ 2259 Err: fmt.Errorf("failed to decode response body, %w", err), 2260 Snapshot: snapshot.Bytes(), 2261 } 2262 return out, metadata, err 2263 } 2264 2265 return out, metadata, err 2266} 2267 2268func awsAwsquery_deserializeOpErrorDeleteDBInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2269 var errorBuffer bytes.Buffer 2270 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2271 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2272 } 2273 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2274 2275 errorCode := "UnknownError" 2276 errorMessage := errorCode 2277 2278 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2279 if err != nil { 2280 return err 2281 } 2282 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2283 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2284 } 2285 if len(errorComponents.Code) != 0 { 2286 errorCode = errorComponents.Code 2287 } 2288 if len(errorComponents.Message) != 0 { 2289 errorMessage = errorComponents.Message 2290 } 2291 errorBody.Seek(0, io.SeekStart) 2292 switch { 2293 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 2294 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 2295 2296 case strings.EqualFold("DBSnapshotAlreadyExistsFault", errorCode): 2297 return awsAwsquery_deserializeErrorDBSnapshotAlreadyExistsFault(response, errorBody) 2298 2299 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 2300 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 2301 2302 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 2303 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 2304 2305 case strings.EqualFold("SnapshotQuotaExceededFault", errorCode): 2306 return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody) 2307 2308 default: 2309 genericError := &smithy.GenericAPIError{ 2310 Code: errorCode, 2311 Message: errorMessage, 2312 } 2313 return genericError 2314 2315 } 2316} 2317 2318type awsAwsquery_deserializeOpDeleteDBParameterGroup struct { 2319} 2320 2321func (*awsAwsquery_deserializeOpDeleteDBParameterGroup) ID() string { 2322 return "OperationDeserializer" 2323} 2324 2325func (m *awsAwsquery_deserializeOpDeleteDBParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2326 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2327) { 2328 out, metadata, err = next.HandleDeserialize(ctx, in) 2329 if err != nil { 2330 return out, metadata, err 2331 } 2332 2333 response, ok := out.RawResponse.(*smithyhttp.Response) 2334 if !ok { 2335 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2336 } 2337 2338 if response.StatusCode < 200 || response.StatusCode >= 300 { 2339 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBParameterGroup(response, &metadata) 2340 } 2341 output := &DeleteDBParameterGroupOutput{} 2342 out.Result = output 2343 2344 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2345 return out, metadata, &smithy.DeserializationError{ 2346 Err: fmt.Errorf("failed to discard response body, %w", err), 2347 } 2348 } 2349 2350 return out, metadata, err 2351} 2352 2353func awsAwsquery_deserializeOpErrorDeleteDBParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2354 var errorBuffer bytes.Buffer 2355 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2356 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2357 } 2358 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2359 2360 errorCode := "UnknownError" 2361 errorMessage := errorCode 2362 2363 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2364 if err != nil { 2365 return err 2366 } 2367 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2368 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2369 } 2370 if len(errorComponents.Code) != 0 { 2371 errorCode = errorComponents.Code 2372 } 2373 if len(errorComponents.Message) != 0 { 2374 errorMessage = errorComponents.Message 2375 } 2376 errorBody.Seek(0, io.SeekStart) 2377 switch { 2378 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 2379 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 2380 2381 case strings.EqualFold("InvalidDBParameterGroupStateFault", errorCode): 2382 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 2383 2384 default: 2385 genericError := &smithy.GenericAPIError{ 2386 Code: errorCode, 2387 Message: errorMessage, 2388 } 2389 return genericError 2390 2391 } 2392} 2393 2394type awsAwsquery_deserializeOpDeleteDBSubnetGroup struct { 2395} 2396 2397func (*awsAwsquery_deserializeOpDeleteDBSubnetGroup) ID() string { 2398 return "OperationDeserializer" 2399} 2400 2401func (m *awsAwsquery_deserializeOpDeleteDBSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2402 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2403) { 2404 out, metadata, err = next.HandleDeserialize(ctx, in) 2405 if err != nil { 2406 return out, metadata, err 2407 } 2408 2409 response, ok := out.RawResponse.(*smithyhttp.Response) 2410 if !ok { 2411 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2412 } 2413 2414 if response.StatusCode < 200 || response.StatusCode >= 300 { 2415 return out, metadata, awsAwsquery_deserializeOpErrorDeleteDBSubnetGroup(response, &metadata) 2416 } 2417 output := &DeleteDBSubnetGroupOutput{} 2418 out.Result = output 2419 2420 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2421 return out, metadata, &smithy.DeserializationError{ 2422 Err: fmt.Errorf("failed to discard response body, %w", err), 2423 } 2424 } 2425 2426 return out, metadata, err 2427} 2428 2429func awsAwsquery_deserializeOpErrorDeleteDBSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2430 var errorBuffer bytes.Buffer 2431 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2432 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2433 } 2434 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2435 2436 errorCode := "UnknownError" 2437 errorMessage := errorCode 2438 2439 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2440 if err != nil { 2441 return err 2442 } 2443 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2444 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2445 } 2446 if len(errorComponents.Code) != 0 { 2447 errorCode = errorComponents.Code 2448 } 2449 if len(errorComponents.Message) != 0 { 2450 errorMessage = errorComponents.Message 2451 } 2452 errorBody.Seek(0, io.SeekStart) 2453 switch { 2454 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 2455 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 2456 2457 case strings.EqualFold("InvalidDBSubnetGroupStateFault", errorCode): 2458 return awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response, errorBody) 2459 2460 case strings.EqualFold("InvalidDBSubnetStateFault", errorCode): 2461 return awsAwsquery_deserializeErrorInvalidDBSubnetStateFault(response, errorBody) 2462 2463 default: 2464 genericError := &smithy.GenericAPIError{ 2465 Code: errorCode, 2466 Message: errorMessage, 2467 } 2468 return genericError 2469 2470 } 2471} 2472 2473type awsAwsquery_deserializeOpDeleteEventSubscription struct { 2474} 2475 2476func (*awsAwsquery_deserializeOpDeleteEventSubscription) ID() string { 2477 return "OperationDeserializer" 2478} 2479 2480func (m *awsAwsquery_deserializeOpDeleteEventSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2481 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2482) { 2483 out, metadata, err = next.HandleDeserialize(ctx, in) 2484 if err != nil { 2485 return out, metadata, err 2486 } 2487 2488 response, ok := out.RawResponse.(*smithyhttp.Response) 2489 if !ok { 2490 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2491 } 2492 2493 if response.StatusCode < 200 || response.StatusCode >= 300 { 2494 return out, metadata, awsAwsquery_deserializeOpErrorDeleteEventSubscription(response, &metadata) 2495 } 2496 output := &DeleteEventSubscriptionOutput{} 2497 out.Result = output 2498 2499 var buff [1024]byte 2500 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2501 body := io.TeeReader(response.Body, ringBuffer) 2502 rootDecoder := xml.NewDecoder(body) 2503 t, err := smithyxml.FetchRootElement(rootDecoder) 2504 if err == io.EOF { 2505 return out, metadata, nil 2506 } 2507 if err != nil { 2508 var snapshot bytes.Buffer 2509 io.Copy(&snapshot, ringBuffer) 2510 return out, metadata, &smithy.DeserializationError{ 2511 Err: fmt.Errorf("failed to decode response body, %w", err), 2512 Snapshot: snapshot.Bytes(), 2513 } 2514 } 2515 2516 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2517 t, err = decoder.GetElement("DeleteEventSubscriptionResult") 2518 if err != nil { 2519 var snapshot bytes.Buffer 2520 io.Copy(&snapshot, ringBuffer) 2521 err = &smithy.DeserializationError{ 2522 Err: fmt.Errorf("failed to decode response body, %w", err), 2523 Snapshot: snapshot.Bytes(), 2524 } 2525 return out, metadata, err 2526 } 2527 2528 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2529 err = awsAwsquery_deserializeOpDocumentDeleteEventSubscriptionOutput(&output, decoder) 2530 if err != nil { 2531 var snapshot bytes.Buffer 2532 io.Copy(&snapshot, ringBuffer) 2533 err = &smithy.DeserializationError{ 2534 Err: fmt.Errorf("failed to decode response body, %w", err), 2535 Snapshot: snapshot.Bytes(), 2536 } 2537 return out, metadata, err 2538 } 2539 2540 return out, metadata, err 2541} 2542 2543func awsAwsquery_deserializeOpErrorDeleteEventSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2544 var errorBuffer bytes.Buffer 2545 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2546 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2547 } 2548 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2549 2550 errorCode := "UnknownError" 2551 errorMessage := errorCode 2552 2553 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2554 if err != nil { 2555 return err 2556 } 2557 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2558 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2559 } 2560 if len(errorComponents.Code) != 0 { 2561 errorCode = errorComponents.Code 2562 } 2563 if len(errorComponents.Message) != 0 { 2564 errorMessage = errorComponents.Message 2565 } 2566 errorBody.Seek(0, io.SeekStart) 2567 switch { 2568 case strings.EqualFold("InvalidEventSubscriptionStateFault", errorCode): 2569 return awsAwsquery_deserializeErrorInvalidEventSubscriptionStateFault(response, errorBody) 2570 2571 case strings.EqualFold("SubscriptionNotFoundFault", errorCode): 2572 return awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response, errorBody) 2573 2574 default: 2575 genericError := &smithy.GenericAPIError{ 2576 Code: errorCode, 2577 Message: errorMessage, 2578 } 2579 return genericError 2580 2581 } 2582} 2583 2584type awsAwsquery_deserializeOpDescribeDBClusterEndpoints struct { 2585} 2586 2587func (*awsAwsquery_deserializeOpDescribeDBClusterEndpoints) ID() string { 2588 return "OperationDeserializer" 2589} 2590 2591func (m *awsAwsquery_deserializeOpDescribeDBClusterEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2592 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2593) { 2594 out, metadata, err = next.HandleDeserialize(ctx, in) 2595 if err != nil { 2596 return out, metadata, err 2597 } 2598 2599 response, ok := out.RawResponse.(*smithyhttp.Response) 2600 if !ok { 2601 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2602 } 2603 2604 if response.StatusCode < 200 || response.StatusCode >= 300 { 2605 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterEndpoints(response, &metadata) 2606 } 2607 output := &DescribeDBClusterEndpointsOutput{} 2608 out.Result = output 2609 2610 var buff [1024]byte 2611 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2612 body := io.TeeReader(response.Body, ringBuffer) 2613 rootDecoder := xml.NewDecoder(body) 2614 t, err := smithyxml.FetchRootElement(rootDecoder) 2615 if err == io.EOF { 2616 return out, metadata, nil 2617 } 2618 if err != nil { 2619 var snapshot bytes.Buffer 2620 io.Copy(&snapshot, ringBuffer) 2621 return out, metadata, &smithy.DeserializationError{ 2622 Err: fmt.Errorf("failed to decode response body, %w", err), 2623 Snapshot: snapshot.Bytes(), 2624 } 2625 } 2626 2627 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2628 t, err = decoder.GetElement("DescribeDBClusterEndpointsResult") 2629 if err != nil { 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 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2640 err = awsAwsquery_deserializeOpDocumentDescribeDBClusterEndpointsOutput(&output, decoder) 2641 if err != nil { 2642 var snapshot bytes.Buffer 2643 io.Copy(&snapshot, ringBuffer) 2644 err = &smithy.DeserializationError{ 2645 Err: fmt.Errorf("failed to decode response body, %w", err), 2646 Snapshot: snapshot.Bytes(), 2647 } 2648 return out, metadata, err 2649 } 2650 2651 return out, metadata, err 2652} 2653 2654func awsAwsquery_deserializeOpErrorDescribeDBClusterEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2655 var errorBuffer bytes.Buffer 2656 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2657 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2658 } 2659 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2660 2661 errorCode := "UnknownError" 2662 errorMessage := errorCode 2663 2664 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2665 if err != nil { 2666 return err 2667 } 2668 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2669 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2670 } 2671 if len(errorComponents.Code) != 0 { 2672 errorCode = errorComponents.Code 2673 } 2674 if len(errorComponents.Message) != 0 { 2675 errorMessage = errorComponents.Message 2676 } 2677 errorBody.Seek(0, io.SeekStart) 2678 switch { 2679 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 2680 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 2681 2682 default: 2683 genericError := &smithy.GenericAPIError{ 2684 Code: errorCode, 2685 Message: errorMessage, 2686 } 2687 return genericError 2688 2689 } 2690} 2691 2692type awsAwsquery_deserializeOpDescribeDBClusterParameterGroups struct { 2693} 2694 2695func (*awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) ID() string { 2696 return "OperationDeserializer" 2697} 2698 2699func (m *awsAwsquery_deserializeOpDescribeDBClusterParameterGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2700 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2701) { 2702 out, metadata, err = next.HandleDeserialize(ctx, in) 2703 if err != nil { 2704 return out, metadata, err 2705 } 2706 2707 response, ok := out.RawResponse.(*smithyhttp.Response) 2708 if !ok { 2709 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2710 } 2711 2712 if response.StatusCode < 200 || response.StatusCode >= 300 { 2713 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterParameterGroups(response, &metadata) 2714 } 2715 output := &DescribeDBClusterParameterGroupsOutput{} 2716 out.Result = output 2717 2718 var buff [1024]byte 2719 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2720 body := io.TeeReader(response.Body, ringBuffer) 2721 rootDecoder := xml.NewDecoder(body) 2722 t, err := smithyxml.FetchRootElement(rootDecoder) 2723 if err == io.EOF { 2724 return out, metadata, nil 2725 } 2726 if err != nil { 2727 var snapshot bytes.Buffer 2728 io.Copy(&snapshot, ringBuffer) 2729 return out, metadata, &smithy.DeserializationError{ 2730 Err: fmt.Errorf("failed to decode response body, %w", err), 2731 Snapshot: snapshot.Bytes(), 2732 } 2733 } 2734 2735 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2736 t, err = decoder.GetElement("DescribeDBClusterParameterGroupsResult") 2737 if err != nil { 2738 var snapshot bytes.Buffer 2739 io.Copy(&snapshot, ringBuffer) 2740 err = &smithy.DeserializationError{ 2741 Err: fmt.Errorf("failed to decode response body, %w", err), 2742 Snapshot: snapshot.Bytes(), 2743 } 2744 return out, metadata, err 2745 } 2746 2747 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2748 err = awsAwsquery_deserializeOpDocumentDescribeDBClusterParameterGroupsOutput(&output, decoder) 2749 if err != nil { 2750 var snapshot bytes.Buffer 2751 io.Copy(&snapshot, ringBuffer) 2752 err = &smithy.DeserializationError{ 2753 Err: fmt.Errorf("failed to decode response body, %w", err), 2754 Snapshot: snapshot.Bytes(), 2755 } 2756 return out, metadata, err 2757 } 2758 2759 return out, metadata, err 2760} 2761 2762func awsAwsquery_deserializeOpErrorDescribeDBClusterParameterGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2763 var errorBuffer bytes.Buffer 2764 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2765 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2766 } 2767 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2768 2769 errorCode := "UnknownError" 2770 errorMessage := errorCode 2771 2772 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2773 if err != nil { 2774 return err 2775 } 2776 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2777 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2778 } 2779 if len(errorComponents.Code) != 0 { 2780 errorCode = errorComponents.Code 2781 } 2782 if len(errorComponents.Message) != 0 { 2783 errorMessage = errorComponents.Message 2784 } 2785 errorBody.Seek(0, io.SeekStart) 2786 switch { 2787 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 2788 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 2789 2790 default: 2791 genericError := &smithy.GenericAPIError{ 2792 Code: errorCode, 2793 Message: errorMessage, 2794 } 2795 return genericError 2796 2797 } 2798} 2799 2800type awsAwsquery_deserializeOpDescribeDBClusterParameters struct { 2801} 2802 2803func (*awsAwsquery_deserializeOpDescribeDBClusterParameters) ID() string { 2804 return "OperationDeserializer" 2805} 2806 2807func (m *awsAwsquery_deserializeOpDescribeDBClusterParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2808 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2809) { 2810 out, metadata, err = next.HandleDeserialize(ctx, in) 2811 if err != nil { 2812 return out, metadata, err 2813 } 2814 2815 response, ok := out.RawResponse.(*smithyhttp.Response) 2816 if !ok { 2817 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2818 } 2819 2820 if response.StatusCode < 200 || response.StatusCode >= 300 { 2821 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterParameters(response, &metadata) 2822 } 2823 output := &DescribeDBClusterParametersOutput{} 2824 out.Result = output 2825 2826 var buff [1024]byte 2827 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2828 body := io.TeeReader(response.Body, ringBuffer) 2829 rootDecoder := xml.NewDecoder(body) 2830 t, err := smithyxml.FetchRootElement(rootDecoder) 2831 if err == io.EOF { 2832 return out, metadata, nil 2833 } 2834 if err != nil { 2835 var snapshot bytes.Buffer 2836 io.Copy(&snapshot, ringBuffer) 2837 return out, metadata, &smithy.DeserializationError{ 2838 Err: fmt.Errorf("failed to decode response body, %w", err), 2839 Snapshot: snapshot.Bytes(), 2840 } 2841 } 2842 2843 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2844 t, err = decoder.GetElement("DescribeDBClusterParametersResult") 2845 if err != nil { 2846 var snapshot bytes.Buffer 2847 io.Copy(&snapshot, ringBuffer) 2848 err = &smithy.DeserializationError{ 2849 Err: fmt.Errorf("failed to decode response body, %w", err), 2850 Snapshot: snapshot.Bytes(), 2851 } 2852 return out, metadata, err 2853 } 2854 2855 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2856 err = awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(&output, decoder) 2857 if err != nil { 2858 var snapshot bytes.Buffer 2859 io.Copy(&snapshot, ringBuffer) 2860 err = &smithy.DeserializationError{ 2861 Err: fmt.Errorf("failed to decode response body, %w", err), 2862 Snapshot: snapshot.Bytes(), 2863 } 2864 return out, metadata, err 2865 } 2866 2867 return out, metadata, err 2868} 2869 2870func awsAwsquery_deserializeOpErrorDescribeDBClusterParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2871 var errorBuffer bytes.Buffer 2872 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2873 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2874 } 2875 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2876 2877 errorCode := "UnknownError" 2878 errorMessage := errorCode 2879 2880 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2881 if err != nil { 2882 return err 2883 } 2884 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2885 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2886 } 2887 if len(errorComponents.Code) != 0 { 2888 errorCode = errorComponents.Code 2889 } 2890 if len(errorComponents.Message) != 0 { 2891 errorMessage = errorComponents.Message 2892 } 2893 errorBody.Seek(0, io.SeekStart) 2894 switch { 2895 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 2896 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 2897 2898 default: 2899 genericError := &smithy.GenericAPIError{ 2900 Code: errorCode, 2901 Message: errorMessage, 2902 } 2903 return genericError 2904 2905 } 2906} 2907 2908type awsAwsquery_deserializeOpDescribeDBClusters struct { 2909} 2910 2911func (*awsAwsquery_deserializeOpDescribeDBClusters) ID() string { 2912 return "OperationDeserializer" 2913} 2914 2915func (m *awsAwsquery_deserializeOpDescribeDBClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2916 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2917) { 2918 out, metadata, err = next.HandleDeserialize(ctx, in) 2919 if err != nil { 2920 return out, metadata, err 2921 } 2922 2923 response, ok := out.RawResponse.(*smithyhttp.Response) 2924 if !ok { 2925 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2926 } 2927 2928 if response.StatusCode < 200 || response.StatusCode >= 300 { 2929 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusters(response, &metadata) 2930 } 2931 output := &DescribeDBClustersOutput{} 2932 out.Result = output 2933 2934 var buff [1024]byte 2935 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2936 body := io.TeeReader(response.Body, ringBuffer) 2937 rootDecoder := xml.NewDecoder(body) 2938 t, err := smithyxml.FetchRootElement(rootDecoder) 2939 if err == io.EOF { 2940 return out, metadata, nil 2941 } 2942 if err != nil { 2943 var snapshot bytes.Buffer 2944 io.Copy(&snapshot, ringBuffer) 2945 return out, metadata, &smithy.DeserializationError{ 2946 Err: fmt.Errorf("failed to decode response body, %w", err), 2947 Snapshot: snapshot.Bytes(), 2948 } 2949 } 2950 2951 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2952 t, err = decoder.GetElement("DescribeDBClustersResult") 2953 if err != nil { 2954 var snapshot bytes.Buffer 2955 io.Copy(&snapshot, ringBuffer) 2956 err = &smithy.DeserializationError{ 2957 Err: fmt.Errorf("failed to decode response body, %w", err), 2958 Snapshot: snapshot.Bytes(), 2959 } 2960 return out, metadata, err 2961 } 2962 2963 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2964 err = awsAwsquery_deserializeOpDocumentDescribeDBClustersOutput(&output, decoder) 2965 if err != nil { 2966 var snapshot bytes.Buffer 2967 io.Copy(&snapshot, ringBuffer) 2968 err = &smithy.DeserializationError{ 2969 Err: fmt.Errorf("failed to decode response body, %w", err), 2970 Snapshot: snapshot.Bytes(), 2971 } 2972 return out, metadata, err 2973 } 2974 2975 return out, metadata, err 2976} 2977 2978func awsAwsquery_deserializeOpErrorDescribeDBClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2979 var errorBuffer bytes.Buffer 2980 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2981 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2982 } 2983 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2984 2985 errorCode := "UnknownError" 2986 errorMessage := errorCode 2987 2988 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2989 if err != nil { 2990 return err 2991 } 2992 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2993 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2994 } 2995 if len(errorComponents.Code) != 0 { 2996 errorCode = errorComponents.Code 2997 } 2998 if len(errorComponents.Message) != 0 { 2999 errorMessage = errorComponents.Message 3000 } 3001 errorBody.Seek(0, io.SeekStart) 3002 switch { 3003 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 3004 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 3005 3006 default: 3007 genericError := &smithy.GenericAPIError{ 3008 Code: errorCode, 3009 Message: errorMessage, 3010 } 3011 return genericError 3012 3013 } 3014} 3015 3016type awsAwsquery_deserializeOpDescribeDBClusterSnapshotAttributes struct { 3017} 3018 3019func (*awsAwsquery_deserializeOpDescribeDBClusterSnapshotAttributes) ID() string { 3020 return "OperationDeserializer" 3021} 3022 3023func (m *awsAwsquery_deserializeOpDescribeDBClusterSnapshotAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3024 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3025) { 3026 out, metadata, err = next.HandleDeserialize(ctx, in) 3027 if err != nil { 3028 return out, metadata, err 3029 } 3030 3031 response, ok := out.RawResponse.(*smithyhttp.Response) 3032 if !ok { 3033 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3034 } 3035 3036 if response.StatusCode < 200 || response.StatusCode >= 300 { 3037 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterSnapshotAttributes(response, &metadata) 3038 } 3039 output := &DescribeDBClusterSnapshotAttributesOutput{} 3040 out.Result = output 3041 3042 var buff [1024]byte 3043 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3044 body := io.TeeReader(response.Body, ringBuffer) 3045 rootDecoder := xml.NewDecoder(body) 3046 t, err := smithyxml.FetchRootElement(rootDecoder) 3047 if err == io.EOF { 3048 return out, metadata, nil 3049 } 3050 if err != nil { 3051 var snapshot bytes.Buffer 3052 io.Copy(&snapshot, ringBuffer) 3053 return out, metadata, &smithy.DeserializationError{ 3054 Err: fmt.Errorf("failed to decode response body, %w", err), 3055 Snapshot: snapshot.Bytes(), 3056 } 3057 } 3058 3059 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3060 t, err = decoder.GetElement("DescribeDBClusterSnapshotAttributesResult") 3061 if err != nil { 3062 var snapshot bytes.Buffer 3063 io.Copy(&snapshot, ringBuffer) 3064 err = &smithy.DeserializationError{ 3065 Err: fmt.Errorf("failed to decode response body, %w", err), 3066 Snapshot: snapshot.Bytes(), 3067 } 3068 return out, metadata, err 3069 } 3070 3071 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3072 err = awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotAttributesOutput(&output, decoder) 3073 if err != nil { 3074 var snapshot bytes.Buffer 3075 io.Copy(&snapshot, ringBuffer) 3076 err = &smithy.DeserializationError{ 3077 Err: fmt.Errorf("failed to decode response body, %w", err), 3078 Snapshot: snapshot.Bytes(), 3079 } 3080 return out, metadata, err 3081 } 3082 3083 return out, metadata, err 3084} 3085 3086func awsAwsquery_deserializeOpErrorDescribeDBClusterSnapshotAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3087 var errorBuffer bytes.Buffer 3088 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3089 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3090 } 3091 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3092 3093 errorCode := "UnknownError" 3094 errorMessage := errorCode 3095 3096 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3097 if err != nil { 3098 return err 3099 } 3100 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3101 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3102 } 3103 if len(errorComponents.Code) != 0 { 3104 errorCode = errorComponents.Code 3105 } 3106 if len(errorComponents.Message) != 0 { 3107 errorMessage = errorComponents.Message 3108 } 3109 errorBody.Seek(0, io.SeekStart) 3110 switch { 3111 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 3112 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 3113 3114 default: 3115 genericError := &smithy.GenericAPIError{ 3116 Code: errorCode, 3117 Message: errorMessage, 3118 } 3119 return genericError 3120 3121 } 3122} 3123 3124type awsAwsquery_deserializeOpDescribeDBClusterSnapshots struct { 3125} 3126 3127func (*awsAwsquery_deserializeOpDescribeDBClusterSnapshots) ID() string { 3128 return "OperationDeserializer" 3129} 3130 3131func (m *awsAwsquery_deserializeOpDescribeDBClusterSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3132 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3133) { 3134 out, metadata, err = next.HandleDeserialize(ctx, in) 3135 if err != nil { 3136 return out, metadata, err 3137 } 3138 3139 response, ok := out.RawResponse.(*smithyhttp.Response) 3140 if !ok { 3141 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3142 } 3143 3144 if response.StatusCode < 200 || response.StatusCode >= 300 { 3145 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBClusterSnapshots(response, &metadata) 3146 } 3147 output := &DescribeDBClusterSnapshotsOutput{} 3148 out.Result = output 3149 3150 var buff [1024]byte 3151 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3152 body := io.TeeReader(response.Body, ringBuffer) 3153 rootDecoder := xml.NewDecoder(body) 3154 t, err := smithyxml.FetchRootElement(rootDecoder) 3155 if err == io.EOF { 3156 return out, metadata, nil 3157 } 3158 if err != nil { 3159 var snapshot bytes.Buffer 3160 io.Copy(&snapshot, ringBuffer) 3161 return out, metadata, &smithy.DeserializationError{ 3162 Err: fmt.Errorf("failed to decode response body, %w", err), 3163 Snapshot: snapshot.Bytes(), 3164 } 3165 } 3166 3167 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3168 t, err = decoder.GetElement("DescribeDBClusterSnapshotsResult") 3169 if err != nil { 3170 var snapshot bytes.Buffer 3171 io.Copy(&snapshot, ringBuffer) 3172 err = &smithy.DeserializationError{ 3173 Err: fmt.Errorf("failed to decode response body, %w", err), 3174 Snapshot: snapshot.Bytes(), 3175 } 3176 return out, metadata, err 3177 } 3178 3179 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3180 err = awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotsOutput(&output, decoder) 3181 if err != nil { 3182 var snapshot bytes.Buffer 3183 io.Copy(&snapshot, ringBuffer) 3184 err = &smithy.DeserializationError{ 3185 Err: fmt.Errorf("failed to decode response body, %w", err), 3186 Snapshot: snapshot.Bytes(), 3187 } 3188 return out, metadata, err 3189 } 3190 3191 return out, metadata, err 3192} 3193 3194func awsAwsquery_deserializeOpErrorDescribeDBClusterSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3195 var errorBuffer bytes.Buffer 3196 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3197 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3198 } 3199 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3200 3201 errorCode := "UnknownError" 3202 errorMessage := errorCode 3203 3204 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3205 if err != nil { 3206 return err 3207 } 3208 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3209 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3210 } 3211 if len(errorComponents.Code) != 0 { 3212 errorCode = errorComponents.Code 3213 } 3214 if len(errorComponents.Message) != 0 { 3215 errorMessage = errorComponents.Message 3216 } 3217 errorBody.Seek(0, io.SeekStart) 3218 switch { 3219 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 3220 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 3221 3222 default: 3223 genericError := &smithy.GenericAPIError{ 3224 Code: errorCode, 3225 Message: errorMessage, 3226 } 3227 return genericError 3228 3229 } 3230} 3231 3232type awsAwsquery_deserializeOpDescribeDBEngineVersions struct { 3233} 3234 3235func (*awsAwsquery_deserializeOpDescribeDBEngineVersions) ID() string { 3236 return "OperationDeserializer" 3237} 3238 3239func (m *awsAwsquery_deserializeOpDescribeDBEngineVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3240 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3241) { 3242 out, metadata, err = next.HandleDeserialize(ctx, in) 3243 if err != nil { 3244 return out, metadata, err 3245 } 3246 3247 response, ok := out.RawResponse.(*smithyhttp.Response) 3248 if !ok { 3249 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3250 } 3251 3252 if response.StatusCode < 200 || response.StatusCode >= 300 { 3253 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBEngineVersions(response, &metadata) 3254 } 3255 output := &DescribeDBEngineVersionsOutput{} 3256 out.Result = output 3257 3258 var buff [1024]byte 3259 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3260 body := io.TeeReader(response.Body, ringBuffer) 3261 rootDecoder := xml.NewDecoder(body) 3262 t, err := smithyxml.FetchRootElement(rootDecoder) 3263 if err == io.EOF { 3264 return out, metadata, nil 3265 } 3266 if err != nil { 3267 var snapshot bytes.Buffer 3268 io.Copy(&snapshot, ringBuffer) 3269 return out, metadata, &smithy.DeserializationError{ 3270 Err: fmt.Errorf("failed to decode response body, %w", err), 3271 Snapshot: snapshot.Bytes(), 3272 } 3273 } 3274 3275 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3276 t, err = decoder.GetElement("DescribeDBEngineVersionsResult") 3277 if err != nil { 3278 var snapshot bytes.Buffer 3279 io.Copy(&snapshot, ringBuffer) 3280 err = &smithy.DeserializationError{ 3281 Err: fmt.Errorf("failed to decode response body, %w", err), 3282 Snapshot: snapshot.Bytes(), 3283 } 3284 return out, metadata, err 3285 } 3286 3287 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3288 err = awsAwsquery_deserializeOpDocumentDescribeDBEngineVersionsOutput(&output, decoder) 3289 if err != nil { 3290 var snapshot bytes.Buffer 3291 io.Copy(&snapshot, ringBuffer) 3292 err = &smithy.DeserializationError{ 3293 Err: fmt.Errorf("failed to decode response body, %w", err), 3294 Snapshot: snapshot.Bytes(), 3295 } 3296 return out, metadata, err 3297 } 3298 3299 return out, metadata, err 3300} 3301 3302func awsAwsquery_deserializeOpErrorDescribeDBEngineVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3303 var errorBuffer bytes.Buffer 3304 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3305 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3306 } 3307 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3308 3309 errorCode := "UnknownError" 3310 errorMessage := errorCode 3311 3312 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3313 if err != nil { 3314 return err 3315 } 3316 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3317 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3318 } 3319 if len(errorComponents.Code) != 0 { 3320 errorCode = errorComponents.Code 3321 } 3322 if len(errorComponents.Message) != 0 { 3323 errorMessage = errorComponents.Message 3324 } 3325 errorBody.Seek(0, io.SeekStart) 3326 switch { 3327 default: 3328 genericError := &smithy.GenericAPIError{ 3329 Code: errorCode, 3330 Message: errorMessage, 3331 } 3332 return genericError 3333 3334 } 3335} 3336 3337type awsAwsquery_deserializeOpDescribeDBInstances struct { 3338} 3339 3340func (*awsAwsquery_deserializeOpDescribeDBInstances) ID() string { 3341 return "OperationDeserializer" 3342} 3343 3344func (m *awsAwsquery_deserializeOpDescribeDBInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3345 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3346) { 3347 out, metadata, err = next.HandleDeserialize(ctx, in) 3348 if err != nil { 3349 return out, metadata, err 3350 } 3351 3352 response, ok := out.RawResponse.(*smithyhttp.Response) 3353 if !ok { 3354 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3355 } 3356 3357 if response.StatusCode < 200 || response.StatusCode >= 300 { 3358 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBInstances(response, &metadata) 3359 } 3360 output := &DescribeDBInstancesOutput{} 3361 out.Result = output 3362 3363 var buff [1024]byte 3364 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3365 body := io.TeeReader(response.Body, ringBuffer) 3366 rootDecoder := xml.NewDecoder(body) 3367 t, err := smithyxml.FetchRootElement(rootDecoder) 3368 if err == io.EOF { 3369 return out, metadata, nil 3370 } 3371 if err != nil { 3372 var snapshot bytes.Buffer 3373 io.Copy(&snapshot, ringBuffer) 3374 return out, metadata, &smithy.DeserializationError{ 3375 Err: fmt.Errorf("failed to decode response body, %w", err), 3376 Snapshot: snapshot.Bytes(), 3377 } 3378 } 3379 3380 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3381 t, err = decoder.GetElement("DescribeDBInstancesResult") 3382 if err != nil { 3383 var snapshot bytes.Buffer 3384 io.Copy(&snapshot, ringBuffer) 3385 err = &smithy.DeserializationError{ 3386 Err: fmt.Errorf("failed to decode response body, %w", err), 3387 Snapshot: snapshot.Bytes(), 3388 } 3389 return out, metadata, err 3390 } 3391 3392 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3393 err = awsAwsquery_deserializeOpDocumentDescribeDBInstancesOutput(&output, decoder) 3394 if err != nil { 3395 var snapshot bytes.Buffer 3396 io.Copy(&snapshot, ringBuffer) 3397 err = &smithy.DeserializationError{ 3398 Err: fmt.Errorf("failed to decode response body, %w", err), 3399 Snapshot: snapshot.Bytes(), 3400 } 3401 return out, metadata, err 3402 } 3403 3404 return out, metadata, err 3405} 3406 3407func awsAwsquery_deserializeOpErrorDescribeDBInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3408 var errorBuffer bytes.Buffer 3409 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3410 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3411 } 3412 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3413 3414 errorCode := "UnknownError" 3415 errorMessage := errorCode 3416 3417 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3418 if err != nil { 3419 return err 3420 } 3421 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3422 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3423 } 3424 if len(errorComponents.Code) != 0 { 3425 errorCode = errorComponents.Code 3426 } 3427 if len(errorComponents.Message) != 0 { 3428 errorMessage = errorComponents.Message 3429 } 3430 errorBody.Seek(0, io.SeekStart) 3431 switch { 3432 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 3433 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 3434 3435 default: 3436 genericError := &smithy.GenericAPIError{ 3437 Code: errorCode, 3438 Message: errorMessage, 3439 } 3440 return genericError 3441 3442 } 3443} 3444 3445type awsAwsquery_deserializeOpDescribeDBParameterGroups struct { 3446} 3447 3448func (*awsAwsquery_deserializeOpDescribeDBParameterGroups) ID() string { 3449 return "OperationDeserializer" 3450} 3451 3452func (m *awsAwsquery_deserializeOpDescribeDBParameterGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3453 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3454) { 3455 out, metadata, err = next.HandleDeserialize(ctx, in) 3456 if err != nil { 3457 return out, metadata, err 3458 } 3459 3460 response, ok := out.RawResponse.(*smithyhttp.Response) 3461 if !ok { 3462 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3463 } 3464 3465 if response.StatusCode < 200 || response.StatusCode >= 300 { 3466 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBParameterGroups(response, &metadata) 3467 } 3468 output := &DescribeDBParameterGroupsOutput{} 3469 out.Result = output 3470 3471 var buff [1024]byte 3472 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3473 body := io.TeeReader(response.Body, ringBuffer) 3474 rootDecoder := xml.NewDecoder(body) 3475 t, err := smithyxml.FetchRootElement(rootDecoder) 3476 if err == io.EOF { 3477 return out, metadata, nil 3478 } 3479 if err != nil { 3480 var snapshot bytes.Buffer 3481 io.Copy(&snapshot, ringBuffer) 3482 return out, metadata, &smithy.DeserializationError{ 3483 Err: fmt.Errorf("failed to decode response body, %w", err), 3484 Snapshot: snapshot.Bytes(), 3485 } 3486 } 3487 3488 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3489 t, err = decoder.GetElement("DescribeDBParameterGroupsResult") 3490 if err != nil { 3491 var snapshot bytes.Buffer 3492 io.Copy(&snapshot, ringBuffer) 3493 err = &smithy.DeserializationError{ 3494 Err: fmt.Errorf("failed to decode response body, %w", err), 3495 Snapshot: snapshot.Bytes(), 3496 } 3497 return out, metadata, err 3498 } 3499 3500 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3501 err = awsAwsquery_deserializeOpDocumentDescribeDBParameterGroupsOutput(&output, decoder) 3502 if err != nil { 3503 var snapshot bytes.Buffer 3504 io.Copy(&snapshot, ringBuffer) 3505 err = &smithy.DeserializationError{ 3506 Err: fmt.Errorf("failed to decode response body, %w", err), 3507 Snapshot: snapshot.Bytes(), 3508 } 3509 return out, metadata, err 3510 } 3511 3512 return out, metadata, err 3513} 3514 3515func awsAwsquery_deserializeOpErrorDescribeDBParameterGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3516 var errorBuffer bytes.Buffer 3517 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3518 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3519 } 3520 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3521 3522 errorCode := "UnknownError" 3523 errorMessage := errorCode 3524 3525 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3526 if err != nil { 3527 return err 3528 } 3529 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3530 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3531 } 3532 if len(errorComponents.Code) != 0 { 3533 errorCode = errorComponents.Code 3534 } 3535 if len(errorComponents.Message) != 0 { 3536 errorMessage = errorComponents.Message 3537 } 3538 errorBody.Seek(0, io.SeekStart) 3539 switch { 3540 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 3541 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 3542 3543 default: 3544 genericError := &smithy.GenericAPIError{ 3545 Code: errorCode, 3546 Message: errorMessage, 3547 } 3548 return genericError 3549 3550 } 3551} 3552 3553type awsAwsquery_deserializeOpDescribeDBParameters struct { 3554} 3555 3556func (*awsAwsquery_deserializeOpDescribeDBParameters) ID() string { 3557 return "OperationDeserializer" 3558} 3559 3560func (m *awsAwsquery_deserializeOpDescribeDBParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3561 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3562) { 3563 out, metadata, err = next.HandleDeserialize(ctx, in) 3564 if err != nil { 3565 return out, metadata, err 3566 } 3567 3568 response, ok := out.RawResponse.(*smithyhttp.Response) 3569 if !ok { 3570 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3571 } 3572 3573 if response.StatusCode < 200 || response.StatusCode >= 300 { 3574 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBParameters(response, &metadata) 3575 } 3576 output := &DescribeDBParametersOutput{} 3577 out.Result = output 3578 3579 var buff [1024]byte 3580 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3581 body := io.TeeReader(response.Body, ringBuffer) 3582 rootDecoder := xml.NewDecoder(body) 3583 t, err := smithyxml.FetchRootElement(rootDecoder) 3584 if err == io.EOF { 3585 return out, metadata, nil 3586 } 3587 if err != nil { 3588 var snapshot bytes.Buffer 3589 io.Copy(&snapshot, ringBuffer) 3590 return out, metadata, &smithy.DeserializationError{ 3591 Err: fmt.Errorf("failed to decode response body, %w", err), 3592 Snapshot: snapshot.Bytes(), 3593 } 3594 } 3595 3596 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3597 t, err = decoder.GetElement("DescribeDBParametersResult") 3598 if err != nil { 3599 var snapshot bytes.Buffer 3600 io.Copy(&snapshot, ringBuffer) 3601 err = &smithy.DeserializationError{ 3602 Err: fmt.Errorf("failed to decode response body, %w", err), 3603 Snapshot: snapshot.Bytes(), 3604 } 3605 return out, metadata, err 3606 } 3607 3608 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3609 err = awsAwsquery_deserializeOpDocumentDescribeDBParametersOutput(&output, decoder) 3610 if err != nil { 3611 var snapshot bytes.Buffer 3612 io.Copy(&snapshot, ringBuffer) 3613 err = &smithy.DeserializationError{ 3614 Err: fmt.Errorf("failed to decode response body, %w", err), 3615 Snapshot: snapshot.Bytes(), 3616 } 3617 return out, metadata, err 3618 } 3619 3620 return out, metadata, err 3621} 3622 3623func awsAwsquery_deserializeOpErrorDescribeDBParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3624 var errorBuffer bytes.Buffer 3625 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3626 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3627 } 3628 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3629 3630 errorCode := "UnknownError" 3631 errorMessage := errorCode 3632 3633 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3634 if err != nil { 3635 return err 3636 } 3637 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3638 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3639 } 3640 if len(errorComponents.Code) != 0 { 3641 errorCode = errorComponents.Code 3642 } 3643 if len(errorComponents.Message) != 0 { 3644 errorMessage = errorComponents.Message 3645 } 3646 errorBody.Seek(0, io.SeekStart) 3647 switch { 3648 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 3649 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 3650 3651 default: 3652 genericError := &smithy.GenericAPIError{ 3653 Code: errorCode, 3654 Message: errorMessage, 3655 } 3656 return genericError 3657 3658 } 3659} 3660 3661type awsAwsquery_deserializeOpDescribeDBSubnetGroups struct { 3662} 3663 3664func (*awsAwsquery_deserializeOpDescribeDBSubnetGroups) ID() string { 3665 return "OperationDeserializer" 3666} 3667 3668func (m *awsAwsquery_deserializeOpDescribeDBSubnetGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3669 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3670) { 3671 out, metadata, err = next.HandleDeserialize(ctx, in) 3672 if err != nil { 3673 return out, metadata, err 3674 } 3675 3676 response, ok := out.RawResponse.(*smithyhttp.Response) 3677 if !ok { 3678 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3679 } 3680 3681 if response.StatusCode < 200 || response.StatusCode >= 300 { 3682 return out, metadata, awsAwsquery_deserializeOpErrorDescribeDBSubnetGroups(response, &metadata) 3683 } 3684 output := &DescribeDBSubnetGroupsOutput{} 3685 out.Result = output 3686 3687 var buff [1024]byte 3688 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3689 body := io.TeeReader(response.Body, ringBuffer) 3690 rootDecoder := xml.NewDecoder(body) 3691 t, err := smithyxml.FetchRootElement(rootDecoder) 3692 if err == io.EOF { 3693 return out, metadata, nil 3694 } 3695 if err != nil { 3696 var snapshot bytes.Buffer 3697 io.Copy(&snapshot, ringBuffer) 3698 return out, metadata, &smithy.DeserializationError{ 3699 Err: fmt.Errorf("failed to decode response body, %w", err), 3700 Snapshot: snapshot.Bytes(), 3701 } 3702 } 3703 3704 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3705 t, err = decoder.GetElement("DescribeDBSubnetGroupsResult") 3706 if err != nil { 3707 var snapshot bytes.Buffer 3708 io.Copy(&snapshot, ringBuffer) 3709 err = &smithy.DeserializationError{ 3710 Err: fmt.Errorf("failed to decode response body, %w", err), 3711 Snapshot: snapshot.Bytes(), 3712 } 3713 return out, metadata, err 3714 } 3715 3716 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3717 err = awsAwsquery_deserializeOpDocumentDescribeDBSubnetGroupsOutput(&output, decoder) 3718 if err != nil { 3719 var snapshot bytes.Buffer 3720 io.Copy(&snapshot, ringBuffer) 3721 err = &smithy.DeserializationError{ 3722 Err: fmt.Errorf("failed to decode response body, %w", err), 3723 Snapshot: snapshot.Bytes(), 3724 } 3725 return out, metadata, err 3726 } 3727 3728 return out, metadata, err 3729} 3730 3731func awsAwsquery_deserializeOpErrorDescribeDBSubnetGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3732 var errorBuffer bytes.Buffer 3733 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3734 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3735 } 3736 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3737 3738 errorCode := "UnknownError" 3739 errorMessage := errorCode 3740 3741 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3742 if err != nil { 3743 return err 3744 } 3745 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3746 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3747 } 3748 if len(errorComponents.Code) != 0 { 3749 errorCode = errorComponents.Code 3750 } 3751 if len(errorComponents.Message) != 0 { 3752 errorMessage = errorComponents.Message 3753 } 3754 errorBody.Seek(0, io.SeekStart) 3755 switch { 3756 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 3757 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 3758 3759 default: 3760 genericError := &smithy.GenericAPIError{ 3761 Code: errorCode, 3762 Message: errorMessage, 3763 } 3764 return genericError 3765 3766 } 3767} 3768 3769type awsAwsquery_deserializeOpDescribeEngineDefaultClusterParameters struct { 3770} 3771 3772func (*awsAwsquery_deserializeOpDescribeEngineDefaultClusterParameters) ID() string { 3773 return "OperationDeserializer" 3774} 3775 3776func (m *awsAwsquery_deserializeOpDescribeEngineDefaultClusterParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3777 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3778) { 3779 out, metadata, err = next.HandleDeserialize(ctx, in) 3780 if err != nil { 3781 return out, metadata, err 3782 } 3783 3784 response, ok := out.RawResponse.(*smithyhttp.Response) 3785 if !ok { 3786 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3787 } 3788 3789 if response.StatusCode < 200 || response.StatusCode >= 300 { 3790 return out, metadata, awsAwsquery_deserializeOpErrorDescribeEngineDefaultClusterParameters(response, &metadata) 3791 } 3792 output := &DescribeEngineDefaultClusterParametersOutput{} 3793 out.Result = output 3794 3795 var buff [1024]byte 3796 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3797 body := io.TeeReader(response.Body, ringBuffer) 3798 rootDecoder := xml.NewDecoder(body) 3799 t, err := smithyxml.FetchRootElement(rootDecoder) 3800 if err == io.EOF { 3801 return out, metadata, nil 3802 } 3803 if err != nil { 3804 var snapshot bytes.Buffer 3805 io.Copy(&snapshot, ringBuffer) 3806 return out, metadata, &smithy.DeserializationError{ 3807 Err: fmt.Errorf("failed to decode response body, %w", err), 3808 Snapshot: snapshot.Bytes(), 3809 } 3810 } 3811 3812 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3813 t, err = decoder.GetElement("DescribeEngineDefaultClusterParametersResult") 3814 if err != nil { 3815 var snapshot bytes.Buffer 3816 io.Copy(&snapshot, ringBuffer) 3817 err = &smithy.DeserializationError{ 3818 Err: fmt.Errorf("failed to decode response body, %w", err), 3819 Snapshot: snapshot.Bytes(), 3820 } 3821 return out, metadata, err 3822 } 3823 3824 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3825 err = awsAwsquery_deserializeOpDocumentDescribeEngineDefaultClusterParametersOutput(&output, decoder) 3826 if err != nil { 3827 var snapshot bytes.Buffer 3828 io.Copy(&snapshot, ringBuffer) 3829 err = &smithy.DeserializationError{ 3830 Err: fmt.Errorf("failed to decode response body, %w", err), 3831 Snapshot: snapshot.Bytes(), 3832 } 3833 return out, metadata, err 3834 } 3835 3836 return out, metadata, err 3837} 3838 3839func awsAwsquery_deserializeOpErrorDescribeEngineDefaultClusterParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3840 var errorBuffer bytes.Buffer 3841 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3842 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3843 } 3844 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3845 3846 errorCode := "UnknownError" 3847 errorMessage := errorCode 3848 3849 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3850 if err != nil { 3851 return err 3852 } 3853 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3854 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3855 } 3856 if len(errorComponents.Code) != 0 { 3857 errorCode = errorComponents.Code 3858 } 3859 if len(errorComponents.Message) != 0 { 3860 errorMessage = errorComponents.Message 3861 } 3862 errorBody.Seek(0, io.SeekStart) 3863 switch { 3864 default: 3865 genericError := &smithy.GenericAPIError{ 3866 Code: errorCode, 3867 Message: errorMessage, 3868 } 3869 return genericError 3870 3871 } 3872} 3873 3874type awsAwsquery_deserializeOpDescribeEngineDefaultParameters struct { 3875} 3876 3877func (*awsAwsquery_deserializeOpDescribeEngineDefaultParameters) ID() string { 3878 return "OperationDeserializer" 3879} 3880 3881func (m *awsAwsquery_deserializeOpDescribeEngineDefaultParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3882 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3883) { 3884 out, metadata, err = next.HandleDeserialize(ctx, in) 3885 if err != nil { 3886 return out, metadata, err 3887 } 3888 3889 response, ok := out.RawResponse.(*smithyhttp.Response) 3890 if !ok { 3891 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3892 } 3893 3894 if response.StatusCode < 200 || response.StatusCode >= 300 { 3895 return out, metadata, awsAwsquery_deserializeOpErrorDescribeEngineDefaultParameters(response, &metadata) 3896 } 3897 output := &DescribeEngineDefaultParametersOutput{} 3898 out.Result = output 3899 3900 var buff [1024]byte 3901 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3902 body := io.TeeReader(response.Body, ringBuffer) 3903 rootDecoder := xml.NewDecoder(body) 3904 t, err := smithyxml.FetchRootElement(rootDecoder) 3905 if err == io.EOF { 3906 return out, metadata, nil 3907 } 3908 if err != nil { 3909 var snapshot bytes.Buffer 3910 io.Copy(&snapshot, ringBuffer) 3911 return out, metadata, &smithy.DeserializationError{ 3912 Err: fmt.Errorf("failed to decode response body, %w", err), 3913 Snapshot: snapshot.Bytes(), 3914 } 3915 } 3916 3917 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3918 t, err = decoder.GetElement("DescribeEngineDefaultParametersResult") 3919 if err != nil { 3920 var snapshot bytes.Buffer 3921 io.Copy(&snapshot, ringBuffer) 3922 err = &smithy.DeserializationError{ 3923 Err: fmt.Errorf("failed to decode response body, %w", err), 3924 Snapshot: snapshot.Bytes(), 3925 } 3926 return out, metadata, err 3927 } 3928 3929 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3930 err = awsAwsquery_deserializeOpDocumentDescribeEngineDefaultParametersOutput(&output, decoder) 3931 if err != nil { 3932 var snapshot bytes.Buffer 3933 io.Copy(&snapshot, ringBuffer) 3934 err = &smithy.DeserializationError{ 3935 Err: fmt.Errorf("failed to decode response body, %w", err), 3936 Snapshot: snapshot.Bytes(), 3937 } 3938 return out, metadata, err 3939 } 3940 3941 return out, metadata, err 3942} 3943 3944func awsAwsquery_deserializeOpErrorDescribeEngineDefaultParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3945 var errorBuffer bytes.Buffer 3946 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3947 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3948 } 3949 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3950 3951 errorCode := "UnknownError" 3952 errorMessage := errorCode 3953 3954 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3955 if err != nil { 3956 return err 3957 } 3958 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3959 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3960 } 3961 if len(errorComponents.Code) != 0 { 3962 errorCode = errorComponents.Code 3963 } 3964 if len(errorComponents.Message) != 0 { 3965 errorMessage = errorComponents.Message 3966 } 3967 errorBody.Seek(0, io.SeekStart) 3968 switch { 3969 default: 3970 genericError := &smithy.GenericAPIError{ 3971 Code: errorCode, 3972 Message: errorMessage, 3973 } 3974 return genericError 3975 3976 } 3977} 3978 3979type awsAwsquery_deserializeOpDescribeEventCategories struct { 3980} 3981 3982func (*awsAwsquery_deserializeOpDescribeEventCategories) ID() string { 3983 return "OperationDeserializer" 3984} 3985 3986func (m *awsAwsquery_deserializeOpDescribeEventCategories) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3987 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3988) { 3989 out, metadata, err = next.HandleDeserialize(ctx, in) 3990 if err != nil { 3991 return out, metadata, err 3992 } 3993 3994 response, ok := out.RawResponse.(*smithyhttp.Response) 3995 if !ok { 3996 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3997 } 3998 3999 if response.StatusCode < 200 || response.StatusCode >= 300 { 4000 return out, metadata, awsAwsquery_deserializeOpErrorDescribeEventCategories(response, &metadata) 4001 } 4002 output := &DescribeEventCategoriesOutput{} 4003 out.Result = output 4004 4005 var buff [1024]byte 4006 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4007 body := io.TeeReader(response.Body, ringBuffer) 4008 rootDecoder := xml.NewDecoder(body) 4009 t, err := smithyxml.FetchRootElement(rootDecoder) 4010 if err == io.EOF { 4011 return out, metadata, nil 4012 } 4013 if err != nil { 4014 var snapshot bytes.Buffer 4015 io.Copy(&snapshot, ringBuffer) 4016 return out, metadata, &smithy.DeserializationError{ 4017 Err: fmt.Errorf("failed to decode response body, %w", err), 4018 Snapshot: snapshot.Bytes(), 4019 } 4020 } 4021 4022 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4023 t, err = decoder.GetElement("DescribeEventCategoriesResult") 4024 if err != nil { 4025 var snapshot bytes.Buffer 4026 io.Copy(&snapshot, ringBuffer) 4027 err = &smithy.DeserializationError{ 4028 Err: fmt.Errorf("failed to decode response body, %w", err), 4029 Snapshot: snapshot.Bytes(), 4030 } 4031 return out, metadata, err 4032 } 4033 4034 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4035 err = awsAwsquery_deserializeOpDocumentDescribeEventCategoriesOutput(&output, decoder) 4036 if err != nil { 4037 var snapshot bytes.Buffer 4038 io.Copy(&snapshot, ringBuffer) 4039 err = &smithy.DeserializationError{ 4040 Err: fmt.Errorf("failed to decode response body, %w", err), 4041 Snapshot: snapshot.Bytes(), 4042 } 4043 return out, metadata, err 4044 } 4045 4046 return out, metadata, err 4047} 4048 4049func awsAwsquery_deserializeOpErrorDescribeEventCategories(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4050 var errorBuffer bytes.Buffer 4051 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4052 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4053 } 4054 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4055 4056 errorCode := "UnknownError" 4057 errorMessage := errorCode 4058 4059 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4060 if err != nil { 4061 return err 4062 } 4063 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4064 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4065 } 4066 if len(errorComponents.Code) != 0 { 4067 errorCode = errorComponents.Code 4068 } 4069 if len(errorComponents.Message) != 0 { 4070 errorMessage = errorComponents.Message 4071 } 4072 errorBody.Seek(0, io.SeekStart) 4073 switch { 4074 default: 4075 genericError := &smithy.GenericAPIError{ 4076 Code: errorCode, 4077 Message: errorMessage, 4078 } 4079 return genericError 4080 4081 } 4082} 4083 4084type awsAwsquery_deserializeOpDescribeEvents struct { 4085} 4086 4087func (*awsAwsquery_deserializeOpDescribeEvents) ID() string { 4088 return "OperationDeserializer" 4089} 4090 4091func (m *awsAwsquery_deserializeOpDescribeEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4092 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4093) { 4094 out, metadata, err = next.HandleDeserialize(ctx, in) 4095 if err != nil { 4096 return out, metadata, err 4097 } 4098 4099 response, ok := out.RawResponse.(*smithyhttp.Response) 4100 if !ok { 4101 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4102 } 4103 4104 if response.StatusCode < 200 || response.StatusCode >= 300 { 4105 return out, metadata, awsAwsquery_deserializeOpErrorDescribeEvents(response, &metadata) 4106 } 4107 output := &DescribeEventsOutput{} 4108 out.Result = output 4109 4110 var buff [1024]byte 4111 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4112 body := io.TeeReader(response.Body, ringBuffer) 4113 rootDecoder := xml.NewDecoder(body) 4114 t, err := smithyxml.FetchRootElement(rootDecoder) 4115 if err == io.EOF { 4116 return out, metadata, nil 4117 } 4118 if err != nil { 4119 var snapshot bytes.Buffer 4120 io.Copy(&snapshot, ringBuffer) 4121 return out, metadata, &smithy.DeserializationError{ 4122 Err: fmt.Errorf("failed to decode response body, %w", err), 4123 Snapshot: snapshot.Bytes(), 4124 } 4125 } 4126 4127 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4128 t, err = decoder.GetElement("DescribeEventsResult") 4129 if err != nil { 4130 var snapshot bytes.Buffer 4131 io.Copy(&snapshot, ringBuffer) 4132 err = &smithy.DeserializationError{ 4133 Err: fmt.Errorf("failed to decode response body, %w", err), 4134 Snapshot: snapshot.Bytes(), 4135 } 4136 return out, metadata, err 4137 } 4138 4139 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4140 err = awsAwsquery_deserializeOpDocumentDescribeEventsOutput(&output, decoder) 4141 if err != nil { 4142 var snapshot bytes.Buffer 4143 io.Copy(&snapshot, ringBuffer) 4144 err = &smithy.DeserializationError{ 4145 Err: fmt.Errorf("failed to decode response body, %w", err), 4146 Snapshot: snapshot.Bytes(), 4147 } 4148 return out, metadata, err 4149 } 4150 4151 return out, metadata, err 4152} 4153 4154func awsAwsquery_deserializeOpErrorDescribeEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4155 var errorBuffer bytes.Buffer 4156 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4157 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4158 } 4159 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4160 4161 errorCode := "UnknownError" 4162 errorMessage := errorCode 4163 4164 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4165 if err != nil { 4166 return err 4167 } 4168 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4169 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4170 } 4171 if len(errorComponents.Code) != 0 { 4172 errorCode = errorComponents.Code 4173 } 4174 if len(errorComponents.Message) != 0 { 4175 errorMessage = errorComponents.Message 4176 } 4177 errorBody.Seek(0, io.SeekStart) 4178 switch { 4179 default: 4180 genericError := &smithy.GenericAPIError{ 4181 Code: errorCode, 4182 Message: errorMessage, 4183 } 4184 return genericError 4185 4186 } 4187} 4188 4189type awsAwsquery_deserializeOpDescribeEventSubscriptions struct { 4190} 4191 4192func (*awsAwsquery_deserializeOpDescribeEventSubscriptions) ID() string { 4193 return "OperationDeserializer" 4194} 4195 4196func (m *awsAwsquery_deserializeOpDescribeEventSubscriptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4197 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4198) { 4199 out, metadata, err = next.HandleDeserialize(ctx, in) 4200 if err != nil { 4201 return out, metadata, err 4202 } 4203 4204 response, ok := out.RawResponse.(*smithyhttp.Response) 4205 if !ok { 4206 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4207 } 4208 4209 if response.StatusCode < 200 || response.StatusCode >= 300 { 4210 return out, metadata, awsAwsquery_deserializeOpErrorDescribeEventSubscriptions(response, &metadata) 4211 } 4212 output := &DescribeEventSubscriptionsOutput{} 4213 out.Result = output 4214 4215 var buff [1024]byte 4216 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4217 body := io.TeeReader(response.Body, ringBuffer) 4218 rootDecoder := xml.NewDecoder(body) 4219 t, err := smithyxml.FetchRootElement(rootDecoder) 4220 if err == io.EOF { 4221 return out, metadata, nil 4222 } 4223 if err != nil { 4224 var snapshot bytes.Buffer 4225 io.Copy(&snapshot, ringBuffer) 4226 return out, metadata, &smithy.DeserializationError{ 4227 Err: fmt.Errorf("failed to decode response body, %w", err), 4228 Snapshot: snapshot.Bytes(), 4229 } 4230 } 4231 4232 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4233 t, err = decoder.GetElement("DescribeEventSubscriptionsResult") 4234 if err != nil { 4235 var snapshot bytes.Buffer 4236 io.Copy(&snapshot, ringBuffer) 4237 err = &smithy.DeserializationError{ 4238 Err: fmt.Errorf("failed to decode response body, %w", err), 4239 Snapshot: snapshot.Bytes(), 4240 } 4241 return out, metadata, err 4242 } 4243 4244 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4245 err = awsAwsquery_deserializeOpDocumentDescribeEventSubscriptionsOutput(&output, decoder) 4246 if err != nil { 4247 var snapshot bytes.Buffer 4248 io.Copy(&snapshot, ringBuffer) 4249 err = &smithy.DeserializationError{ 4250 Err: fmt.Errorf("failed to decode response body, %w", err), 4251 Snapshot: snapshot.Bytes(), 4252 } 4253 return out, metadata, err 4254 } 4255 4256 return out, metadata, err 4257} 4258 4259func awsAwsquery_deserializeOpErrorDescribeEventSubscriptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4260 var errorBuffer bytes.Buffer 4261 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4262 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4263 } 4264 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4265 4266 errorCode := "UnknownError" 4267 errorMessage := errorCode 4268 4269 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4270 if err != nil { 4271 return err 4272 } 4273 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4274 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4275 } 4276 if len(errorComponents.Code) != 0 { 4277 errorCode = errorComponents.Code 4278 } 4279 if len(errorComponents.Message) != 0 { 4280 errorMessage = errorComponents.Message 4281 } 4282 errorBody.Seek(0, io.SeekStart) 4283 switch { 4284 case strings.EqualFold("SubscriptionNotFoundFault", errorCode): 4285 return awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response, errorBody) 4286 4287 default: 4288 genericError := &smithy.GenericAPIError{ 4289 Code: errorCode, 4290 Message: errorMessage, 4291 } 4292 return genericError 4293 4294 } 4295} 4296 4297type awsAwsquery_deserializeOpDescribeOrderableDBInstanceOptions struct { 4298} 4299 4300func (*awsAwsquery_deserializeOpDescribeOrderableDBInstanceOptions) ID() string { 4301 return "OperationDeserializer" 4302} 4303 4304func (m *awsAwsquery_deserializeOpDescribeOrderableDBInstanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4305 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4306) { 4307 out, metadata, err = next.HandleDeserialize(ctx, in) 4308 if err != nil { 4309 return out, metadata, err 4310 } 4311 4312 response, ok := out.RawResponse.(*smithyhttp.Response) 4313 if !ok { 4314 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4315 } 4316 4317 if response.StatusCode < 200 || response.StatusCode >= 300 { 4318 return out, metadata, awsAwsquery_deserializeOpErrorDescribeOrderableDBInstanceOptions(response, &metadata) 4319 } 4320 output := &DescribeOrderableDBInstanceOptionsOutput{} 4321 out.Result = output 4322 4323 var buff [1024]byte 4324 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4325 body := io.TeeReader(response.Body, ringBuffer) 4326 rootDecoder := xml.NewDecoder(body) 4327 t, err := smithyxml.FetchRootElement(rootDecoder) 4328 if err == io.EOF { 4329 return out, metadata, nil 4330 } 4331 if err != nil { 4332 var snapshot bytes.Buffer 4333 io.Copy(&snapshot, ringBuffer) 4334 return out, metadata, &smithy.DeserializationError{ 4335 Err: fmt.Errorf("failed to decode response body, %w", err), 4336 Snapshot: snapshot.Bytes(), 4337 } 4338 } 4339 4340 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4341 t, err = decoder.GetElement("DescribeOrderableDBInstanceOptionsResult") 4342 if err != nil { 4343 var snapshot bytes.Buffer 4344 io.Copy(&snapshot, ringBuffer) 4345 err = &smithy.DeserializationError{ 4346 Err: fmt.Errorf("failed to decode response body, %w", err), 4347 Snapshot: snapshot.Bytes(), 4348 } 4349 return out, metadata, err 4350 } 4351 4352 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4353 err = awsAwsquery_deserializeOpDocumentDescribeOrderableDBInstanceOptionsOutput(&output, decoder) 4354 if err != nil { 4355 var snapshot bytes.Buffer 4356 io.Copy(&snapshot, ringBuffer) 4357 err = &smithy.DeserializationError{ 4358 Err: fmt.Errorf("failed to decode response body, %w", err), 4359 Snapshot: snapshot.Bytes(), 4360 } 4361 return out, metadata, err 4362 } 4363 4364 return out, metadata, err 4365} 4366 4367func awsAwsquery_deserializeOpErrorDescribeOrderableDBInstanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4368 var errorBuffer bytes.Buffer 4369 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4370 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4371 } 4372 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4373 4374 errorCode := "UnknownError" 4375 errorMessage := errorCode 4376 4377 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4378 if err != nil { 4379 return err 4380 } 4381 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4382 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4383 } 4384 if len(errorComponents.Code) != 0 { 4385 errorCode = errorComponents.Code 4386 } 4387 if len(errorComponents.Message) != 0 { 4388 errorMessage = errorComponents.Message 4389 } 4390 errorBody.Seek(0, io.SeekStart) 4391 switch { 4392 default: 4393 genericError := &smithy.GenericAPIError{ 4394 Code: errorCode, 4395 Message: errorMessage, 4396 } 4397 return genericError 4398 4399 } 4400} 4401 4402type awsAwsquery_deserializeOpDescribePendingMaintenanceActions struct { 4403} 4404 4405func (*awsAwsquery_deserializeOpDescribePendingMaintenanceActions) ID() string { 4406 return "OperationDeserializer" 4407} 4408 4409func (m *awsAwsquery_deserializeOpDescribePendingMaintenanceActions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4410 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4411) { 4412 out, metadata, err = next.HandleDeserialize(ctx, in) 4413 if err != nil { 4414 return out, metadata, err 4415 } 4416 4417 response, ok := out.RawResponse.(*smithyhttp.Response) 4418 if !ok { 4419 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4420 } 4421 4422 if response.StatusCode < 200 || response.StatusCode >= 300 { 4423 return out, metadata, awsAwsquery_deserializeOpErrorDescribePendingMaintenanceActions(response, &metadata) 4424 } 4425 output := &DescribePendingMaintenanceActionsOutput{} 4426 out.Result = output 4427 4428 var buff [1024]byte 4429 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4430 body := io.TeeReader(response.Body, ringBuffer) 4431 rootDecoder := xml.NewDecoder(body) 4432 t, err := smithyxml.FetchRootElement(rootDecoder) 4433 if err == io.EOF { 4434 return out, metadata, nil 4435 } 4436 if err != nil { 4437 var snapshot bytes.Buffer 4438 io.Copy(&snapshot, ringBuffer) 4439 return out, metadata, &smithy.DeserializationError{ 4440 Err: fmt.Errorf("failed to decode response body, %w", err), 4441 Snapshot: snapshot.Bytes(), 4442 } 4443 } 4444 4445 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4446 t, err = decoder.GetElement("DescribePendingMaintenanceActionsResult") 4447 if err != nil { 4448 var snapshot bytes.Buffer 4449 io.Copy(&snapshot, ringBuffer) 4450 err = &smithy.DeserializationError{ 4451 Err: fmt.Errorf("failed to decode response body, %w", err), 4452 Snapshot: snapshot.Bytes(), 4453 } 4454 return out, metadata, err 4455 } 4456 4457 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4458 err = awsAwsquery_deserializeOpDocumentDescribePendingMaintenanceActionsOutput(&output, decoder) 4459 if err != nil { 4460 var snapshot bytes.Buffer 4461 io.Copy(&snapshot, ringBuffer) 4462 err = &smithy.DeserializationError{ 4463 Err: fmt.Errorf("failed to decode response body, %w", err), 4464 Snapshot: snapshot.Bytes(), 4465 } 4466 return out, metadata, err 4467 } 4468 4469 return out, metadata, err 4470} 4471 4472func awsAwsquery_deserializeOpErrorDescribePendingMaintenanceActions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4473 var errorBuffer bytes.Buffer 4474 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4475 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4476 } 4477 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4478 4479 errorCode := "UnknownError" 4480 errorMessage := errorCode 4481 4482 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4483 if err != nil { 4484 return err 4485 } 4486 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4487 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4488 } 4489 if len(errorComponents.Code) != 0 { 4490 errorCode = errorComponents.Code 4491 } 4492 if len(errorComponents.Message) != 0 { 4493 errorMessage = errorComponents.Message 4494 } 4495 errorBody.Seek(0, io.SeekStart) 4496 switch { 4497 case strings.EqualFold("ResourceNotFoundFault", errorCode): 4498 return awsAwsquery_deserializeErrorResourceNotFoundFault(response, errorBody) 4499 4500 default: 4501 genericError := &smithy.GenericAPIError{ 4502 Code: errorCode, 4503 Message: errorMessage, 4504 } 4505 return genericError 4506 4507 } 4508} 4509 4510type awsAwsquery_deserializeOpDescribeValidDBInstanceModifications struct { 4511} 4512 4513func (*awsAwsquery_deserializeOpDescribeValidDBInstanceModifications) ID() string { 4514 return "OperationDeserializer" 4515} 4516 4517func (m *awsAwsquery_deserializeOpDescribeValidDBInstanceModifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4518 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4519) { 4520 out, metadata, err = next.HandleDeserialize(ctx, in) 4521 if err != nil { 4522 return out, metadata, err 4523 } 4524 4525 response, ok := out.RawResponse.(*smithyhttp.Response) 4526 if !ok { 4527 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4528 } 4529 4530 if response.StatusCode < 200 || response.StatusCode >= 300 { 4531 return out, metadata, awsAwsquery_deserializeOpErrorDescribeValidDBInstanceModifications(response, &metadata) 4532 } 4533 output := &DescribeValidDBInstanceModificationsOutput{} 4534 out.Result = output 4535 4536 var buff [1024]byte 4537 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4538 body := io.TeeReader(response.Body, ringBuffer) 4539 rootDecoder := xml.NewDecoder(body) 4540 t, err := smithyxml.FetchRootElement(rootDecoder) 4541 if err == io.EOF { 4542 return out, metadata, nil 4543 } 4544 if err != nil { 4545 var snapshot bytes.Buffer 4546 io.Copy(&snapshot, ringBuffer) 4547 return out, metadata, &smithy.DeserializationError{ 4548 Err: fmt.Errorf("failed to decode response body, %w", err), 4549 Snapshot: snapshot.Bytes(), 4550 } 4551 } 4552 4553 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4554 t, err = decoder.GetElement("DescribeValidDBInstanceModificationsResult") 4555 if err != nil { 4556 var snapshot bytes.Buffer 4557 io.Copy(&snapshot, ringBuffer) 4558 err = &smithy.DeserializationError{ 4559 Err: fmt.Errorf("failed to decode response body, %w", err), 4560 Snapshot: snapshot.Bytes(), 4561 } 4562 return out, metadata, err 4563 } 4564 4565 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4566 err = awsAwsquery_deserializeOpDocumentDescribeValidDBInstanceModificationsOutput(&output, decoder) 4567 if err != nil { 4568 var snapshot bytes.Buffer 4569 io.Copy(&snapshot, ringBuffer) 4570 err = &smithy.DeserializationError{ 4571 Err: fmt.Errorf("failed to decode response body, %w", err), 4572 Snapshot: snapshot.Bytes(), 4573 } 4574 return out, metadata, err 4575 } 4576 4577 return out, metadata, err 4578} 4579 4580func awsAwsquery_deserializeOpErrorDescribeValidDBInstanceModifications(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4581 var errorBuffer bytes.Buffer 4582 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4583 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4584 } 4585 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4586 4587 errorCode := "UnknownError" 4588 errorMessage := errorCode 4589 4590 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4591 if err != nil { 4592 return err 4593 } 4594 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4595 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4596 } 4597 if len(errorComponents.Code) != 0 { 4598 errorCode = errorComponents.Code 4599 } 4600 if len(errorComponents.Message) != 0 { 4601 errorMessage = errorComponents.Message 4602 } 4603 errorBody.Seek(0, io.SeekStart) 4604 switch { 4605 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 4606 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 4607 4608 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 4609 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 4610 4611 default: 4612 genericError := &smithy.GenericAPIError{ 4613 Code: errorCode, 4614 Message: errorMessage, 4615 } 4616 return genericError 4617 4618 } 4619} 4620 4621type awsAwsquery_deserializeOpFailoverDBCluster struct { 4622} 4623 4624func (*awsAwsquery_deserializeOpFailoverDBCluster) ID() string { 4625 return "OperationDeserializer" 4626} 4627 4628func (m *awsAwsquery_deserializeOpFailoverDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4629 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4630) { 4631 out, metadata, err = next.HandleDeserialize(ctx, in) 4632 if err != nil { 4633 return out, metadata, err 4634 } 4635 4636 response, ok := out.RawResponse.(*smithyhttp.Response) 4637 if !ok { 4638 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4639 } 4640 4641 if response.StatusCode < 200 || response.StatusCode >= 300 { 4642 return out, metadata, awsAwsquery_deserializeOpErrorFailoverDBCluster(response, &metadata) 4643 } 4644 output := &FailoverDBClusterOutput{} 4645 out.Result = output 4646 4647 var buff [1024]byte 4648 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4649 body := io.TeeReader(response.Body, ringBuffer) 4650 rootDecoder := xml.NewDecoder(body) 4651 t, err := smithyxml.FetchRootElement(rootDecoder) 4652 if err == io.EOF { 4653 return out, metadata, nil 4654 } 4655 if err != nil { 4656 var snapshot bytes.Buffer 4657 io.Copy(&snapshot, ringBuffer) 4658 return out, metadata, &smithy.DeserializationError{ 4659 Err: fmt.Errorf("failed to decode response body, %w", err), 4660 Snapshot: snapshot.Bytes(), 4661 } 4662 } 4663 4664 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4665 t, err = decoder.GetElement("FailoverDBClusterResult") 4666 if err != nil { 4667 var snapshot bytes.Buffer 4668 io.Copy(&snapshot, ringBuffer) 4669 err = &smithy.DeserializationError{ 4670 Err: fmt.Errorf("failed to decode response body, %w", err), 4671 Snapshot: snapshot.Bytes(), 4672 } 4673 return out, metadata, err 4674 } 4675 4676 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4677 err = awsAwsquery_deserializeOpDocumentFailoverDBClusterOutput(&output, decoder) 4678 if err != nil { 4679 var snapshot bytes.Buffer 4680 io.Copy(&snapshot, ringBuffer) 4681 err = &smithy.DeserializationError{ 4682 Err: fmt.Errorf("failed to decode response body, %w", err), 4683 Snapshot: snapshot.Bytes(), 4684 } 4685 return out, metadata, err 4686 } 4687 4688 return out, metadata, err 4689} 4690 4691func awsAwsquery_deserializeOpErrorFailoverDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4692 var errorBuffer bytes.Buffer 4693 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4694 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4695 } 4696 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4697 4698 errorCode := "UnknownError" 4699 errorMessage := errorCode 4700 4701 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4702 if err != nil { 4703 return err 4704 } 4705 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4706 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4707 } 4708 if len(errorComponents.Code) != 0 { 4709 errorCode = errorComponents.Code 4710 } 4711 if len(errorComponents.Message) != 0 { 4712 errorMessage = errorComponents.Message 4713 } 4714 errorBody.Seek(0, io.SeekStart) 4715 switch { 4716 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 4717 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 4718 4719 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 4720 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 4721 4722 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 4723 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 4724 4725 default: 4726 genericError := &smithy.GenericAPIError{ 4727 Code: errorCode, 4728 Message: errorMessage, 4729 } 4730 return genericError 4731 4732 } 4733} 4734 4735type awsAwsquery_deserializeOpListTagsForResource struct { 4736} 4737 4738func (*awsAwsquery_deserializeOpListTagsForResource) ID() string { 4739 return "OperationDeserializer" 4740} 4741 4742func (m *awsAwsquery_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4743 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4744) { 4745 out, metadata, err = next.HandleDeserialize(ctx, in) 4746 if err != nil { 4747 return out, metadata, err 4748 } 4749 4750 response, ok := out.RawResponse.(*smithyhttp.Response) 4751 if !ok { 4752 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4753 } 4754 4755 if response.StatusCode < 200 || response.StatusCode >= 300 { 4756 return out, metadata, awsAwsquery_deserializeOpErrorListTagsForResource(response, &metadata) 4757 } 4758 output := &ListTagsForResourceOutput{} 4759 out.Result = output 4760 4761 var buff [1024]byte 4762 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4763 body := io.TeeReader(response.Body, ringBuffer) 4764 rootDecoder := xml.NewDecoder(body) 4765 t, err := smithyxml.FetchRootElement(rootDecoder) 4766 if err == io.EOF { 4767 return out, metadata, nil 4768 } 4769 if err != nil { 4770 var snapshot bytes.Buffer 4771 io.Copy(&snapshot, ringBuffer) 4772 return out, metadata, &smithy.DeserializationError{ 4773 Err: fmt.Errorf("failed to decode response body, %w", err), 4774 Snapshot: snapshot.Bytes(), 4775 } 4776 } 4777 4778 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4779 t, err = decoder.GetElement("ListTagsForResourceResult") 4780 if err != nil { 4781 var snapshot bytes.Buffer 4782 io.Copy(&snapshot, ringBuffer) 4783 err = &smithy.DeserializationError{ 4784 Err: fmt.Errorf("failed to decode response body, %w", err), 4785 Snapshot: snapshot.Bytes(), 4786 } 4787 return out, metadata, err 4788 } 4789 4790 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4791 err = awsAwsquery_deserializeOpDocumentListTagsForResourceOutput(&output, decoder) 4792 if err != nil { 4793 var snapshot bytes.Buffer 4794 io.Copy(&snapshot, ringBuffer) 4795 err = &smithy.DeserializationError{ 4796 Err: fmt.Errorf("failed to decode response body, %w", err), 4797 Snapshot: snapshot.Bytes(), 4798 } 4799 return out, metadata, err 4800 } 4801 4802 return out, metadata, err 4803} 4804 4805func awsAwsquery_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4806 var errorBuffer bytes.Buffer 4807 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4808 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4809 } 4810 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4811 4812 errorCode := "UnknownError" 4813 errorMessage := errorCode 4814 4815 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4816 if err != nil { 4817 return err 4818 } 4819 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4820 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4821 } 4822 if len(errorComponents.Code) != 0 { 4823 errorCode = errorComponents.Code 4824 } 4825 if len(errorComponents.Message) != 0 { 4826 errorMessage = errorComponents.Message 4827 } 4828 errorBody.Seek(0, io.SeekStart) 4829 switch { 4830 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 4831 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 4832 4833 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 4834 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 4835 4836 case strings.EqualFold("DBSnapshotNotFoundFault", errorCode): 4837 return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) 4838 4839 default: 4840 genericError := &smithy.GenericAPIError{ 4841 Code: errorCode, 4842 Message: errorMessage, 4843 } 4844 return genericError 4845 4846 } 4847} 4848 4849type awsAwsquery_deserializeOpModifyDBCluster struct { 4850} 4851 4852func (*awsAwsquery_deserializeOpModifyDBCluster) ID() string { 4853 return "OperationDeserializer" 4854} 4855 4856func (m *awsAwsquery_deserializeOpModifyDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4857 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4858) { 4859 out, metadata, err = next.HandleDeserialize(ctx, in) 4860 if err != nil { 4861 return out, metadata, err 4862 } 4863 4864 response, ok := out.RawResponse.(*smithyhttp.Response) 4865 if !ok { 4866 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4867 } 4868 4869 if response.StatusCode < 200 || response.StatusCode >= 300 { 4870 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBCluster(response, &metadata) 4871 } 4872 output := &ModifyDBClusterOutput{} 4873 out.Result = output 4874 4875 var buff [1024]byte 4876 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4877 body := io.TeeReader(response.Body, ringBuffer) 4878 rootDecoder := xml.NewDecoder(body) 4879 t, err := smithyxml.FetchRootElement(rootDecoder) 4880 if err == io.EOF { 4881 return out, metadata, nil 4882 } 4883 if err != nil { 4884 var snapshot bytes.Buffer 4885 io.Copy(&snapshot, ringBuffer) 4886 return out, metadata, &smithy.DeserializationError{ 4887 Err: fmt.Errorf("failed to decode response body, %w", err), 4888 Snapshot: snapshot.Bytes(), 4889 } 4890 } 4891 4892 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4893 t, err = decoder.GetElement("ModifyDBClusterResult") 4894 if err != nil { 4895 var snapshot bytes.Buffer 4896 io.Copy(&snapshot, ringBuffer) 4897 err = &smithy.DeserializationError{ 4898 Err: fmt.Errorf("failed to decode response body, %w", err), 4899 Snapshot: snapshot.Bytes(), 4900 } 4901 return out, metadata, err 4902 } 4903 4904 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4905 err = awsAwsquery_deserializeOpDocumentModifyDBClusterOutput(&output, decoder) 4906 if err != nil { 4907 var snapshot bytes.Buffer 4908 io.Copy(&snapshot, ringBuffer) 4909 err = &smithy.DeserializationError{ 4910 Err: fmt.Errorf("failed to decode response body, %w", err), 4911 Snapshot: snapshot.Bytes(), 4912 } 4913 return out, metadata, err 4914 } 4915 4916 return out, metadata, err 4917} 4918 4919func awsAwsquery_deserializeOpErrorModifyDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4920 var errorBuffer bytes.Buffer 4921 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4922 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4923 } 4924 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4925 4926 errorCode := "UnknownError" 4927 errorMessage := errorCode 4928 4929 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4930 if err != nil { 4931 return err 4932 } 4933 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4934 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4935 } 4936 if len(errorComponents.Code) != 0 { 4937 errorCode = errorComponents.Code 4938 } 4939 if len(errorComponents.Message) != 0 { 4940 errorMessage = errorComponents.Message 4941 } 4942 errorBody.Seek(0, io.SeekStart) 4943 switch { 4944 case strings.EqualFold("DBClusterAlreadyExistsFault", errorCode): 4945 return awsAwsquery_deserializeErrorDBClusterAlreadyExistsFault(response, errorBody) 4946 4947 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 4948 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 4949 4950 case strings.EqualFold("DBClusterParameterGroupNotFoundFault", errorCode): 4951 return awsAwsquery_deserializeErrorDBClusterParameterGroupNotFoundFault(response, errorBody) 4952 4953 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 4954 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 4955 4956 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 4957 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 4958 4959 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 4960 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 4961 4962 case strings.EqualFold("InvalidDBSecurityGroupStateFault", errorCode): 4963 return awsAwsquery_deserializeErrorInvalidDBSecurityGroupStateFault(response, errorBody) 4964 4965 case strings.EqualFold("InvalidDBSubnetGroupStateFault", errorCode): 4966 return awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response, errorBody) 4967 4968 case strings.EqualFold("InvalidSubnet", errorCode): 4969 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 4970 4971 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 4972 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 4973 4974 case strings.EqualFold("StorageQuotaExceededFault", errorCode): 4975 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 4976 4977 default: 4978 genericError := &smithy.GenericAPIError{ 4979 Code: errorCode, 4980 Message: errorMessage, 4981 } 4982 return genericError 4983 4984 } 4985} 4986 4987type awsAwsquery_deserializeOpModifyDBClusterEndpoint struct { 4988} 4989 4990func (*awsAwsquery_deserializeOpModifyDBClusterEndpoint) ID() string { 4991 return "OperationDeserializer" 4992} 4993 4994func (m *awsAwsquery_deserializeOpModifyDBClusterEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4995 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4996) { 4997 out, metadata, err = next.HandleDeserialize(ctx, in) 4998 if err != nil { 4999 return out, metadata, err 5000 } 5001 5002 response, ok := out.RawResponse.(*smithyhttp.Response) 5003 if !ok { 5004 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5005 } 5006 5007 if response.StatusCode < 200 || response.StatusCode >= 300 { 5008 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBClusterEndpoint(response, &metadata) 5009 } 5010 output := &ModifyDBClusterEndpointOutput{} 5011 out.Result = output 5012 5013 var buff [1024]byte 5014 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5015 body := io.TeeReader(response.Body, ringBuffer) 5016 rootDecoder := xml.NewDecoder(body) 5017 t, err := smithyxml.FetchRootElement(rootDecoder) 5018 if err == io.EOF { 5019 return out, metadata, nil 5020 } 5021 if err != nil { 5022 var snapshot bytes.Buffer 5023 io.Copy(&snapshot, ringBuffer) 5024 return out, metadata, &smithy.DeserializationError{ 5025 Err: fmt.Errorf("failed to decode response body, %w", err), 5026 Snapshot: snapshot.Bytes(), 5027 } 5028 } 5029 5030 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5031 t, err = decoder.GetElement("ModifyDBClusterEndpointResult") 5032 if err != nil { 5033 var snapshot bytes.Buffer 5034 io.Copy(&snapshot, ringBuffer) 5035 err = &smithy.DeserializationError{ 5036 Err: fmt.Errorf("failed to decode response body, %w", err), 5037 Snapshot: snapshot.Bytes(), 5038 } 5039 return out, metadata, err 5040 } 5041 5042 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5043 err = awsAwsquery_deserializeOpDocumentModifyDBClusterEndpointOutput(&output, decoder) 5044 if err != nil { 5045 var snapshot bytes.Buffer 5046 io.Copy(&snapshot, ringBuffer) 5047 err = &smithy.DeserializationError{ 5048 Err: fmt.Errorf("failed to decode response body, %w", err), 5049 Snapshot: snapshot.Bytes(), 5050 } 5051 return out, metadata, err 5052 } 5053 5054 return out, metadata, err 5055} 5056 5057func awsAwsquery_deserializeOpErrorModifyDBClusterEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5058 var errorBuffer bytes.Buffer 5059 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5060 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5061 } 5062 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5063 5064 errorCode := "UnknownError" 5065 errorMessage := errorCode 5066 5067 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5068 if err != nil { 5069 return err 5070 } 5071 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5072 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5073 } 5074 if len(errorComponents.Code) != 0 { 5075 errorCode = errorComponents.Code 5076 } 5077 if len(errorComponents.Message) != 0 { 5078 errorMessage = errorComponents.Message 5079 } 5080 errorBody.Seek(0, io.SeekStart) 5081 switch { 5082 case strings.EqualFold("DBClusterEndpointNotFoundFault", errorCode): 5083 return awsAwsquery_deserializeErrorDBClusterEndpointNotFoundFault(response, errorBody) 5084 5085 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 5086 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 5087 5088 case strings.EqualFold("InvalidDBClusterEndpointStateFault", errorCode): 5089 return awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response, errorBody) 5090 5091 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 5092 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 5093 5094 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 5095 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 5096 5097 default: 5098 genericError := &smithy.GenericAPIError{ 5099 Code: errorCode, 5100 Message: errorMessage, 5101 } 5102 return genericError 5103 5104 } 5105} 5106 5107type awsAwsquery_deserializeOpModifyDBClusterParameterGroup struct { 5108} 5109 5110func (*awsAwsquery_deserializeOpModifyDBClusterParameterGroup) ID() string { 5111 return "OperationDeserializer" 5112} 5113 5114func (m *awsAwsquery_deserializeOpModifyDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5115 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5116) { 5117 out, metadata, err = next.HandleDeserialize(ctx, in) 5118 if err != nil { 5119 return out, metadata, err 5120 } 5121 5122 response, ok := out.RawResponse.(*smithyhttp.Response) 5123 if !ok { 5124 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5125 } 5126 5127 if response.StatusCode < 200 || response.StatusCode >= 300 { 5128 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBClusterParameterGroup(response, &metadata) 5129 } 5130 output := &ModifyDBClusterParameterGroupOutput{} 5131 out.Result = output 5132 5133 var buff [1024]byte 5134 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5135 body := io.TeeReader(response.Body, ringBuffer) 5136 rootDecoder := xml.NewDecoder(body) 5137 t, err := smithyxml.FetchRootElement(rootDecoder) 5138 if err == io.EOF { 5139 return out, metadata, nil 5140 } 5141 if err != nil { 5142 var snapshot bytes.Buffer 5143 io.Copy(&snapshot, ringBuffer) 5144 return out, metadata, &smithy.DeserializationError{ 5145 Err: fmt.Errorf("failed to decode response body, %w", err), 5146 Snapshot: snapshot.Bytes(), 5147 } 5148 } 5149 5150 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5151 t, err = decoder.GetElement("ModifyDBClusterParameterGroupResult") 5152 if err != nil { 5153 var snapshot bytes.Buffer 5154 io.Copy(&snapshot, ringBuffer) 5155 err = &smithy.DeserializationError{ 5156 Err: fmt.Errorf("failed to decode response body, %w", err), 5157 Snapshot: snapshot.Bytes(), 5158 } 5159 return out, metadata, err 5160 } 5161 5162 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5163 err = awsAwsquery_deserializeOpDocumentModifyDBClusterParameterGroupOutput(&output, decoder) 5164 if err != nil { 5165 var snapshot bytes.Buffer 5166 io.Copy(&snapshot, ringBuffer) 5167 err = &smithy.DeserializationError{ 5168 Err: fmt.Errorf("failed to decode response body, %w", err), 5169 Snapshot: snapshot.Bytes(), 5170 } 5171 return out, metadata, err 5172 } 5173 5174 return out, metadata, err 5175} 5176 5177func awsAwsquery_deserializeOpErrorModifyDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5178 var errorBuffer bytes.Buffer 5179 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5180 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5181 } 5182 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5183 5184 errorCode := "UnknownError" 5185 errorMessage := errorCode 5186 5187 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5188 if err != nil { 5189 return err 5190 } 5191 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5192 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5193 } 5194 if len(errorComponents.Code) != 0 { 5195 errorCode = errorComponents.Code 5196 } 5197 if len(errorComponents.Message) != 0 { 5198 errorMessage = errorComponents.Message 5199 } 5200 errorBody.Seek(0, io.SeekStart) 5201 switch { 5202 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 5203 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 5204 5205 case strings.EqualFold("InvalidDBParameterGroupStateFault", errorCode): 5206 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 5207 5208 default: 5209 genericError := &smithy.GenericAPIError{ 5210 Code: errorCode, 5211 Message: errorMessage, 5212 } 5213 return genericError 5214 5215 } 5216} 5217 5218type awsAwsquery_deserializeOpModifyDBClusterSnapshotAttribute struct { 5219} 5220 5221func (*awsAwsquery_deserializeOpModifyDBClusterSnapshotAttribute) ID() string { 5222 return "OperationDeserializer" 5223} 5224 5225func (m *awsAwsquery_deserializeOpModifyDBClusterSnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5226 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5227) { 5228 out, metadata, err = next.HandleDeserialize(ctx, in) 5229 if err != nil { 5230 return out, metadata, err 5231 } 5232 5233 response, ok := out.RawResponse.(*smithyhttp.Response) 5234 if !ok { 5235 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5236 } 5237 5238 if response.StatusCode < 200 || response.StatusCode >= 300 { 5239 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBClusterSnapshotAttribute(response, &metadata) 5240 } 5241 output := &ModifyDBClusterSnapshotAttributeOutput{} 5242 out.Result = output 5243 5244 var buff [1024]byte 5245 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5246 body := io.TeeReader(response.Body, ringBuffer) 5247 rootDecoder := xml.NewDecoder(body) 5248 t, err := smithyxml.FetchRootElement(rootDecoder) 5249 if err == io.EOF { 5250 return out, metadata, nil 5251 } 5252 if err != nil { 5253 var snapshot bytes.Buffer 5254 io.Copy(&snapshot, ringBuffer) 5255 return out, metadata, &smithy.DeserializationError{ 5256 Err: fmt.Errorf("failed to decode response body, %w", err), 5257 Snapshot: snapshot.Bytes(), 5258 } 5259 } 5260 5261 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5262 t, err = decoder.GetElement("ModifyDBClusterSnapshotAttributeResult") 5263 if err != nil { 5264 var snapshot bytes.Buffer 5265 io.Copy(&snapshot, ringBuffer) 5266 err = &smithy.DeserializationError{ 5267 Err: fmt.Errorf("failed to decode response body, %w", err), 5268 Snapshot: snapshot.Bytes(), 5269 } 5270 return out, metadata, err 5271 } 5272 5273 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5274 err = awsAwsquery_deserializeOpDocumentModifyDBClusterSnapshotAttributeOutput(&output, decoder) 5275 if err != nil { 5276 var snapshot bytes.Buffer 5277 io.Copy(&snapshot, ringBuffer) 5278 err = &smithy.DeserializationError{ 5279 Err: fmt.Errorf("failed to decode response body, %w", err), 5280 Snapshot: snapshot.Bytes(), 5281 } 5282 return out, metadata, err 5283 } 5284 5285 return out, metadata, err 5286} 5287 5288func awsAwsquery_deserializeOpErrorModifyDBClusterSnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5289 var errorBuffer bytes.Buffer 5290 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5291 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5292 } 5293 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5294 5295 errorCode := "UnknownError" 5296 errorMessage := errorCode 5297 5298 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5299 if err != nil { 5300 return err 5301 } 5302 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5303 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5304 } 5305 if len(errorComponents.Code) != 0 { 5306 errorCode = errorComponents.Code 5307 } 5308 if len(errorComponents.Message) != 0 { 5309 errorMessage = errorComponents.Message 5310 } 5311 errorBody.Seek(0, io.SeekStart) 5312 switch { 5313 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 5314 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 5315 5316 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 5317 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 5318 5319 case strings.EqualFold("SharedSnapshotQuotaExceededFault", errorCode): 5320 return awsAwsquery_deserializeErrorSharedSnapshotQuotaExceededFault(response, errorBody) 5321 5322 default: 5323 genericError := &smithy.GenericAPIError{ 5324 Code: errorCode, 5325 Message: errorMessage, 5326 } 5327 return genericError 5328 5329 } 5330} 5331 5332type awsAwsquery_deserializeOpModifyDBInstance struct { 5333} 5334 5335func (*awsAwsquery_deserializeOpModifyDBInstance) ID() string { 5336 return "OperationDeserializer" 5337} 5338 5339func (m *awsAwsquery_deserializeOpModifyDBInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5340 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5341) { 5342 out, metadata, err = next.HandleDeserialize(ctx, in) 5343 if err != nil { 5344 return out, metadata, err 5345 } 5346 5347 response, ok := out.RawResponse.(*smithyhttp.Response) 5348 if !ok { 5349 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5350 } 5351 5352 if response.StatusCode < 200 || response.StatusCode >= 300 { 5353 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBInstance(response, &metadata) 5354 } 5355 output := &ModifyDBInstanceOutput{} 5356 out.Result = output 5357 5358 var buff [1024]byte 5359 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5360 body := io.TeeReader(response.Body, ringBuffer) 5361 rootDecoder := xml.NewDecoder(body) 5362 t, err := smithyxml.FetchRootElement(rootDecoder) 5363 if err == io.EOF { 5364 return out, metadata, nil 5365 } 5366 if err != nil { 5367 var snapshot bytes.Buffer 5368 io.Copy(&snapshot, ringBuffer) 5369 return out, metadata, &smithy.DeserializationError{ 5370 Err: fmt.Errorf("failed to decode response body, %w", err), 5371 Snapshot: snapshot.Bytes(), 5372 } 5373 } 5374 5375 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5376 t, err = decoder.GetElement("ModifyDBInstanceResult") 5377 if err != nil { 5378 var snapshot bytes.Buffer 5379 io.Copy(&snapshot, ringBuffer) 5380 err = &smithy.DeserializationError{ 5381 Err: fmt.Errorf("failed to decode response body, %w", err), 5382 Snapshot: snapshot.Bytes(), 5383 } 5384 return out, metadata, err 5385 } 5386 5387 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5388 err = awsAwsquery_deserializeOpDocumentModifyDBInstanceOutput(&output, decoder) 5389 if err != nil { 5390 var snapshot bytes.Buffer 5391 io.Copy(&snapshot, ringBuffer) 5392 err = &smithy.DeserializationError{ 5393 Err: fmt.Errorf("failed to decode response body, %w", err), 5394 Snapshot: snapshot.Bytes(), 5395 } 5396 return out, metadata, err 5397 } 5398 5399 return out, metadata, err 5400} 5401 5402func awsAwsquery_deserializeOpErrorModifyDBInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5403 var errorBuffer bytes.Buffer 5404 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5405 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5406 } 5407 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5408 5409 errorCode := "UnknownError" 5410 errorMessage := errorCode 5411 5412 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5413 if err != nil { 5414 return err 5415 } 5416 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5417 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5418 } 5419 if len(errorComponents.Code) != 0 { 5420 errorCode = errorComponents.Code 5421 } 5422 if len(errorComponents.Message) != 0 { 5423 errorMessage = errorComponents.Message 5424 } 5425 errorBody.Seek(0, io.SeekStart) 5426 switch { 5427 case strings.EqualFold("AuthorizationNotFoundFault", errorCode): 5428 return awsAwsquery_deserializeErrorAuthorizationNotFoundFault(response, errorBody) 5429 5430 case strings.EqualFold("CertificateNotFoundFault", errorCode): 5431 return awsAwsquery_deserializeErrorCertificateNotFoundFault(response, errorBody) 5432 5433 case strings.EqualFold("DBInstanceAlreadyExistsFault", errorCode): 5434 return awsAwsquery_deserializeErrorDBInstanceAlreadyExistsFault(response, errorBody) 5435 5436 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 5437 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 5438 5439 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 5440 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 5441 5442 case strings.EqualFold("DBSecurityGroupNotFoundFault", errorCode): 5443 return awsAwsquery_deserializeErrorDBSecurityGroupNotFoundFault(response, errorBody) 5444 5445 case strings.EqualFold("DBUpgradeDependencyFailureFault", errorCode): 5446 return awsAwsquery_deserializeErrorDBUpgradeDependencyFailureFault(response, errorBody) 5447 5448 case strings.EqualFold("DomainNotFoundFault", errorCode): 5449 return awsAwsquery_deserializeErrorDomainNotFoundFault(response, errorBody) 5450 5451 case strings.EqualFold("InsufficientDBInstanceCapacityFault", errorCode): 5452 return awsAwsquery_deserializeErrorInsufficientDBInstanceCapacityFault(response, errorBody) 5453 5454 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 5455 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 5456 5457 case strings.EqualFold("InvalidDBSecurityGroupStateFault", errorCode): 5458 return awsAwsquery_deserializeErrorInvalidDBSecurityGroupStateFault(response, errorBody) 5459 5460 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 5461 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 5462 5463 case strings.EqualFold("OptionGroupNotFoundFault", errorCode): 5464 return awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response, errorBody) 5465 5466 case strings.EqualFold("ProvisionedIopsNotAvailableInAZFault", errorCode): 5467 return awsAwsquery_deserializeErrorProvisionedIopsNotAvailableInAZFault(response, errorBody) 5468 5469 case strings.EqualFold("StorageQuotaExceededFault", errorCode): 5470 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 5471 5472 case strings.EqualFold("StorageTypeNotSupportedFault", errorCode): 5473 return awsAwsquery_deserializeErrorStorageTypeNotSupportedFault(response, errorBody) 5474 5475 default: 5476 genericError := &smithy.GenericAPIError{ 5477 Code: errorCode, 5478 Message: errorMessage, 5479 } 5480 return genericError 5481 5482 } 5483} 5484 5485type awsAwsquery_deserializeOpModifyDBParameterGroup struct { 5486} 5487 5488func (*awsAwsquery_deserializeOpModifyDBParameterGroup) ID() string { 5489 return "OperationDeserializer" 5490} 5491 5492func (m *awsAwsquery_deserializeOpModifyDBParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5493 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5494) { 5495 out, metadata, err = next.HandleDeserialize(ctx, in) 5496 if err != nil { 5497 return out, metadata, err 5498 } 5499 5500 response, ok := out.RawResponse.(*smithyhttp.Response) 5501 if !ok { 5502 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5503 } 5504 5505 if response.StatusCode < 200 || response.StatusCode >= 300 { 5506 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBParameterGroup(response, &metadata) 5507 } 5508 output := &ModifyDBParameterGroupOutput{} 5509 out.Result = output 5510 5511 var buff [1024]byte 5512 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5513 body := io.TeeReader(response.Body, ringBuffer) 5514 rootDecoder := xml.NewDecoder(body) 5515 t, err := smithyxml.FetchRootElement(rootDecoder) 5516 if err == io.EOF { 5517 return out, metadata, nil 5518 } 5519 if err != nil { 5520 var snapshot bytes.Buffer 5521 io.Copy(&snapshot, ringBuffer) 5522 return out, metadata, &smithy.DeserializationError{ 5523 Err: fmt.Errorf("failed to decode response body, %w", err), 5524 Snapshot: snapshot.Bytes(), 5525 } 5526 } 5527 5528 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5529 t, err = decoder.GetElement("ModifyDBParameterGroupResult") 5530 if err != nil { 5531 var snapshot bytes.Buffer 5532 io.Copy(&snapshot, ringBuffer) 5533 err = &smithy.DeserializationError{ 5534 Err: fmt.Errorf("failed to decode response body, %w", err), 5535 Snapshot: snapshot.Bytes(), 5536 } 5537 return out, metadata, err 5538 } 5539 5540 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5541 err = awsAwsquery_deserializeOpDocumentModifyDBParameterGroupOutput(&output, decoder) 5542 if err != nil { 5543 var snapshot bytes.Buffer 5544 io.Copy(&snapshot, ringBuffer) 5545 err = &smithy.DeserializationError{ 5546 Err: fmt.Errorf("failed to decode response body, %w", err), 5547 Snapshot: snapshot.Bytes(), 5548 } 5549 return out, metadata, err 5550 } 5551 5552 return out, metadata, err 5553} 5554 5555func awsAwsquery_deserializeOpErrorModifyDBParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5556 var errorBuffer bytes.Buffer 5557 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5558 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5559 } 5560 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5561 5562 errorCode := "UnknownError" 5563 errorMessage := errorCode 5564 5565 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5566 if err != nil { 5567 return err 5568 } 5569 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5570 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5571 } 5572 if len(errorComponents.Code) != 0 { 5573 errorCode = errorComponents.Code 5574 } 5575 if len(errorComponents.Message) != 0 { 5576 errorMessage = errorComponents.Message 5577 } 5578 errorBody.Seek(0, io.SeekStart) 5579 switch { 5580 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 5581 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 5582 5583 case strings.EqualFold("InvalidDBParameterGroupStateFault", errorCode): 5584 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 5585 5586 default: 5587 genericError := &smithy.GenericAPIError{ 5588 Code: errorCode, 5589 Message: errorMessage, 5590 } 5591 return genericError 5592 5593 } 5594} 5595 5596type awsAwsquery_deserializeOpModifyDBSubnetGroup struct { 5597} 5598 5599func (*awsAwsquery_deserializeOpModifyDBSubnetGroup) ID() string { 5600 return "OperationDeserializer" 5601} 5602 5603func (m *awsAwsquery_deserializeOpModifyDBSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5604 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5605) { 5606 out, metadata, err = next.HandleDeserialize(ctx, in) 5607 if err != nil { 5608 return out, metadata, err 5609 } 5610 5611 response, ok := out.RawResponse.(*smithyhttp.Response) 5612 if !ok { 5613 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5614 } 5615 5616 if response.StatusCode < 200 || response.StatusCode >= 300 { 5617 return out, metadata, awsAwsquery_deserializeOpErrorModifyDBSubnetGroup(response, &metadata) 5618 } 5619 output := &ModifyDBSubnetGroupOutput{} 5620 out.Result = output 5621 5622 var buff [1024]byte 5623 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5624 body := io.TeeReader(response.Body, ringBuffer) 5625 rootDecoder := xml.NewDecoder(body) 5626 t, err := smithyxml.FetchRootElement(rootDecoder) 5627 if err == io.EOF { 5628 return out, metadata, nil 5629 } 5630 if err != nil { 5631 var snapshot bytes.Buffer 5632 io.Copy(&snapshot, ringBuffer) 5633 return out, metadata, &smithy.DeserializationError{ 5634 Err: fmt.Errorf("failed to decode response body, %w", err), 5635 Snapshot: snapshot.Bytes(), 5636 } 5637 } 5638 5639 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5640 t, err = decoder.GetElement("ModifyDBSubnetGroupResult") 5641 if err != nil { 5642 var snapshot bytes.Buffer 5643 io.Copy(&snapshot, ringBuffer) 5644 err = &smithy.DeserializationError{ 5645 Err: fmt.Errorf("failed to decode response body, %w", err), 5646 Snapshot: snapshot.Bytes(), 5647 } 5648 return out, metadata, err 5649 } 5650 5651 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5652 err = awsAwsquery_deserializeOpDocumentModifyDBSubnetGroupOutput(&output, decoder) 5653 if err != nil { 5654 var snapshot bytes.Buffer 5655 io.Copy(&snapshot, ringBuffer) 5656 err = &smithy.DeserializationError{ 5657 Err: fmt.Errorf("failed to decode response body, %w", err), 5658 Snapshot: snapshot.Bytes(), 5659 } 5660 return out, metadata, err 5661 } 5662 5663 return out, metadata, err 5664} 5665 5666func awsAwsquery_deserializeOpErrorModifyDBSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5667 var errorBuffer bytes.Buffer 5668 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5669 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5670 } 5671 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5672 5673 errorCode := "UnknownError" 5674 errorMessage := errorCode 5675 5676 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5677 if err != nil { 5678 return err 5679 } 5680 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5681 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5682 } 5683 if len(errorComponents.Code) != 0 { 5684 errorCode = errorComponents.Code 5685 } 5686 if len(errorComponents.Message) != 0 { 5687 errorMessage = errorComponents.Message 5688 } 5689 errorBody.Seek(0, io.SeekStart) 5690 switch { 5691 case strings.EqualFold("DBSubnetGroupDoesNotCoverEnoughAZs", errorCode): 5692 return awsAwsquery_deserializeErrorDBSubnetGroupDoesNotCoverEnoughAZs(response, errorBody) 5693 5694 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 5695 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 5696 5697 case strings.EqualFold("DBSubnetQuotaExceededFault", errorCode): 5698 return awsAwsquery_deserializeErrorDBSubnetQuotaExceededFault(response, errorBody) 5699 5700 case strings.EqualFold("InvalidSubnet", errorCode): 5701 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 5702 5703 case strings.EqualFold("SubnetAlreadyInUse", errorCode): 5704 return awsAwsquery_deserializeErrorSubnetAlreadyInUse(response, errorBody) 5705 5706 default: 5707 genericError := &smithy.GenericAPIError{ 5708 Code: errorCode, 5709 Message: errorMessage, 5710 } 5711 return genericError 5712 5713 } 5714} 5715 5716type awsAwsquery_deserializeOpModifyEventSubscription struct { 5717} 5718 5719func (*awsAwsquery_deserializeOpModifyEventSubscription) ID() string { 5720 return "OperationDeserializer" 5721} 5722 5723func (m *awsAwsquery_deserializeOpModifyEventSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5724 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5725) { 5726 out, metadata, err = next.HandleDeserialize(ctx, in) 5727 if err != nil { 5728 return out, metadata, err 5729 } 5730 5731 response, ok := out.RawResponse.(*smithyhttp.Response) 5732 if !ok { 5733 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5734 } 5735 5736 if response.StatusCode < 200 || response.StatusCode >= 300 { 5737 return out, metadata, awsAwsquery_deserializeOpErrorModifyEventSubscription(response, &metadata) 5738 } 5739 output := &ModifyEventSubscriptionOutput{} 5740 out.Result = output 5741 5742 var buff [1024]byte 5743 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5744 body := io.TeeReader(response.Body, ringBuffer) 5745 rootDecoder := xml.NewDecoder(body) 5746 t, err := smithyxml.FetchRootElement(rootDecoder) 5747 if err == io.EOF { 5748 return out, metadata, nil 5749 } 5750 if err != nil { 5751 var snapshot bytes.Buffer 5752 io.Copy(&snapshot, ringBuffer) 5753 return out, metadata, &smithy.DeserializationError{ 5754 Err: fmt.Errorf("failed to decode response body, %w", err), 5755 Snapshot: snapshot.Bytes(), 5756 } 5757 } 5758 5759 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5760 t, err = decoder.GetElement("ModifyEventSubscriptionResult") 5761 if err != nil { 5762 var snapshot bytes.Buffer 5763 io.Copy(&snapshot, ringBuffer) 5764 err = &smithy.DeserializationError{ 5765 Err: fmt.Errorf("failed to decode response body, %w", err), 5766 Snapshot: snapshot.Bytes(), 5767 } 5768 return out, metadata, err 5769 } 5770 5771 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5772 err = awsAwsquery_deserializeOpDocumentModifyEventSubscriptionOutput(&output, decoder) 5773 if err != nil { 5774 var snapshot bytes.Buffer 5775 io.Copy(&snapshot, ringBuffer) 5776 err = &smithy.DeserializationError{ 5777 Err: fmt.Errorf("failed to decode response body, %w", err), 5778 Snapshot: snapshot.Bytes(), 5779 } 5780 return out, metadata, err 5781 } 5782 5783 return out, metadata, err 5784} 5785 5786func awsAwsquery_deserializeOpErrorModifyEventSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5787 var errorBuffer bytes.Buffer 5788 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5789 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5790 } 5791 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5792 5793 errorCode := "UnknownError" 5794 errorMessage := errorCode 5795 5796 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5797 if err != nil { 5798 return err 5799 } 5800 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5801 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5802 } 5803 if len(errorComponents.Code) != 0 { 5804 errorCode = errorComponents.Code 5805 } 5806 if len(errorComponents.Message) != 0 { 5807 errorMessage = errorComponents.Message 5808 } 5809 errorBody.Seek(0, io.SeekStart) 5810 switch { 5811 case strings.EqualFold("EventSubscriptionQuotaExceededFault", errorCode): 5812 return awsAwsquery_deserializeErrorEventSubscriptionQuotaExceededFault(response, errorBody) 5813 5814 case strings.EqualFold("SNSInvalidTopicFault", errorCode): 5815 return awsAwsquery_deserializeErrorSNSInvalidTopicFault(response, errorBody) 5816 5817 case strings.EqualFold("SNSNoAuthorizationFault", errorCode): 5818 return awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response, errorBody) 5819 5820 case strings.EqualFold("SNSTopicArnNotFoundFault", errorCode): 5821 return awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response, errorBody) 5822 5823 case strings.EqualFold("SubscriptionCategoryNotFoundFault", errorCode): 5824 return awsAwsquery_deserializeErrorSubscriptionCategoryNotFoundFault(response, errorBody) 5825 5826 case strings.EqualFold("SubscriptionNotFoundFault", errorCode): 5827 return awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response, errorBody) 5828 5829 default: 5830 genericError := &smithy.GenericAPIError{ 5831 Code: errorCode, 5832 Message: errorMessage, 5833 } 5834 return genericError 5835 5836 } 5837} 5838 5839type awsAwsquery_deserializeOpPromoteReadReplicaDBCluster struct { 5840} 5841 5842func (*awsAwsquery_deserializeOpPromoteReadReplicaDBCluster) ID() string { 5843 return "OperationDeserializer" 5844} 5845 5846func (m *awsAwsquery_deserializeOpPromoteReadReplicaDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5847 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5848) { 5849 out, metadata, err = next.HandleDeserialize(ctx, in) 5850 if err != nil { 5851 return out, metadata, err 5852 } 5853 5854 response, ok := out.RawResponse.(*smithyhttp.Response) 5855 if !ok { 5856 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5857 } 5858 5859 if response.StatusCode < 200 || response.StatusCode >= 300 { 5860 return out, metadata, awsAwsquery_deserializeOpErrorPromoteReadReplicaDBCluster(response, &metadata) 5861 } 5862 output := &PromoteReadReplicaDBClusterOutput{} 5863 out.Result = output 5864 5865 var buff [1024]byte 5866 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5867 body := io.TeeReader(response.Body, ringBuffer) 5868 rootDecoder := xml.NewDecoder(body) 5869 t, err := smithyxml.FetchRootElement(rootDecoder) 5870 if err == io.EOF { 5871 return out, metadata, nil 5872 } 5873 if err != nil { 5874 var snapshot bytes.Buffer 5875 io.Copy(&snapshot, ringBuffer) 5876 return out, metadata, &smithy.DeserializationError{ 5877 Err: fmt.Errorf("failed to decode response body, %w", err), 5878 Snapshot: snapshot.Bytes(), 5879 } 5880 } 5881 5882 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5883 t, err = decoder.GetElement("PromoteReadReplicaDBClusterResult") 5884 if err != nil { 5885 var snapshot bytes.Buffer 5886 io.Copy(&snapshot, ringBuffer) 5887 err = &smithy.DeserializationError{ 5888 Err: fmt.Errorf("failed to decode response body, %w", err), 5889 Snapshot: snapshot.Bytes(), 5890 } 5891 return out, metadata, err 5892 } 5893 5894 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5895 err = awsAwsquery_deserializeOpDocumentPromoteReadReplicaDBClusterOutput(&output, decoder) 5896 if err != nil { 5897 var snapshot bytes.Buffer 5898 io.Copy(&snapshot, ringBuffer) 5899 err = &smithy.DeserializationError{ 5900 Err: fmt.Errorf("failed to decode response body, %w", err), 5901 Snapshot: snapshot.Bytes(), 5902 } 5903 return out, metadata, err 5904 } 5905 5906 return out, metadata, err 5907} 5908 5909func awsAwsquery_deserializeOpErrorPromoteReadReplicaDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5910 var errorBuffer bytes.Buffer 5911 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5912 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5913 } 5914 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5915 5916 errorCode := "UnknownError" 5917 errorMessage := errorCode 5918 5919 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5920 if err != nil { 5921 return err 5922 } 5923 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5924 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5925 } 5926 if len(errorComponents.Code) != 0 { 5927 errorCode = errorComponents.Code 5928 } 5929 if len(errorComponents.Message) != 0 { 5930 errorMessage = errorComponents.Message 5931 } 5932 errorBody.Seek(0, io.SeekStart) 5933 switch { 5934 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 5935 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 5936 5937 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 5938 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 5939 5940 default: 5941 genericError := &smithy.GenericAPIError{ 5942 Code: errorCode, 5943 Message: errorMessage, 5944 } 5945 return genericError 5946 5947 } 5948} 5949 5950type awsAwsquery_deserializeOpRebootDBInstance struct { 5951} 5952 5953func (*awsAwsquery_deserializeOpRebootDBInstance) ID() string { 5954 return "OperationDeserializer" 5955} 5956 5957func (m *awsAwsquery_deserializeOpRebootDBInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5958 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5959) { 5960 out, metadata, err = next.HandleDeserialize(ctx, in) 5961 if err != nil { 5962 return out, metadata, err 5963 } 5964 5965 response, ok := out.RawResponse.(*smithyhttp.Response) 5966 if !ok { 5967 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5968 } 5969 5970 if response.StatusCode < 200 || response.StatusCode >= 300 { 5971 return out, metadata, awsAwsquery_deserializeOpErrorRebootDBInstance(response, &metadata) 5972 } 5973 output := &RebootDBInstanceOutput{} 5974 out.Result = output 5975 5976 var buff [1024]byte 5977 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5978 body := io.TeeReader(response.Body, ringBuffer) 5979 rootDecoder := xml.NewDecoder(body) 5980 t, err := smithyxml.FetchRootElement(rootDecoder) 5981 if err == io.EOF { 5982 return out, metadata, nil 5983 } 5984 if err != nil { 5985 var snapshot bytes.Buffer 5986 io.Copy(&snapshot, ringBuffer) 5987 return out, metadata, &smithy.DeserializationError{ 5988 Err: fmt.Errorf("failed to decode response body, %w", err), 5989 Snapshot: snapshot.Bytes(), 5990 } 5991 } 5992 5993 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5994 t, err = decoder.GetElement("RebootDBInstanceResult") 5995 if err != nil { 5996 var snapshot bytes.Buffer 5997 io.Copy(&snapshot, ringBuffer) 5998 err = &smithy.DeserializationError{ 5999 Err: fmt.Errorf("failed to decode response body, %w", err), 6000 Snapshot: snapshot.Bytes(), 6001 } 6002 return out, metadata, err 6003 } 6004 6005 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6006 err = awsAwsquery_deserializeOpDocumentRebootDBInstanceOutput(&output, decoder) 6007 if err != nil { 6008 var snapshot bytes.Buffer 6009 io.Copy(&snapshot, ringBuffer) 6010 err = &smithy.DeserializationError{ 6011 Err: fmt.Errorf("failed to decode response body, %w", err), 6012 Snapshot: snapshot.Bytes(), 6013 } 6014 return out, metadata, err 6015 } 6016 6017 return out, metadata, err 6018} 6019 6020func awsAwsquery_deserializeOpErrorRebootDBInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6021 var errorBuffer bytes.Buffer 6022 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6023 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6024 } 6025 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6026 6027 errorCode := "UnknownError" 6028 errorMessage := errorCode 6029 6030 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6031 if err != nil { 6032 return err 6033 } 6034 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6035 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6036 } 6037 if len(errorComponents.Code) != 0 { 6038 errorCode = errorComponents.Code 6039 } 6040 if len(errorComponents.Message) != 0 { 6041 errorMessage = errorComponents.Message 6042 } 6043 errorBody.Seek(0, io.SeekStart) 6044 switch { 6045 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 6046 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 6047 6048 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 6049 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 6050 6051 default: 6052 genericError := &smithy.GenericAPIError{ 6053 Code: errorCode, 6054 Message: errorMessage, 6055 } 6056 return genericError 6057 6058 } 6059} 6060 6061type awsAwsquery_deserializeOpRemoveRoleFromDBCluster struct { 6062} 6063 6064func (*awsAwsquery_deserializeOpRemoveRoleFromDBCluster) ID() string { 6065 return "OperationDeserializer" 6066} 6067 6068func (m *awsAwsquery_deserializeOpRemoveRoleFromDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6069 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6070) { 6071 out, metadata, err = next.HandleDeserialize(ctx, in) 6072 if err != nil { 6073 return out, metadata, err 6074 } 6075 6076 response, ok := out.RawResponse.(*smithyhttp.Response) 6077 if !ok { 6078 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6079 } 6080 6081 if response.StatusCode < 200 || response.StatusCode >= 300 { 6082 return out, metadata, awsAwsquery_deserializeOpErrorRemoveRoleFromDBCluster(response, &metadata) 6083 } 6084 output := &RemoveRoleFromDBClusterOutput{} 6085 out.Result = output 6086 6087 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 6088 return out, metadata, &smithy.DeserializationError{ 6089 Err: fmt.Errorf("failed to discard response body, %w", err), 6090 } 6091 } 6092 6093 return out, metadata, err 6094} 6095 6096func awsAwsquery_deserializeOpErrorRemoveRoleFromDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6097 var errorBuffer bytes.Buffer 6098 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6099 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6100 } 6101 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6102 6103 errorCode := "UnknownError" 6104 errorMessage := errorCode 6105 6106 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6107 if err != nil { 6108 return err 6109 } 6110 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6111 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6112 } 6113 if len(errorComponents.Code) != 0 { 6114 errorCode = errorComponents.Code 6115 } 6116 if len(errorComponents.Message) != 0 { 6117 errorMessage = errorComponents.Message 6118 } 6119 errorBody.Seek(0, io.SeekStart) 6120 switch { 6121 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 6122 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 6123 6124 case strings.EqualFold("DBClusterRoleNotFoundFault", errorCode): 6125 return awsAwsquery_deserializeErrorDBClusterRoleNotFoundFault(response, errorBody) 6126 6127 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 6128 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 6129 6130 default: 6131 genericError := &smithy.GenericAPIError{ 6132 Code: errorCode, 6133 Message: errorMessage, 6134 } 6135 return genericError 6136 6137 } 6138} 6139 6140type awsAwsquery_deserializeOpRemoveSourceIdentifierFromSubscription struct { 6141} 6142 6143func (*awsAwsquery_deserializeOpRemoveSourceIdentifierFromSubscription) ID() string { 6144 return "OperationDeserializer" 6145} 6146 6147func (m *awsAwsquery_deserializeOpRemoveSourceIdentifierFromSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6148 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6149) { 6150 out, metadata, err = next.HandleDeserialize(ctx, in) 6151 if err != nil { 6152 return out, metadata, err 6153 } 6154 6155 response, ok := out.RawResponse.(*smithyhttp.Response) 6156 if !ok { 6157 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6158 } 6159 6160 if response.StatusCode < 200 || response.StatusCode >= 300 { 6161 return out, metadata, awsAwsquery_deserializeOpErrorRemoveSourceIdentifierFromSubscription(response, &metadata) 6162 } 6163 output := &RemoveSourceIdentifierFromSubscriptionOutput{} 6164 out.Result = output 6165 6166 var buff [1024]byte 6167 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6168 body := io.TeeReader(response.Body, ringBuffer) 6169 rootDecoder := xml.NewDecoder(body) 6170 t, err := smithyxml.FetchRootElement(rootDecoder) 6171 if err == io.EOF { 6172 return out, metadata, nil 6173 } 6174 if err != nil { 6175 var snapshot bytes.Buffer 6176 io.Copy(&snapshot, ringBuffer) 6177 return out, metadata, &smithy.DeserializationError{ 6178 Err: fmt.Errorf("failed to decode response body, %w", err), 6179 Snapshot: snapshot.Bytes(), 6180 } 6181 } 6182 6183 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6184 t, err = decoder.GetElement("RemoveSourceIdentifierFromSubscriptionResult") 6185 if err != nil { 6186 var snapshot bytes.Buffer 6187 io.Copy(&snapshot, ringBuffer) 6188 err = &smithy.DeserializationError{ 6189 Err: fmt.Errorf("failed to decode response body, %w", err), 6190 Snapshot: snapshot.Bytes(), 6191 } 6192 return out, metadata, err 6193 } 6194 6195 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6196 err = awsAwsquery_deserializeOpDocumentRemoveSourceIdentifierFromSubscriptionOutput(&output, decoder) 6197 if err != nil { 6198 var snapshot bytes.Buffer 6199 io.Copy(&snapshot, ringBuffer) 6200 err = &smithy.DeserializationError{ 6201 Err: fmt.Errorf("failed to decode response body, %w", err), 6202 Snapshot: snapshot.Bytes(), 6203 } 6204 return out, metadata, err 6205 } 6206 6207 return out, metadata, err 6208} 6209 6210func awsAwsquery_deserializeOpErrorRemoveSourceIdentifierFromSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6211 var errorBuffer bytes.Buffer 6212 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6213 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6214 } 6215 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6216 6217 errorCode := "UnknownError" 6218 errorMessage := errorCode 6219 6220 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6221 if err != nil { 6222 return err 6223 } 6224 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6225 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6226 } 6227 if len(errorComponents.Code) != 0 { 6228 errorCode = errorComponents.Code 6229 } 6230 if len(errorComponents.Message) != 0 { 6231 errorMessage = errorComponents.Message 6232 } 6233 errorBody.Seek(0, io.SeekStart) 6234 switch { 6235 case strings.EqualFold("SourceNotFoundFault", errorCode): 6236 return awsAwsquery_deserializeErrorSourceNotFoundFault(response, errorBody) 6237 6238 case strings.EqualFold("SubscriptionNotFoundFault", errorCode): 6239 return awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response, errorBody) 6240 6241 default: 6242 genericError := &smithy.GenericAPIError{ 6243 Code: errorCode, 6244 Message: errorMessage, 6245 } 6246 return genericError 6247 6248 } 6249} 6250 6251type awsAwsquery_deserializeOpRemoveTagsFromResource struct { 6252} 6253 6254func (*awsAwsquery_deserializeOpRemoveTagsFromResource) ID() string { 6255 return "OperationDeserializer" 6256} 6257 6258func (m *awsAwsquery_deserializeOpRemoveTagsFromResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6259 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6260) { 6261 out, metadata, err = next.HandleDeserialize(ctx, in) 6262 if err != nil { 6263 return out, metadata, err 6264 } 6265 6266 response, ok := out.RawResponse.(*smithyhttp.Response) 6267 if !ok { 6268 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6269 } 6270 6271 if response.StatusCode < 200 || response.StatusCode >= 300 { 6272 return out, metadata, awsAwsquery_deserializeOpErrorRemoveTagsFromResource(response, &metadata) 6273 } 6274 output := &RemoveTagsFromResourceOutput{} 6275 out.Result = output 6276 6277 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 6278 return out, metadata, &smithy.DeserializationError{ 6279 Err: fmt.Errorf("failed to discard response body, %w", err), 6280 } 6281 } 6282 6283 return out, metadata, err 6284} 6285 6286func awsAwsquery_deserializeOpErrorRemoveTagsFromResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6287 var errorBuffer bytes.Buffer 6288 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6289 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6290 } 6291 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6292 6293 errorCode := "UnknownError" 6294 errorMessage := errorCode 6295 6296 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6297 if err != nil { 6298 return err 6299 } 6300 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6301 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6302 } 6303 if len(errorComponents.Code) != 0 { 6304 errorCode = errorComponents.Code 6305 } 6306 if len(errorComponents.Message) != 0 { 6307 errorMessage = errorComponents.Message 6308 } 6309 errorBody.Seek(0, io.SeekStart) 6310 switch { 6311 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 6312 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 6313 6314 case strings.EqualFold("DBInstanceNotFoundFault", errorCode): 6315 return awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response, errorBody) 6316 6317 case strings.EqualFold("DBSnapshotNotFoundFault", errorCode): 6318 return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) 6319 6320 default: 6321 genericError := &smithy.GenericAPIError{ 6322 Code: errorCode, 6323 Message: errorMessage, 6324 } 6325 return genericError 6326 6327 } 6328} 6329 6330type awsAwsquery_deserializeOpResetDBClusterParameterGroup struct { 6331} 6332 6333func (*awsAwsquery_deserializeOpResetDBClusterParameterGroup) ID() string { 6334 return "OperationDeserializer" 6335} 6336 6337func (m *awsAwsquery_deserializeOpResetDBClusterParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6338 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6339) { 6340 out, metadata, err = next.HandleDeserialize(ctx, in) 6341 if err != nil { 6342 return out, metadata, err 6343 } 6344 6345 response, ok := out.RawResponse.(*smithyhttp.Response) 6346 if !ok { 6347 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6348 } 6349 6350 if response.StatusCode < 200 || response.StatusCode >= 300 { 6351 return out, metadata, awsAwsquery_deserializeOpErrorResetDBClusterParameterGroup(response, &metadata) 6352 } 6353 output := &ResetDBClusterParameterGroupOutput{} 6354 out.Result = output 6355 6356 var buff [1024]byte 6357 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6358 body := io.TeeReader(response.Body, ringBuffer) 6359 rootDecoder := xml.NewDecoder(body) 6360 t, err := smithyxml.FetchRootElement(rootDecoder) 6361 if err == io.EOF { 6362 return out, metadata, nil 6363 } 6364 if err != nil { 6365 var snapshot bytes.Buffer 6366 io.Copy(&snapshot, ringBuffer) 6367 return out, metadata, &smithy.DeserializationError{ 6368 Err: fmt.Errorf("failed to decode response body, %w", err), 6369 Snapshot: snapshot.Bytes(), 6370 } 6371 } 6372 6373 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6374 t, err = decoder.GetElement("ResetDBClusterParameterGroupResult") 6375 if err != nil { 6376 var snapshot bytes.Buffer 6377 io.Copy(&snapshot, ringBuffer) 6378 err = &smithy.DeserializationError{ 6379 Err: fmt.Errorf("failed to decode response body, %w", err), 6380 Snapshot: snapshot.Bytes(), 6381 } 6382 return out, metadata, err 6383 } 6384 6385 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6386 err = awsAwsquery_deserializeOpDocumentResetDBClusterParameterGroupOutput(&output, decoder) 6387 if err != nil { 6388 var snapshot bytes.Buffer 6389 io.Copy(&snapshot, ringBuffer) 6390 err = &smithy.DeserializationError{ 6391 Err: fmt.Errorf("failed to decode response body, %w", err), 6392 Snapshot: snapshot.Bytes(), 6393 } 6394 return out, metadata, err 6395 } 6396 6397 return out, metadata, err 6398} 6399 6400func awsAwsquery_deserializeOpErrorResetDBClusterParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6401 var errorBuffer bytes.Buffer 6402 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6403 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6404 } 6405 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6406 6407 errorCode := "UnknownError" 6408 errorMessage := errorCode 6409 6410 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6411 if err != nil { 6412 return err 6413 } 6414 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6415 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6416 } 6417 if len(errorComponents.Code) != 0 { 6418 errorCode = errorComponents.Code 6419 } 6420 if len(errorComponents.Message) != 0 { 6421 errorMessage = errorComponents.Message 6422 } 6423 errorBody.Seek(0, io.SeekStart) 6424 switch { 6425 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 6426 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 6427 6428 case strings.EqualFold("InvalidDBParameterGroupStateFault", errorCode): 6429 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 6430 6431 default: 6432 genericError := &smithy.GenericAPIError{ 6433 Code: errorCode, 6434 Message: errorMessage, 6435 } 6436 return genericError 6437 6438 } 6439} 6440 6441type awsAwsquery_deserializeOpResetDBParameterGroup struct { 6442} 6443 6444func (*awsAwsquery_deserializeOpResetDBParameterGroup) ID() string { 6445 return "OperationDeserializer" 6446} 6447 6448func (m *awsAwsquery_deserializeOpResetDBParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6449 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6450) { 6451 out, metadata, err = next.HandleDeserialize(ctx, in) 6452 if err != nil { 6453 return out, metadata, err 6454 } 6455 6456 response, ok := out.RawResponse.(*smithyhttp.Response) 6457 if !ok { 6458 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6459 } 6460 6461 if response.StatusCode < 200 || response.StatusCode >= 300 { 6462 return out, metadata, awsAwsquery_deserializeOpErrorResetDBParameterGroup(response, &metadata) 6463 } 6464 output := &ResetDBParameterGroupOutput{} 6465 out.Result = output 6466 6467 var buff [1024]byte 6468 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6469 body := io.TeeReader(response.Body, ringBuffer) 6470 rootDecoder := xml.NewDecoder(body) 6471 t, err := smithyxml.FetchRootElement(rootDecoder) 6472 if err == io.EOF { 6473 return out, metadata, nil 6474 } 6475 if err != nil { 6476 var snapshot bytes.Buffer 6477 io.Copy(&snapshot, ringBuffer) 6478 return out, metadata, &smithy.DeserializationError{ 6479 Err: fmt.Errorf("failed to decode response body, %w", err), 6480 Snapshot: snapshot.Bytes(), 6481 } 6482 } 6483 6484 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6485 t, err = decoder.GetElement("ResetDBParameterGroupResult") 6486 if err != nil { 6487 var snapshot bytes.Buffer 6488 io.Copy(&snapshot, ringBuffer) 6489 err = &smithy.DeserializationError{ 6490 Err: fmt.Errorf("failed to decode response body, %w", err), 6491 Snapshot: snapshot.Bytes(), 6492 } 6493 return out, metadata, err 6494 } 6495 6496 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6497 err = awsAwsquery_deserializeOpDocumentResetDBParameterGroupOutput(&output, decoder) 6498 if err != nil { 6499 var snapshot bytes.Buffer 6500 io.Copy(&snapshot, ringBuffer) 6501 err = &smithy.DeserializationError{ 6502 Err: fmt.Errorf("failed to decode response body, %w", err), 6503 Snapshot: snapshot.Bytes(), 6504 } 6505 return out, metadata, err 6506 } 6507 6508 return out, metadata, err 6509} 6510 6511func awsAwsquery_deserializeOpErrorResetDBParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6512 var errorBuffer bytes.Buffer 6513 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6514 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6515 } 6516 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6517 6518 errorCode := "UnknownError" 6519 errorMessage := errorCode 6520 6521 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6522 if err != nil { 6523 return err 6524 } 6525 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6526 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6527 } 6528 if len(errorComponents.Code) != 0 { 6529 errorCode = errorComponents.Code 6530 } 6531 if len(errorComponents.Message) != 0 { 6532 errorMessage = errorComponents.Message 6533 } 6534 errorBody.Seek(0, io.SeekStart) 6535 switch { 6536 case strings.EqualFold("DBParameterGroupNotFoundFault", errorCode): 6537 return awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response, errorBody) 6538 6539 case strings.EqualFold("InvalidDBParameterGroupStateFault", errorCode): 6540 return awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response, errorBody) 6541 6542 default: 6543 genericError := &smithy.GenericAPIError{ 6544 Code: errorCode, 6545 Message: errorMessage, 6546 } 6547 return genericError 6548 6549 } 6550} 6551 6552type awsAwsquery_deserializeOpRestoreDBClusterFromSnapshot struct { 6553} 6554 6555func (*awsAwsquery_deserializeOpRestoreDBClusterFromSnapshot) ID() string { 6556 return "OperationDeserializer" 6557} 6558 6559func (m *awsAwsquery_deserializeOpRestoreDBClusterFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6560 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6561) { 6562 out, metadata, err = next.HandleDeserialize(ctx, in) 6563 if err != nil { 6564 return out, metadata, err 6565 } 6566 6567 response, ok := out.RawResponse.(*smithyhttp.Response) 6568 if !ok { 6569 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6570 } 6571 6572 if response.StatusCode < 200 || response.StatusCode >= 300 { 6573 return out, metadata, awsAwsquery_deserializeOpErrorRestoreDBClusterFromSnapshot(response, &metadata) 6574 } 6575 output := &RestoreDBClusterFromSnapshotOutput{} 6576 out.Result = output 6577 6578 var buff [1024]byte 6579 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6580 body := io.TeeReader(response.Body, ringBuffer) 6581 rootDecoder := xml.NewDecoder(body) 6582 t, err := smithyxml.FetchRootElement(rootDecoder) 6583 if err == io.EOF { 6584 return out, metadata, nil 6585 } 6586 if err != nil { 6587 var snapshot bytes.Buffer 6588 io.Copy(&snapshot, ringBuffer) 6589 return out, metadata, &smithy.DeserializationError{ 6590 Err: fmt.Errorf("failed to decode response body, %w", err), 6591 Snapshot: snapshot.Bytes(), 6592 } 6593 } 6594 6595 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6596 t, err = decoder.GetElement("RestoreDBClusterFromSnapshotResult") 6597 if err != nil { 6598 var snapshot bytes.Buffer 6599 io.Copy(&snapshot, ringBuffer) 6600 err = &smithy.DeserializationError{ 6601 Err: fmt.Errorf("failed to decode response body, %w", err), 6602 Snapshot: snapshot.Bytes(), 6603 } 6604 return out, metadata, err 6605 } 6606 6607 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6608 err = awsAwsquery_deserializeOpDocumentRestoreDBClusterFromSnapshotOutput(&output, decoder) 6609 if err != nil { 6610 var snapshot bytes.Buffer 6611 io.Copy(&snapshot, ringBuffer) 6612 err = &smithy.DeserializationError{ 6613 Err: fmt.Errorf("failed to decode response body, %w", err), 6614 Snapshot: snapshot.Bytes(), 6615 } 6616 return out, metadata, err 6617 } 6618 6619 return out, metadata, err 6620} 6621 6622func awsAwsquery_deserializeOpErrorRestoreDBClusterFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6623 var errorBuffer bytes.Buffer 6624 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6625 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6626 } 6627 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6628 6629 errorCode := "UnknownError" 6630 errorMessage := errorCode 6631 6632 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6633 if err != nil { 6634 return err 6635 } 6636 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6637 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6638 } 6639 if len(errorComponents.Code) != 0 { 6640 errorCode = errorComponents.Code 6641 } 6642 if len(errorComponents.Message) != 0 { 6643 errorMessage = errorComponents.Message 6644 } 6645 errorBody.Seek(0, io.SeekStart) 6646 switch { 6647 case strings.EqualFold("DBClusterAlreadyExistsFault", errorCode): 6648 return awsAwsquery_deserializeErrorDBClusterAlreadyExistsFault(response, errorBody) 6649 6650 case strings.EqualFold("DBClusterParameterGroupNotFoundFault", errorCode): 6651 return awsAwsquery_deserializeErrorDBClusterParameterGroupNotFoundFault(response, errorBody) 6652 6653 case strings.EqualFold("DBClusterQuotaExceededFault", errorCode): 6654 return awsAwsquery_deserializeErrorDBClusterQuotaExceededFault(response, errorBody) 6655 6656 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 6657 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 6658 6659 case strings.EqualFold("DBSnapshotNotFoundFault", errorCode): 6660 return awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response, errorBody) 6661 6662 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 6663 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 6664 6665 case strings.EqualFold("InsufficientDBClusterCapacityFault", errorCode): 6666 return awsAwsquery_deserializeErrorInsufficientDBClusterCapacityFault(response, errorBody) 6667 6668 case strings.EqualFold("InsufficientStorageClusterCapacityFault", errorCode): 6669 return awsAwsquery_deserializeErrorInsufficientStorageClusterCapacityFault(response, errorBody) 6670 6671 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 6672 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 6673 6674 case strings.EqualFold("InvalidDBSnapshotStateFault", errorCode): 6675 return awsAwsquery_deserializeErrorInvalidDBSnapshotStateFault(response, errorBody) 6676 6677 case strings.EqualFold("InvalidRestoreFault", errorCode): 6678 return awsAwsquery_deserializeErrorInvalidRestoreFault(response, errorBody) 6679 6680 case strings.EqualFold("InvalidSubnet", errorCode): 6681 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 6682 6683 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 6684 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 6685 6686 case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): 6687 return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) 6688 6689 case strings.EqualFold("OptionGroupNotFoundFault", errorCode): 6690 return awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response, errorBody) 6691 6692 case strings.EqualFold("StorageQuotaExceededFault", errorCode): 6693 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 6694 6695 default: 6696 genericError := &smithy.GenericAPIError{ 6697 Code: errorCode, 6698 Message: errorMessage, 6699 } 6700 return genericError 6701 6702 } 6703} 6704 6705type awsAwsquery_deserializeOpRestoreDBClusterToPointInTime struct { 6706} 6707 6708func (*awsAwsquery_deserializeOpRestoreDBClusterToPointInTime) ID() string { 6709 return "OperationDeserializer" 6710} 6711 6712func (m *awsAwsquery_deserializeOpRestoreDBClusterToPointInTime) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6713 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6714) { 6715 out, metadata, err = next.HandleDeserialize(ctx, in) 6716 if err != nil { 6717 return out, metadata, err 6718 } 6719 6720 response, ok := out.RawResponse.(*smithyhttp.Response) 6721 if !ok { 6722 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6723 } 6724 6725 if response.StatusCode < 200 || response.StatusCode >= 300 { 6726 return out, metadata, awsAwsquery_deserializeOpErrorRestoreDBClusterToPointInTime(response, &metadata) 6727 } 6728 output := &RestoreDBClusterToPointInTimeOutput{} 6729 out.Result = output 6730 6731 var buff [1024]byte 6732 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6733 body := io.TeeReader(response.Body, ringBuffer) 6734 rootDecoder := xml.NewDecoder(body) 6735 t, err := smithyxml.FetchRootElement(rootDecoder) 6736 if err == io.EOF { 6737 return out, metadata, nil 6738 } 6739 if err != nil { 6740 var snapshot bytes.Buffer 6741 io.Copy(&snapshot, ringBuffer) 6742 return out, metadata, &smithy.DeserializationError{ 6743 Err: fmt.Errorf("failed to decode response body, %w", err), 6744 Snapshot: snapshot.Bytes(), 6745 } 6746 } 6747 6748 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6749 t, err = decoder.GetElement("RestoreDBClusterToPointInTimeResult") 6750 if err != nil { 6751 var snapshot bytes.Buffer 6752 io.Copy(&snapshot, ringBuffer) 6753 err = &smithy.DeserializationError{ 6754 Err: fmt.Errorf("failed to decode response body, %w", err), 6755 Snapshot: snapshot.Bytes(), 6756 } 6757 return out, metadata, err 6758 } 6759 6760 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6761 err = awsAwsquery_deserializeOpDocumentRestoreDBClusterToPointInTimeOutput(&output, decoder) 6762 if err != nil { 6763 var snapshot bytes.Buffer 6764 io.Copy(&snapshot, ringBuffer) 6765 err = &smithy.DeserializationError{ 6766 Err: fmt.Errorf("failed to decode response body, %w", err), 6767 Snapshot: snapshot.Bytes(), 6768 } 6769 return out, metadata, err 6770 } 6771 6772 return out, metadata, err 6773} 6774 6775func awsAwsquery_deserializeOpErrorRestoreDBClusterToPointInTime(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6776 var errorBuffer bytes.Buffer 6777 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6778 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6779 } 6780 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6781 6782 errorCode := "UnknownError" 6783 errorMessage := errorCode 6784 6785 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6786 if err != nil { 6787 return err 6788 } 6789 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6790 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6791 } 6792 if len(errorComponents.Code) != 0 { 6793 errorCode = errorComponents.Code 6794 } 6795 if len(errorComponents.Message) != 0 { 6796 errorMessage = errorComponents.Message 6797 } 6798 errorBody.Seek(0, io.SeekStart) 6799 switch { 6800 case strings.EqualFold("DBClusterAlreadyExistsFault", errorCode): 6801 return awsAwsquery_deserializeErrorDBClusterAlreadyExistsFault(response, errorBody) 6802 6803 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 6804 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 6805 6806 case strings.EqualFold("DBClusterParameterGroupNotFoundFault", errorCode): 6807 return awsAwsquery_deserializeErrorDBClusterParameterGroupNotFoundFault(response, errorBody) 6808 6809 case strings.EqualFold("DBClusterQuotaExceededFault", errorCode): 6810 return awsAwsquery_deserializeErrorDBClusterQuotaExceededFault(response, errorBody) 6811 6812 case strings.EqualFold("DBClusterSnapshotNotFoundFault", errorCode): 6813 return awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response, errorBody) 6814 6815 case strings.EqualFold("DBSubnetGroupNotFoundFault", errorCode): 6816 return awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response, errorBody) 6817 6818 case strings.EqualFold("InsufficientDBClusterCapacityFault", errorCode): 6819 return awsAwsquery_deserializeErrorInsufficientDBClusterCapacityFault(response, errorBody) 6820 6821 case strings.EqualFold("InsufficientStorageClusterCapacityFault", errorCode): 6822 return awsAwsquery_deserializeErrorInsufficientStorageClusterCapacityFault(response, errorBody) 6823 6824 case strings.EqualFold("InvalidDBClusterSnapshotStateFault", errorCode): 6825 return awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response, errorBody) 6826 6827 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 6828 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 6829 6830 case strings.EqualFold("InvalidDBSnapshotStateFault", errorCode): 6831 return awsAwsquery_deserializeErrorInvalidDBSnapshotStateFault(response, errorBody) 6832 6833 case strings.EqualFold("InvalidRestoreFault", errorCode): 6834 return awsAwsquery_deserializeErrorInvalidRestoreFault(response, errorBody) 6835 6836 case strings.EqualFold("InvalidSubnet", errorCode): 6837 return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody) 6838 6839 case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode): 6840 return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody) 6841 6842 case strings.EqualFold("KMSKeyNotAccessibleFault", errorCode): 6843 return awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response, errorBody) 6844 6845 case strings.EqualFold("OptionGroupNotFoundFault", errorCode): 6846 return awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response, errorBody) 6847 6848 case strings.EqualFold("StorageQuotaExceededFault", errorCode): 6849 return awsAwsquery_deserializeErrorStorageQuotaExceededFault(response, errorBody) 6850 6851 default: 6852 genericError := &smithy.GenericAPIError{ 6853 Code: errorCode, 6854 Message: errorMessage, 6855 } 6856 return genericError 6857 6858 } 6859} 6860 6861type awsAwsquery_deserializeOpStartDBCluster struct { 6862} 6863 6864func (*awsAwsquery_deserializeOpStartDBCluster) ID() string { 6865 return "OperationDeserializer" 6866} 6867 6868func (m *awsAwsquery_deserializeOpStartDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6869 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6870) { 6871 out, metadata, err = next.HandleDeserialize(ctx, in) 6872 if err != nil { 6873 return out, metadata, err 6874 } 6875 6876 response, ok := out.RawResponse.(*smithyhttp.Response) 6877 if !ok { 6878 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6879 } 6880 6881 if response.StatusCode < 200 || response.StatusCode >= 300 { 6882 return out, metadata, awsAwsquery_deserializeOpErrorStartDBCluster(response, &metadata) 6883 } 6884 output := &StartDBClusterOutput{} 6885 out.Result = output 6886 6887 var buff [1024]byte 6888 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6889 body := io.TeeReader(response.Body, ringBuffer) 6890 rootDecoder := xml.NewDecoder(body) 6891 t, err := smithyxml.FetchRootElement(rootDecoder) 6892 if err == io.EOF { 6893 return out, metadata, nil 6894 } 6895 if err != nil { 6896 var snapshot bytes.Buffer 6897 io.Copy(&snapshot, ringBuffer) 6898 return out, metadata, &smithy.DeserializationError{ 6899 Err: fmt.Errorf("failed to decode response body, %w", err), 6900 Snapshot: snapshot.Bytes(), 6901 } 6902 } 6903 6904 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6905 t, err = decoder.GetElement("StartDBClusterResult") 6906 if err != nil { 6907 var snapshot bytes.Buffer 6908 io.Copy(&snapshot, ringBuffer) 6909 err = &smithy.DeserializationError{ 6910 Err: fmt.Errorf("failed to decode response body, %w", err), 6911 Snapshot: snapshot.Bytes(), 6912 } 6913 return out, metadata, err 6914 } 6915 6916 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6917 err = awsAwsquery_deserializeOpDocumentStartDBClusterOutput(&output, decoder) 6918 if err != nil { 6919 var snapshot bytes.Buffer 6920 io.Copy(&snapshot, ringBuffer) 6921 err = &smithy.DeserializationError{ 6922 Err: fmt.Errorf("failed to decode response body, %w", err), 6923 Snapshot: snapshot.Bytes(), 6924 } 6925 return out, metadata, err 6926 } 6927 6928 return out, metadata, err 6929} 6930 6931func awsAwsquery_deserializeOpErrorStartDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6932 var errorBuffer bytes.Buffer 6933 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6934 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6935 } 6936 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6937 6938 errorCode := "UnknownError" 6939 errorMessage := errorCode 6940 6941 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 6942 if err != nil { 6943 return err 6944 } 6945 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6946 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6947 } 6948 if len(errorComponents.Code) != 0 { 6949 errorCode = errorComponents.Code 6950 } 6951 if len(errorComponents.Message) != 0 { 6952 errorMessage = errorComponents.Message 6953 } 6954 errorBody.Seek(0, io.SeekStart) 6955 switch { 6956 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 6957 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 6958 6959 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 6960 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 6961 6962 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 6963 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 6964 6965 default: 6966 genericError := &smithy.GenericAPIError{ 6967 Code: errorCode, 6968 Message: errorMessage, 6969 } 6970 return genericError 6971 6972 } 6973} 6974 6975type awsAwsquery_deserializeOpStopDBCluster struct { 6976} 6977 6978func (*awsAwsquery_deserializeOpStopDBCluster) ID() string { 6979 return "OperationDeserializer" 6980} 6981 6982func (m *awsAwsquery_deserializeOpStopDBCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6983 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6984) { 6985 out, metadata, err = next.HandleDeserialize(ctx, in) 6986 if err != nil { 6987 return out, metadata, err 6988 } 6989 6990 response, ok := out.RawResponse.(*smithyhttp.Response) 6991 if !ok { 6992 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6993 } 6994 6995 if response.StatusCode < 200 || response.StatusCode >= 300 { 6996 return out, metadata, awsAwsquery_deserializeOpErrorStopDBCluster(response, &metadata) 6997 } 6998 output := &StopDBClusterOutput{} 6999 out.Result = output 7000 7001 var buff [1024]byte 7002 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7003 body := io.TeeReader(response.Body, ringBuffer) 7004 rootDecoder := xml.NewDecoder(body) 7005 t, err := smithyxml.FetchRootElement(rootDecoder) 7006 if err == io.EOF { 7007 return out, metadata, nil 7008 } 7009 if err != nil { 7010 var snapshot bytes.Buffer 7011 io.Copy(&snapshot, ringBuffer) 7012 return out, metadata, &smithy.DeserializationError{ 7013 Err: fmt.Errorf("failed to decode response body, %w", err), 7014 Snapshot: snapshot.Bytes(), 7015 } 7016 } 7017 7018 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7019 t, err = decoder.GetElement("StopDBClusterResult") 7020 if err != nil { 7021 var snapshot bytes.Buffer 7022 io.Copy(&snapshot, ringBuffer) 7023 err = &smithy.DeserializationError{ 7024 Err: fmt.Errorf("failed to decode response body, %w", err), 7025 Snapshot: snapshot.Bytes(), 7026 } 7027 return out, metadata, err 7028 } 7029 7030 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7031 err = awsAwsquery_deserializeOpDocumentStopDBClusterOutput(&output, decoder) 7032 if err != nil { 7033 var snapshot bytes.Buffer 7034 io.Copy(&snapshot, ringBuffer) 7035 err = &smithy.DeserializationError{ 7036 Err: fmt.Errorf("failed to decode response body, %w", err), 7037 Snapshot: snapshot.Bytes(), 7038 } 7039 return out, metadata, err 7040 } 7041 7042 return out, metadata, err 7043} 7044 7045func awsAwsquery_deserializeOpErrorStopDBCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7046 var errorBuffer bytes.Buffer 7047 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7048 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7049 } 7050 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7051 7052 errorCode := "UnknownError" 7053 errorMessage := errorCode 7054 7055 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 7056 if err != nil { 7057 return err 7058 } 7059 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7060 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7061 } 7062 if len(errorComponents.Code) != 0 { 7063 errorCode = errorComponents.Code 7064 } 7065 if len(errorComponents.Message) != 0 { 7066 errorMessage = errorComponents.Message 7067 } 7068 errorBody.Seek(0, io.SeekStart) 7069 switch { 7070 case strings.EqualFold("DBClusterNotFoundFault", errorCode): 7071 return awsAwsquery_deserializeErrorDBClusterNotFoundFault(response, errorBody) 7072 7073 case strings.EqualFold("InvalidDBClusterStateFault", errorCode): 7074 return awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response, errorBody) 7075 7076 case strings.EqualFold("InvalidDBInstanceStateFault", errorCode): 7077 return awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response, errorBody) 7078 7079 default: 7080 genericError := &smithy.GenericAPIError{ 7081 Code: errorCode, 7082 Message: errorMessage, 7083 } 7084 return genericError 7085 7086 } 7087} 7088 7089func awsAwsquery_deserializeErrorAuthorizationNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7090 output := &types.AuthorizationNotFoundFault{} 7091 var buff [1024]byte 7092 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7093 body := io.TeeReader(errorBody, ringBuffer) 7094 rootDecoder := xml.NewDecoder(body) 7095 t, err := smithyxml.FetchRootElement(rootDecoder) 7096 if err == io.EOF { 7097 return output 7098 } 7099 if err != nil { 7100 var snapshot bytes.Buffer 7101 io.Copy(&snapshot, ringBuffer) 7102 return &smithy.DeserializationError{ 7103 Err: fmt.Errorf("failed to decode response body, %w", err), 7104 Snapshot: snapshot.Bytes(), 7105 } 7106 } 7107 7108 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7109 t, err = decoder.GetElement("Error") 7110 if err != nil { 7111 var snapshot bytes.Buffer 7112 io.Copy(&snapshot, ringBuffer) 7113 return &smithy.DeserializationError{ 7114 Err: fmt.Errorf("failed to decode response body, %w", err), 7115 Snapshot: snapshot.Bytes(), 7116 } 7117 } 7118 7119 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7120 err = awsAwsquery_deserializeDocumentAuthorizationNotFoundFault(&output, decoder) 7121 if err != nil { 7122 var snapshot bytes.Buffer 7123 io.Copy(&snapshot, ringBuffer) 7124 return &smithy.DeserializationError{ 7125 Err: fmt.Errorf("failed to decode response body, %w", err), 7126 Snapshot: snapshot.Bytes(), 7127 } 7128 } 7129 7130 return output 7131} 7132 7133func awsAwsquery_deserializeErrorCertificateNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7134 output := &types.CertificateNotFoundFault{} 7135 var buff [1024]byte 7136 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7137 body := io.TeeReader(errorBody, ringBuffer) 7138 rootDecoder := xml.NewDecoder(body) 7139 t, err := smithyxml.FetchRootElement(rootDecoder) 7140 if err == io.EOF { 7141 return output 7142 } 7143 if err != nil { 7144 var snapshot bytes.Buffer 7145 io.Copy(&snapshot, ringBuffer) 7146 return &smithy.DeserializationError{ 7147 Err: fmt.Errorf("failed to decode response body, %w", err), 7148 Snapshot: snapshot.Bytes(), 7149 } 7150 } 7151 7152 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7153 t, err = decoder.GetElement("Error") 7154 if err != nil { 7155 var snapshot bytes.Buffer 7156 io.Copy(&snapshot, ringBuffer) 7157 return &smithy.DeserializationError{ 7158 Err: fmt.Errorf("failed to decode response body, %w", err), 7159 Snapshot: snapshot.Bytes(), 7160 } 7161 } 7162 7163 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7164 err = awsAwsquery_deserializeDocumentCertificateNotFoundFault(&output, decoder) 7165 if err != nil { 7166 var snapshot bytes.Buffer 7167 io.Copy(&snapshot, ringBuffer) 7168 return &smithy.DeserializationError{ 7169 Err: fmt.Errorf("failed to decode response body, %w", err), 7170 Snapshot: snapshot.Bytes(), 7171 } 7172 } 7173 7174 return output 7175} 7176 7177func awsAwsquery_deserializeErrorDBClusterAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7178 output := &types.DBClusterAlreadyExistsFault{} 7179 var buff [1024]byte 7180 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7181 body := io.TeeReader(errorBody, ringBuffer) 7182 rootDecoder := xml.NewDecoder(body) 7183 t, err := smithyxml.FetchRootElement(rootDecoder) 7184 if err == io.EOF { 7185 return output 7186 } 7187 if err != nil { 7188 var snapshot bytes.Buffer 7189 io.Copy(&snapshot, ringBuffer) 7190 return &smithy.DeserializationError{ 7191 Err: fmt.Errorf("failed to decode response body, %w", err), 7192 Snapshot: snapshot.Bytes(), 7193 } 7194 } 7195 7196 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7197 t, err = decoder.GetElement("Error") 7198 if err != nil { 7199 var snapshot bytes.Buffer 7200 io.Copy(&snapshot, ringBuffer) 7201 return &smithy.DeserializationError{ 7202 Err: fmt.Errorf("failed to decode response body, %w", err), 7203 Snapshot: snapshot.Bytes(), 7204 } 7205 } 7206 7207 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7208 err = awsAwsquery_deserializeDocumentDBClusterAlreadyExistsFault(&output, decoder) 7209 if err != nil { 7210 var snapshot bytes.Buffer 7211 io.Copy(&snapshot, ringBuffer) 7212 return &smithy.DeserializationError{ 7213 Err: fmt.Errorf("failed to decode response body, %w", err), 7214 Snapshot: snapshot.Bytes(), 7215 } 7216 } 7217 7218 return output 7219} 7220 7221func awsAwsquery_deserializeErrorDBClusterEndpointAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7222 output := &types.DBClusterEndpointAlreadyExistsFault{} 7223 var buff [1024]byte 7224 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7225 body := io.TeeReader(errorBody, ringBuffer) 7226 rootDecoder := xml.NewDecoder(body) 7227 t, err := smithyxml.FetchRootElement(rootDecoder) 7228 if err == io.EOF { 7229 return output 7230 } 7231 if err != nil { 7232 var snapshot bytes.Buffer 7233 io.Copy(&snapshot, ringBuffer) 7234 return &smithy.DeserializationError{ 7235 Err: fmt.Errorf("failed to decode response body, %w", err), 7236 Snapshot: snapshot.Bytes(), 7237 } 7238 } 7239 7240 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7241 t, err = decoder.GetElement("Error") 7242 if err != nil { 7243 var snapshot bytes.Buffer 7244 io.Copy(&snapshot, ringBuffer) 7245 return &smithy.DeserializationError{ 7246 Err: fmt.Errorf("failed to decode response body, %w", err), 7247 Snapshot: snapshot.Bytes(), 7248 } 7249 } 7250 7251 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7252 err = awsAwsquery_deserializeDocumentDBClusterEndpointAlreadyExistsFault(&output, decoder) 7253 if err != nil { 7254 var snapshot bytes.Buffer 7255 io.Copy(&snapshot, ringBuffer) 7256 return &smithy.DeserializationError{ 7257 Err: fmt.Errorf("failed to decode response body, %w", err), 7258 Snapshot: snapshot.Bytes(), 7259 } 7260 } 7261 7262 return output 7263} 7264 7265func awsAwsquery_deserializeErrorDBClusterEndpointNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7266 output := &types.DBClusterEndpointNotFoundFault{} 7267 var buff [1024]byte 7268 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7269 body := io.TeeReader(errorBody, ringBuffer) 7270 rootDecoder := xml.NewDecoder(body) 7271 t, err := smithyxml.FetchRootElement(rootDecoder) 7272 if err == io.EOF { 7273 return output 7274 } 7275 if err != nil { 7276 var snapshot bytes.Buffer 7277 io.Copy(&snapshot, ringBuffer) 7278 return &smithy.DeserializationError{ 7279 Err: fmt.Errorf("failed to decode response body, %w", err), 7280 Snapshot: snapshot.Bytes(), 7281 } 7282 } 7283 7284 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7285 t, err = decoder.GetElement("Error") 7286 if err != nil { 7287 var snapshot bytes.Buffer 7288 io.Copy(&snapshot, ringBuffer) 7289 return &smithy.DeserializationError{ 7290 Err: fmt.Errorf("failed to decode response body, %w", err), 7291 Snapshot: snapshot.Bytes(), 7292 } 7293 } 7294 7295 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7296 err = awsAwsquery_deserializeDocumentDBClusterEndpointNotFoundFault(&output, decoder) 7297 if err != nil { 7298 var snapshot bytes.Buffer 7299 io.Copy(&snapshot, ringBuffer) 7300 return &smithy.DeserializationError{ 7301 Err: fmt.Errorf("failed to decode response body, %w", err), 7302 Snapshot: snapshot.Bytes(), 7303 } 7304 } 7305 7306 return output 7307} 7308 7309func awsAwsquery_deserializeErrorDBClusterEndpointQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7310 output := &types.DBClusterEndpointQuotaExceededFault{} 7311 var buff [1024]byte 7312 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7313 body := io.TeeReader(errorBody, ringBuffer) 7314 rootDecoder := xml.NewDecoder(body) 7315 t, err := smithyxml.FetchRootElement(rootDecoder) 7316 if err == io.EOF { 7317 return output 7318 } 7319 if err != nil { 7320 var snapshot bytes.Buffer 7321 io.Copy(&snapshot, ringBuffer) 7322 return &smithy.DeserializationError{ 7323 Err: fmt.Errorf("failed to decode response body, %w", err), 7324 Snapshot: snapshot.Bytes(), 7325 } 7326 } 7327 7328 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7329 t, err = decoder.GetElement("Error") 7330 if err != nil { 7331 var snapshot bytes.Buffer 7332 io.Copy(&snapshot, ringBuffer) 7333 return &smithy.DeserializationError{ 7334 Err: fmt.Errorf("failed to decode response body, %w", err), 7335 Snapshot: snapshot.Bytes(), 7336 } 7337 } 7338 7339 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7340 err = awsAwsquery_deserializeDocumentDBClusterEndpointQuotaExceededFault(&output, decoder) 7341 if err != nil { 7342 var snapshot bytes.Buffer 7343 io.Copy(&snapshot, ringBuffer) 7344 return &smithy.DeserializationError{ 7345 Err: fmt.Errorf("failed to decode response body, %w", err), 7346 Snapshot: snapshot.Bytes(), 7347 } 7348 } 7349 7350 return output 7351} 7352 7353func awsAwsquery_deserializeErrorDBClusterNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7354 output := &types.DBClusterNotFoundFault{} 7355 var buff [1024]byte 7356 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7357 body := io.TeeReader(errorBody, ringBuffer) 7358 rootDecoder := xml.NewDecoder(body) 7359 t, err := smithyxml.FetchRootElement(rootDecoder) 7360 if err == io.EOF { 7361 return output 7362 } 7363 if err != nil { 7364 var snapshot bytes.Buffer 7365 io.Copy(&snapshot, ringBuffer) 7366 return &smithy.DeserializationError{ 7367 Err: fmt.Errorf("failed to decode response body, %w", err), 7368 Snapshot: snapshot.Bytes(), 7369 } 7370 } 7371 7372 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7373 t, err = decoder.GetElement("Error") 7374 if err != nil { 7375 var snapshot bytes.Buffer 7376 io.Copy(&snapshot, ringBuffer) 7377 return &smithy.DeserializationError{ 7378 Err: fmt.Errorf("failed to decode response body, %w", err), 7379 Snapshot: snapshot.Bytes(), 7380 } 7381 } 7382 7383 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7384 err = awsAwsquery_deserializeDocumentDBClusterNotFoundFault(&output, decoder) 7385 if err != nil { 7386 var snapshot bytes.Buffer 7387 io.Copy(&snapshot, ringBuffer) 7388 return &smithy.DeserializationError{ 7389 Err: fmt.Errorf("failed to decode response body, %w", err), 7390 Snapshot: snapshot.Bytes(), 7391 } 7392 } 7393 7394 return output 7395} 7396 7397func awsAwsquery_deserializeErrorDBClusterParameterGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7398 output := &types.DBClusterParameterGroupNotFoundFault{} 7399 var buff [1024]byte 7400 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7401 body := io.TeeReader(errorBody, ringBuffer) 7402 rootDecoder := xml.NewDecoder(body) 7403 t, err := smithyxml.FetchRootElement(rootDecoder) 7404 if err == io.EOF { 7405 return output 7406 } 7407 if err != nil { 7408 var snapshot bytes.Buffer 7409 io.Copy(&snapshot, ringBuffer) 7410 return &smithy.DeserializationError{ 7411 Err: fmt.Errorf("failed to decode response body, %w", err), 7412 Snapshot: snapshot.Bytes(), 7413 } 7414 } 7415 7416 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7417 t, err = decoder.GetElement("Error") 7418 if err != nil { 7419 var snapshot bytes.Buffer 7420 io.Copy(&snapshot, ringBuffer) 7421 return &smithy.DeserializationError{ 7422 Err: fmt.Errorf("failed to decode response body, %w", err), 7423 Snapshot: snapshot.Bytes(), 7424 } 7425 } 7426 7427 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7428 err = awsAwsquery_deserializeDocumentDBClusterParameterGroupNotFoundFault(&output, decoder) 7429 if err != nil { 7430 var snapshot bytes.Buffer 7431 io.Copy(&snapshot, ringBuffer) 7432 return &smithy.DeserializationError{ 7433 Err: fmt.Errorf("failed to decode response body, %w", err), 7434 Snapshot: snapshot.Bytes(), 7435 } 7436 } 7437 7438 return output 7439} 7440 7441func awsAwsquery_deserializeErrorDBClusterQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7442 output := &types.DBClusterQuotaExceededFault{} 7443 var buff [1024]byte 7444 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7445 body := io.TeeReader(errorBody, ringBuffer) 7446 rootDecoder := xml.NewDecoder(body) 7447 t, err := smithyxml.FetchRootElement(rootDecoder) 7448 if err == io.EOF { 7449 return output 7450 } 7451 if err != nil { 7452 var snapshot bytes.Buffer 7453 io.Copy(&snapshot, ringBuffer) 7454 return &smithy.DeserializationError{ 7455 Err: fmt.Errorf("failed to decode response body, %w", err), 7456 Snapshot: snapshot.Bytes(), 7457 } 7458 } 7459 7460 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7461 t, err = decoder.GetElement("Error") 7462 if err != nil { 7463 var snapshot bytes.Buffer 7464 io.Copy(&snapshot, ringBuffer) 7465 return &smithy.DeserializationError{ 7466 Err: fmt.Errorf("failed to decode response body, %w", err), 7467 Snapshot: snapshot.Bytes(), 7468 } 7469 } 7470 7471 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7472 err = awsAwsquery_deserializeDocumentDBClusterQuotaExceededFault(&output, decoder) 7473 if err != nil { 7474 var snapshot bytes.Buffer 7475 io.Copy(&snapshot, ringBuffer) 7476 return &smithy.DeserializationError{ 7477 Err: fmt.Errorf("failed to decode response body, %w", err), 7478 Snapshot: snapshot.Bytes(), 7479 } 7480 } 7481 7482 return output 7483} 7484 7485func awsAwsquery_deserializeErrorDBClusterRoleAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7486 output := &types.DBClusterRoleAlreadyExistsFault{} 7487 var buff [1024]byte 7488 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7489 body := io.TeeReader(errorBody, ringBuffer) 7490 rootDecoder := xml.NewDecoder(body) 7491 t, err := smithyxml.FetchRootElement(rootDecoder) 7492 if err == io.EOF { 7493 return output 7494 } 7495 if err != nil { 7496 var snapshot bytes.Buffer 7497 io.Copy(&snapshot, ringBuffer) 7498 return &smithy.DeserializationError{ 7499 Err: fmt.Errorf("failed to decode response body, %w", err), 7500 Snapshot: snapshot.Bytes(), 7501 } 7502 } 7503 7504 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7505 t, err = decoder.GetElement("Error") 7506 if err != nil { 7507 var snapshot bytes.Buffer 7508 io.Copy(&snapshot, ringBuffer) 7509 return &smithy.DeserializationError{ 7510 Err: fmt.Errorf("failed to decode response body, %w", err), 7511 Snapshot: snapshot.Bytes(), 7512 } 7513 } 7514 7515 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7516 err = awsAwsquery_deserializeDocumentDBClusterRoleAlreadyExistsFault(&output, decoder) 7517 if err != nil { 7518 var snapshot bytes.Buffer 7519 io.Copy(&snapshot, ringBuffer) 7520 return &smithy.DeserializationError{ 7521 Err: fmt.Errorf("failed to decode response body, %w", err), 7522 Snapshot: snapshot.Bytes(), 7523 } 7524 } 7525 7526 return output 7527} 7528 7529func awsAwsquery_deserializeErrorDBClusterRoleNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7530 output := &types.DBClusterRoleNotFoundFault{} 7531 var buff [1024]byte 7532 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7533 body := io.TeeReader(errorBody, ringBuffer) 7534 rootDecoder := xml.NewDecoder(body) 7535 t, err := smithyxml.FetchRootElement(rootDecoder) 7536 if err == io.EOF { 7537 return output 7538 } 7539 if err != nil { 7540 var snapshot bytes.Buffer 7541 io.Copy(&snapshot, ringBuffer) 7542 return &smithy.DeserializationError{ 7543 Err: fmt.Errorf("failed to decode response body, %w", err), 7544 Snapshot: snapshot.Bytes(), 7545 } 7546 } 7547 7548 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7549 t, err = decoder.GetElement("Error") 7550 if err != nil { 7551 var snapshot bytes.Buffer 7552 io.Copy(&snapshot, ringBuffer) 7553 return &smithy.DeserializationError{ 7554 Err: fmt.Errorf("failed to decode response body, %w", err), 7555 Snapshot: snapshot.Bytes(), 7556 } 7557 } 7558 7559 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7560 err = awsAwsquery_deserializeDocumentDBClusterRoleNotFoundFault(&output, decoder) 7561 if err != nil { 7562 var snapshot bytes.Buffer 7563 io.Copy(&snapshot, ringBuffer) 7564 return &smithy.DeserializationError{ 7565 Err: fmt.Errorf("failed to decode response body, %w", err), 7566 Snapshot: snapshot.Bytes(), 7567 } 7568 } 7569 7570 return output 7571} 7572 7573func awsAwsquery_deserializeErrorDBClusterRoleQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7574 output := &types.DBClusterRoleQuotaExceededFault{} 7575 var buff [1024]byte 7576 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7577 body := io.TeeReader(errorBody, ringBuffer) 7578 rootDecoder := xml.NewDecoder(body) 7579 t, err := smithyxml.FetchRootElement(rootDecoder) 7580 if err == io.EOF { 7581 return output 7582 } 7583 if err != nil { 7584 var snapshot bytes.Buffer 7585 io.Copy(&snapshot, ringBuffer) 7586 return &smithy.DeserializationError{ 7587 Err: fmt.Errorf("failed to decode response body, %w", err), 7588 Snapshot: snapshot.Bytes(), 7589 } 7590 } 7591 7592 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7593 t, err = decoder.GetElement("Error") 7594 if err != nil { 7595 var snapshot bytes.Buffer 7596 io.Copy(&snapshot, ringBuffer) 7597 return &smithy.DeserializationError{ 7598 Err: fmt.Errorf("failed to decode response body, %w", err), 7599 Snapshot: snapshot.Bytes(), 7600 } 7601 } 7602 7603 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7604 err = awsAwsquery_deserializeDocumentDBClusterRoleQuotaExceededFault(&output, decoder) 7605 if err != nil { 7606 var snapshot bytes.Buffer 7607 io.Copy(&snapshot, ringBuffer) 7608 return &smithy.DeserializationError{ 7609 Err: fmt.Errorf("failed to decode response body, %w", err), 7610 Snapshot: snapshot.Bytes(), 7611 } 7612 } 7613 7614 return output 7615} 7616 7617func awsAwsquery_deserializeErrorDBClusterSnapshotAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7618 output := &types.DBClusterSnapshotAlreadyExistsFault{} 7619 var buff [1024]byte 7620 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7621 body := io.TeeReader(errorBody, ringBuffer) 7622 rootDecoder := xml.NewDecoder(body) 7623 t, err := smithyxml.FetchRootElement(rootDecoder) 7624 if err == io.EOF { 7625 return output 7626 } 7627 if err != nil { 7628 var snapshot bytes.Buffer 7629 io.Copy(&snapshot, ringBuffer) 7630 return &smithy.DeserializationError{ 7631 Err: fmt.Errorf("failed to decode response body, %w", err), 7632 Snapshot: snapshot.Bytes(), 7633 } 7634 } 7635 7636 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7637 t, err = decoder.GetElement("Error") 7638 if err != nil { 7639 var snapshot bytes.Buffer 7640 io.Copy(&snapshot, ringBuffer) 7641 return &smithy.DeserializationError{ 7642 Err: fmt.Errorf("failed to decode response body, %w", err), 7643 Snapshot: snapshot.Bytes(), 7644 } 7645 } 7646 7647 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7648 err = awsAwsquery_deserializeDocumentDBClusterSnapshotAlreadyExistsFault(&output, decoder) 7649 if err != nil { 7650 var snapshot bytes.Buffer 7651 io.Copy(&snapshot, ringBuffer) 7652 return &smithy.DeserializationError{ 7653 Err: fmt.Errorf("failed to decode response body, %w", err), 7654 Snapshot: snapshot.Bytes(), 7655 } 7656 } 7657 7658 return output 7659} 7660 7661func awsAwsquery_deserializeErrorDBClusterSnapshotNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7662 output := &types.DBClusterSnapshotNotFoundFault{} 7663 var buff [1024]byte 7664 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7665 body := io.TeeReader(errorBody, ringBuffer) 7666 rootDecoder := xml.NewDecoder(body) 7667 t, err := smithyxml.FetchRootElement(rootDecoder) 7668 if err == io.EOF { 7669 return output 7670 } 7671 if err != nil { 7672 var snapshot bytes.Buffer 7673 io.Copy(&snapshot, ringBuffer) 7674 return &smithy.DeserializationError{ 7675 Err: fmt.Errorf("failed to decode response body, %w", err), 7676 Snapshot: snapshot.Bytes(), 7677 } 7678 } 7679 7680 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7681 t, err = decoder.GetElement("Error") 7682 if err != nil { 7683 var snapshot bytes.Buffer 7684 io.Copy(&snapshot, ringBuffer) 7685 return &smithy.DeserializationError{ 7686 Err: fmt.Errorf("failed to decode response body, %w", err), 7687 Snapshot: snapshot.Bytes(), 7688 } 7689 } 7690 7691 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7692 err = awsAwsquery_deserializeDocumentDBClusterSnapshotNotFoundFault(&output, decoder) 7693 if err != nil { 7694 var snapshot bytes.Buffer 7695 io.Copy(&snapshot, ringBuffer) 7696 return &smithy.DeserializationError{ 7697 Err: fmt.Errorf("failed to decode response body, %w", err), 7698 Snapshot: snapshot.Bytes(), 7699 } 7700 } 7701 7702 return output 7703} 7704 7705func awsAwsquery_deserializeErrorDBInstanceAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7706 output := &types.DBInstanceAlreadyExistsFault{} 7707 var buff [1024]byte 7708 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7709 body := io.TeeReader(errorBody, ringBuffer) 7710 rootDecoder := xml.NewDecoder(body) 7711 t, err := smithyxml.FetchRootElement(rootDecoder) 7712 if err == io.EOF { 7713 return output 7714 } 7715 if err != nil { 7716 var snapshot bytes.Buffer 7717 io.Copy(&snapshot, ringBuffer) 7718 return &smithy.DeserializationError{ 7719 Err: fmt.Errorf("failed to decode response body, %w", err), 7720 Snapshot: snapshot.Bytes(), 7721 } 7722 } 7723 7724 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7725 t, err = decoder.GetElement("Error") 7726 if err != nil { 7727 var snapshot bytes.Buffer 7728 io.Copy(&snapshot, ringBuffer) 7729 return &smithy.DeserializationError{ 7730 Err: fmt.Errorf("failed to decode response body, %w", err), 7731 Snapshot: snapshot.Bytes(), 7732 } 7733 } 7734 7735 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7736 err = awsAwsquery_deserializeDocumentDBInstanceAlreadyExistsFault(&output, decoder) 7737 if err != nil { 7738 var snapshot bytes.Buffer 7739 io.Copy(&snapshot, ringBuffer) 7740 return &smithy.DeserializationError{ 7741 Err: fmt.Errorf("failed to decode response body, %w", err), 7742 Snapshot: snapshot.Bytes(), 7743 } 7744 } 7745 7746 return output 7747} 7748 7749func awsAwsquery_deserializeErrorDBInstanceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7750 output := &types.DBInstanceNotFoundFault{} 7751 var buff [1024]byte 7752 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7753 body := io.TeeReader(errorBody, ringBuffer) 7754 rootDecoder := xml.NewDecoder(body) 7755 t, err := smithyxml.FetchRootElement(rootDecoder) 7756 if err == io.EOF { 7757 return output 7758 } 7759 if err != nil { 7760 var snapshot bytes.Buffer 7761 io.Copy(&snapshot, ringBuffer) 7762 return &smithy.DeserializationError{ 7763 Err: fmt.Errorf("failed to decode response body, %w", err), 7764 Snapshot: snapshot.Bytes(), 7765 } 7766 } 7767 7768 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7769 t, err = decoder.GetElement("Error") 7770 if err != nil { 7771 var snapshot bytes.Buffer 7772 io.Copy(&snapshot, ringBuffer) 7773 return &smithy.DeserializationError{ 7774 Err: fmt.Errorf("failed to decode response body, %w", err), 7775 Snapshot: snapshot.Bytes(), 7776 } 7777 } 7778 7779 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7780 err = awsAwsquery_deserializeDocumentDBInstanceNotFoundFault(&output, decoder) 7781 if err != nil { 7782 var snapshot bytes.Buffer 7783 io.Copy(&snapshot, ringBuffer) 7784 return &smithy.DeserializationError{ 7785 Err: fmt.Errorf("failed to decode response body, %w", err), 7786 Snapshot: snapshot.Bytes(), 7787 } 7788 } 7789 7790 return output 7791} 7792 7793func awsAwsquery_deserializeErrorDBParameterGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7794 output := &types.DBParameterGroupAlreadyExistsFault{} 7795 var buff [1024]byte 7796 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7797 body := io.TeeReader(errorBody, ringBuffer) 7798 rootDecoder := xml.NewDecoder(body) 7799 t, err := smithyxml.FetchRootElement(rootDecoder) 7800 if err == io.EOF { 7801 return output 7802 } 7803 if err != nil { 7804 var snapshot bytes.Buffer 7805 io.Copy(&snapshot, ringBuffer) 7806 return &smithy.DeserializationError{ 7807 Err: fmt.Errorf("failed to decode response body, %w", err), 7808 Snapshot: snapshot.Bytes(), 7809 } 7810 } 7811 7812 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7813 t, err = decoder.GetElement("Error") 7814 if err != nil { 7815 var snapshot bytes.Buffer 7816 io.Copy(&snapshot, ringBuffer) 7817 return &smithy.DeserializationError{ 7818 Err: fmt.Errorf("failed to decode response body, %w", err), 7819 Snapshot: snapshot.Bytes(), 7820 } 7821 } 7822 7823 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7824 err = awsAwsquery_deserializeDocumentDBParameterGroupAlreadyExistsFault(&output, decoder) 7825 if err != nil { 7826 var snapshot bytes.Buffer 7827 io.Copy(&snapshot, ringBuffer) 7828 return &smithy.DeserializationError{ 7829 Err: fmt.Errorf("failed to decode response body, %w", err), 7830 Snapshot: snapshot.Bytes(), 7831 } 7832 } 7833 7834 return output 7835} 7836 7837func awsAwsquery_deserializeErrorDBParameterGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7838 output := &types.DBParameterGroupNotFoundFault{} 7839 var buff [1024]byte 7840 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7841 body := io.TeeReader(errorBody, ringBuffer) 7842 rootDecoder := xml.NewDecoder(body) 7843 t, err := smithyxml.FetchRootElement(rootDecoder) 7844 if err == io.EOF { 7845 return output 7846 } 7847 if err != nil { 7848 var snapshot bytes.Buffer 7849 io.Copy(&snapshot, ringBuffer) 7850 return &smithy.DeserializationError{ 7851 Err: fmt.Errorf("failed to decode response body, %w", err), 7852 Snapshot: snapshot.Bytes(), 7853 } 7854 } 7855 7856 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7857 t, err = decoder.GetElement("Error") 7858 if err != nil { 7859 var snapshot bytes.Buffer 7860 io.Copy(&snapshot, ringBuffer) 7861 return &smithy.DeserializationError{ 7862 Err: fmt.Errorf("failed to decode response body, %w", err), 7863 Snapshot: snapshot.Bytes(), 7864 } 7865 } 7866 7867 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7868 err = awsAwsquery_deserializeDocumentDBParameterGroupNotFoundFault(&output, decoder) 7869 if err != nil { 7870 var snapshot bytes.Buffer 7871 io.Copy(&snapshot, ringBuffer) 7872 return &smithy.DeserializationError{ 7873 Err: fmt.Errorf("failed to decode response body, %w", err), 7874 Snapshot: snapshot.Bytes(), 7875 } 7876 } 7877 7878 return output 7879} 7880 7881func awsAwsquery_deserializeErrorDBParameterGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7882 output := &types.DBParameterGroupQuotaExceededFault{} 7883 var buff [1024]byte 7884 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7885 body := io.TeeReader(errorBody, ringBuffer) 7886 rootDecoder := xml.NewDecoder(body) 7887 t, err := smithyxml.FetchRootElement(rootDecoder) 7888 if err == io.EOF { 7889 return output 7890 } 7891 if err != nil { 7892 var snapshot bytes.Buffer 7893 io.Copy(&snapshot, ringBuffer) 7894 return &smithy.DeserializationError{ 7895 Err: fmt.Errorf("failed to decode response body, %w", err), 7896 Snapshot: snapshot.Bytes(), 7897 } 7898 } 7899 7900 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7901 t, err = decoder.GetElement("Error") 7902 if err != nil { 7903 var snapshot bytes.Buffer 7904 io.Copy(&snapshot, ringBuffer) 7905 return &smithy.DeserializationError{ 7906 Err: fmt.Errorf("failed to decode response body, %w", err), 7907 Snapshot: snapshot.Bytes(), 7908 } 7909 } 7910 7911 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7912 err = awsAwsquery_deserializeDocumentDBParameterGroupQuotaExceededFault(&output, decoder) 7913 if err != nil { 7914 var snapshot bytes.Buffer 7915 io.Copy(&snapshot, ringBuffer) 7916 return &smithy.DeserializationError{ 7917 Err: fmt.Errorf("failed to decode response body, %w", err), 7918 Snapshot: snapshot.Bytes(), 7919 } 7920 } 7921 7922 return output 7923} 7924 7925func awsAwsquery_deserializeErrorDBSecurityGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7926 output := &types.DBSecurityGroupNotFoundFault{} 7927 var buff [1024]byte 7928 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7929 body := io.TeeReader(errorBody, ringBuffer) 7930 rootDecoder := xml.NewDecoder(body) 7931 t, err := smithyxml.FetchRootElement(rootDecoder) 7932 if err == io.EOF { 7933 return output 7934 } 7935 if err != nil { 7936 var snapshot bytes.Buffer 7937 io.Copy(&snapshot, ringBuffer) 7938 return &smithy.DeserializationError{ 7939 Err: fmt.Errorf("failed to decode response body, %w", err), 7940 Snapshot: snapshot.Bytes(), 7941 } 7942 } 7943 7944 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7945 t, err = decoder.GetElement("Error") 7946 if err != nil { 7947 var snapshot bytes.Buffer 7948 io.Copy(&snapshot, ringBuffer) 7949 return &smithy.DeserializationError{ 7950 Err: fmt.Errorf("failed to decode response body, %w", err), 7951 Snapshot: snapshot.Bytes(), 7952 } 7953 } 7954 7955 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7956 err = awsAwsquery_deserializeDocumentDBSecurityGroupNotFoundFault(&output, decoder) 7957 if err != nil { 7958 var snapshot bytes.Buffer 7959 io.Copy(&snapshot, ringBuffer) 7960 return &smithy.DeserializationError{ 7961 Err: fmt.Errorf("failed to decode response body, %w", err), 7962 Snapshot: snapshot.Bytes(), 7963 } 7964 } 7965 7966 return output 7967} 7968 7969func awsAwsquery_deserializeErrorDBSnapshotAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7970 output := &types.DBSnapshotAlreadyExistsFault{} 7971 var buff [1024]byte 7972 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7973 body := io.TeeReader(errorBody, ringBuffer) 7974 rootDecoder := xml.NewDecoder(body) 7975 t, err := smithyxml.FetchRootElement(rootDecoder) 7976 if err == io.EOF { 7977 return output 7978 } 7979 if err != nil { 7980 var snapshot bytes.Buffer 7981 io.Copy(&snapshot, ringBuffer) 7982 return &smithy.DeserializationError{ 7983 Err: fmt.Errorf("failed to decode response body, %w", err), 7984 Snapshot: snapshot.Bytes(), 7985 } 7986 } 7987 7988 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7989 t, err = decoder.GetElement("Error") 7990 if err != nil { 7991 var snapshot bytes.Buffer 7992 io.Copy(&snapshot, ringBuffer) 7993 return &smithy.DeserializationError{ 7994 Err: fmt.Errorf("failed to decode response body, %w", err), 7995 Snapshot: snapshot.Bytes(), 7996 } 7997 } 7998 7999 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8000 err = awsAwsquery_deserializeDocumentDBSnapshotAlreadyExistsFault(&output, decoder) 8001 if err != nil { 8002 var snapshot bytes.Buffer 8003 io.Copy(&snapshot, ringBuffer) 8004 return &smithy.DeserializationError{ 8005 Err: fmt.Errorf("failed to decode response body, %w", err), 8006 Snapshot: snapshot.Bytes(), 8007 } 8008 } 8009 8010 return output 8011} 8012 8013func awsAwsquery_deserializeErrorDBSnapshotNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8014 output := &types.DBSnapshotNotFoundFault{} 8015 var buff [1024]byte 8016 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8017 body := io.TeeReader(errorBody, ringBuffer) 8018 rootDecoder := xml.NewDecoder(body) 8019 t, err := smithyxml.FetchRootElement(rootDecoder) 8020 if err == io.EOF { 8021 return output 8022 } 8023 if err != nil { 8024 var snapshot bytes.Buffer 8025 io.Copy(&snapshot, ringBuffer) 8026 return &smithy.DeserializationError{ 8027 Err: fmt.Errorf("failed to decode response body, %w", err), 8028 Snapshot: snapshot.Bytes(), 8029 } 8030 } 8031 8032 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8033 t, err = decoder.GetElement("Error") 8034 if err != nil { 8035 var snapshot bytes.Buffer 8036 io.Copy(&snapshot, ringBuffer) 8037 return &smithy.DeserializationError{ 8038 Err: fmt.Errorf("failed to decode response body, %w", err), 8039 Snapshot: snapshot.Bytes(), 8040 } 8041 } 8042 8043 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8044 err = awsAwsquery_deserializeDocumentDBSnapshotNotFoundFault(&output, decoder) 8045 if err != nil { 8046 var snapshot bytes.Buffer 8047 io.Copy(&snapshot, ringBuffer) 8048 return &smithy.DeserializationError{ 8049 Err: fmt.Errorf("failed to decode response body, %w", err), 8050 Snapshot: snapshot.Bytes(), 8051 } 8052 } 8053 8054 return output 8055} 8056 8057func awsAwsquery_deserializeErrorDBSubnetGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8058 output := &types.DBSubnetGroupAlreadyExistsFault{} 8059 var buff [1024]byte 8060 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8061 body := io.TeeReader(errorBody, ringBuffer) 8062 rootDecoder := xml.NewDecoder(body) 8063 t, err := smithyxml.FetchRootElement(rootDecoder) 8064 if err == io.EOF { 8065 return output 8066 } 8067 if err != nil { 8068 var snapshot bytes.Buffer 8069 io.Copy(&snapshot, ringBuffer) 8070 return &smithy.DeserializationError{ 8071 Err: fmt.Errorf("failed to decode response body, %w", err), 8072 Snapshot: snapshot.Bytes(), 8073 } 8074 } 8075 8076 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8077 t, err = decoder.GetElement("Error") 8078 if err != nil { 8079 var snapshot bytes.Buffer 8080 io.Copy(&snapshot, ringBuffer) 8081 return &smithy.DeserializationError{ 8082 Err: fmt.Errorf("failed to decode response body, %w", err), 8083 Snapshot: snapshot.Bytes(), 8084 } 8085 } 8086 8087 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8088 err = awsAwsquery_deserializeDocumentDBSubnetGroupAlreadyExistsFault(&output, decoder) 8089 if err != nil { 8090 var snapshot bytes.Buffer 8091 io.Copy(&snapshot, ringBuffer) 8092 return &smithy.DeserializationError{ 8093 Err: fmt.Errorf("failed to decode response body, %w", err), 8094 Snapshot: snapshot.Bytes(), 8095 } 8096 } 8097 8098 return output 8099} 8100 8101func awsAwsquery_deserializeErrorDBSubnetGroupDoesNotCoverEnoughAZs(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8102 output := &types.DBSubnetGroupDoesNotCoverEnoughAZs{} 8103 var buff [1024]byte 8104 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8105 body := io.TeeReader(errorBody, ringBuffer) 8106 rootDecoder := xml.NewDecoder(body) 8107 t, err := smithyxml.FetchRootElement(rootDecoder) 8108 if err == io.EOF { 8109 return output 8110 } 8111 if err != nil { 8112 var snapshot bytes.Buffer 8113 io.Copy(&snapshot, ringBuffer) 8114 return &smithy.DeserializationError{ 8115 Err: fmt.Errorf("failed to decode response body, %w", err), 8116 Snapshot: snapshot.Bytes(), 8117 } 8118 } 8119 8120 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8121 t, err = decoder.GetElement("Error") 8122 if err != nil { 8123 var snapshot bytes.Buffer 8124 io.Copy(&snapshot, ringBuffer) 8125 return &smithy.DeserializationError{ 8126 Err: fmt.Errorf("failed to decode response body, %w", err), 8127 Snapshot: snapshot.Bytes(), 8128 } 8129 } 8130 8131 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8132 err = awsAwsquery_deserializeDocumentDBSubnetGroupDoesNotCoverEnoughAZs(&output, decoder) 8133 if err != nil { 8134 var snapshot bytes.Buffer 8135 io.Copy(&snapshot, ringBuffer) 8136 return &smithy.DeserializationError{ 8137 Err: fmt.Errorf("failed to decode response body, %w", err), 8138 Snapshot: snapshot.Bytes(), 8139 } 8140 } 8141 8142 return output 8143} 8144 8145func awsAwsquery_deserializeErrorDBSubnetGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8146 output := &types.DBSubnetGroupNotFoundFault{} 8147 var buff [1024]byte 8148 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8149 body := io.TeeReader(errorBody, ringBuffer) 8150 rootDecoder := xml.NewDecoder(body) 8151 t, err := smithyxml.FetchRootElement(rootDecoder) 8152 if err == io.EOF { 8153 return output 8154 } 8155 if err != nil { 8156 var snapshot bytes.Buffer 8157 io.Copy(&snapshot, ringBuffer) 8158 return &smithy.DeserializationError{ 8159 Err: fmt.Errorf("failed to decode response body, %w", err), 8160 Snapshot: snapshot.Bytes(), 8161 } 8162 } 8163 8164 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8165 t, err = decoder.GetElement("Error") 8166 if err != nil { 8167 var snapshot bytes.Buffer 8168 io.Copy(&snapshot, ringBuffer) 8169 return &smithy.DeserializationError{ 8170 Err: fmt.Errorf("failed to decode response body, %w", err), 8171 Snapshot: snapshot.Bytes(), 8172 } 8173 } 8174 8175 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8176 err = awsAwsquery_deserializeDocumentDBSubnetGroupNotFoundFault(&output, decoder) 8177 if err != nil { 8178 var snapshot bytes.Buffer 8179 io.Copy(&snapshot, ringBuffer) 8180 return &smithy.DeserializationError{ 8181 Err: fmt.Errorf("failed to decode response body, %w", err), 8182 Snapshot: snapshot.Bytes(), 8183 } 8184 } 8185 8186 return output 8187} 8188 8189func awsAwsquery_deserializeErrorDBSubnetGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8190 output := &types.DBSubnetGroupQuotaExceededFault{} 8191 var buff [1024]byte 8192 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8193 body := io.TeeReader(errorBody, ringBuffer) 8194 rootDecoder := xml.NewDecoder(body) 8195 t, err := smithyxml.FetchRootElement(rootDecoder) 8196 if err == io.EOF { 8197 return output 8198 } 8199 if err != nil { 8200 var snapshot bytes.Buffer 8201 io.Copy(&snapshot, ringBuffer) 8202 return &smithy.DeserializationError{ 8203 Err: fmt.Errorf("failed to decode response body, %w", err), 8204 Snapshot: snapshot.Bytes(), 8205 } 8206 } 8207 8208 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8209 t, err = decoder.GetElement("Error") 8210 if err != nil { 8211 var snapshot bytes.Buffer 8212 io.Copy(&snapshot, ringBuffer) 8213 return &smithy.DeserializationError{ 8214 Err: fmt.Errorf("failed to decode response body, %w", err), 8215 Snapshot: snapshot.Bytes(), 8216 } 8217 } 8218 8219 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8220 err = awsAwsquery_deserializeDocumentDBSubnetGroupQuotaExceededFault(&output, decoder) 8221 if err != nil { 8222 var snapshot bytes.Buffer 8223 io.Copy(&snapshot, ringBuffer) 8224 return &smithy.DeserializationError{ 8225 Err: fmt.Errorf("failed to decode response body, %w", err), 8226 Snapshot: snapshot.Bytes(), 8227 } 8228 } 8229 8230 return output 8231} 8232 8233func awsAwsquery_deserializeErrorDBSubnetQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8234 output := &types.DBSubnetQuotaExceededFault{} 8235 var buff [1024]byte 8236 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8237 body := io.TeeReader(errorBody, ringBuffer) 8238 rootDecoder := xml.NewDecoder(body) 8239 t, err := smithyxml.FetchRootElement(rootDecoder) 8240 if err == io.EOF { 8241 return output 8242 } 8243 if err != nil { 8244 var snapshot bytes.Buffer 8245 io.Copy(&snapshot, ringBuffer) 8246 return &smithy.DeserializationError{ 8247 Err: fmt.Errorf("failed to decode response body, %w", err), 8248 Snapshot: snapshot.Bytes(), 8249 } 8250 } 8251 8252 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8253 t, err = decoder.GetElement("Error") 8254 if err != nil { 8255 var snapshot bytes.Buffer 8256 io.Copy(&snapshot, ringBuffer) 8257 return &smithy.DeserializationError{ 8258 Err: fmt.Errorf("failed to decode response body, %w", err), 8259 Snapshot: snapshot.Bytes(), 8260 } 8261 } 8262 8263 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8264 err = awsAwsquery_deserializeDocumentDBSubnetQuotaExceededFault(&output, decoder) 8265 if err != nil { 8266 var snapshot bytes.Buffer 8267 io.Copy(&snapshot, ringBuffer) 8268 return &smithy.DeserializationError{ 8269 Err: fmt.Errorf("failed to decode response body, %w", err), 8270 Snapshot: snapshot.Bytes(), 8271 } 8272 } 8273 8274 return output 8275} 8276 8277func awsAwsquery_deserializeErrorDBUpgradeDependencyFailureFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8278 output := &types.DBUpgradeDependencyFailureFault{} 8279 var buff [1024]byte 8280 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8281 body := io.TeeReader(errorBody, ringBuffer) 8282 rootDecoder := xml.NewDecoder(body) 8283 t, err := smithyxml.FetchRootElement(rootDecoder) 8284 if err == io.EOF { 8285 return output 8286 } 8287 if err != nil { 8288 var snapshot bytes.Buffer 8289 io.Copy(&snapshot, ringBuffer) 8290 return &smithy.DeserializationError{ 8291 Err: fmt.Errorf("failed to decode response body, %w", err), 8292 Snapshot: snapshot.Bytes(), 8293 } 8294 } 8295 8296 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8297 t, err = decoder.GetElement("Error") 8298 if err != nil { 8299 var snapshot bytes.Buffer 8300 io.Copy(&snapshot, ringBuffer) 8301 return &smithy.DeserializationError{ 8302 Err: fmt.Errorf("failed to decode response body, %w", err), 8303 Snapshot: snapshot.Bytes(), 8304 } 8305 } 8306 8307 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8308 err = awsAwsquery_deserializeDocumentDBUpgradeDependencyFailureFault(&output, decoder) 8309 if err != nil { 8310 var snapshot bytes.Buffer 8311 io.Copy(&snapshot, ringBuffer) 8312 return &smithy.DeserializationError{ 8313 Err: fmt.Errorf("failed to decode response body, %w", err), 8314 Snapshot: snapshot.Bytes(), 8315 } 8316 } 8317 8318 return output 8319} 8320 8321func awsAwsquery_deserializeErrorDomainNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8322 output := &types.DomainNotFoundFault{} 8323 var buff [1024]byte 8324 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8325 body := io.TeeReader(errorBody, ringBuffer) 8326 rootDecoder := xml.NewDecoder(body) 8327 t, err := smithyxml.FetchRootElement(rootDecoder) 8328 if err == io.EOF { 8329 return output 8330 } 8331 if err != nil { 8332 var snapshot bytes.Buffer 8333 io.Copy(&snapshot, ringBuffer) 8334 return &smithy.DeserializationError{ 8335 Err: fmt.Errorf("failed to decode response body, %w", err), 8336 Snapshot: snapshot.Bytes(), 8337 } 8338 } 8339 8340 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8341 t, err = decoder.GetElement("Error") 8342 if err != nil { 8343 var snapshot bytes.Buffer 8344 io.Copy(&snapshot, ringBuffer) 8345 return &smithy.DeserializationError{ 8346 Err: fmt.Errorf("failed to decode response body, %w", err), 8347 Snapshot: snapshot.Bytes(), 8348 } 8349 } 8350 8351 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8352 err = awsAwsquery_deserializeDocumentDomainNotFoundFault(&output, decoder) 8353 if err != nil { 8354 var snapshot bytes.Buffer 8355 io.Copy(&snapshot, ringBuffer) 8356 return &smithy.DeserializationError{ 8357 Err: fmt.Errorf("failed to decode response body, %w", err), 8358 Snapshot: snapshot.Bytes(), 8359 } 8360 } 8361 8362 return output 8363} 8364 8365func awsAwsquery_deserializeErrorEventSubscriptionQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8366 output := &types.EventSubscriptionQuotaExceededFault{} 8367 var buff [1024]byte 8368 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8369 body := io.TeeReader(errorBody, ringBuffer) 8370 rootDecoder := xml.NewDecoder(body) 8371 t, err := smithyxml.FetchRootElement(rootDecoder) 8372 if err == io.EOF { 8373 return output 8374 } 8375 if err != nil { 8376 var snapshot bytes.Buffer 8377 io.Copy(&snapshot, ringBuffer) 8378 return &smithy.DeserializationError{ 8379 Err: fmt.Errorf("failed to decode response body, %w", err), 8380 Snapshot: snapshot.Bytes(), 8381 } 8382 } 8383 8384 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8385 t, err = decoder.GetElement("Error") 8386 if err != nil { 8387 var snapshot bytes.Buffer 8388 io.Copy(&snapshot, ringBuffer) 8389 return &smithy.DeserializationError{ 8390 Err: fmt.Errorf("failed to decode response body, %w", err), 8391 Snapshot: snapshot.Bytes(), 8392 } 8393 } 8394 8395 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8396 err = awsAwsquery_deserializeDocumentEventSubscriptionQuotaExceededFault(&output, decoder) 8397 if err != nil { 8398 var snapshot bytes.Buffer 8399 io.Copy(&snapshot, ringBuffer) 8400 return &smithy.DeserializationError{ 8401 Err: fmt.Errorf("failed to decode response body, %w", err), 8402 Snapshot: snapshot.Bytes(), 8403 } 8404 } 8405 8406 return output 8407} 8408 8409func awsAwsquery_deserializeErrorInstanceQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8410 output := &types.InstanceQuotaExceededFault{} 8411 var buff [1024]byte 8412 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8413 body := io.TeeReader(errorBody, ringBuffer) 8414 rootDecoder := xml.NewDecoder(body) 8415 t, err := smithyxml.FetchRootElement(rootDecoder) 8416 if err == io.EOF { 8417 return output 8418 } 8419 if err != nil { 8420 var snapshot bytes.Buffer 8421 io.Copy(&snapshot, ringBuffer) 8422 return &smithy.DeserializationError{ 8423 Err: fmt.Errorf("failed to decode response body, %w", err), 8424 Snapshot: snapshot.Bytes(), 8425 } 8426 } 8427 8428 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8429 t, err = decoder.GetElement("Error") 8430 if err != nil { 8431 var snapshot bytes.Buffer 8432 io.Copy(&snapshot, ringBuffer) 8433 return &smithy.DeserializationError{ 8434 Err: fmt.Errorf("failed to decode response body, %w", err), 8435 Snapshot: snapshot.Bytes(), 8436 } 8437 } 8438 8439 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8440 err = awsAwsquery_deserializeDocumentInstanceQuotaExceededFault(&output, decoder) 8441 if err != nil { 8442 var snapshot bytes.Buffer 8443 io.Copy(&snapshot, ringBuffer) 8444 return &smithy.DeserializationError{ 8445 Err: fmt.Errorf("failed to decode response body, %w", err), 8446 Snapshot: snapshot.Bytes(), 8447 } 8448 } 8449 8450 return output 8451} 8452 8453func awsAwsquery_deserializeErrorInsufficientDBClusterCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8454 output := &types.InsufficientDBClusterCapacityFault{} 8455 var buff [1024]byte 8456 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8457 body := io.TeeReader(errorBody, ringBuffer) 8458 rootDecoder := xml.NewDecoder(body) 8459 t, err := smithyxml.FetchRootElement(rootDecoder) 8460 if err == io.EOF { 8461 return output 8462 } 8463 if err != nil { 8464 var snapshot bytes.Buffer 8465 io.Copy(&snapshot, ringBuffer) 8466 return &smithy.DeserializationError{ 8467 Err: fmt.Errorf("failed to decode response body, %w", err), 8468 Snapshot: snapshot.Bytes(), 8469 } 8470 } 8471 8472 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8473 t, err = decoder.GetElement("Error") 8474 if err != nil { 8475 var snapshot bytes.Buffer 8476 io.Copy(&snapshot, ringBuffer) 8477 return &smithy.DeserializationError{ 8478 Err: fmt.Errorf("failed to decode response body, %w", err), 8479 Snapshot: snapshot.Bytes(), 8480 } 8481 } 8482 8483 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8484 err = awsAwsquery_deserializeDocumentInsufficientDBClusterCapacityFault(&output, decoder) 8485 if err != nil { 8486 var snapshot bytes.Buffer 8487 io.Copy(&snapshot, ringBuffer) 8488 return &smithy.DeserializationError{ 8489 Err: fmt.Errorf("failed to decode response body, %w", err), 8490 Snapshot: snapshot.Bytes(), 8491 } 8492 } 8493 8494 return output 8495} 8496 8497func awsAwsquery_deserializeErrorInsufficientDBInstanceCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8498 output := &types.InsufficientDBInstanceCapacityFault{} 8499 var buff [1024]byte 8500 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8501 body := io.TeeReader(errorBody, ringBuffer) 8502 rootDecoder := xml.NewDecoder(body) 8503 t, err := smithyxml.FetchRootElement(rootDecoder) 8504 if err == io.EOF { 8505 return output 8506 } 8507 if err != nil { 8508 var snapshot bytes.Buffer 8509 io.Copy(&snapshot, ringBuffer) 8510 return &smithy.DeserializationError{ 8511 Err: fmt.Errorf("failed to decode response body, %w", err), 8512 Snapshot: snapshot.Bytes(), 8513 } 8514 } 8515 8516 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8517 t, err = decoder.GetElement("Error") 8518 if err != nil { 8519 var snapshot bytes.Buffer 8520 io.Copy(&snapshot, ringBuffer) 8521 return &smithy.DeserializationError{ 8522 Err: fmt.Errorf("failed to decode response body, %w", err), 8523 Snapshot: snapshot.Bytes(), 8524 } 8525 } 8526 8527 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8528 err = awsAwsquery_deserializeDocumentInsufficientDBInstanceCapacityFault(&output, decoder) 8529 if err != nil { 8530 var snapshot bytes.Buffer 8531 io.Copy(&snapshot, ringBuffer) 8532 return &smithy.DeserializationError{ 8533 Err: fmt.Errorf("failed to decode response body, %w", err), 8534 Snapshot: snapshot.Bytes(), 8535 } 8536 } 8537 8538 return output 8539} 8540 8541func awsAwsquery_deserializeErrorInsufficientStorageClusterCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8542 output := &types.InsufficientStorageClusterCapacityFault{} 8543 var buff [1024]byte 8544 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8545 body := io.TeeReader(errorBody, ringBuffer) 8546 rootDecoder := xml.NewDecoder(body) 8547 t, err := smithyxml.FetchRootElement(rootDecoder) 8548 if err == io.EOF { 8549 return output 8550 } 8551 if err != nil { 8552 var snapshot bytes.Buffer 8553 io.Copy(&snapshot, ringBuffer) 8554 return &smithy.DeserializationError{ 8555 Err: fmt.Errorf("failed to decode response body, %w", err), 8556 Snapshot: snapshot.Bytes(), 8557 } 8558 } 8559 8560 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8561 t, err = decoder.GetElement("Error") 8562 if err != nil { 8563 var snapshot bytes.Buffer 8564 io.Copy(&snapshot, ringBuffer) 8565 return &smithy.DeserializationError{ 8566 Err: fmt.Errorf("failed to decode response body, %w", err), 8567 Snapshot: snapshot.Bytes(), 8568 } 8569 } 8570 8571 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8572 err = awsAwsquery_deserializeDocumentInsufficientStorageClusterCapacityFault(&output, decoder) 8573 if err != nil { 8574 var snapshot bytes.Buffer 8575 io.Copy(&snapshot, ringBuffer) 8576 return &smithy.DeserializationError{ 8577 Err: fmt.Errorf("failed to decode response body, %w", err), 8578 Snapshot: snapshot.Bytes(), 8579 } 8580 } 8581 8582 return output 8583} 8584 8585func awsAwsquery_deserializeErrorInvalidDBClusterEndpointStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8586 output := &types.InvalidDBClusterEndpointStateFault{} 8587 var buff [1024]byte 8588 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8589 body := io.TeeReader(errorBody, ringBuffer) 8590 rootDecoder := xml.NewDecoder(body) 8591 t, err := smithyxml.FetchRootElement(rootDecoder) 8592 if err == io.EOF { 8593 return output 8594 } 8595 if err != nil { 8596 var snapshot bytes.Buffer 8597 io.Copy(&snapshot, ringBuffer) 8598 return &smithy.DeserializationError{ 8599 Err: fmt.Errorf("failed to decode response body, %w", err), 8600 Snapshot: snapshot.Bytes(), 8601 } 8602 } 8603 8604 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8605 t, err = decoder.GetElement("Error") 8606 if err != nil { 8607 var snapshot bytes.Buffer 8608 io.Copy(&snapshot, ringBuffer) 8609 return &smithy.DeserializationError{ 8610 Err: fmt.Errorf("failed to decode response body, %w", err), 8611 Snapshot: snapshot.Bytes(), 8612 } 8613 } 8614 8615 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8616 err = awsAwsquery_deserializeDocumentInvalidDBClusterEndpointStateFault(&output, decoder) 8617 if err != nil { 8618 var snapshot bytes.Buffer 8619 io.Copy(&snapshot, ringBuffer) 8620 return &smithy.DeserializationError{ 8621 Err: fmt.Errorf("failed to decode response body, %w", err), 8622 Snapshot: snapshot.Bytes(), 8623 } 8624 } 8625 8626 return output 8627} 8628 8629func awsAwsquery_deserializeErrorInvalidDBClusterSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8630 output := &types.InvalidDBClusterSnapshotStateFault{} 8631 var buff [1024]byte 8632 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8633 body := io.TeeReader(errorBody, ringBuffer) 8634 rootDecoder := xml.NewDecoder(body) 8635 t, err := smithyxml.FetchRootElement(rootDecoder) 8636 if err == io.EOF { 8637 return output 8638 } 8639 if err != nil { 8640 var snapshot bytes.Buffer 8641 io.Copy(&snapshot, ringBuffer) 8642 return &smithy.DeserializationError{ 8643 Err: fmt.Errorf("failed to decode response body, %w", err), 8644 Snapshot: snapshot.Bytes(), 8645 } 8646 } 8647 8648 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8649 t, err = decoder.GetElement("Error") 8650 if err != nil { 8651 var snapshot bytes.Buffer 8652 io.Copy(&snapshot, ringBuffer) 8653 return &smithy.DeserializationError{ 8654 Err: fmt.Errorf("failed to decode response body, %w", err), 8655 Snapshot: snapshot.Bytes(), 8656 } 8657 } 8658 8659 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8660 err = awsAwsquery_deserializeDocumentInvalidDBClusterSnapshotStateFault(&output, decoder) 8661 if err != nil { 8662 var snapshot bytes.Buffer 8663 io.Copy(&snapshot, ringBuffer) 8664 return &smithy.DeserializationError{ 8665 Err: fmt.Errorf("failed to decode response body, %w", err), 8666 Snapshot: snapshot.Bytes(), 8667 } 8668 } 8669 8670 return output 8671} 8672 8673func awsAwsquery_deserializeErrorInvalidDBClusterStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8674 output := &types.InvalidDBClusterStateFault{} 8675 var buff [1024]byte 8676 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8677 body := io.TeeReader(errorBody, ringBuffer) 8678 rootDecoder := xml.NewDecoder(body) 8679 t, err := smithyxml.FetchRootElement(rootDecoder) 8680 if err == io.EOF { 8681 return output 8682 } 8683 if err != nil { 8684 var snapshot bytes.Buffer 8685 io.Copy(&snapshot, ringBuffer) 8686 return &smithy.DeserializationError{ 8687 Err: fmt.Errorf("failed to decode response body, %w", err), 8688 Snapshot: snapshot.Bytes(), 8689 } 8690 } 8691 8692 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8693 t, err = decoder.GetElement("Error") 8694 if err != nil { 8695 var snapshot bytes.Buffer 8696 io.Copy(&snapshot, ringBuffer) 8697 return &smithy.DeserializationError{ 8698 Err: fmt.Errorf("failed to decode response body, %w", err), 8699 Snapshot: snapshot.Bytes(), 8700 } 8701 } 8702 8703 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8704 err = awsAwsquery_deserializeDocumentInvalidDBClusterStateFault(&output, decoder) 8705 if err != nil { 8706 var snapshot bytes.Buffer 8707 io.Copy(&snapshot, ringBuffer) 8708 return &smithy.DeserializationError{ 8709 Err: fmt.Errorf("failed to decode response body, %w", err), 8710 Snapshot: snapshot.Bytes(), 8711 } 8712 } 8713 8714 return output 8715} 8716 8717func awsAwsquery_deserializeErrorInvalidDBInstanceStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8718 output := &types.InvalidDBInstanceStateFault{} 8719 var buff [1024]byte 8720 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8721 body := io.TeeReader(errorBody, ringBuffer) 8722 rootDecoder := xml.NewDecoder(body) 8723 t, err := smithyxml.FetchRootElement(rootDecoder) 8724 if err == io.EOF { 8725 return output 8726 } 8727 if err != nil { 8728 var snapshot bytes.Buffer 8729 io.Copy(&snapshot, ringBuffer) 8730 return &smithy.DeserializationError{ 8731 Err: fmt.Errorf("failed to decode response body, %w", err), 8732 Snapshot: snapshot.Bytes(), 8733 } 8734 } 8735 8736 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8737 t, err = decoder.GetElement("Error") 8738 if err != nil { 8739 var snapshot bytes.Buffer 8740 io.Copy(&snapshot, ringBuffer) 8741 return &smithy.DeserializationError{ 8742 Err: fmt.Errorf("failed to decode response body, %w", err), 8743 Snapshot: snapshot.Bytes(), 8744 } 8745 } 8746 8747 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8748 err = awsAwsquery_deserializeDocumentInvalidDBInstanceStateFault(&output, decoder) 8749 if err != nil { 8750 var snapshot bytes.Buffer 8751 io.Copy(&snapshot, ringBuffer) 8752 return &smithy.DeserializationError{ 8753 Err: fmt.Errorf("failed to decode response body, %w", err), 8754 Snapshot: snapshot.Bytes(), 8755 } 8756 } 8757 8758 return output 8759} 8760 8761func awsAwsquery_deserializeErrorInvalidDBParameterGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8762 output := &types.InvalidDBParameterGroupStateFault{} 8763 var buff [1024]byte 8764 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8765 body := io.TeeReader(errorBody, ringBuffer) 8766 rootDecoder := xml.NewDecoder(body) 8767 t, err := smithyxml.FetchRootElement(rootDecoder) 8768 if err == io.EOF { 8769 return output 8770 } 8771 if err != nil { 8772 var snapshot bytes.Buffer 8773 io.Copy(&snapshot, ringBuffer) 8774 return &smithy.DeserializationError{ 8775 Err: fmt.Errorf("failed to decode response body, %w", err), 8776 Snapshot: snapshot.Bytes(), 8777 } 8778 } 8779 8780 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8781 t, err = decoder.GetElement("Error") 8782 if err != nil { 8783 var snapshot bytes.Buffer 8784 io.Copy(&snapshot, ringBuffer) 8785 return &smithy.DeserializationError{ 8786 Err: fmt.Errorf("failed to decode response body, %w", err), 8787 Snapshot: snapshot.Bytes(), 8788 } 8789 } 8790 8791 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8792 err = awsAwsquery_deserializeDocumentInvalidDBParameterGroupStateFault(&output, decoder) 8793 if err != nil { 8794 var snapshot bytes.Buffer 8795 io.Copy(&snapshot, ringBuffer) 8796 return &smithy.DeserializationError{ 8797 Err: fmt.Errorf("failed to decode response body, %w", err), 8798 Snapshot: snapshot.Bytes(), 8799 } 8800 } 8801 8802 return output 8803} 8804 8805func awsAwsquery_deserializeErrorInvalidDBSecurityGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8806 output := &types.InvalidDBSecurityGroupStateFault{} 8807 var buff [1024]byte 8808 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8809 body := io.TeeReader(errorBody, ringBuffer) 8810 rootDecoder := xml.NewDecoder(body) 8811 t, err := smithyxml.FetchRootElement(rootDecoder) 8812 if err == io.EOF { 8813 return output 8814 } 8815 if err != nil { 8816 var snapshot bytes.Buffer 8817 io.Copy(&snapshot, ringBuffer) 8818 return &smithy.DeserializationError{ 8819 Err: fmt.Errorf("failed to decode response body, %w", err), 8820 Snapshot: snapshot.Bytes(), 8821 } 8822 } 8823 8824 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8825 t, err = decoder.GetElement("Error") 8826 if err != nil { 8827 var snapshot bytes.Buffer 8828 io.Copy(&snapshot, ringBuffer) 8829 return &smithy.DeserializationError{ 8830 Err: fmt.Errorf("failed to decode response body, %w", err), 8831 Snapshot: snapshot.Bytes(), 8832 } 8833 } 8834 8835 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8836 err = awsAwsquery_deserializeDocumentInvalidDBSecurityGroupStateFault(&output, decoder) 8837 if err != nil { 8838 var snapshot bytes.Buffer 8839 io.Copy(&snapshot, ringBuffer) 8840 return &smithy.DeserializationError{ 8841 Err: fmt.Errorf("failed to decode response body, %w", err), 8842 Snapshot: snapshot.Bytes(), 8843 } 8844 } 8845 8846 return output 8847} 8848 8849func awsAwsquery_deserializeErrorInvalidDBSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8850 output := &types.InvalidDBSnapshotStateFault{} 8851 var buff [1024]byte 8852 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8853 body := io.TeeReader(errorBody, ringBuffer) 8854 rootDecoder := xml.NewDecoder(body) 8855 t, err := smithyxml.FetchRootElement(rootDecoder) 8856 if err == io.EOF { 8857 return output 8858 } 8859 if err != nil { 8860 var snapshot bytes.Buffer 8861 io.Copy(&snapshot, ringBuffer) 8862 return &smithy.DeserializationError{ 8863 Err: fmt.Errorf("failed to decode response body, %w", err), 8864 Snapshot: snapshot.Bytes(), 8865 } 8866 } 8867 8868 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8869 t, err = decoder.GetElement("Error") 8870 if err != nil { 8871 var snapshot bytes.Buffer 8872 io.Copy(&snapshot, ringBuffer) 8873 return &smithy.DeserializationError{ 8874 Err: fmt.Errorf("failed to decode response body, %w", err), 8875 Snapshot: snapshot.Bytes(), 8876 } 8877 } 8878 8879 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8880 err = awsAwsquery_deserializeDocumentInvalidDBSnapshotStateFault(&output, decoder) 8881 if err != nil { 8882 var snapshot bytes.Buffer 8883 io.Copy(&snapshot, ringBuffer) 8884 return &smithy.DeserializationError{ 8885 Err: fmt.Errorf("failed to decode response body, %w", err), 8886 Snapshot: snapshot.Bytes(), 8887 } 8888 } 8889 8890 return output 8891} 8892 8893func awsAwsquery_deserializeErrorInvalidDBSubnetGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8894 output := &types.InvalidDBSubnetGroupStateFault{} 8895 var buff [1024]byte 8896 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8897 body := io.TeeReader(errorBody, ringBuffer) 8898 rootDecoder := xml.NewDecoder(body) 8899 t, err := smithyxml.FetchRootElement(rootDecoder) 8900 if err == io.EOF { 8901 return output 8902 } 8903 if err != nil { 8904 var snapshot bytes.Buffer 8905 io.Copy(&snapshot, ringBuffer) 8906 return &smithy.DeserializationError{ 8907 Err: fmt.Errorf("failed to decode response body, %w", err), 8908 Snapshot: snapshot.Bytes(), 8909 } 8910 } 8911 8912 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8913 t, err = decoder.GetElement("Error") 8914 if err != nil { 8915 var snapshot bytes.Buffer 8916 io.Copy(&snapshot, ringBuffer) 8917 return &smithy.DeserializationError{ 8918 Err: fmt.Errorf("failed to decode response body, %w", err), 8919 Snapshot: snapshot.Bytes(), 8920 } 8921 } 8922 8923 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8924 err = awsAwsquery_deserializeDocumentInvalidDBSubnetGroupStateFault(&output, decoder) 8925 if err != nil { 8926 var snapshot bytes.Buffer 8927 io.Copy(&snapshot, ringBuffer) 8928 return &smithy.DeserializationError{ 8929 Err: fmt.Errorf("failed to decode response body, %w", err), 8930 Snapshot: snapshot.Bytes(), 8931 } 8932 } 8933 8934 return output 8935} 8936 8937func awsAwsquery_deserializeErrorInvalidDBSubnetStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8938 output := &types.InvalidDBSubnetStateFault{} 8939 var buff [1024]byte 8940 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8941 body := io.TeeReader(errorBody, ringBuffer) 8942 rootDecoder := xml.NewDecoder(body) 8943 t, err := smithyxml.FetchRootElement(rootDecoder) 8944 if err == io.EOF { 8945 return output 8946 } 8947 if err != nil { 8948 var snapshot bytes.Buffer 8949 io.Copy(&snapshot, ringBuffer) 8950 return &smithy.DeserializationError{ 8951 Err: fmt.Errorf("failed to decode response body, %w", err), 8952 Snapshot: snapshot.Bytes(), 8953 } 8954 } 8955 8956 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8957 t, err = decoder.GetElement("Error") 8958 if err != nil { 8959 var snapshot bytes.Buffer 8960 io.Copy(&snapshot, ringBuffer) 8961 return &smithy.DeserializationError{ 8962 Err: fmt.Errorf("failed to decode response body, %w", err), 8963 Snapshot: snapshot.Bytes(), 8964 } 8965 } 8966 8967 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8968 err = awsAwsquery_deserializeDocumentInvalidDBSubnetStateFault(&output, decoder) 8969 if err != nil { 8970 var snapshot bytes.Buffer 8971 io.Copy(&snapshot, ringBuffer) 8972 return &smithy.DeserializationError{ 8973 Err: fmt.Errorf("failed to decode response body, %w", err), 8974 Snapshot: snapshot.Bytes(), 8975 } 8976 } 8977 8978 return output 8979} 8980 8981func awsAwsquery_deserializeErrorInvalidEventSubscriptionStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 8982 output := &types.InvalidEventSubscriptionStateFault{} 8983 var buff [1024]byte 8984 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8985 body := io.TeeReader(errorBody, ringBuffer) 8986 rootDecoder := xml.NewDecoder(body) 8987 t, err := smithyxml.FetchRootElement(rootDecoder) 8988 if err == io.EOF { 8989 return output 8990 } 8991 if err != nil { 8992 var snapshot bytes.Buffer 8993 io.Copy(&snapshot, ringBuffer) 8994 return &smithy.DeserializationError{ 8995 Err: fmt.Errorf("failed to decode response body, %w", err), 8996 Snapshot: snapshot.Bytes(), 8997 } 8998 } 8999 9000 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9001 t, err = decoder.GetElement("Error") 9002 if err != nil { 9003 var snapshot bytes.Buffer 9004 io.Copy(&snapshot, ringBuffer) 9005 return &smithy.DeserializationError{ 9006 Err: fmt.Errorf("failed to decode response body, %w", err), 9007 Snapshot: snapshot.Bytes(), 9008 } 9009 } 9010 9011 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9012 err = awsAwsquery_deserializeDocumentInvalidEventSubscriptionStateFault(&output, decoder) 9013 if err != nil { 9014 var snapshot bytes.Buffer 9015 io.Copy(&snapshot, ringBuffer) 9016 return &smithy.DeserializationError{ 9017 Err: fmt.Errorf("failed to decode response body, %w", err), 9018 Snapshot: snapshot.Bytes(), 9019 } 9020 } 9021 9022 return output 9023} 9024 9025func awsAwsquery_deserializeErrorInvalidRestoreFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9026 output := &types.InvalidRestoreFault{} 9027 var buff [1024]byte 9028 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9029 body := io.TeeReader(errorBody, ringBuffer) 9030 rootDecoder := xml.NewDecoder(body) 9031 t, err := smithyxml.FetchRootElement(rootDecoder) 9032 if err == io.EOF { 9033 return output 9034 } 9035 if err != nil { 9036 var snapshot bytes.Buffer 9037 io.Copy(&snapshot, ringBuffer) 9038 return &smithy.DeserializationError{ 9039 Err: fmt.Errorf("failed to decode response body, %w", err), 9040 Snapshot: snapshot.Bytes(), 9041 } 9042 } 9043 9044 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9045 t, err = decoder.GetElement("Error") 9046 if err != nil { 9047 var snapshot bytes.Buffer 9048 io.Copy(&snapshot, ringBuffer) 9049 return &smithy.DeserializationError{ 9050 Err: fmt.Errorf("failed to decode response body, %w", err), 9051 Snapshot: snapshot.Bytes(), 9052 } 9053 } 9054 9055 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9056 err = awsAwsquery_deserializeDocumentInvalidRestoreFault(&output, decoder) 9057 if err != nil { 9058 var snapshot bytes.Buffer 9059 io.Copy(&snapshot, ringBuffer) 9060 return &smithy.DeserializationError{ 9061 Err: fmt.Errorf("failed to decode response body, %w", err), 9062 Snapshot: snapshot.Bytes(), 9063 } 9064 } 9065 9066 return output 9067} 9068 9069func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9070 output := &types.InvalidSubnet{} 9071 var buff [1024]byte 9072 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9073 body := io.TeeReader(errorBody, ringBuffer) 9074 rootDecoder := xml.NewDecoder(body) 9075 t, err := smithyxml.FetchRootElement(rootDecoder) 9076 if err == io.EOF { 9077 return output 9078 } 9079 if err != nil { 9080 var snapshot bytes.Buffer 9081 io.Copy(&snapshot, ringBuffer) 9082 return &smithy.DeserializationError{ 9083 Err: fmt.Errorf("failed to decode response body, %w", err), 9084 Snapshot: snapshot.Bytes(), 9085 } 9086 } 9087 9088 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9089 t, err = decoder.GetElement("Error") 9090 if err != nil { 9091 var snapshot bytes.Buffer 9092 io.Copy(&snapshot, ringBuffer) 9093 return &smithy.DeserializationError{ 9094 Err: fmt.Errorf("failed to decode response body, %w", err), 9095 Snapshot: snapshot.Bytes(), 9096 } 9097 } 9098 9099 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9100 err = awsAwsquery_deserializeDocumentInvalidSubnet(&output, decoder) 9101 if err != nil { 9102 var snapshot bytes.Buffer 9103 io.Copy(&snapshot, ringBuffer) 9104 return &smithy.DeserializationError{ 9105 Err: fmt.Errorf("failed to decode response body, %w", err), 9106 Snapshot: snapshot.Bytes(), 9107 } 9108 } 9109 9110 return output 9111} 9112 9113func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9114 output := &types.InvalidVPCNetworkStateFault{} 9115 var buff [1024]byte 9116 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9117 body := io.TeeReader(errorBody, ringBuffer) 9118 rootDecoder := xml.NewDecoder(body) 9119 t, err := smithyxml.FetchRootElement(rootDecoder) 9120 if err == io.EOF { 9121 return output 9122 } 9123 if err != nil { 9124 var snapshot bytes.Buffer 9125 io.Copy(&snapshot, ringBuffer) 9126 return &smithy.DeserializationError{ 9127 Err: fmt.Errorf("failed to decode response body, %w", err), 9128 Snapshot: snapshot.Bytes(), 9129 } 9130 } 9131 9132 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9133 t, err = decoder.GetElement("Error") 9134 if err != nil { 9135 var snapshot bytes.Buffer 9136 io.Copy(&snapshot, ringBuffer) 9137 return &smithy.DeserializationError{ 9138 Err: fmt.Errorf("failed to decode response body, %w", err), 9139 Snapshot: snapshot.Bytes(), 9140 } 9141 } 9142 9143 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9144 err = awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(&output, decoder) 9145 if err != nil { 9146 var snapshot bytes.Buffer 9147 io.Copy(&snapshot, ringBuffer) 9148 return &smithy.DeserializationError{ 9149 Err: fmt.Errorf("failed to decode response body, %w", err), 9150 Snapshot: snapshot.Bytes(), 9151 } 9152 } 9153 9154 return output 9155} 9156 9157func awsAwsquery_deserializeErrorKMSKeyNotAccessibleFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9158 output := &types.KMSKeyNotAccessibleFault{} 9159 var buff [1024]byte 9160 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9161 body := io.TeeReader(errorBody, ringBuffer) 9162 rootDecoder := xml.NewDecoder(body) 9163 t, err := smithyxml.FetchRootElement(rootDecoder) 9164 if err == io.EOF { 9165 return output 9166 } 9167 if err != nil { 9168 var snapshot bytes.Buffer 9169 io.Copy(&snapshot, ringBuffer) 9170 return &smithy.DeserializationError{ 9171 Err: fmt.Errorf("failed to decode response body, %w", err), 9172 Snapshot: snapshot.Bytes(), 9173 } 9174 } 9175 9176 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9177 t, err = decoder.GetElement("Error") 9178 if err != nil { 9179 var snapshot bytes.Buffer 9180 io.Copy(&snapshot, ringBuffer) 9181 return &smithy.DeserializationError{ 9182 Err: fmt.Errorf("failed to decode response body, %w", err), 9183 Snapshot: snapshot.Bytes(), 9184 } 9185 } 9186 9187 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9188 err = awsAwsquery_deserializeDocumentKMSKeyNotAccessibleFault(&output, decoder) 9189 if err != nil { 9190 var snapshot bytes.Buffer 9191 io.Copy(&snapshot, ringBuffer) 9192 return &smithy.DeserializationError{ 9193 Err: fmt.Errorf("failed to decode response body, %w", err), 9194 Snapshot: snapshot.Bytes(), 9195 } 9196 } 9197 9198 return output 9199} 9200 9201func awsAwsquery_deserializeErrorOptionGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9202 output := &types.OptionGroupNotFoundFault{} 9203 var buff [1024]byte 9204 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9205 body := io.TeeReader(errorBody, ringBuffer) 9206 rootDecoder := xml.NewDecoder(body) 9207 t, err := smithyxml.FetchRootElement(rootDecoder) 9208 if err == io.EOF { 9209 return output 9210 } 9211 if err != nil { 9212 var snapshot bytes.Buffer 9213 io.Copy(&snapshot, ringBuffer) 9214 return &smithy.DeserializationError{ 9215 Err: fmt.Errorf("failed to decode response body, %w", err), 9216 Snapshot: snapshot.Bytes(), 9217 } 9218 } 9219 9220 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9221 t, err = decoder.GetElement("Error") 9222 if err != nil { 9223 var snapshot bytes.Buffer 9224 io.Copy(&snapshot, ringBuffer) 9225 return &smithy.DeserializationError{ 9226 Err: fmt.Errorf("failed to decode response body, %w", err), 9227 Snapshot: snapshot.Bytes(), 9228 } 9229 } 9230 9231 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9232 err = awsAwsquery_deserializeDocumentOptionGroupNotFoundFault(&output, decoder) 9233 if err != nil { 9234 var snapshot bytes.Buffer 9235 io.Copy(&snapshot, ringBuffer) 9236 return &smithy.DeserializationError{ 9237 Err: fmt.Errorf("failed to decode response body, %w", err), 9238 Snapshot: snapshot.Bytes(), 9239 } 9240 } 9241 9242 return output 9243} 9244 9245func awsAwsquery_deserializeErrorProvisionedIopsNotAvailableInAZFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9246 output := &types.ProvisionedIopsNotAvailableInAZFault{} 9247 var buff [1024]byte 9248 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9249 body := io.TeeReader(errorBody, ringBuffer) 9250 rootDecoder := xml.NewDecoder(body) 9251 t, err := smithyxml.FetchRootElement(rootDecoder) 9252 if err == io.EOF { 9253 return output 9254 } 9255 if err != nil { 9256 var snapshot bytes.Buffer 9257 io.Copy(&snapshot, ringBuffer) 9258 return &smithy.DeserializationError{ 9259 Err: fmt.Errorf("failed to decode response body, %w", err), 9260 Snapshot: snapshot.Bytes(), 9261 } 9262 } 9263 9264 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9265 t, err = decoder.GetElement("Error") 9266 if err != nil { 9267 var snapshot bytes.Buffer 9268 io.Copy(&snapshot, ringBuffer) 9269 return &smithy.DeserializationError{ 9270 Err: fmt.Errorf("failed to decode response body, %w", err), 9271 Snapshot: snapshot.Bytes(), 9272 } 9273 } 9274 9275 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9276 err = awsAwsquery_deserializeDocumentProvisionedIopsNotAvailableInAZFault(&output, decoder) 9277 if err != nil { 9278 var snapshot bytes.Buffer 9279 io.Copy(&snapshot, ringBuffer) 9280 return &smithy.DeserializationError{ 9281 Err: fmt.Errorf("failed to decode response body, %w", err), 9282 Snapshot: snapshot.Bytes(), 9283 } 9284 } 9285 9286 return output 9287} 9288 9289func awsAwsquery_deserializeErrorResourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9290 output := &types.ResourceNotFoundFault{} 9291 var buff [1024]byte 9292 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9293 body := io.TeeReader(errorBody, ringBuffer) 9294 rootDecoder := xml.NewDecoder(body) 9295 t, err := smithyxml.FetchRootElement(rootDecoder) 9296 if err == io.EOF { 9297 return output 9298 } 9299 if err != nil { 9300 var snapshot bytes.Buffer 9301 io.Copy(&snapshot, ringBuffer) 9302 return &smithy.DeserializationError{ 9303 Err: fmt.Errorf("failed to decode response body, %w", err), 9304 Snapshot: snapshot.Bytes(), 9305 } 9306 } 9307 9308 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9309 t, err = decoder.GetElement("Error") 9310 if err != nil { 9311 var snapshot bytes.Buffer 9312 io.Copy(&snapshot, ringBuffer) 9313 return &smithy.DeserializationError{ 9314 Err: fmt.Errorf("failed to decode response body, %w", err), 9315 Snapshot: snapshot.Bytes(), 9316 } 9317 } 9318 9319 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9320 err = awsAwsquery_deserializeDocumentResourceNotFoundFault(&output, decoder) 9321 if err != nil { 9322 var snapshot bytes.Buffer 9323 io.Copy(&snapshot, ringBuffer) 9324 return &smithy.DeserializationError{ 9325 Err: fmt.Errorf("failed to decode response body, %w", err), 9326 Snapshot: snapshot.Bytes(), 9327 } 9328 } 9329 9330 return output 9331} 9332 9333func awsAwsquery_deserializeErrorSharedSnapshotQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9334 output := &types.SharedSnapshotQuotaExceededFault{} 9335 var buff [1024]byte 9336 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9337 body := io.TeeReader(errorBody, ringBuffer) 9338 rootDecoder := xml.NewDecoder(body) 9339 t, err := smithyxml.FetchRootElement(rootDecoder) 9340 if err == io.EOF { 9341 return output 9342 } 9343 if err != nil { 9344 var snapshot bytes.Buffer 9345 io.Copy(&snapshot, ringBuffer) 9346 return &smithy.DeserializationError{ 9347 Err: fmt.Errorf("failed to decode response body, %w", err), 9348 Snapshot: snapshot.Bytes(), 9349 } 9350 } 9351 9352 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9353 t, err = decoder.GetElement("Error") 9354 if err != nil { 9355 var snapshot bytes.Buffer 9356 io.Copy(&snapshot, ringBuffer) 9357 return &smithy.DeserializationError{ 9358 Err: fmt.Errorf("failed to decode response body, %w", err), 9359 Snapshot: snapshot.Bytes(), 9360 } 9361 } 9362 9363 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9364 err = awsAwsquery_deserializeDocumentSharedSnapshotQuotaExceededFault(&output, decoder) 9365 if err != nil { 9366 var snapshot bytes.Buffer 9367 io.Copy(&snapshot, ringBuffer) 9368 return &smithy.DeserializationError{ 9369 Err: fmt.Errorf("failed to decode response body, %w", err), 9370 Snapshot: snapshot.Bytes(), 9371 } 9372 } 9373 9374 return output 9375} 9376 9377func awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9378 output := &types.SnapshotQuotaExceededFault{} 9379 var buff [1024]byte 9380 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9381 body := io.TeeReader(errorBody, ringBuffer) 9382 rootDecoder := xml.NewDecoder(body) 9383 t, err := smithyxml.FetchRootElement(rootDecoder) 9384 if err == io.EOF { 9385 return output 9386 } 9387 if err != nil { 9388 var snapshot bytes.Buffer 9389 io.Copy(&snapshot, ringBuffer) 9390 return &smithy.DeserializationError{ 9391 Err: fmt.Errorf("failed to decode response body, %w", err), 9392 Snapshot: snapshot.Bytes(), 9393 } 9394 } 9395 9396 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9397 t, err = decoder.GetElement("Error") 9398 if err != nil { 9399 var snapshot bytes.Buffer 9400 io.Copy(&snapshot, ringBuffer) 9401 return &smithy.DeserializationError{ 9402 Err: fmt.Errorf("failed to decode response body, %w", err), 9403 Snapshot: snapshot.Bytes(), 9404 } 9405 } 9406 9407 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9408 err = awsAwsquery_deserializeDocumentSnapshotQuotaExceededFault(&output, decoder) 9409 if err != nil { 9410 var snapshot bytes.Buffer 9411 io.Copy(&snapshot, ringBuffer) 9412 return &smithy.DeserializationError{ 9413 Err: fmt.Errorf("failed to decode response body, %w", err), 9414 Snapshot: snapshot.Bytes(), 9415 } 9416 } 9417 9418 return output 9419} 9420 9421func awsAwsquery_deserializeErrorSNSInvalidTopicFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9422 output := &types.SNSInvalidTopicFault{} 9423 var buff [1024]byte 9424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9425 body := io.TeeReader(errorBody, ringBuffer) 9426 rootDecoder := xml.NewDecoder(body) 9427 t, err := smithyxml.FetchRootElement(rootDecoder) 9428 if err == io.EOF { 9429 return output 9430 } 9431 if err != nil { 9432 var snapshot bytes.Buffer 9433 io.Copy(&snapshot, ringBuffer) 9434 return &smithy.DeserializationError{ 9435 Err: fmt.Errorf("failed to decode response body, %w", err), 9436 Snapshot: snapshot.Bytes(), 9437 } 9438 } 9439 9440 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9441 t, err = decoder.GetElement("Error") 9442 if err != nil { 9443 var snapshot bytes.Buffer 9444 io.Copy(&snapshot, ringBuffer) 9445 return &smithy.DeserializationError{ 9446 Err: fmt.Errorf("failed to decode response body, %w", err), 9447 Snapshot: snapshot.Bytes(), 9448 } 9449 } 9450 9451 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9452 err = awsAwsquery_deserializeDocumentSNSInvalidTopicFault(&output, decoder) 9453 if err != nil { 9454 var snapshot bytes.Buffer 9455 io.Copy(&snapshot, ringBuffer) 9456 return &smithy.DeserializationError{ 9457 Err: fmt.Errorf("failed to decode response body, %w", err), 9458 Snapshot: snapshot.Bytes(), 9459 } 9460 } 9461 9462 return output 9463} 9464 9465func awsAwsquery_deserializeErrorSNSNoAuthorizationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9466 output := &types.SNSNoAuthorizationFault{} 9467 var buff [1024]byte 9468 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9469 body := io.TeeReader(errorBody, ringBuffer) 9470 rootDecoder := xml.NewDecoder(body) 9471 t, err := smithyxml.FetchRootElement(rootDecoder) 9472 if err == io.EOF { 9473 return output 9474 } 9475 if err != nil { 9476 var snapshot bytes.Buffer 9477 io.Copy(&snapshot, ringBuffer) 9478 return &smithy.DeserializationError{ 9479 Err: fmt.Errorf("failed to decode response body, %w", err), 9480 Snapshot: snapshot.Bytes(), 9481 } 9482 } 9483 9484 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9485 t, err = decoder.GetElement("Error") 9486 if err != nil { 9487 var snapshot bytes.Buffer 9488 io.Copy(&snapshot, ringBuffer) 9489 return &smithy.DeserializationError{ 9490 Err: fmt.Errorf("failed to decode response body, %w", err), 9491 Snapshot: snapshot.Bytes(), 9492 } 9493 } 9494 9495 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9496 err = awsAwsquery_deserializeDocumentSNSNoAuthorizationFault(&output, decoder) 9497 if err != nil { 9498 var snapshot bytes.Buffer 9499 io.Copy(&snapshot, ringBuffer) 9500 return &smithy.DeserializationError{ 9501 Err: fmt.Errorf("failed to decode response body, %w", err), 9502 Snapshot: snapshot.Bytes(), 9503 } 9504 } 9505 9506 return output 9507} 9508 9509func awsAwsquery_deserializeErrorSNSTopicArnNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9510 output := &types.SNSTopicArnNotFoundFault{} 9511 var buff [1024]byte 9512 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9513 body := io.TeeReader(errorBody, ringBuffer) 9514 rootDecoder := xml.NewDecoder(body) 9515 t, err := smithyxml.FetchRootElement(rootDecoder) 9516 if err == io.EOF { 9517 return output 9518 } 9519 if err != nil { 9520 var snapshot bytes.Buffer 9521 io.Copy(&snapshot, ringBuffer) 9522 return &smithy.DeserializationError{ 9523 Err: fmt.Errorf("failed to decode response body, %w", err), 9524 Snapshot: snapshot.Bytes(), 9525 } 9526 } 9527 9528 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9529 t, err = decoder.GetElement("Error") 9530 if err != nil { 9531 var snapshot bytes.Buffer 9532 io.Copy(&snapshot, ringBuffer) 9533 return &smithy.DeserializationError{ 9534 Err: fmt.Errorf("failed to decode response body, %w", err), 9535 Snapshot: snapshot.Bytes(), 9536 } 9537 } 9538 9539 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9540 err = awsAwsquery_deserializeDocumentSNSTopicArnNotFoundFault(&output, decoder) 9541 if err != nil { 9542 var snapshot bytes.Buffer 9543 io.Copy(&snapshot, ringBuffer) 9544 return &smithy.DeserializationError{ 9545 Err: fmt.Errorf("failed to decode response body, %w", err), 9546 Snapshot: snapshot.Bytes(), 9547 } 9548 } 9549 9550 return output 9551} 9552 9553func awsAwsquery_deserializeErrorSourceNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9554 output := &types.SourceNotFoundFault{} 9555 var buff [1024]byte 9556 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9557 body := io.TeeReader(errorBody, ringBuffer) 9558 rootDecoder := xml.NewDecoder(body) 9559 t, err := smithyxml.FetchRootElement(rootDecoder) 9560 if err == io.EOF { 9561 return output 9562 } 9563 if err != nil { 9564 var snapshot bytes.Buffer 9565 io.Copy(&snapshot, ringBuffer) 9566 return &smithy.DeserializationError{ 9567 Err: fmt.Errorf("failed to decode response body, %w", err), 9568 Snapshot: snapshot.Bytes(), 9569 } 9570 } 9571 9572 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9573 t, err = decoder.GetElement("Error") 9574 if err != nil { 9575 var snapshot bytes.Buffer 9576 io.Copy(&snapshot, ringBuffer) 9577 return &smithy.DeserializationError{ 9578 Err: fmt.Errorf("failed to decode response body, %w", err), 9579 Snapshot: snapshot.Bytes(), 9580 } 9581 } 9582 9583 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9584 err = awsAwsquery_deserializeDocumentSourceNotFoundFault(&output, decoder) 9585 if err != nil { 9586 var snapshot bytes.Buffer 9587 io.Copy(&snapshot, ringBuffer) 9588 return &smithy.DeserializationError{ 9589 Err: fmt.Errorf("failed to decode response body, %w", err), 9590 Snapshot: snapshot.Bytes(), 9591 } 9592 } 9593 9594 return output 9595} 9596 9597func awsAwsquery_deserializeErrorStorageQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9598 output := &types.StorageQuotaExceededFault{} 9599 var buff [1024]byte 9600 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9601 body := io.TeeReader(errorBody, ringBuffer) 9602 rootDecoder := xml.NewDecoder(body) 9603 t, err := smithyxml.FetchRootElement(rootDecoder) 9604 if err == io.EOF { 9605 return output 9606 } 9607 if err != nil { 9608 var snapshot bytes.Buffer 9609 io.Copy(&snapshot, ringBuffer) 9610 return &smithy.DeserializationError{ 9611 Err: fmt.Errorf("failed to decode response body, %w", err), 9612 Snapshot: snapshot.Bytes(), 9613 } 9614 } 9615 9616 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9617 t, err = decoder.GetElement("Error") 9618 if err != nil { 9619 var snapshot bytes.Buffer 9620 io.Copy(&snapshot, ringBuffer) 9621 return &smithy.DeserializationError{ 9622 Err: fmt.Errorf("failed to decode response body, %w", err), 9623 Snapshot: snapshot.Bytes(), 9624 } 9625 } 9626 9627 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9628 err = awsAwsquery_deserializeDocumentStorageQuotaExceededFault(&output, decoder) 9629 if err != nil { 9630 var snapshot bytes.Buffer 9631 io.Copy(&snapshot, ringBuffer) 9632 return &smithy.DeserializationError{ 9633 Err: fmt.Errorf("failed to decode response body, %w", err), 9634 Snapshot: snapshot.Bytes(), 9635 } 9636 } 9637 9638 return output 9639} 9640 9641func awsAwsquery_deserializeErrorStorageTypeNotSupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9642 output := &types.StorageTypeNotSupportedFault{} 9643 var buff [1024]byte 9644 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9645 body := io.TeeReader(errorBody, ringBuffer) 9646 rootDecoder := xml.NewDecoder(body) 9647 t, err := smithyxml.FetchRootElement(rootDecoder) 9648 if err == io.EOF { 9649 return output 9650 } 9651 if err != nil { 9652 var snapshot bytes.Buffer 9653 io.Copy(&snapshot, ringBuffer) 9654 return &smithy.DeserializationError{ 9655 Err: fmt.Errorf("failed to decode response body, %w", err), 9656 Snapshot: snapshot.Bytes(), 9657 } 9658 } 9659 9660 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9661 t, err = decoder.GetElement("Error") 9662 if err != nil { 9663 var snapshot bytes.Buffer 9664 io.Copy(&snapshot, ringBuffer) 9665 return &smithy.DeserializationError{ 9666 Err: fmt.Errorf("failed to decode response body, %w", err), 9667 Snapshot: snapshot.Bytes(), 9668 } 9669 } 9670 9671 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9672 err = awsAwsquery_deserializeDocumentStorageTypeNotSupportedFault(&output, decoder) 9673 if err != nil { 9674 var snapshot bytes.Buffer 9675 io.Copy(&snapshot, ringBuffer) 9676 return &smithy.DeserializationError{ 9677 Err: fmt.Errorf("failed to decode response body, %w", err), 9678 Snapshot: snapshot.Bytes(), 9679 } 9680 } 9681 9682 return output 9683} 9684 9685func awsAwsquery_deserializeErrorSubnetAlreadyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9686 output := &types.SubnetAlreadyInUse{} 9687 var buff [1024]byte 9688 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9689 body := io.TeeReader(errorBody, ringBuffer) 9690 rootDecoder := xml.NewDecoder(body) 9691 t, err := smithyxml.FetchRootElement(rootDecoder) 9692 if err == io.EOF { 9693 return output 9694 } 9695 if err != nil { 9696 var snapshot bytes.Buffer 9697 io.Copy(&snapshot, ringBuffer) 9698 return &smithy.DeserializationError{ 9699 Err: fmt.Errorf("failed to decode response body, %w", err), 9700 Snapshot: snapshot.Bytes(), 9701 } 9702 } 9703 9704 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9705 t, err = decoder.GetElement("Error") 9706 if err != nil { 9707 var snapshot bytes.Buffer 9708 io.Copy(&snapshot, ringBuffer) 9709 return &smithy.DeserializationError{ 9710 Err: fmt.Errorf("failed to decode response body, %w", err), 9711 Snapshot: snapshot.Bytes(), 9712 } 9713 } 9714 9715 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9716 err = awsAwsquery_deserializeDocumentSubnetAlreadyInUse(&output, decoder) 9717 if err != nil { 9718 var snapshot bytes.Buffer 9719 io.Copy(&snapshot, ringBuffer) 9720 return &smithy.DeserializationError{ 9721 Err: fmt.Errorf("failed to decode response body, %w", err), 9722 Snapshot: snapshot.Bytes(), 9723 } 9724 } 9725 9726 return output 9727} 9728 9729func awsAwsquery_deserializeErrorSubscriptionAlreadyExistFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9730 output := &types.SubscriptionAlreadyExistFault{} 9731 var buff [1024]byte 9732 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9733 body := io.TeeReader(errorBody, ringBuffer) 9734 rootDecoder := xml.NewDecoder(body) 9735 t, err := smithyxml.FetchRootElement(rootDecoder) 9736 if err == io.EOF { 9737 return output 9738 } 9739 if err != nil { 9740 var snapshot bytes.Buffer 9741 io.Copy(&snapshot, ringBuffer) 9742 return &smithy.DeserializationError{ 9743 Err: fmt.Errorf("failed to decode response body, %w", err), 9744 Snapshot: snapshot.Bytes(), 9745 } 9746 } 9747 9748 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9749 t, err = decoder.GetElement("Error") 9750 if err != nil { 9751 var snapshot bytes.Buffer 9752 io.Copy(&snapshot, ringBuffer) 9753 return &smithy.DeserializationError{ 9754 Err: fmt.Errorf("failed to decode response body, %w", err), 9755 Snapshot: snapshot.Bytes(), 9756 } 9757 } 9758 9759 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9760 err = awsAwsquery_deserializeDocumentSubscriptionAlreadyExistFault(&output, decoder) 9761 if err != nil { 9762 var snapshot bytes.Buffer 9763 io.Copy(&snapshot, ringBuffer) 9764 return &smithy.DeserializationError{ 9765 Err: fmt.Errorf("failed to decode response body, %w", err), 9766 Snapshot: snapshot.Bytes(), 9767 } 9768 } 9769 9770 return output 9771} 9772 9773func awsAwsquery_deserializeErrorSubscriptionCategoryNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9774 output := &types.SubscriptionCategoryNotFoundFault{} 9775 var buff [1024]byte 9776 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9777 body := io.TeeReader(errorBody, ringBuffer) 9778 rootDecoder := xml.NewDecoder(body) 9779 t, err := smithyxml.FetchRootElement(rootDecoder) 9780 if err == io.EOF { 9781 return output 9782 } 9783 if err != nil { 9784 var snapshot bytes.Buffer 9785 io.Copy(&snapshot, ringBuffer) 9786 return &smithy.DeserializationError{ 9787 Err: fmt.Errorf("failed to decode response body, %w", err), 9788 Snapshot: snapshot.Bytes(), 9789 } 9790 } 9791 9792 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9793 t, err = decoder.GetElement("Error") 9794 if err != nil { 9795 var snapshot bytes.Buffer 9796 io.Copy(&snapshot, ringBuffer) 9797 return &smithy.DeserializationError{ 9798 Err: fmt.Errorf("failed to decode response body, %w", err), 9799 Snapshot: snapshot.Bytes(), 9800 } 9801 } 9802 9803 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9804 err = awsAwsquery_deserializeDocumentSubscriptionCategoryNotFoundFault(&output, decoder) 9805 if err != nil { 9806 var snapshot bytes.Buffer 9807 io.Copy(&snapshot, ringBuffer) 9808 return &smithy.DeserializationError{ 9809 Err: fmt.Errorf("failed to decode response body, %w", err), 9810 Snapshot: snapshot.Bytes(), 9811 } 9812 } 9813 9814 return output 9815} 9816 9817func awsAwsquery_deserializeErrorSubscriptionNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 9818 output := &types.SubscriptionNotFoundFault{} 9819 var buff [1024]byte 9820 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9821 body := io.TeeReader(errorBody, ringBuffer) 9822 rootDecoder := xml.NewDecoder(body) 9823 t, err := smithyxml.FetchRootElement(rootDecoder) 9824 if err == io.EOF { 9825 return output 9826 } 9827 if err != nil { 9828 var snapshot bytes.Buffer 9829 io.Copy(&snapshot, ringBuffer) 9830 return &smithy.DeserializationError{ 9831 Err: fmt.Errorf("failed to decode response body, %w", err), 9832 Snapshot: snapshot.Bytes(), 9833 } 9834 } 9835 9836 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 9837 t, err = decoder.GetElement("Error") 9838 if err != nil { 9839 var snapshot bytes.Buffer 9840 io.Copy(&snapshot, ringBuffer) 9841 return &smithy.DeserializationError{ 9842 Err: fmt.Errorf("failed to decode response body, %w", err), 9843 Snapshot: snapshot.Bytes(), 9844 } 9845 } 9846 9847 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9848 err = awsAwsquery_deserializeDocumentSubscriptionNotFoundFault(&output, decoder) 9849 if err != nil { 9850 var snapshot bytes.Buffer 9851 io.Copy(&snapshot, ringBuffer) 9852 return &smithy.DeserializationError{ 9853 Err: fmt.Errorf("failed to decode response body, %w", err), 9854 Snapshot: snapshot.Bytes(), 9855 } 9856 } 9857 9858 return output 9859} 9860 9861func awsAwsquery_deserializeDocumentAttributeValueList(v *[]string, decoder smithyxml.NodeDecoder) error { 9862 if v == nil { 9863 return fmt.Errorf("unexpected nil of type %T", v) 9864 } 9865 var sv []string 9866 if *v == nil { 9867 sv = make([]string, 0) 9868 } else { 9869 sv = *v 9870 } 9871 9872 originalDecoder := decoder 9873 for { 9874 t, done, err := decoder.Token() 9875 if err != nil { 9876 return err 9877 } 9878 if done { 9879 break 9880 } 9881 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9882 decoder = memberDecoder 9883 switch { 9884 case strings.EqualFold("AttributeValue", t.Name.Local): 9885 var col string 9886 val, err := decoder.Value() 9887 if err != nil { 9888 return err 9889 } 9890 if val == nil { 9891 break 9892 } 9893 { 9894 xtv := string(val) 9895 col = xtv 9896 } 9897 sv = append(sv, col) 9898 9899 default: 9900 err = decoder.Decoder.Skip() 9901 if err != nil { 9902 return err 9903 } 9904 9905 } 9906 decoder = originalDecoder 9907 } 9908 *v = sv 9909 return nil 9910} 9911 9912func awsAwsquery_deserializeDocumentAttributeValueListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 9913 var sv []string 9914 if *v == nil { 9915 sv = make([]string, 0) 9916 } else { 9917 sv = *v 9918 } 9919 9920 switch { 9921 default: 9922 var mv string 9923 t := decoder.StartEl 9924 _ = t 9925 val, err := decoder.Value() 9926 if err != nil { 9927 return err 9928 } 9929 if val == nil { 9930 break 9931 } 9932 { 9933 xtv := string(val) 9934 mv = xtv 9935 } 9936 sv = append(sv, mv) 9937 } 9938 *v = sv 9939 return nil 9940} 9941func awsAwsquery_deserializeDocumentAuthorizationNotFoundFault(v **types.AuthorizationNotFoundFault, decoder smithyxml.NodeDecoder) error { 9942 if v == nil { 9943 return fmt.Errorf("unexpected nil of type %T", v) 9944 } 9945 var sv *types.AuthorizationNotFoundFault 9946 if *v == nil { 9947 sv = &types.AuthorizationNotFoundFault{} 9948 } else { 9949 sv = *v 9950 } 9951 9952 for { 9953 t, done, err := decoder.Token() 9954 if err != nil { 9955 return err 9956 } 9957 if done { 9958 break 9959 } 9960 originalDecoder := decoder 9961 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 9962 switch { 9963 case strings.EqualFold("message", t.Name.Local): 9964 val, err := decoder.Value() 9965 if err != nil { 9966 return err 9967 } 9968 if val == nil { 9969 break 9970 } 9971 { 9972 xtv := string(val) 9973 sv.Message = ptr.String(xtv) 9974 } 9975 9976 default: 9977 // Do nothing and ignore the unexpected tag element 9978 err = decoder.Decoder.Skip() 9979 if err != nil { 9980 return err 9981 } 9982 9983 } 9984 decoder = originalDecoder 9985 } 9986 *v = sv 9987 return nil 9988} 9989 9990func awsAwsquery_deserializeDocumentAvailabilityZone(v **types.AvailabilityZone, decoder smithyxml.NodeDecoder) error { 9991 if v == nil { 9992 return fmt.Errorf("unexpected nil of type %T", v) 9993 } 9994 var sv *types.AvailabilityZone 9995 if *v == nil { 9996 sv = &types.AvailabilityZone{} 9997 } else { 9998 sv = *v 9999 } 10000 10001 for { 10002 t, done, err := decoder.Token() 10003 if err != nil { 10004 return err 10005 } 10006 if done { 10007 break 10008 } 10009 originalDecoder := decoder 10010 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10011 switch { 10012 case strings.EqualFold("Name", t.Name.Local): 10013 val, err := decoder.Value() 10014 if err != nil { 10015 return err 10016 } 10017 if val == nil { 10018 break 10019 } 10020 { 10021 xtv := string(val) 10022 sv.Name = ptr.String(xtv) 10023 } 10024 10025 default: 10026 // Do nothing and ignore the unexpected tag element 10027 err = decoder.Decoder.Skip() 10028 if err != nil { 10029 return err 10030 } 10031 10032 } 10033 decoder = originalDecoder 10034 } 10035 *v = sv 10036 return nil 10037} 10038 10039func awsAwsquery_deserializeDocumentAvailabilityZoneList(v *[]types.AvailabilityZone, decoder smithyxml.NodeDecoder) error { 10040 if v == nil { 10041 return fmt.Errorf("unexpected nil of type %T", v) 10042 } 10043 var sv []types.AvailabilityZone 10044 if *v == nil { 10045 sv = make([]types.AvailabilityZone, 0) 10046 } else { 10047 sv = *v 10048 } 10049 10050 originalDecoder := decoder 10051 for { 10052 t, done, err := decoder.Token() 10053 if err != nil { 10054 return err 10055 } 10056 if done { 10057 break 10058 } 10059 switch { 10060 case strings.EqualFold("AvailabilityZone", t.Name.Local): 10061 var col types.AvailabilityZone 10062 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10063 destAddr := &col 10064 if err := awsAwsquery_deserializeDocumentAvailabilityZone(&destAddr, nodeDecoder); err != nil { 10065 return err 10066 } 10067 col = *destAddr 10068 sv = append(sv, col) 10069 10070 default: 10071 err = decoder.Decoder.Skip() 10072 if err != nil { 10073 return err 10074 } 10075 10076 } 10077 decoder = originalDecoder 10078 } 10079 *v = sv 10080 return nil 10081} 10082 10083func awsAwsquery_deserializeDocumentAvailabilityZoneListUnwrapped(v *[]types.AvailabilityZone, decoder smithyxml.NodeDecoder) error { 10084 var sv []types.AvailabilityZone 10085 if *v == nil { 10086 sv = make([]types.AvailabilityZone, 0) 10087 } else { 10088 sv = *v 10089 } 10090 10091 switch { 10092 default: 10093 var mv types.AvailabilityZone 10094 t := decoder.StartEl 10095 _ = t 10096 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10097 destAddr := &mv 10098 if err := awsAwsquery_deserializeDocumentAvailabilityZone(&destAddr, nodeDecoder); err != nil { 10099 return err 10100 } 10101 mv = *destAddr 10102 sv = append(sv, mv) 10103 } 10104 *v = sv 10105 return nil 10106} 10107func awsAwsquery_deserializeDocumentAvailabilityZones(v *[]string, decoder smithyxml.NodeDecoder) error { 10108 if v == nil { 10109 return fmt.Errorf("unexpected nil of type %T", v) 10110 } 10111 var sv []string 10112 if *v == nil { 10113 sv = make([]string, 0) 10114 } else { 10115 sv = *v 10116 } 10117 10118 originalDecoder := decoder 10119 for { 10120 t, done, err := decoder.Token() 10121 if err != nil { 10122 return err 10123 } 10124 if done { 10125 break 10126 } 10127 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10128 decoder = memberDecoder 10129 switch { 10130 case strings.EqualFold("AvailabilityZone", t.Name.Local): 10131 var col string 10132 val, err := decoder.Value() 10133 if err != nil { 10134 return err 10135 } 10136 if val == nil { 10137 break 10138 } 10139 { 10140 xtv := string(val) 10141 col = xtv 10142 } 10143 sv = append(sv, col) 10144 10145 default: 10146 err = decoder.Decoder.Skip() 10147 if err != nil { 10148 return err 10149 } 10150 10151 } 10152 decoder = originalDecoder 10153 } 10154 *v = sv 10155 return nil 10156} 10157 10158func awsAwsquery_deserializeDocumentAvailabilityZonesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 10159 var sv []string 10160 if *v == nil { 10161 sv = make([]string, 0) 10162 } else { 10163 sv = *v 10164 } 10165 10166 switch { 10167 default: 10168 var mv string 10169 t := decoder.StartEl 10170 _ = t 10171 val, err := decoder.Value() 10172 if err != nil { 10173 return err 10174 } 10175 if val == nil { 10176 break 10177 } 10178 { 10179 xtv := string(val) 10180 mv = xtv 10181 } 10182 sv = append(sv, mv) 10183 } 10184 *v = sv 10185 return nil 10186} 10187func awsAwsquery_deserializeDocumentCertificateNotFoundFault(v **types.CertificateNotFoundFault, decoder smithyxml.NodeDecoder) error { 10188 if v == nil { 10189 return fmt.Errorf("unexpected nil of type %T", v) 10190 } 10191 var sv *types.CertificateNotFoundFault 10192 if *v == nil { 10193 sv = &types.CertificateNotFoundFault{} 10194 } else { 10195 sv = *v 10196 } 10197 10198 for { 10199 t, done, err := decoder.Token() 10200 if err != nil { 10201 return err 10202 } 10203 if done { 10204 break 10205 } 10206 originalDecoder := decoder 10207 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10208 switch { 10209 case strings.EqualFold("message", t.Name.Local): 10210 val, err := decoder.Value() 10211 if err != nil { 10212 return err 10213 } 10214 if val == nil { 10215 break 10216 } 10217 { 10218 xtv := string(val) 10219 sv.Message = ptr.String(xtv) 10220 } 10221 10222 default: 10223 // Do nothing and ignore the unexpected tag element 10224 err = decoder.Decoder.Skip() 10225 if err != nil { 10226 return err 10227 } 10228 10229 } 10230 decoder = originalDecoder 10231 } 10232 *v = sv 10233 return nil 10234} 10235 10236func awsAwsquery_deserializeDocumentCharacterSet(v **types.CharacterSet, decoder smithyxml.NodeDecoder) error { 10237 if v == nil { 10238 return fmt.Errorf("unexpected nil of type %T", v) 10239 } 10240 var sv *types.CharacterSet 10241 if *v == nil { 10242 sv = &types.CharacterSet{} 10243 } else { 10244 sv = *v 10245 } 10246 10247 for { 10248 t, done, err := decoder.Token() 10249 if err != nil { 10250 return err 10251 } 10252 if done { 10253 break 10254 } 10255 originalDecoder := decoder 10256 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10257 switch { 10258 case strings.EqualFold("CharacterSetDescription", t.Name.Local): 10259 val, err := decoder.Value() 10260 if err != nil { 10261 return err 10262 } 10263 if val == nil { 10264 break 10265 } 10266 { 10267 xtv := string(val) 10268 sv.CharacterSetDescription = ptr.String(xtv) 10269 } 10270 10271 case strings.EqualFold("CharacterSetName", t.Name.Local): 10272 val, err := decoder.Value() 10273 if err != nil { 10274 return err 10275 } 10276 if val == nil { 10277 break 10278 } 10279 { 10280 xtv := string(val) 10281 sv.CharacterSetName = ptr.String(xtv) 10282 } 10283 10284 default: 10285 // Do nothing and ignore the unexpected tag element 10286 err = decoder.Decoder.Skip() 10287 if err != nil { 10288 return err 10289 } 10290 10291 } 10292 decoder = originalDecoder 10293 } 10294 *v = sv 10295 return nil 10296} 10297 10298func awsAwsquery_deserializeDocumentDBCluster(v **types.DBCluster, decoder smithyxml.NodeDecoder) error { 10299 if v == nil { 10300 return fmt.Errorf("unexpected nil of type %T", v) 10301 } 10302 var sv *types.DBCluster 10303 if *v == nil { 10304 sv = &types.DBCluster{} 10305 } else { 10306 sv = *v 10307 } 10308 10309 for { 10310 t, done, err := decoder.Token() 10311 if err != nil { 10312 return err 10313 } 10314 if done { 10315 break 10316 } 10317 originalDecoder := decoder 10318 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10319 switch { 10320 case strings.EqualFold("AllocatedStorage", t.Name.Local): 10321 val, err := decoder.Value() 10322 if err != nil { 10323 return err 10324 } 10325 if val == nil { 10326 break 10327 } 10328 { 10329 xtv := string(val) 10330 i64, err := strconv.ParseInt(xtv, 10, 64) 10331 if err != nil { 10332 return err 10333 } 10334 sv.AllocatedStorage = ptr.Int32(int32(i64)) 10335 } 10336 10337 case strings.EqualFold("AssociatedRoles", t.Name.Local): 10338 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10339 if err := awsAwsquery_deserializeDocumentDBClusterRoles(&sv.AssociatedRoles, nodeDecoder); err != nil { 10340 return err 10341 } 10342 10343 case strings.EqualFold("AvailabilityZones", t.Name.Local): 10344 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10345 if err := awsAwsquery_deserializeDocumentAvailabilityZones(&sv.AvailabilityZones, nodeDecoder); err != nil { 10346 return err 10347 } 10348 10349 case strings.EqualFold("BackupRetentionPeriod", t.Name.Local): 10350 val, err := decoder.Value() 10351 if err != nil { 10352 return err 10353 } 10354 if val == nil { 10355 break 10356 } 10357 { 10358 xtv := string(val) 10359 i64, err := strconv.ParseInt(xtv, 10, 64) 10360 if err != nil { 10361 return err 10362 } 10363 sv.BackupRetentionPeriod = ptr.Int32(int32(i64)) 10364 } 10365 10366 case strings.EqualFold("CharacterSetName", t.Name.Local): 10367 val, err := decoder.Value() 10368 if err != nil { 10369 return err 10370 } 10371 if val == nil { 10372 break 10373 } 10374 { 10375 xtv := string(val) 10376 sv.CharacterSetName = ptr.String(xtv) 10377 } 10378 10379 case strings.EqualFold("CloneGroupId", t.Name.Local): 10380 val, err := decoder.Value() 10381 if err != nil { 10382 return err 10383 } 10384 if val == nil { 10385 break 10386 } 10387 { 10388 xtv := string(val) 10389 sv.CloneGroupId = ptr.String(xtv) 10390 } 10391 10392 case strings.EqualFold("ClusterCreateTime", t.Name.Local): 10393 val, err := decoder.Value() 10394 if err != nil { 10395 return err 10396 } 10397 if val == nil { 10398 break 10399 } 10400 { 10401 xtv := string(val) 10402 t, err := smithytime.ParseDateTime(xtv) 10403 if err != nil { 10404 return err 10405 } 10406 sv.ClusterCreateTime = ptr.Time(t) 10407 } 10408 10409 case strings.EqualFold("DatabaseName", t.Name.Local): 10410 val, err := decoder.Value() 10411 if err != nil { 10412 return err 10413 } 10414 if val == nil { 10415 break 10416 } 10417 { 10418 xtv := string(val) 10419 sv.DatabaseName = ptr.String(xtv) 10420 } 10421 10422 case strings.EqualFold("DBClusterArn", t.Name.Local): 10423 val, err := decoder.Value() 10424 if err != nil { 10425 return err 10426 } 10427 if val == nil { 10428 break 10429 } 10430 { 10431 xtv := string(val) 10432 sv.DBClusterArn = ptr.String(xtv) 10433 } 10434 10435 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 10436 val, err := decoder.Value() 10437 if err != nil { 10438 return err 10439 } 10440 if val == nil { 10441 break 10442 } 10443 { 10444 xtv := string(val) 10445 sv.DBClusterIdentifier = ptr.String(xtv) 10446 } 10447 10448 case strings.EqualFold("DBClusterMembers", t.Name.Local): 10449 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10450 if err := awsAwsquery_deserializeDocumentDBClusterMemberList(&sv.DBClusterMembers, nodeDecoder); err != nil { 10451 return err 10452 } 10453 10454 case strings.EqualFold("DBClusterOptionGroupMemberships", t.Name.Local): 10455 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10456 if err := awsAwsquery_deserializeDocumentDBClusterOptionGroupMemberships(&sv.DBClusterOptionGroupMemberships, nodeDecoder); err != nil { 10457 return err 10458 } 10459 10460 case strings.EqualFold("DBClusterParameterGroup", t.Name.Local): 10461 val, err := decoder.Value() 10462 if err != nil { 10463 return err 10464 } 10465 if val == nil { 10466 break 10467 } 10468 { 10469 xtv := string(val) 10470 sv.DBClusterParameterGroup = ptr.String(xtv) 10471 } 10472 10473 case strings.EqualFold("DbClusterResourceId", t.Name.Local): 10474 val, err := decoder.Value() 10475 if err != nil { 10476 return err 10477 } 10478 if val == nil { 10479 break 10480 } 10481 { 10482 xtv := string(val) 10483 sv.DbClusterResourceId = ptr.String(xtv) 10484 } 10485 10486 case strings.EqualFold("DBSubnetGroup", t.Name.Local): 10487 val, err := decoder.Value() 10488 if err != nil { 10489 return err 10490 } 10491 if val == nil { 10492 break 10493 } 10494 { 10495 xtv := string(val) 10496 sv.DBSubnetGroup = ptr.String(xtv) 10497 } 10498 10499 case strings.EqualFold("DeletionProtection", t.Name.Local): 10500 val, err := decoder.Value() 10501 if err != nil { 10502 return err 10503 } 10504 if val == nil { 10505 break 10506 } 10507 { 10508 xtv, err := strconv.ParseBool(string(val)) 10509 if err != nil { 10510 return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) 10511 } 10512 sv.DeletionProtection = ptr.Bool(xtv) 10513 } 10514 10515 case strings.EqualFold("EarliestRestorableTime", t.Name.Local): 10516 val, err := decoder.Value() 10517 if err != nil { 10518 return err 10519 } 10520 if val == nil { 10521 break 10522 } 10523 { 10524 xtv := string(val) 10525 t, err := smithytime.ParseDateTime(xtv) 10526 if err != nil { 10527 return err 10528 } 10529 sv.EarliestRestorableTime = ptr.Time(t) 10530 } 10531 10532 case strings.EqualFold("EnabledCloudwatchLogsExports", t.Name.Local): 10533 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10534 if err := awsAwsquery_deserializeDocumentLogTypeList(&sv.EnabledCloudwatchLogsExports, nodeDecoder); err != nil { 10535 return err 10536 } 10537 10538 case strings.EqualFold("Endpoint", t.Name.Local): 10539 val, err := decoder.Value() 10540 if err != nil { 10541 return err 10542 } 10543 if val == nil { 10544 break 10545 } 10546 { 10547 xtv := string(val) 10548 sv.Endpoint = ptr.String(xtv) 10549 } 10550 10551 case strings.EqualFold("Engine", t.Name.Local): 10552 val, err := decoder.Value() 10553 if err != nil { 10554 return err 10555 } 10556 if val == nil { 10557 break 10558 } 10559 { 10560 xtv := string(val) 10561 sv.Engine = ptr.String(xtv) 10562 } 10563 10564 case strings.EqualFold("EngineVersion", t.Name.Local): 10565 val, err := decoder.Value() 10566 if err != nil { 10567 return err 10568 } 10569 if val == nil { 10570 break 10571 } 10572 { 10573 xtv := string(val) 10574 sv.EngineVersion = ptr.String(xtv) 10575 } 10576 10577 case strings.EqualFold("HostedZoneId", t.Name.Local): 10578 val, err := decoder.Value() 10579 if err != nil { 10580 return err 10581 } 10582 if val == nil { 10583 break 10584 } 10585 { 10586 xtv := string(val) 10587 sv.HostedZoneId = ptr.String(xtv) 10588 } 10589 10590 case strings.EqualFold("IAMDatabaseAuthenticationEnabled", t.Name.Local): 10591 val, err := decoder.Value() 10592 if err != nil { 10593 return err 10594 } 10595 if val == nil { 10596 break 10597 } 10598 { 10599 xtv, err := strconv.ParseBool(string(val)) 10600 if err != nil { 10601 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 10602 } 10603 sv.IAMDatabaseAuthenticationEnabled = xtv 10604 } 10605 10606 case strings.EqualFold("KmsKeyId", t.Name.Local): 10607 val, err := decoder.Value() 10608 if err != nil { 10609 return err 10610 } 10611 if val == nil { 10612 break 10613 } 10614 { 10615 xtv := string(val) 10616 sv.KmsKeyId = ptr.String(xtv) 10617 } 10618 10619 case strings.EqualFold("LatestRestorableTime", t.Name.Local): 10620 val, err := decoder.Value() 10621 if err != nil { 10622 return err 10623 } 10624 if val == nil { 10625 break 10626 } 10627 { 10628 xtv := string(val) 10629 t, err := smithytime.ParseDateTime(xtv) 10630 if err != nil { 10631 return err 10632 } 10633 sv.LatestRestorableTime = ptr.Time(t) 10634 } 10635 10636 case strings.EqualFold("MasterUsername", t.Name.Local): 10637 val, err := decoder.Value() 10638 if err != nil { 10639 return err 10640 } 10641 if val == nil { 10642 break 10643 } 10644 { 10645 xtv := string(val) 10646 sv.MasterUsername = ptr.String(xtv) 10647 } 10648 10649 case strings.EqualFold("MultiAZ", t.Name.Local): 10650 val, err := decoder.Value() 10651 if err != nil { 10652 return err 10653 } 10654 if val == nil { 10655 break 10656 } 10657 { 10658 xtv, err := strconv.ParseBool(string(val)) 10659 if err != nil { 10660 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 10661 } 10662 sv.MultiAZ = xtv 10663 } 10664 10665 case strings.EqualFold("PercentProgress", t.Name.Local): 10666 val, err := decoder.Value() 10667 if err != nil { 10668 return err 10669 } 10670 if val == nil { 10671 break 10672 } 10673 { 10674 xtv := string(val) 10675 sv.PercentProgress = ptr.String(xtv) 10676 } 10677 10678 case strings.EqualFold("Port", t.Name.Local): 10679 val, err := decoder.Value() 10680 if err != nil { 10681 return err 10682 } 10683 if val == nil { 10684 break 10685 } 10686 { 10687 xtv := string(val) 10688 i64, err := strconv.ParseInt(xtv, 10, 64) 10689 if err != nil { 10690 return err 10691 } 10692 sv.Port = ptr.Int32(int32(i64)) 10693 } 10694 10695 case strings.EqualFold("PreferredBackupWindow", t.Name.Local): 10696 val, err := decoder.Value() 10697 if err != nil { 10698 return err 10699 } 10700 if val == nil { 10701 break 10702 } 10703 { 10704 xtv := string(val) 10705 sv.PreferredBackupWindow = ptr.String(xtv) 10706 } 10707 10708 case strings.EqualFold("PreferredMaintenanceWindow", t.Name.Local): 10709 val, err := decoder.Value() 10710 if err != nil { 10711 return err 10712 } 10713 if val == nil { 10714 break 10715 } 10716 { 10717 xtv := string(val) 10718 sv.PreferredMaintenanceWindow = ptr.String(xtv) 10719 } 10720 10721 case strings.EqualFold("ReaderEndpoint", t.Name.Local): 10722 val, err := decoder.Value() 10723 if err != nil { 10724 return err 10725 } 10726 if val == nil { 10727 break 10728 } 10729 { 10730 xtv := string(val) 10731 sv.ReaderEndpoint = ptr.String(xtv) 10732 } 10733 10734 case strings.EqualFold("ReadReplicaIdentifiers", t.Name.Local): 10735 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10736 if err := awsAwsquery_deserializeDocumentReadReplicaIdentifierList(&sv.ReadReplicaIdentifiers, nodeDecoder); err != nil { 10737 return err 10738 } 10739 10740 case strings.EqualFold("ReplicationSourceIdentifier", t.Name.Local): 10741 val, err := decoder.Value() 10742 if err != nil { 10743 return err 10744 } 10745 if val == nil { 10746 break 10747 } 10748 { 10749 xtv := string(val) 10750 sv.ReplicationSourceIdentifier = ptr.String(xtv) 10751 } 10752 10753 case strings.EqualFold("Status", t.Name.Local): 10754 val, err := decoder.Value() 10755 if err != nil { 10756 return err 10757 } 10758 if val == nil { 10759 break 10760 } 10761 { 10762 xtv := string(val) 10763 sv.Status = ptr.String(xtv) 10764 } 10765 10766 case strings.EqualFold("StorageEncrypted", t.Name.Local): 10767 val, err := decoder.Value() 10768 if err != nil { 10769 return err 10770 } 10771 if val == nil { 10772 break 10773 } 10774 { 10775 xtv, err := strconv.ParseBool(string(val)) 10776 if err != nil { 10777 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 10778 } 10779 sv.StorageEncrypted = xtv 10780 } 10781 10782 case strings.EqualFold("VpcSecurityGroups", t.Name.Local): 10783 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10784 if err := awsAwsquery_deserializeDocumentVpcSecurityGroupMembershipList(&sv.VpcSecurityGroups, nodeDecoder); err != nil { 10785 return err 10786 } 10787 10788 default: 10789 // Do nothing and ignore the unexpected tag element 10790 err = decoder.Decoder.Skip() 10791 if err != nil { 10792 return err 10793 } 10794 10795 } 10796 decoder = originalDecoder 10797 } 10798 *v = sv 10799 return nil 10800} 10801 10802func awsAwsquery_deserializeDocumentDBClusterAlreadyExistsFault(v **types.DBClusterAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 10803 if v == nil { 10804 return fmt.Errorf("unexpected nil of type %T", v) 10805 } 10806 var sv *types.DBClusterAlreadyExistsFault 10807 if *v == nil { 10808 sv = &types.DBClusterAlreadyExistsFault{} 10809 } else { 10810 sv = *v 10811 } 10812 10813 for { 10814 t, done, err := decoder.Token() 10815 if err != nil { 10816 return err 10817 } 10818 if done { 10819 break 10820 } 10821 originalDecoder := decoder 10822 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10823 switch { 10824 case strings.EqualFold("message", t.Name.Local): 10825 val, err := decoder.Value() 10826 if err != nil { 10827 return err 10828 } 10829 if val == nil { 10830 break 10831 } 10832 { 10833 xtv := string(val) 10834 sv.Message = ptr.String(xtv) 10835 } 10836 10837 default: 10838 // Do nothing and ignore the unexpected tag element 10839 err = decoder.Decoder.Skip() 10840 if err != nil { 10841 return err 10842 } 10843 10844 } 10845 decoder = originalDecoder 10846 } 10847 *v = sv 10848 return nil 10849} 10850 10851func awsAwsquery_deserializeDocumentDBClusterEndpoint(v **types.DBClusterEndpoint, decoder smithyxml.NodeDecoder) error { 10852 if v == nil { 10853 return fmt.Errorf("unexpected nil of type %T", v) 10854 } 10855 var sv *types.DBClusterEndpoint 10856 if *v == nil { 10857 sv = &types.DBClusterEndpoint{} 10858 } else { 10859 sv = *v 10860 } 10861 10862 for { 10863 t, done, err := decoder.Token() 10864 if err != nil { 10865 return err 10866 } 10867 if done { 10868 break 10869 } 10870 originalDecoder := decoder 10871 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 10872 switch { 10873 case strings.EqualFold("CustomEndpointType", t.Name.Local): 10874 val, err := decoder.Value() 10875 if err != nil { 10876 return err 10877 } 10878 if val == nil { 10879 break 10880 } 10881 { 10882 xtv := string(val) 10883 sv.CustomEndpointType = ptr.String(xtv) 10884 } 10885 10886 case strings.EqualFold("DBClusterEndpointArn", t.Name.Local): 10887 val, err := decoder.Value() 10888 if err != nil { 10889 return err 10890 } 10891 if val == nil { 10892 break 10893 } 10894 { 10895 xtv := string(val) 10896 sv.DBClusterEndpointArn = ptr.String(xtv) 10897 } 10898 10899 case strings.EqualFold("DBClusterEndpointIdentifier", t.Name.Local): 10900 val, err := decoder.Value() 10901 if err != nil { 10902 return err 10903 } 10904 if val == nil { 10905 break 10906 } 10907 { 10908 xtv := string(val) 10909 sv.DBClusterEndpointIdentifier = ptr.String(xtv) 10910 } 10911 10912 case strings.EqualFold("DBClusterEndpointResourceIdentifier", t.Name.Local): 10913 val, err := decoder.Value() 10914 if err != nil { 10915 return err 10916 } 10917 if val == nil { 10918 break 10919 } 10920 { 10921 xtv := string(val) 10922 sv.DBClusterEndpointResourceIdentifier = ptr.String(xtv) 10923 } 10924 10925 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 10926 val, err := decoder.Value() 10927 if err != nil { 10928 return err 10929 } 10930 if val == nil { 10931 break 10932 } 10933 { 10934 xtv := string(val) 10935 sv.DBClusterIdentifier = ptr.String(xtv) 10936 } 10937 10938 case strings.EqualFold("Endpoint", t.Name.Local): 10939 val, err := decoder.Value() 10940 if err != nil { 10941 return err 10942 } 10943 if val == nil { 10944 break 10945 } 10946 { 10947 xtv := string(val) 10948 sv.Endpoint = ptr.String(xtv) 10949 } 10950 10951 case strings.EqualFold("EndpointType", t.Name.Local): 10952 val, err := decoder.Value() 10953 if err != nil { 10954 return err 10955 } 10956 if val == nil { 10957 break 10958 } 10959 { 10960 xtv := string(val) 10961 sv.EndpointType = ptr.String(xtv) 10962 } 10963 10964 case strings.EqualFold("ExcludedMembers", t.Name.Local): 10965 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10966 if err := awsAwsquery_deserializeDocumentStringList(&sv.ExcludedMembers, nodeDecoder); err != nil { 10967 return err 10968 } 10969 10970 case strings.EqualFold("StaticMembers", t.Name.Local): 10971 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 10972 if err := awsAwsquery_deserializeDocumentStringList(&sv.StaticMembers, nodeDecoder); err != nil { 10973 return err 10974 } 10975 10976 case strings.EqualFold("Status", t.Name.Local): 10977 val, err := decoder.Value() 10978 if err != nil { 10979 return err 10980 } 10981 if val == nil { 10982 break 10983 } 10984 { 10985 xtv := string(val) 10986 sv.Status = ptr.String(xtv) 10987 } 10988 10989 default: 10990 // Do nothing and ignore the unexpected tag element 10991 err = decoder.Decoder.Skip() 10992 if err != nil { 10993 return err 10994 } 10995 10996 } 10997 decoder = originalDecoder 10998 } 10999 *v = sv 11000 return nil 11001} 11002 11003func awsAwsquery_deserializeDocumentDBClusterEndpointAlreadyExistsFault(v **types.DBClusterEndpointAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 11004 if v == nil { 11005 return fmt.Errorf("unexpected nil of type %T", v) 11006 } 11007 var sv *types.DBClusterEndpointAlreadyExistsFault 11008 if *v == nil { 11009 sv = &types.DBClusterEndpointAlreadyExistsFault{} 11010 } else { 11011 sv = *v 11012 } 11013 11014 for { 11015 t, done, err := decoder.Token() 11016 if err != nil { 11017 return err 11018 } 11019 if done { 11020 break 11021 } 11022 originalDecoder := decoder 11023 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11024 switch { 11025 case strings.EqualFold("message", t.Name.Local): 11026 val, err := decoder.Value() 11027 if err != nil { 11028 return err 11029 } 11030 if val == nil { 11031 break 11032 } 11033 { 11034 xtv := string(val) 11035 sv.Message = ptr.String(xtv) 11036 } 11037 11038 default: 11039 // Do nothing and ignore the unexpected tag element 11040 err = decoder.Decoder.Skip() 11041 if err != nil { 11042 return err 11043 } 11044 11045 } 11046 decoder = originalDecoder 11047 } 11048 *v = sv 11049 return nil 11050} 11051 11052func awsAwsquery_deserializeDocumentDBClusterEndpointList(v *[]types.DBClusterEndpoint, decoder smithyxml.NodeDecoder) error { 11053 if v == nil { 11054 return fmt.Errorf("unexpected nil of type %T", v) 11055 } 11056 var sv []types.DBClusterEndpoint 11057 if *v == nil { 11058 sv = make([]types.DBClusterEndpoint, 0) 11059 } else { 11060 sv = *v 11061 } 11062 11063 originalDecoder := decoder 11064 for { 11065 t, done, err := decoder.Token() 11066 if err != nil { 11067 return err 11068 } 11069 if done { 11070 break 11071 } 11072 switch { 11073 case strings.EqualFold("DBClusterEndpointList", t.Name.Local): 11074 var col types.DBClusterEndpoint 11075 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11076 destAddr := &col 11077 if err := awsAwsquery_deserializeDocumentDBClusterEndpoint(&destAddr, nodeDecoder); err != nil { 11078 return err 11079 } 11080 col = *destAddr 11081 sv = append(sv, col) 11082 11083 default: 11084 err = decoder.Decoder.Skip() 11085 if err != nil { 11086 return err 11087 } 11088 11089 } 11090 decoder = originalDecoder 11091 } 11092 *v = sv 11093 return nil 11094} 11095 11096func awsAwsquery_deserializeDocumentDBClusterEndpointListUnwrapped(v *[]types.DBClusterEndpoint, decoder smithyxml.NodeDecoder) error { 11097 var sv []types.DBClusterEndpoint 11098 if *v == nil { 11099 sv = make([]types.DBClusterEndpoint, 0) 11100 } else { 11101 sv = *v 11102 } 11103 11104 switch { 11105 default: 11106 var mv types.DBClusterEndpoint 11107 t := decoder.StartEl 11108 _ = t 11109 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11110 destAddr := &mv 11111 if err := awsAwsquery_deserializeDocumentDBClusterEndpoint(&destAddr, nodeDecoder); err != nil { 11112 return err 11113 } 11114 mv = *destAddr 11115 sv = append(sv, mv) 11116 } 11117 *v = sv 11118 return nil 11119} 11120func awsAwsquery_deserializeDocumentDBClusterEndpointNotFoundFault(v **types.DBClusterEndpointNotFoundFault, decoder smithyxml.NodeDecoder) error { 11121 if v == nil { 11122 return fmt.Errorf("unexpected nil of type %T", v) 11123 } 11124 var sv *types.DBClusterEndpointNotFoundFault 11125 if *v == nil { 11126 sv = &types.DBClusterEndpointNotFoundFault{} 11127 } else { 11128 sv = *v 11129 } 11130 11131 for { 11132 t, done, err := decoder.Token() 11133 if err != nil { 11134 return err 11135 } 11136 if done { 11137 break 11138 } 11139 originalDecoder := decoder 11140 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11141 switch { 11142 case strings.EqualFold("message", t.Name.Local): 11143 val, err := decoder.Value() 11144 if err != nil { 11145 return err 11146 } 11147 if val == nil { 11148 break 11149 } 11150 { 11151 xtv := string(val) 11152 sv.Message = ptr.String(xtv) 11153 } 11154 11155 default: 11156 // Do nothing and ignore the unexpected tag element 11157 err = decoder.Decoder.Skip() 11158 if err != nil { 11159 return err 11160 } 11161 11162 } 11163 decoder = originalDecoder 11164 } 11165 *v = sv 11166 return nil 11167} 11168 11169func awsAwsquery_deserializeDocumentDBClusterEndpointQuotaExceededFault(v **types.DBClusterEndpointQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 11170 if v == nil { 11171 return fmt.Errorf("unexpected nil of type %T", v) 11172 } 11173 var sv *types.DBClusterEndpointQuotaExceededFault 11174 if *v == nil { 11175 sv = &types.DBClusterEndpointQuotaExceededFault{} 11176 } else { 11177 sv = *v 11178 } 11179 11180 for { 11181 t, done, err := decoder.Token() 11182 if err != nil { 11183 return err 11184 } 11185 if done { 11186 break 11187 } 11188 originalDecoder := decoder 11189 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11190 switch { 11191 case strings.EqualFold("message", t.Name.Local): 11192 val, err := decoder.Value() 11193 if err != nil { 11194 return err 11195 } 11196 if val == nil { 11197 break 11198 } 11199 { 11200 xtv := string(val) 11201 sv.Message = ptr.String(xtv) 11202 } 11203 11204 default: 11205 // Do nothing and ignore the unexpected tag element 11206 err = decoder.Decoder.Skip() 11207 if err != nil { 11208 return err 11209 } 11210 11211 } 11212 decoder = originalDecoder 11213 } 11214 *v = sv 11215 return nil 11216} 11217 11218func awsAwsquery_deserializeDocumentDBClusterList(v *[]types.DBCluster, decoder smithyxml.NodeDecoder) error { 11219 if v == nil { 11220 return fmt.Errorf("unexpected nil of type %T", v) 11221 } 11222 var sv []types.DBCluster 11223 if *v == nil { 11224 sv = make([]types.DBCluster, 0) 11225 } else { 11226 sv = *v 11227 } 11228 11229 originalDecoder := decoder 11230 for { 11231 t, done, err := decoder.Token() 11232 if err != nil { 11233 return err 11234 } 11235 if done { 11236 break 11237 } 11238 switch { 11239 case strings.EqualFold("DBCluster", t.Name.Local): 11240 var col types.DBCluster 11241 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11242 destAddr := &col 11243 if err := awsAwsquery_deserializeDocumentDBCluster(&destAddr, nodeDecoder); err != nil { 11244 return err 11245 } 11246 col = *destAddr 11247 sv = append(sv, col) 11248 11249 default: 11250 err = decoder.Decoder.Skip() 11251 if err != nil { 11252 return err 11253 } 11254 11255 } 11256 decoder = originalDecoder 11257 } 11258 *v = sv 11259 return nil 11260} 11261 11262func awsAwsquery_deserializeDocumentDBClusterListUnwrapped(v *[]types.DBCluster, decoder smithyxml.NodeDecoder) error { 11263 var sv []types.DBCluster 11264 if *v == nil { 11265 sv = make([]types.DBCluster, 0) 11266 } else { 11267 sv = *v 11268 } 11269 11270 switch { 11271 default: 11272 var mv types.DBCluster 11273 t := decoder.StartEl 11274 _ = t 11275 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11276 destAddr := &mv 11277 if err := awsAwsquery_deserializeDocumentDBCluster(&destAddr, nodeDecoder); err != nil { 11278 return err 11279 } 11280 mv = *destAddr 11281 sv = append(sv, mv) 11282 } 11283 *v = sv 11284 return nil 11285} 11286func awsAwsquery_deserializeDocumentDBClusterMember(v **types.DBClusterMember, decoder smithyxml.NodeDecoder) error { 11287 if v == nil { 11288 return fmt.Errorf("unexpected nil of type %T", v) 11289 } 11290 var sv *types.DBClusterMember 11291 if *v == nil { 11292 sv = &types.DBClusterMember{} 11293 } else { 11294 sv = *v 11295 } 11296 11297 for { 11298 t, done, err := decoder.Token() 11299 if err != nil { 11300 return err 11301 } 11302 if done { 11303 break 11304 } 11305 originalDecoder := decoder 11306 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11307 switch { 11308 case strings.EqualFold("DBClusterParameterGroupStatus", t.Name.Local): 11309 val, err := decoder.Value() 11310 if err != nil { 11311 return err 11312 } 11313 if val == nil { 11314 break 11315 } 11316 { 11317 xtv := string(val) 11318 sv.DBClusterParameterGroupStatus = ptr.String(xtv) 11319 } 11320 11321 case strings.EqualFold("DBInstanceIdentifier", t.Name.Local): 11322 val, err := decoder.Value() 11323 if err != nil { 11324 return err 11325 } 11326 if val == nil { 11327 break 11328 } 11329 { 11330 xtv := string(val) 11331 sv.DBInstanceIdentifier = ptr.String(xtv) 11332 } 11333 11334 case strings.EqualFold("IsClusterWriter", t.Name.Local): 11335 val, err := decoder.Value() 11336 if err != nil { 11337 return err 11338 } 11339 if val == nil { 11340 break 11341 } 11342 { 11343 xtv, err := strconv.ParseBool(string(val)) 11344 if err != nil { 11345 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 11346 } 11347 sv.IsClusterWriter = xtv 11348 } 11349 11350 case strings.EqualFold("PromotionTier", t.Name.Local): 11351 val, err := decoder.Value() 11352 if err != nil { 11353 return err 11354 } 11355 if val == nil { 11356 break 11357 } 11358 { 11359 xtv := string(val) 11360 i64, err := strconv.ParseInt(xtv, 10, 64) 11361 if err != nil { 11362 return err 11363 } 11364 sv.PromotionTier = ptr.Int32(int32(i64)) 11365 } 11366 11367 default: 11368 // Do nothing and ignore the unexpected tag element 11369 err = decoder.Decoder.Skip() 11370 if err != nil { 11371 return err 11372 } 11373 11374 } 11375 decoder = originalDecoder 11376 } 11377 *v = sv 11378 return nil 11379} 11380 11381func awsAwsquery_deserializeDocumentDBClusterMemberList(v *[]types.DBClusterMember, decoder smithyxml.NodeDecoder) error { 11382 if v == nil { 11383 return fmt.Errorf("unexpected nil of type %T", v) 11384 } 11385 var sv []types.DBClusterMember 11386 if *v == nil { 11387 sv = make([]types.DBClusterMember, 0) 11388 } else { 11389 sv = *v 11390 } 11391 11392 originalDecoder := decoder 11393 for { 11394 t, done, err := decoder.Token() 11395 if err != nil { 11396 return err 11397 } 11398 if done { 11399 break 11400 } 11401 switch { 11402 case strings.EqualFold("DBClusterMember", t.Name.Local): 11403 var col types.DBClusterMember 11404 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11405 destAddr := &col 11406 if err := awsAwsquery_deserializeDocumentDBClusterMember(&destAddr, nodeDecoder); err != nil { 11407 return err 11408 } 11409 col = *destAddr 11410 sv = append(sv, col) 11411 11412 default: 11413 err = decoder.Decoder.Skip() 11414 if err != nil { 11415 return err 11416 } 11417 11418 } 11419 decoder = originalDecoder 11420 } 11421 *v = sv 11422 return nil 11423} 11424 11425func awsAwsquery_deserializeDocumentDBClusterMemberListUnwrapped(v *[]types.DBClusterMember, decoder smithyxml.NodeDecoder) error { 11426 var sv []types.DBClusterMember 11427 if *v == nil { 11428 sv = make([]types.DBClusterMember, 0) 11429 } else { 11430 sv = *v 11431 } 11432 11433 switch { 11434 default: 11435 var mv types.DBClusterMember 11436 t := decoder.StartEl 11437 _ = t 11438 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11439 destAddr := &mv 11440 if err := awsAwsquery_deserializeDocumentDBClusterMember(&destAddr, nodeDecoder); err != nil { 11441 return err 11442 } 11443 mv = *destAddr 11444 sv = append(sv, mv) 11445 } 11446 *v = sv 11447 return nil 11448} 11449func awsAwsquery_deserializeDocumentDBClusterNotFoundFault(v **types.DBClusterNotFoundFault, decoder smithyxml.NodeDecoder) error { 11450 if v == nil { 11451 return fmt.Errorf("unexpected nil of type %T", v) 11452 } 11453 var sv *types.DBClusterNotFoundFault 11454 if *v == nil { 11455 sv = &types.DBClusterNotFoundFault{} 11456 } else { 11457 sv = *v 11458 } 11459 11460 for { 11461 t, done, err := decoder.Token() 11462 if err != nil { 11463 return err 11464 } 11465 if done { 11466 break 11467 } 11468 originalDecoder := decoder 11469 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11470 switch { 11471 case strings.EqualFold("message", t.Name.Local): 11472 val, err := decoder.Value() 11473 if err != nil { 11474 return err 11475 } 11476 if val == nil { 11477 break 11478 } 11479 { 11480 xtv := string(val) 11481 sv.Message = ptr.String(xtv) 11482 } 11483 11484 default: 11485 // Do nothing and ignore the unexpected tag element 11486 err = decoder.Decoder.Skip() 11487 if err != nil { 11488 return err 11489 } 11490 11491 } 11492 decoder = originalDecoder 11493 } 11494 *v = sv 11495 return nil 11496} 11497 11498func awsAwsquery_deserializeDocumentDBClusterOptionGroupMemberships(v *[]types.DBClusterOptionGroupStatus, decoder smithyxml.NodeDecoder) error { 11499 if v == nil { 11500 return fmt.Errorf("unexpected nil of type %T", v) 11501 } 11502 var sv []types.DBClusterOptionGroupStatus 11503 if *v == nil { 11504 sv = make([]types.DBClusterOptionGroupStatus, 0) 11505 } else { 11506 sv = *v 11507 } 11508 11509 originalDecoder := decoder 11510 for { 11511 t, done, err := decoder.Token() 11512 if err != nil { 11513 return err 11514 } 11515 if done { 11516 break 11517 } 11518 switch { 11519 case strings.EqualFold("DBClusterOptionGroup", t.Name.Local): 11520 var col types.DBClusterOptionGroupStatus 11521 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11522 destAddr := &col 11523 if err := awsAwsquery_deserializeDocumentDBClusterOptionGroupStatus(&destAddr, nodeDecoder); err != nil { 11524 return err 11525 } 11526 col = *destAddr 11527 sv = append(sv, col) 11528 11529 default: 11530 err = decoder.Decoder.Skip() 11531 if err != nil { 11532 return err 11533 } 11534 11535 } 11536 decoder = originalDecoder 11537 } 11538 *v = sv 11539 return nil 11540} 11541 11542func awsAwsquery_deserializeDocumentDBClusterOptionGroupMembershipsUnwrapped(v *[]types.DBClusterOptionGroupStatus, decoder smithyxml.NodeDecoder) error { 11543 var sv []types.DBClusterOptionGroupStatus 11544 if *v == nil { 11545 sv = make([]types.DBClusterOptionGroupStatus, 0) 11546 } else { 11547 sv = *v 11548 } 11549 11550 switch { 11551 default: 11552 var mv types.DBClusterOptionGroupStatus 11553 t := decoder.StartEl 11554 _ = t 11555 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11556 destAddr := &mv 11557 if err := awsAwsquery_deserializeDocumentDBClusterOptionGroupStatus(&destAddr, nodeDecoder); err != nil { 11558 return err 11559 } 11560 mv = *destAddr 11561 sv = append(sv, mv) 11562 } 11563 *v = sv 11564 return nil 11565} 11566func awsAwsquery_deserializeDocumentDBClusterOptionGroupStatus(v **types.DBClusterOptionGroupStatus, decoder smithyxml.NodeDecoder) error { 11567 if v == nil { 11568 return fmt.Errorf("unexpected nil of type %T", v) 11569 } 11570 var sv *types.DBClusterOptionGroupStatus 11571 if *v == nil { 11572 sv = &types.DBClusterOptionGroupStatus{} 11573 } else { 11574 sv = *v 11575 } 11576 11577 for { 11578 t, done, err := decoder.Token() 11579 if err != nil { 11580 return err 11581 } 11582 if done { 11583 break 11584 } 11585 originalDecoder := decoder 11586 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11587 switch { 11588 case strings.EqualFold("DBClusterOptionGroupName", t.Name.Local): 11589 val, err := decoder.Value() 11590 if err != nil { 11591 return err 11592 } 11593 if val == nil { 11594 break 11595 } 11596 { 11597 xtv := string(val) 11598 sv.DBClusterOptionGroupName = ptr.String(xtv) 11599 } 11600 11601 case strings.EqualFold("Status", t.Name.Local): 11602 val, err := decoder.Value() 11603 if err != nil { 11604 return err 11605 } 11606 if val == nil { 11607 break 11608 } 11609 { 11610 xtv := string(val) 11611 sv.Status = ptr.String(xtv) 11612 } 11613 11614 default: 11615 // Do nothing and ignore the unexpected tag element 11616 err = decoder.Decoder.Skip() 11617 if err != nil { 11618 return err 11619 } 11620 11621 } 11622 decoder = originalDecoder 11623 } 11624 *v = sv 11625 return nil 11626} 11627 11628func awsAwsquery_deserializeDocumentDBClusterParameterGroup(v **types.DBClusterParameterGroup, decoder smithyxml.NodeDecoder) error { 11629 if v == nil { 11630 return fmt.Errorf("unexpected nil of type %T", v) 11631 } 11632 var sv *types.DBClusterParameterGroup 11633 if *v == nil { 11634 sv = &types.DBClusterParameterGroup{} 11635 } else { 11636 sv = *v 11637 } 11638 11639 for { 11640 t, done, err := decoder.Token() 11641 if err != nil { 11642 return err 11643 } 11644 if done { 11645 break 11646 } 11647 originalDecoder := decoder 11648 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11649 switch { 11650 case strings.EqualFold("DBClusterParameterGroupArn", t.Name.Local): 11651 val, err := decoder.Value() 11652 if err != nil { 11653 return err 11654 } 11655 if val == nil { 11656 break 11657 } 11658 { 11659 xtv := string(val) 11660 sv.DBClusterParameterGroupArn = ptr.String(xtv) 11661 } 11662 11663 case strings.EqualFold("DBClusterParameterGroupName", t.Name.Local): 11664 val, err := decoder.Value() 11665 if err != nil { 11666 return err 11667 } 11668 if val == nil { 11669 break 11670 } 11671 { 11672 xtv := string(val) 11673 sv.DBClusterParameterGroupName = ptr.String(xtv) 11674 } 11675 11676 case strings.EqualFold("DBParameterGroupFamily", t.Name.Local): 11677 val, err := decoder.Value() 11678 if err != nil { 11679 return err 11680 } 11681 if val == nil { 11682 break 11683 } 11684 { 11685 xtv := string(val) 11686 sv.DBParameterGroupFamily = ptr.String(xtv) 11687 } 11688 11689 case strings.EqualFold("Description", t.Name.Local): 11690 val, err := decoder.Value() 11691 if err != nil { 11692 return err 11693 } 11694 if val == nil { 11695 break 11696 } 11697 { 11698 xtv := string(val) 11699 sv.Description = ptr.String(xtv) 11700 } 11701 11702 default: 11703 // Do nothing and ignore the unexpected tag element 11704 err = decoder.Decoder.Skip() 11705 if err != nil { 11706 return err 11707 } 11708 11709 } 11710 decoder = originalDecoder 11711 } 11712 *v = sv 11713 return nil 11714} 11715 11716func awsAwsquery_deserializeDocumentDBClusterParameterGroupList(v *[]types.DBClusterParameterGroup, decoder smithyxml.NodeDecoder) error { 11717 if v == nil { 11718 return fmt.Errorf("unexpected nil of type %T", v) 11719 } 11720 var sv []types.DBClusterParameterGroup 11721 if *v == nil { 11722 sv = make([]types.DBClusterParameterGroup, 0) 11723 } else { 11724 sv = *v 11725 } 11726 11727 originalDecoder := decoder 11728 for { 11729 t, done, err := decoder.Token() 11730 if err != nil { 11731 return err 11732 } 11733 if done { 11734 break 11735 } 11736 switch { 11737 case strings.EqualFold("DBClusterParameterGroup", t.Name.Local): 11738 var col types.DBClusterParameterGroup 11739 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11740 destAddr := &col 11741 if err := awsAwsquery_deserializeDocumentDBClusterParameterGroup(&destAddr, nodeDecoder); err != nil { 11742 return err 11743 } 11744 col = *destAddr 11745 sv = append(sv, col) 11746 11747 default: 11748 err = decoder.Decoder.Skip() 11749 if err != nil { 11750 return err 11751 } 11752 11753 } 11754 decoder = originalDecoder 11755 } 11756 *v = sv 11757 return nil 11758} 11759 11760func awsAwsquery_deserializeDocumentDBClusterParameterGroupListUnwrapped(v *[]types.DBClusterParameterGroup, decoder smithyxml.NodeDecoder) error { 11761 var sv []types.DBClusterParameterGroup 11762 if *v == nil { 11763 sv = make([]types.DBClusterParameterGroup, 0) 11764 } else { 11765 sv = *v 11766 } 11767 11768 switch { 11769 default: 11770 var mv types.DBClusterParameterGroup 11771 t := decoder.StartEl 11772 _ = t 11773 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11774 destAddr := &mv 11775 if err := awsAwsquery_deserializeDocumentDBClusterParameterGroup(&destAddr, nodeDecoder); err != nil { 11776 return err 11777 } 11778 mv = *destAddr 11779 sv = append(sv, mv) 11780 } 11781 *v = sv 11782 return nil 11783} 11784func awsAwsquery_deserializeDocumentDBClusterParameterGroupNotFoundFault(v **types.DBClusterParameterGroupNotFoundFault, decoder smithyxml.NodeDecoder) error { 11785 if v == nil { 11786 return fmt.Errorf("unexpected nil of type %T", v) 11787 } 11788 var sv *types.DBClusterParameterGroupNotFoundFault 11789 if *v == nil { 11790 sv = &types.DBClusterParameterGroupNotFoundFault{} 11791 } else { 11792 sv = *v 11793 } 11794 11795 for { 11796 t, done, err := decoder.Token() 11797 if err != nil { 11798 return err 11799 } 11800 if done { 11801 break 11802 } 11803 originalDecoder := decoder 11804 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11805 switch { 11806 case strings.EqualFold("message", t.Name.Local): 11807 val, err := decoder.Value() 11808 if err != nil { 11809 return err 11810 } 11811 if val == nil { 11812 break 11813 } 11814 { 11815 xtv := string(val) 11816 sv.Message = ptr.String(xtv) 11817 } 11818 11819 default: 11820 // Do nothing and ignore the unexpected tag element 11821 err = decoder.Decoder.Skip() 11822 if err != nil { 11823 return err 11824 } 11825 11826 } 11827 decoder = originalDecoder 11828 } 11829 *v = sv 11830 return nil 11831} 11832 11833func awsAwsquery_deserializeDocumentDBClusterQuotaExceededFault(v **types.DBClusterQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 11834 if v == nil { 11835 return fmt.Errorf("unexpected nil of type %T", v) 11836 } 11837 var sv *types.DBClusterQuotaExceededFault 11838 if *v == nil { 11839 sv = &types.DBClusterQuotaExceededFault{} 11840 } else { 11841 sv = *v 11842 } 11843 11844 for { 11845 t, done, err := decoder.Token() 11846 if err != nil { 11847 return err 11848 } 11849 if done { 11850 break 11851 } 11852 originalDecoder := decoder 11853 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11854 switch { 11855 case strings.EqualFold("message", t.Name.Local): 11856 val, err := decoder.Value() 11857 if err != nil { 11858 return err 11859 } 11860 if val == nil { 11861 break 11862 } 11863 { 11864 xtv := string(val) 11865 sv.Message = ptr.String(xtv) 11866 } 11867 11868 default: 11869 // Do nothing and ignore the unexpected tag element 11870 err = decoder.Decoder.Skip() 11871 if err != nil { 11872 return err 11873 } 11874 11875 } 11876 decoder = originalDecoder 11877 } 11878 *v = sv 11879 return nil 11880} 11881 11882func awsAwsquery_deserializeDocumentDBClusterRole(v **types.DBClusterRole, decoder smithyxml.NodeDecoder) error { 11883 if v == nil { 11884 return fmt.Errorf("unexpected nil of type %T", v) 11885 } 11886 var sv *types.DBClusterRole 11887 if *v == nil { 11888 sv = &types.DBClusterRole{} 11889 } else { 11890 sv = *v 11891 } 11892 11893 for { 11894 t, done, err := decoder.Token() 11895 if err != nil { 11896 return err 11897 } 11898 if done { 11899 break 11900 } 11901 originalDecoder := decoder 11902 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11903 switch { 11904 case strings.EqualFold("FeatureName", t.Name.Local): 11905 val, err := decoder.Value() 11906 if err != nil { 11907 return err 11908 } 11909 if val == nil { 11910 break 11911 } 11912 { 11913 xtv := string(val) 11914 sv.FeatureName = ptr.String(xtv) 11915 } 11916 11917 case strings.EqualFold("RoleArn", t.Name.Local): 11918 val, err := decoder.Value() 11919 if err != nil { 11920 return err 11921 } 11922 if val == nil { 11923 break 11924 } 11925 { 11926 xtv := string(val) 11927 sv.RoleArn = ptr.String(xtv) 11928 } 11929 11930 case strings.EqualFold("Status", t.Name.Local): 11931 val, err := decoder.Value() 11932 if err != nil { 11933 return err 11934 } 11935 if val == nil { 11936 break 11937 } 11938 { 11939 xtv := string(val) 11940 sv.Status = ptr.String(xtv) 11941 } 11942 11943 default: 11944 // Do nothing and ignore the unexpected tag element 11945 err = decoder.Decoder.Skip() 11946 if err != nil { 11947 return err 11948 } 11949 11950 } 11951 decoder = originalDecoder 11952 } 11953 *v = sv 11954 return nil 11955} 11956 11957func awsAwsquery_deserializeDocumentDBClusterRoleAlreadyExistsFault(v **types.DBClusterRoleAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 11958 if v == nil { 11959 return fmt.Errorf("unexpected nil of type %T", v) 11960 } 11961 var sv *types.DBClusterRoleAlreadyExistsFault 11962 if *v == nil { 11963 sv = &types.DBClusterRoleAlreadyExistsFault{} 11964 } else { 11965 sv = *v 11966 } 11967 11968 for { 11969 t, done, err := decoder.Token() 11970 if err != nil { 11971 return err 11972 } 11973 if done { 11974 break 11975 } 11976 originalDecoder := decoder 11977 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11978 switch { 11979 case strings.EqualFold("message", t.Name.Local): 11980 val, err := decoder.Value() 11981 if err != nil { 11982 return err 11983 } 11984 if val == nil { 11985 break 11986 } 11987 { 11988 xtv := string(val) 11989 sv.Message = ptr.String(xtv) 11990 } 11991 11992 default: 11993 // Do nothing and ignore the unexpected tag element 11994 err = decoder.Decoder.Skip() 11995 if err != nil { 11996 return err 11997 } 11998 11999 } 12000 decoder = originalDecoder 12001 } 12002 *v = sv 12003 return nil 12004} 12005 12006func awsAwsquery_deserializeDocumentDBClusterRoleNotFoundFault(v **types.DBClusterRoleNotFoundFault, decoder smithyxml.NodeDecoder) error { 12007 if v == nil { 12008 return fmt.Errorf("unexpected nil of type %T", v) 12009 } 12010 var sv *types.DBClusterRoleNotFoundFault 12011 if *v == nil { 12012 sv = &types.DBClusterRoleNotFoundFault{} 12013 } else { 12014 sv = *v 12015 } 12016 12017 for { 12018 t, done, err := decoder.Token() 12019 if err != nil { 12020 return err 12021 } 12022 if done { 12023 break 12024 } 12025 originalDecoder := decoder 12026 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12027 switch { 12028 case strings.EqualFold("message", t.Name.Local): 12029 val, err := decoder.Value() 12030 if err != nil { 12031 return err 12032 } 12033 if val == nil { 12034 break 12035 } 12036 { 12037 xtv := string(val) 12038 sv.Message = ptr.String(xtv) 12039 } 12040 12041 default: 12042 // Do nothing and ignore the unexpected tag element 12043 err = decoder.Decoder.Skip() 12044 if err != nil { 12045 return err 12046 } 12047 12048 } 12049 decoder = originalDecoder 12050 } 12051 *v = sv 12052 return nil 12053} 12054 12055func awsAwsquery_deserializeDocumentDBClusterRoleQuotaExceededFault(v **types.DBClusterRoleQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 12056 if v == nil { 12057 return fmt.Errorf("unexpected nil of type %T", v) 12058 } 12059 var sv *types.DBClusterRoleQuotaExceededFault 12060 if *v == nil { 12061 sv = &types.DBClusterRoleQuotaExceededFault{} 12062 } else { 12063 sv = *v 12064 } 12065 12066 for { 12067 t, done, err := decoder.Token() 12068 if err != nil { 12069 return err 12070 } 12071 if done { 12072 break 12073 } 12074 originalDecoder := decoder 12075 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12076 switch { 12077 case strings.EqualFold("message", t.Name.Local): 12078 val, err := decoder.Value() 12079 if err != nil { 12080 return err 12081 } 12082 if val == nil { 12083 break 12084 } 12085 { 12086 xtv := string(val) 12087 sv.Message = ptr.String(xtv) 12088 } 12089 12090 default: 12091 // Do nothing and ignore the unexpected tag element 12092 err = decoder.Decoder.Skip() 12093 if err != nil { 12094 return err 12095 } 12096 12097 } 12098 decoder = originalDecoder 12099 } 12100 *v = sv 12101 return nil 12102} 12103 12104func awsAwsquery_deserializeDocumentDBClusterRoles(v *[]types.DBClusterRole, decoder smithyxml.NodeDecoder) error { 12105 if v == nil { 12106 return fmt.Errorf("unexpected nil of type %T", v) 12107 } 12108 var sv []types.DBClusterRole 12109 if *v == nil { 12110 sv = make([]types.DBClusterRole, 0) 12111 } else { 12112 sv = *v 12113 } 12114 12115 originalDecoder := decoder 12116 for { 12117 t, done, err := decoder.Token() 12118 if err != nil { 12119 return err 12120 } 12121 if done { 12122 break 12123 } 12124 switch { 12125 case strings.EqualFold("DBClusterRole", t.Name.Local): 12126 var col types.DBClusterRole 12127 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12128 destAddr := &col 12129 if err := awsAwsquery_deserializeDocumentDBClusterRole(&destAddr, nodeDecoder); err != nil { 12130 return err 12131 } 12132 col = *destAddr 12133 sv = append(sv, col) 12134 12135 default: 12136 err = decoder.Decoder.Skip() 12137 if err != nil { 12138 return err 12139 } 12140 12141 } 12142 decoder = originalDecoder 12143 } 12144 *v = sv 12145 return nil 12146} 12147 12148func awsAwsquery_deserializeDocumentDBClusterRolesUnwrapped(v *[]types.DBClusterRole, decoder smithyxml.NodeDecoder) error { 12149 var sv []types.DBClusterRole 12150 if *v == nil { 12151 sv = make([]types.DBClusterRole, 0) 12152 } else { 12153 sv = *v 12154 } 12155 12156 switch { 12157 default: 12158 var mv types.DBClusterRole 12159 t := decoder.StartEl 12160 _ = t 12161 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12162 destAddr := &mv 12163 if err := awsAwsquery_deserializeDocumentDBClusterRole(&destAddr, nodeDecoder); err != nil { 12164 return err 12165 } 12166 mv = *destAddr 12167 sv = append(sv, mv) 12168 } 12169 *v = sv 12170 return nil 12171} 12172func awsAwsquery_deserializeDocumentDBClusterSnapshot(v **types.DBClusterSnapshot, decoder smithyxml.NodeDecoder) error { 12173 if v == nil { 12174 return fmt.Errorf("unexpected nil of type %T", v) 12175 } 12176 var sv *types.DBClusterSnapshot 12177 if *v == nil { 12178 sv = &types.DBClusterSnapshot{} 12179 } else { 12180 sv = *v 12181 } 12182 12183 for { 12184 t, done, err := decoder.Token() 12185 if err != nil { 12186 return err 12187 } 12188 if done { 12189 break 12190 } 12191 originalDecoder := decoder 12192 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12193 switch { 12194 case strings.EqualFold("AllocatedStorage", t.Name.Local): 12195 val, err := decoder.Value() 12196 if err != nil { 12197 return err 12198 } 12199 if val == nil { 12200 break 12201 } 12202 { 12203 xtv := string(val) 12204 i64, err := strconv.ParseInt(xtv, 10, 64) 12205 if err != nil { 12206 return err 12207 } 12208 sv.AllocatedStorage = int32(i64) 12209 } 12210 12211 case strings.EqualFold("AvailabilityZones", t.Name.Local): 12212 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12213 if err := awsAwsquery_deserializeDocumentAvailabilityZones(&sv.AvailabilityZones, nodeDecoder); err != nil { 12214 return err 12215 } 12216 12217 case strings.EqualFold("ClusterCreateTime", t.Name.Local): 12218 val, err := decoder.Value() 12219 if err != nil { 12220 return err 12221 } 12222 if val == nil { 12223 break 12224 } 12225 { 12226 xtv := string(val) 12227 t, err := smithytime.ParseDateTime(xtv) 12228 if err != nil { 12229 return err 12230 } 12231 sv.ClusterCreateTime = ptr.Time(t) 12232 } 12233 12234 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 12235 val, err := decoder.Value() 12236 if err != nil { 12237 return err 12238 } 12239 if val == nil { 12240 break 12241 } 12242 { 12243 xtv := string(val) 12244 sv.DBClusterIdentifier = ptr.String(xtv) 12245 } 12246 12247 case strings.EqualFold("DBClusterSnapshotArn", t.Name.Local): 12248 val, err := decoder.Value() 12249 if err != nil { 12250 return err 12251 } 12252 if val == nil { 12253 break 12254 } 12255 { 12256 xtv := string(val) 12257 sv.DBClusterSnapshotArn = ptr.String(xtv) 12258 } 12259 12260 case strings.EqualFold("DBClusterSnapshotIdentifier", t.Name.Local): 12261 val, err := decoder.Value() 12262 if err != nil { 12263 return err 12264 } 12265 if val == nil { 12266 break 12267 } 12268 { 12269 xtv := string(val) 12270 sv.DBClusterSnapshotIdentifier = ptr.String(xtv) 12271 } 12272 12273 case strings.EqualFold("Engine", t.Name.Local): 12274 val, err := decoder.Value() 12275 if err != nil { 12276 return err 12277 } 12278 if val == nil { 12279 break 12280 } 12281 { 12282 xtv := string(val) 12283 sv.Engine = ptr.String(xtv) 12284 } 12285 12286 case strings.EqualFold("EngineVersion", t.Name.Local): 12287 val, err := decoder.Value() 12288 if err != nil { 12289 return err 12290 } 12291 if val == nil { 12292 break 12293 } 12294 { 12295 xtv := string(val) 12296 sv.EngineVersion = ptr.String(xtv) 12297 } 12298 12299 case strings.EqualFold("IAMDatabaseAuthenticationEnabled", t.Name.Local): 12300 val, err := decoder.Value() 12301 if err != nil { 12302 return err 12303 } 12304 if val == nil { 12305 break 12306 } 12307 { 12308 xtv, err := strconv.ParseBool(string(val)) 12309 if err != nil { 12310 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 12311 } 12312 sv.IAMDatabaseAuthenticationEnabled = xtv 12313 } 12314 12315 case strings.EqualFold("KmsKeyId", t.Name.Local): 12316 val, err := decoder.Value() 12317 if err != nil { 12318 return err 12319 } 12320 if val == nil { 12321 break 12322 } 12323 { 12324 xtv := string(val) 12325 sv.KmsKeyId = ptr.String(xtv) 12326 } 12327 12328 case strings.EqualFold("LicenseModel", t.Name.Local): 12329 val, err := decoder.Value() 12330 if err != nil { 12331 return err 12332 } 12333 if val == nil { 12334 break 12335 } 12336 { 12337 xtv := string(val) 12338 sv.LicenseModel = ptr.String(xtv) 12339 } 12340 12341 case strings.EqualFold("MasterUsername", t.Name.Local): 12342 val, err := decoder.Value() 12343 if err != nil { 12344 return err 12345 } 12346 if val == nil { 12347 break 12348 } 12349 { 12350 xtv := string(val) 12351 sv.MasterUsername = ptr.String(xtv) 12352 } 12353 12354 case strings.EqualFold("PercentProgress", t.Name.Local): 12355 val, err := decoder.Value() 12356 if err != nil { 12357 return err 12358 } 12359 if val == nil { 12360 break 12361 } 12362 { 12363 xtv := string(val) 12364 i64, err := strconv.ParseInt(xtv, 10, 64) 12365 if err != nil { 12366 return err 12367 } 12368 sv.PercentProgress = int32(i64) 12369 } 12370 12371 case strings.EqualFold("Port", t.Name.Local): 12372 val, err := decoder.Value() 12373 if err != nil { 12374 return err 12375 } 12376 if val == nil { 12377 break 12378 } 12379 { 12380 xtv := string(val) 12381 i64, err := strconv.ParseInt(xtv, 10, 64) 12382 if err != nil { 12383 return err 12384 } 12385 sv.Port = int32(i64) 12386 } 12387 12388 case strings.EqualFold("SnapshotCreateTime", t.Name.Local): 12389 val, err := decoder.Value() 12390 if err != nil { 12391 return err 12392 } 12393 if val == nil { 12394 break 12395 } 12396 { 12397 xtv := string(val) 12398 t, err := smithytime.ParseDateTime(xtv) 12399 if err != nil { 12400 return err 12401 } 12402 sv.SnapshotCreateTime = ptr.Time(t) 12403 } 12404 12405 case strings.EqualFold("SnapshotType", t.Name.Local): 12406 val, err := decoder.Value() 12407 if err != nil { 12408 return err 12409 } 12410 if val == nil { 12411 break 12412 } 12413 { 12414 xtv := string(val) 12415 sv.SnapshotType = ptr.String(xtv) 12416 } 12417 12418 case strings.EqualFold("SourceDBClusterSnapshotArn", t.Name.Local): 12419 val, err := decoder.Value() 12420 if err != nil { 12421 return err 12422 } 12423 if val == nil { 12424 break 12425 } 12426 { 12427 xtv := string(val) 12428 sv.SourceDBClusterSnapshotArn = ptr.String(xtv) 12429 } 12430 12431 case strings.EqualFold("Status", t.Name.Local): 12432 val, err := decoder.Value() 12433 if err != nil { 12434 return err 12435 } 12436 if val == nil { 12437 break 12438 } 12439 { 12440 xtv := string(val) 12441 sv.Status = ptr.String(xtv) 12442 } 12443 12444 case strings.EqualFold("StorageEncrypted", t.Name.Local): 12445 val, err := decoder.Value() 12446 if err != nil { 12447 return err 12448 } 12449 if val == nil { 12450 break 12451 } 12452 { 12453 xtv, err := strconv.ParseBool(string(val)) 12454 if err != nil { 12455 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 12456 } 12457 sv.StorageEncrypted = xtv 12458 } 12459 12460 case strings.EqualFold("VpcId", t.Name.Local): 12461 val, err := decoder.Value() 12462 if err != nil { 12463 return err 12464 } 12465 if val == nil { 12466 break 12467 } 12468 { 12469 xtv := string(val) 12470 sv.VpcId = ptr.String(xtv) 12471 } 12472 12473 default: 12474 // Do nothing and ignore the unexpected tag element 12475 err = decoder.Decoder.Skip() 12476 if err != nil { 12477 return err 12478 } 12479 12480 } 12481 decoder = originalDecoder 12482 } 12483 *v = sv 12484 return nil 12485} 12486 12487func awsAwsquery_deserializeDocumentDBClusterSnapshotAlreadyExistsFault(v **types.DBClusterSnapshotAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 12488 if v == nil { 12489 return fmt.Errorf("unexpected nil of type %T", v) 12490 } 12491 var sv *types.DBClusterSnapshotAlreadyExistsFault 12492 if *v == nil { 12493 sv = &types.DBClusterSnapshotAlreadyExistsFault{} 12494 } else { 12495 sv = *v 12496 } 12497 12498 for { 12499 t, done, err := decoder.Token() 12500 if err != nil { 12501 return err 12502 } 12503 if done { 12504 break 12505 } 12506 originalDecoder := decoder 12507 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12508 switch { 12509 case strings.EqualFold("message", t.Name.Local): 12510 val, err := decoder.Value() 12511 if err != nil { 12512 return err 12513 } 12514 if val == nil { 12515 break 12516 } 12517 { 12518 xtv := string(val) 12519 sv.Message = ptr.String(xtv) 12520 } 12521 12522 default: 12523 // Do nothing and ignore the unexpected tag element 12524 err = decoder.Decoder.Skip() 12525 if err != nil { 12526 return err 12527 } 12528 12529 } 12530 decoder = originalDecoder 12531 } 12532 *v = sv 12533 return nil 12534} 12535 12536func awsAwsquery_deserializeDocumentDBClusterSnapshotAttribute(v **types.DBClusterSnapshotAttribute, decoder smithyxml.NodeDecoder) error { 12537 if v == nil { 12538 return fmt.Errorf("unexpected nil of type %T", v) 12539 } 12540 var sv *types.DBClusterSnapshotAttribute 12541 if *v == nil { 12542 sv = &types.DBClusterSnapshotAttribute{} 12543 } else { 12544 sv = *v 12545 } 12546 12547 for { 12548 t, done, err := decoder.Token() 12549 if err != nil { 12550 return err 12551 } 12552 if done { 12553 break 12554 } 12555 originalDecoder := decoder 12556 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12557 switch { 12558 case strings.EqualFold("AttributeName", t.Name.Local): 12559 val, err := decoder.Value() 12560 if err != nil { 12561 return err 12562 } 12563 if val == nil { 12564 break 12565 } 12566 { 12567 xtv := string(val) 12568 sv.AttributeName = ptr.String(xtv) 12569 } 12570 12571 case strings.EqualFold("AttributeValues", t.Name.Local): 12572 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12573 if err := awsAwsquery_deserializeDocumentAttributeValueList(&sv.AttributeValues, nodeDecoder); err != nil { 12574 return err 12575 } 12576 12577 default: 12578 // Do nothing and ignore the unexpected tag element 12579 err = decoder.Decoder.Skip() 12580 if err != nil { 12581 return err 12582 } 12583 12584 } 12585 decoder = originalDecoder 12586 } 12587 *v = sv 12588 return nil 12589} 12590 12591func awsAwsquery_deserializeDocumentDBClusterSnapshotAttributeList(v *[]types.DBClusterSnapshotAttribute, decoder smithyxml.NodeDecoder) error { 12592 if v == nil { 12593 return fmt.Errorf("unexpected nil of type %T", v) 12594 } 12595 var sv []types.DBClusterSnapshotAttribute 12596 if *v == nil { 12597 sv = make([]types.DBClusterSnapshotAttribute, 0) 12598 } else { 12599 sv = *v 12600 } 12601 12602 originalDecoder := decoder 12603 for { 12604 t, done, err := decoder.Token() 12605 if err != nil { 12606 return err 12607 } 12608 if done { 12609 break 12610 } 12611 switch { 12612 case strings.EqualFold("DBClusterSnapshotAttribute", t.Name.Local): 12613 var col types.DBClusterSnapshotAttribute 12614 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12615 destAddr := &col 12616 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttribute(&destAddr, nodeDecoder); err != nil { 12617 return err 12618 } 12619 col = *destAddr 12620 sv = append(sv, col) 12621 12622 default: 12623 err = decoder.Decoder.Skip() 12624 if err != nil { 12625 return err 12626 } 12627 12628 } 12629 decoder = originalDecoder 12630 } 12631 *v = sv 12632 return nil 12633} 12634 12635func awsAwsquery_deserializeDocumentDBClusterSnapshotAttributeListUnwrapped(v *[]types.DBClusterSnapshotAttribute, decoder smithyxml.NodeDecoder) error { 12636 var sv []types.DBClusterSnapshotAttribute 12637 if *v == nil { 12638 sv = make([]types.DBClusterSnapshotAttribute, 0) 12639 } else { 12640 sv = *v 12641 } 12642 12643 switch { 12644 default: 12645 var mv types.DBClusterSnapshotAttribute 12646 t := decoder.StartEl 12647 _ = t 12648 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12649 destAddr := &mv 12650 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttribute(&destAddr, nodeDecoder); err != nil { 12651 return err 12652 } 12653 mv = *destAddr 12654 sv = append(sv, mv) 12655 } 12656 *v = sv 12657 return nil 12658} 12659func awsAwsquery_deserializeDocumentDBClusterSnapshotAttributesResult(v **types.DBClusterSnapshotAttributesResult, decoder smithyxml.NodeDecoder) error { 12660 if v == nil { 12661 return fmt.Errorf("unexpected nil of type %T", v) 12662 } 12663 var sv *types.DBClusterSnapshotAttributesResult 12664 if *v == nil { 12665 sv = &types.DBClusterSnapshotAttributesResult{} 12666 } else { 12667 sv = *v 12668 } 12669 12670 for { 12671 t, done, err := decoder.Token() 12672 if err != nil { 12673 return err 12674 } 12675 if done { 12676 break 12677 } 12678 originalDecoder := decoder 12679 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12680 switch { 12681 case strings.EqualFold("DBClusterSnapshotAttributes", t.Name.Local): 12682 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12683 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttributeList(&sv.DBClusterSnapshotAttributes, nodeDecoder); err != nil { 12684 return err 12685 } 12686 12687 case strings.EqualFold("DBClusterSnapshotIdentifier", t.Name.Local): 12688 val, err := decoder.Value() 12689 if err != nil { 12690 return err 12691 } 12692 if val == nil { 12693 break 12694 } 12695 { 12696 xtv := string(val) 12697 sv.DBClusterSnapshotIdentifier = ptr.String(xtv) 12698 } 12699 12700 default: 12701 // Do nothing and ignore the unexpected tag element 12702 err = decoder.Decoder.Skip() 12703 if err != nil { 12704 return err 12705 } 12706 12707 } 12708 decoder = originalDecoder 12709 } 12710 *v = sv 12711 return nil 12712} 12713 12714func awsAwsquery_deserializeDocumentDBClusterSnapshotList(v *[]types.DBClusterSnapshot, decoder smithyxml.NodeDecoder) error { 12715 if v == nil { 12716 return fmt.Errorf("unexpected nil of type %T", v) 12717 } 12718 var sv []types.DBClusterSnapshot 12719 if *v == nil { 12720 sv = make([]types.DBClusterSnapshot, 0) 12721 } else { 12722 sv = *v 12723 } 12724 12725 originalDecoder := decoder 12726 for { 12727 t, done, err := decoder.Token() 12728 if err != nil { 12729 return err 12730 } 12731 if done { 12732 break 12733 } 12734 switch { 12735 case strings.EqualFold("DBClusterSnapshot", t.Name.Local): 12736 var col types.DBClusterSnapshot 12737 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12738 destAddr := &col 12739 if err := awsAwsquery_deserializeDocumentDBClusterSnapshot(&destAddr, nodeDecoder); err != nil { 12740 return err 12741 } 12742 col = *destAddr 12743 sv = append(sv, col) 12744 12745 default: 12746 err = decoder.Decoder.Skip() 12747 if err != nil { 12748 return err 12749 } 12750 12751 } 12752 decoder = originalDecoder 12753 } 12754 *v = sv 12755 return nil 12756} 12757 12758func awsAwsquery_deserializeDocumentDBClusterSnapshotListUnwrapped(v *[]types.DBClusterSnapshot, decoder smithyxml.NodeDecoder) error { 12759 var sv []types.DBClusterSnapshot 12760 if *v == nil { 12761 sv = make([]types.DBClusterSnapshot, 0) 12762 } else { 12763 sv = *v 12764 } 12765 12766 switch { 12767 default: 12768 var mv types.DBClusterSnapshot 12769 t := decoder.StartEl 12770 _ = t 12771 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12772 destAddr := &mv 12773 if err := awsAwsquery_deserializeDocumentDBClusterSnapshot(&destAddr, nodeDecoder); err != nil { 12774 return err 12775 } 12776 mv = *destAddr 12777 sv = append(sv, mv) 12778 } 12779 *v = sv 12780 return nil 12781} 12782func awsAwsquery_deserializeDocumentDBClusterSnapshotNotFoundFault(v **types.DBClusterSnapshotNotFoundFault, decoder smithyxml.NodeDecoder) error { 12783 if v == nil { 12784 return fmt.Errorf("unexpected nil of type %T", v) 12785 } 12786 var sv *types.DBClusterSnapshotNotFoundFault 12787 if *v == nil { 12788 sv = &types.DBClusterSnapshotNotFoundFault{} 12789 } else { 12790 sv = *v 12791 } 12792 12793 for { 12794 t, done, err := decoder.Token() 12795 if err != nil { 12796 return err 12797 } 12798 if done { 12799 break 12800 } 12801 originalDecoder := decoder 12802 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12803 switch { 12804 case strings.EqualFold("message", t.Name.Local): 12805 val, err := decoder.Value() 12806 if err != nil { 12807 return err 12808 } 12809 if val == nil { 12810 break 12811 } 12812 { 12813 xtv := string(val) 12814 sv.Message = ptr.String(xtv) 12815 } 12816 12817 default: 12818 // Do nothing and ignore the unexpected tag element 12819 err = decoder.Decoder.Skip() 12820 if err != nil { 12821 return err 12822 } 12823 12824 } 12825 decoder = originalDecoder 12826 } 12827 *v = sv 12828 return nil 12829} 12830 12831func awsAwsquery_deserializeDocumentDBEngineVersion(v **types.DBEngineVersion, decoder smithyxml.NodeDecoder) error { 12832 if v == nil { 12833 return fmt.Errorf("unexpected nil of type %T", v) 12834 } 12835 var sv *types.DBEngineVersion 12836 if *v == nil { 12837 sv = &types.DBEngineVersion{} 12838 } else { 12839 sv = *v 12840 } 12841 12842 for { 12843 t, done, err := decoder.Token() 12844 if err != nil { 12845 return err 12846 } 12847 if done { 12848 break 12849 } 12850 originalDecoder := decoder 12851 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12852 switch { 12853 case strings.EqualFold("DBEngineDescription", t.Name.Local): 12854 val, err := decoder.Value() 12855 if err != nil { 12856 return err 12857 } 12858 if val == nil { 12859 break 12860 } 12861 { 12862 xtv := string(val) 12863 sv.DBEngineDescription = ptr.String(xtv) 12864 } 12865 12866 case strings.EqualFold("DBEngineVersionDescription", t.Name.Local): 12867 val, err := decoder.Value() 12868 if err != nil { 12869 return err 12870 } 12871 if val == nil { 12872 break 12873 } 12874 { 12875 xtv := string(val) 12876 sv.DBEngineVersionDescription = ptr.String(xtv) 12877 } 12878 12879 case strings.EqualFold("DBParameterGroupFamily", t.Name.Local): 12880 val, err := decoder.Value() 12881 if err != nil { 12882 return err 12883 } 12884 if val == nil { 12885 break 12886 } 12887 { 12888 xtv := string(val) 12889 sv.DBParameterGroupFamily = ptr.String(xtv) 12890 } 12891 12892 case strings.EqualFold("DefaultCharacterSet", t.Name.Local): 12893 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12894 if err := awsAwsquery_deserializeDocumentCharacterSet(&sv.DefaultCharacterSet, nodeDecoder); err != nil { 12895 return err 12896 } 12897 12898 case strings.EqualFold("Engine", t.Name.Local): 12899 val, err := decoder.Value() 12900 if err != nil { 12901 return err 12902 } 12903 if val == nil { 12904 break 12905 } 12906 { 12907 xtv := string(val) 12908 sv.Engine = ptr.String(xtv) 12909 } 12910 12911 case strings.EqualFold("EngineVersion", t.Name.Local): 12912 val, err := decoder.Value() 12913 if err != nil { 12914 return err 12915 } 12916 if val == nil { 12917 break 12918 } 12919 { 12920 xtv := string(val) 12921 sv.EngineVersion = ptr.String(xtv) 12922 } 12923 12924 case strings.EqualFold("ExportableLogTypes", t.Name.Local): 12925 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12926 if err := awsAwsquery_deserializeDocumentLogTypeList(&sv.ExportableLogTypes, nodeDecoder); err != nil { 12927 return err 12928 } 12929 12930 case strings.EqualFold("SupportedCharacterSets", t.Name.Local): 12931 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12932 if err := awsAwsquery_deserializeDocumentSupportedCharacterSetsList(&sv.SupportedCharacterSets, nodeDecoder); err != nil { 12933 return err 12934 } 12935 12936 case strings.EqualFold("SupportedTimezones", t.Name.Local): 12937 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12938 if err := awsAwsquery_deserializeDocumentSupportedTimezonesList(&sv.SupportedTimezones, nodeDecoder); err != nil { 12939 return err 12940 } 12941 12942 case strings.EqualFold("SupportsLogExportsToCloudwatchLogs", t.Name.Local): 12943 val, err := decoder.Value() 12944 if err != nil { 12945 return err 12946 } 12947 if val == nil { 12948 break 12949 } 12950 { 12951 xtv, err := strconv.ParseBool(string(val)) 12952 if err != nil { 12953 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 12954 } 12955 sv.SupportsLogExportsToCloudwatchLogs = xtv 12956 } 12957 12958 case strings.EqualFold("SupportsReadReplica", t.Name.Local): 12959 val, err := decoder.Value() 12960 if err != nil { 12961 return err 12962 } 12963 if val == nil { 12964 break 12965 } 12966 { 12967 xtv, err := strconv.ParseBool(string(val)) 12968 if err != nil { 12969 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 12970 } 12971 sv.SupportsReadReplica = xtv 12972 } 12973 12974 case strings.EqualFold("ValidUpgradeTarget", t.Name.Local): 12975 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12976 if err := awsAwsquery_deserializeDocumentValidUpgradeTargetList(&sv.ValidUpgradeTarget, nodeDecoder); err != nil { 12977 return err 12978 } 12979 12980 default: 12981 // Do nothing and ignore the unexpected tag element 12982 err = decoder.Decoder.Skip() 12983 if err != nil { 12984 return err 12985 } 12986 12987 } 12988 decoder = originalDecoder 12989 } 12990 *v = sv 12991 return nil 12992} 12993 12994func awsAwsquery_deserializeDocumentDBEngineVersionList(v *[]types.DBEngineVersion, decoder smithyxml.NodeDecoder) error { 12995 if v == nil { 12996 return fmt.Errorf("unexpected nil of type %T", v) 12997 } 12998 var sv []types.DBEngineVersion 12999 if *v == nil { 13000 sv = make([]types.DBEngineVersion, 0) 13001 } else { 13002 sv = *v 13003 } 13004 13005 originalDecoder := decoder 13006 for { 13007 t, done, err := decoder.Token() 13008 if err != nil { 13009 return err 13010 } 13011 if done { 13012 break 13013 } 13014 switch { 13015 case strings.EqualFold("DBEngineVersion", t.Name.Local): 13016 var col types.DBEngineVersion 13017 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13018 destAddr := &col 13019 if err := awsAwsquery_deserializeDocumentDBEngineVersion(&destAddr, nodeDecoder); err != nil { 13020 return err 13021 } 13022 col = *destAddr 13023 sv = append(sv, col) 13024 13025 default: 13026 err = decoder.Decoder.Skip() 13027 if err != nil { 13028 return err 13029 } 13030 13031 } 13032 decoder = originalDecoder 13033 } 13034 *v = sv 13035 return nil 13036} 13037 13038func awsAwsquery_deserializeDocumentDBEngineVersionListUnwrapped(v *[]types.DBEngineVersion, decoder smithyxml.NodeDecoder) error { 13039 var sv []types.DBEngineVersion 13040 if *v == nil { 13041 sv = make([]types.DBEngineVersion, 0) 13042 } else { 13043 sv = *v 13044 } 13045 13046 switch { 13047 default: 13048 var mv types.DBEngineVersion 13049 t := decoder.StartEl 13050 _ = t 13051 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13052 destAddr := &mv 13053 if err := awsAwsquery_deserializeDocumentDBEngineVersion(&destAddr, nodeDecoder); err != nil { 13054 return err 13055 } 13056 mv = *destAddr 13057 sv = append(sv, mv) 13058 } 13059 *v = sv 13060 return nil 13061} 13062func awsAwsquery_deserializeDocumentDBInstance(v **types.DBInstance, decoder smithyxml.NodeDecoder) error { 13063 if v == nil { 13064 return fmt.Errorf("unexpected nil of type %T", v) 13065 } 13066 var sv *types.DBInstance 13067 if *v == nil { 13068 sv = &types.DBInstance{} 13069 } else { 13070 sv = *v 13071 } 13072 13073 for { 13074 t, done, err := decoder.Token() 13075 if err != nil { 13076 return err 13077 } 13078 if done { 13079 break 13080 } 13081 originalDecoder := decoder 13082 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13083 switch { 13084 case strings.EqualFold("AllocatedStorage", t.Name.Local): 13085 val, err := decoder.Value() 13086 if err != nil { 13087 return err 13088 } 13089 if val == nil { 13090 break 13091 } 13092 { 13093 xtv := string(val) 13094 i64, err := strconv.ParseInt(xtv, 10, 64) 13095 if err != nil { 13096 return err 13097 } 13098 sv.AllocatedStorage = int32(i64) 13099 } 13100 13101 case strings.EqualFold("AutoMinorVersionUpgrade", t.Name.Local): 13102 val, err := decoder.Value() 13103 if err != nil { 13104 return err 13105 } 13106 if val == nil { 13107 break 13108 } 13109 { 13110 xtv, err := strconv.ParseBool(string(val)) 13111 if err != nil { 13112 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13113 } 13114 sv.AutoMinorVersionUpgrade = xtv 13115 } 13116 13117 case strings.EqualFold("AvailabilityZone", t.Name.Local): 13118 val, err := decoder.Value() 13119 if err != nil { 13120 return err 13121 } 13122 if val == nil { 13123 break 13124 } 13125 { 13126 xtv := string(val) 13127 sv.AvailabilityZone = ptr.String(xtv) 13128 } 13129 13130 case strings.EqualFold("BackupRetentionPeriod", t.Name.Local): 13131 val, err := decoder.Value() 13132 if err != nil { 13133 return err 13134 } 13135 if val == nil { 13136 break 13137 } 13138 { 13139 xtv := string(val) 13140 i64, err := strconv.ParseInt(xtv, 10, 64) 13141 if err != nil { 13142 return err 13143 } 13144 sv.BackupRetentionPeriod = int32(i64) 13145 } 13146 13147 case strings.EqualFold("CACertificateIdentifier", t.Name.Local): 13148 val, err := decoder.Value() 13149 if err != nil { 13150 return err 13151 } 13152 if val == nil { 13153 break 13154 } 13155 { 13156 xtv := string(val) 13157 sv.CACertificateIdentifier = ptr.String(xtv) 13158 } 13159 13160 case strings.EqualFold("CharacterSetName", t.Name.Local): 13161 val, err := decoder.Value() 13162 if err != nil { 13163 return err 13164 } 13165 if val == nil { 13166 break 13167 } 13168 { 13169 xtv := string(val) 13170 sv.CharacterSetName = ptr.String(xtv) 13171 } 13172 13173 case strings.EqualFold("CopyTagsToSnapshot", t.Name.Local): 13174 val, err := decoder.Value() 13175 if err != nil { 13176 return err 13177 } 13178 if val == nil { 13179 break 13180 } 13181 { 13182 xtv, err := strconv.ParseBool(string(val)) 13183 if err != nil { 13184 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13185 } 13186 sv.CopyTagsToSnapshot = xtv 13187 } 13188 13189 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 13190 val, err := decoder.Value() 13191 if err != nil { 13192 return err 13193 } 13194 if val == nil { 13195 break 13196 } 13197 { 13198 xtv := string(val) 13199 sv.DBClusterIdentifier = ptr.String(xtv) 13200 } 13201 13202 case strings.EqualFold("DBInstanceArn", t.Name.Local): 13203 val, err := decoder.Value() 13204 if err != nil { 13205 return err 13206 } 13207 if val == nil { 13208 break 13209 } 13210 { 13211 xtv := string(val) 13212 sv.DBInstanceArn = ptr.String(xtv) 13213 } 13214 13215 case strings.EqualFold("DBInstanceClass", t.Name.Local): 13216 val, err := decoder.Value() 13217 if err != nil { 13218 return err 13219 } 13220 if val == nil { 13221 break 13222 } 13223 { 13224 xtv := string(val) 13225 sv.DBInstanceClass = ptr.String(xtv) 13226 } 13227 13228 case strings.EqualFold("DBInstanceIdentifier", t.Name.Local): 13229 val, err := decoder.Value() 13230 if err != nil { 13231 return err 13232 } 13233 if val == nil { 13234 break 13235 } 13236 { 13237 xtv := string(val) 13238 sv.DBInstanceIdentifier = ptr.String(xtv) 13239 } 13240 13241 case strings.EqualFold("DbInstancePort", t.Name.Local): 13242 val, err := decoder.Value() 13243 if err != nil { 13244 return err 13245 } 13246 if val == nil { 13247 break 13248 } 13249 { 13250 xtv := string(val) 13251 i64, err := strconv.ParseInt(xtv, 10, 64) 13252 if err != nil { 13253 return err 13254 } 13255 sv.DbInstancePort = int32(i64) 13256 } 13257 13258 case strings.EqualFold("DBInstanceStatus", t.Name.Local): 13259 val, err := decoder.Value() 13260 if err != nil { 13261 return err 13262 } 13263 if val == nil { 13264 break 13265 } 13266 { 13267 xtv := string(val) 13268 sv.DBInstanceStatus = ptr.String(xtv) 13269 } 13270 13271 case strings.EqualFold("DbiResourceId", t.Name.Local): 13272 val, err := decoder.Value() 13273 if err != nil { 13274 return err 13275 } 13276 if val == nil { 13277 break 13278 } 13279 { 13280 xtv := string(val) 13281 sv.DbiResourceId = ptr.String(xtv) 13282 } 13283 13284 case strings.EqualFold("DBName", t.Name.Local): 13285 val, err := decoder.Value() 13286 if err != nil { 13287 return err 13288 } 13289 if val == nil { 13290 break 13291 } 13292 { 13293 xtv := string(val) 13294 sv.DBName = ptr.String(xtv) 13295 } 13296 13297 case strings.EqualFold("DBParameterGroups", t.Name.Local): 13298 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13299 if err := awsAwsquery_deserializeDocumentDBParameterGroupStatusList(&sv.DBParameterGroups, nodeDecoder); err != nil { 13300 return err 13301 } 13302 13303 case strings.EqualFold("DBSecurityGroups", t.Name.Local): 13304 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13305 if err := awsAwsquery_deserializeDocumentDBSecurityGroupMembershipList(&sv.DBSecurityGroups, nodeDecoder); err != nil { 13306 return err 13307 } 13308 13309 case strings.EqualFold("DBSubnetGroup", t.Name.Local): 13310 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13311 if err := awsAwsquery_deserializeDocumentDBSubnetGroup(&sv.DBSubnetGroup, nodeDecoder); err != nil { 13312 return err 13313 } 13314 13315 case strings.EqualFold("DeletionProtection", t.Name.Local): 13316 val, err := decoder.Value() 13317 if err != nil { 13318 return err 13319 } 13320 if val == nil { 13321 break 13322 } 13323 { 13324 xtv, err := strconv.ParseBool(string(val)) 13325 if err != nil { 13326 return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) 13327 } 13328 sv.DeletionProtection = ptr.Bool(xtv) 13329 } 13330 13331 case strings.EqualFold("DomainMemberships", t.Name.Local): 13332 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13333 if err := awsAwsquery_deserializeDocumentDomainMembershipList(&sv.DomainMemberships, nodeDecoder); err != nil { 13334 return err 13335 } 13336 13337 case strings.EqualFold("EnabledCloudwatchLogsExports", t.Name.Local): 13338 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13339 if err := awsAwsquery_deserializeDocumentLogTypeList(&sv.EnabledCloudwatchLogsExports, nodeDecoder); err != nil { 13340 return err 13341 } 13342 13343 case strings.EqualFold("Endpoint", t.Name.Local): 13344 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13345 if err := awsAwsquery_deserializeDocumentEndpoint(&sv.Endpoint, nodeDecoder); err != nil { 13346 return err 13347 } 13348 13349 case strings.EqualFold("Engine", t.Name.Local): 13350 val, err := decoder.Value() 13351 if err != nil { 13352 return err 13353 } 13354 if val == nil { 13355 break 13356 } 13357 { 13358 xtv := string(val) 13359 sv.Engine = ptr.String(xtv) 13360 } 13361 13362 case strings.EqualFold("EngineVersion", t.Name.Local): 13363 val, err := decoder.Value() 13364 if err != nil { 13365 return err 13366 } 13367 if val == nil { 13368 break 13369 } 13370 { 13371 xtv := string(val) 13372 sv.EngineVersion = ptr.String(xtv) 13373 } 13374 13375 case strings.EqualFold("EnhancedMonitoringResourceArn", t.Name.Local): 13376 val, err := decoder.Value() 13377 if err != nil { 13378 return err 13379 } 13380 if val == nil { 13381 break 13382 } 13383 { 13384 xtv := string(val) 13385 sv.EnhancedMonitoringResourceArn = ptr.String(xtv) 13386 } 13387 13388 case strings.EqualFold("IAMDatabaseAuthenticationEnabled", t.Name.Local): 13389 val, err := decoder.Value() 13390 if err != nil { 13391 return err 13392 } 13393 if val == nil { 13394 break 13395 } 13396 { 13397 xtv, err := strconv.ParseBool(string(val)) 13398 if err != nil { 13399 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13400 } 13401 sv.IAMDatabaseAuthenticationEnabled = xtv 13402 } 13403 13404 case strings.EqualFold("InstanceCreateTime", t.Name.Local): 13405 val, err := decoder.Value() 13406 if err != nil { 13407 return err 13408 } 13409 if val == nil { 13410 break 13411 } 13412 { 13413 xtv := string(val) 13414 t, err := smithytime.ParseDateTime(xtv) 13415 if err != nil { 13416 return err 13417 } 13418 sv.InstanceCreateTime = ptr.Time(t) 13419 } 13420 13421 case strings.EqualFold("Iops", t.Name.Local): 13422 val, err := decoder.Value() 13423 if err != nil { 13424 return err 13425 } 13426 if val == nil { 13427 break 13428 } 13429 { 13430 xtv := string(val) 13431 i64, err := strconv.ParseInt(xtv, 10, 64) 13432 if err != nil { 13433 return err 13434 } 13435 sv.Iops = ptr.Int32(int32(i64)) 13436 } 13437 13438 case strings.EqualFold("KmsKeyId", t.Name.Local): 13439 val, err := decoder.Value() 13440 if err != nil { 13441 return err 13442 } 13443 if val == nil { 13444 break 13445 } 13446 { 13447 xtv := string(val) 13448 sv.KmsKeyId = ptr.String(xtv) 13449 } 13450 13451 case strings.EqualFold("LatestRestorableTime", t.Name.Local): 13452 val, err := decoder.Value() 13453 if err != nil { 13454 return err 13455 } 13456 if val == nil { 13457 break 13458 } 13459 { 13460 xtv := string(val) 13461 t, err := smithytime.ParseDateTime(xtv) 13462 if err != nil { 13463 return err 13464 } 13465 sv.LatestRestorableTime = ptr.Time(t) 13466 } 13467 13468 case strings.EqualFold("LicenseModel", t.Name.Local): 13469 val, err := decoder.Value() 13470 if err != nil { 13471 return err 13472 } 13473 if val == nil { 13474 break 13475 } 13476 { 13477 xtv := string(val) 13478 sv.LicenseModel = ptr.String(xtv) 13479 } 13480 13481 case strings.EqualFold("MasterUsername", t.Name.Local): 13482 val, err := decoder.Value() 13483 if err != nil { 13484 return err 13485 } 13486 if val == nil { 13487 break 13488 } 13489 { 13490 xtv := string(val) 13491 sv.MasterUsername = ptr.String(xtv) 13492 } 13493 13494 case strings.EqualFold("MonitoringInterval", t.Name.Local): 13495 val, err := decoder.Value() 13496 if err != nil { 13497 return err 13498 } 13499 if val == nil { 13500 break 13501 } 13502 { 13503 xtv := string(val) 13504 i64, err := strconv.ParseInt(xtv, 10, 64) 13505 if err != nil { 13506 return err 13507 } 13508 sv.MonitoringInterval = ptr.Int32(int32(i64)) 13509 } 13510 13511 case strings.EqualFold("MonitoringRoleArn", t.Name.Local): 13512 val, err := decoder.Value() 13513 if err != nil { 13514 return err 13515 } 13516 if val == nil { 13517 break 13518 } 13519 { 13520 xtv := string(val) 13521 sv.MonitoringRoleArn = ptr.String(xtv) 13522 } 13523 13524 case strings.EqualFold("MultiAZ", t.Name.Local): 13525 val, err := decoder.Value() 13526 if err != nil { 13527 return err 13528 } 13529 if val == nil { 13530 break 13531 } 13532 { 13533 xtv, err := strconv.ParseBool(string(val)) 13534 if err != nil { 13535 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13536 } 13537 sv.MultiAZ = xtv 13538 } 13539 13540 case strings.EqualFold("OptionGroupMemberships", t.Name.Local): 13541 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13542 if err := awsAwsquery_deserializeDocumentOptionGroupMembershipList(&sv.OptionGroupMemberships, nodeDecoder); err != nil { 13543 return err 13544 } 13545 13546 case strings.EqualFold("PendingModifiedValues", t.Name.Local): 13547 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13548 if err := awsAwsquery_deserializeDocumentPendingModifiedValues(&sv.PendingModifiedValues, nodeDecoder); err != nil { 13549 return err 13550 } 13551 13552 case strings.EqualFold("PerformanceInsightsEnabled", t.Name.Local): 13553 val, err := decoder.Value() 13554 if err != nil { 13555 return err 13556 } 13557 if val == nil { 13558 break 13559 } 13560 { 13561 xtv, err := strconv.ParseBool(string(val)) 13562 if err != nil { 13563 return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) 13564 } 13565 sv.PerformanceInsightsEnabled = ptr.Bool(xtv) 13566 } 13567 13568 case strings.EqualFold("PerformanceInsightsKMSKeyId", t.Name.Local): 13569 val, err := decoder.Value() 13570 if err != nil { 13571 return err 13572 } 13573 if val == nil { 13574 break 13575 } 13576 { 13577 xtv := string(val) 13578 sv.PerformanceInsightsKMSKeyId = ptr.String(xtv) 13579 } 13580 13581 case strings.EqualFold("PreferredBackupWindow", t.Name.Local): 13582 val, err := decoder.Value() 13583 if err != nil { 13584 return err 13585 } 13586 if val == nil { 13587 break 13588 } 13589 { 13590 xtv := string(val) 13591 sv.PreferredBackupWindow = ptr.String(xtv) 13592 } 13593 13594 case strings.EqualFold("PreferredMaintenanceWindow", t.Name.Local): 13595 val, err := decoder.Value() 13596 if err != nil { 13597 return err 13598 } 13599 if val == nil { 13600 break 13601 } 13602 { 13603 xtv := string(val) 13604 sv.PreferredMaintenanceWindow = ptr.String(xtv) 13605 } 13606 13607 case strings.EqualFold("PromotionTier", t.Name.Local): 13608 val, err := decoder.Value() 13609 if err != nil { 13610 return err 13611 } 13612 if val == nil { 13613 break 13614 } 13615 { 13616 xtv := string(val) 13617 i64, err := strconv.ParseInt(xtv, 10, 64) 13618 if err != nil { 13619 return err 13620 } 13621 sv.PromotionTier = ptr.Int32(int32(i64)) 13622 } 13623 13624 case strings.EqualFold("PubliclyAccessible", t.Name.Local): 13625 val, err := decoder.Value() 13626 if err != nil { 13627 return err 13628 } 13629 if val == nil { 13630 break 13631 } 13632 { 13633 xtv, err := strconv.ParseBool(string(val)) 13634 if err != nil { 13635 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13636 } 13637 sv.PubliclyAccessible = xtv 13638 } 13639 13640 case strings.EqualFold("ReadReplicaDBClusterIdentifiers", t.Name.Local): 13641 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13642 if err := awsAwsquery_deserializeDocumentReadReplicaDBClusterIdentifierList(&sv.ReadReplicaDBClusterIdentifiers, nodeDecoder); err != nil { 13643 return err 13644 } 13645 13646 case strings.EqualFold("ReadReplicaDBInstanceIdentifiers", t.Name.Local): 13647 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13648 if err := awsAwsquery_deserializeDocumentReadReplicaDBInstanceIdentifierList(&sv.ReadReplicaDBInstanceIdentifiers, nodeDecoder); err != nil { 13649 return err 13650 } 13651 13652 case strings.EqualFold("ReadReplicaSourceDBInstanceIdentifier", t.Name.Local): 13653 val, err := decoder.Value() 13654 if err != nil { 13655 return err 13656 } 13657 if val == nil { 13658 break 13659 } 13660 { 13661 xtv := string(val) 13662 sv.ReadReplicaSourceDBInstanceIdentifier = ptr.String(xtv) 13663 } 13664 13665 case strings.EqualFold("SecondaryAvailabilityZone", t.Name.Local): 13666 val, err := decoder.Value() 13667 if err != nil { 13668 return err 13669 } 13670 if val == nil { 13671 break 13672 } 13673 { 13674 xtv := string(val) 13675 sv.SecondaryAvailabilityZone = ptr.String(xtv) 13676 } 13677 13678 case strings.EqualFold("StatusInfos", t.Name.Local): 13679 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13680 if err := awsAwsquery_deserializeDocumentDBInstanceStatusInfoList(&sv.StatusInfos, nodeDecoder); err != nil { 13681 return err 13682 } 13683 13684 case strings.EqualFold("StorageEncrypted", t.Name.Local): 13685 val, err := decoder.Value() 13686 if err != nil { 13687 return err 13688 } 13689 if val == nil { 13690 break 13691 } 13692 { 13693 xtv, err := strconv.ParseBool(string(val)) 13694 if err != nil { 13695 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13696 } 13697 sv.StorageEncrypted = xtv 13698 } 13699 13700 case strings.EqualFold("StorageType", t.Name.Local): 13701 val, err := decoder.Value() 13702 if err != nil { 13703 return err 13704 } 13705 if val == nil { 13706 break 13707 } 13708 { 13709 xtv := string(val) 13710 sv.StorageType = ptr.String(xtv) 13711 } 13712 13713 case strings.EqualFold("TdeCredentialArn", t.Name.Local): 13714 val, err := decoder.Value() 13715 if err != nil { 13716 return err 13717 } 13718 if val == nil { 13719 break 13720 } 13721 { 13722 xtv := string(val) 13723 sv.TdeCredentialArn = ptr.String(xtv) 13724 } 13725 13726 case strings.EqualFold("Timezone", t.Name.Local): 13727 val, err := decoder.Value() 13728 if err != nil { 13729 return err 13730 } 13731 if val == nil { 13732 break 13733 } 13734 { 13735 xtv := string(val) 13736 sv.Timezone = ptr.String(xtv) 13737 } 13738 13739 case strings.EqualFold("VpcSecurityGroups", t.Name.Local): 13740 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13741 if err := awsAwsquery_deserializeDocumentVpcSecurityGroupMembershipList(&sv.VpcSecurityGroups, nodeDecoder); err != nil { 13742 return err 13743 } 13744 13745 default: 13746 // Do nothing and ignore the unexpected tag element 13747 err = decoder.Decoder.Skip() 13748 if err != nil { 13749 return err 13750 } 13751 13752 } 13753 decoder = originalDecoder 13754 } 13755 *v = sv 13756 return nil 13757} 13758 13759func awsAwsquery_deserializeDocumentDBInstanceAlreadyExistsFault(v **types.DBInstanceAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 13760 if v == nil { 13761 return fmt.Errorf("unexpected nil of type %T", v) 13762 } 13763 var sv *types.DBInstanceAlreadyExistsFault 13764 if *v == nil { 13765 sv = &types.DBInstanceAlreadyExistsFault{} 13766 } else { 13767 sv = *v 13768 } 13769 13770 for { 13771 t, done, err := decoder.Token() 13772 if err != nil { 13773 return err 13774 } 13775 if done { 13776 break 13777 } 13778 originalDecoder := decoder 13779 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13780 switch { 13781 case strings.EqualFold("message", t.Name.Local): 13782 val, err := decoder.Value() 13783 if err != nil { 13784 return err 13785 } 13786 if val == nil { 13787 break 13788 } 13789 { 13790 xtv := string(val) 13791 sv.Message = ptr.String(xtv) 13792 } 13793 13794 default: 13795 // Do nothing and ignore the unexpected tag element 13796 err = decoder.Decoder.Skip() 13797 if err != nil { 13798 return err 13799 } 13800 13801 } 13802 decoder = originalDecoder 13803 } 13804 *v = sv 13805 return nil 13806} 13807 13808func awsAwsquery_deserializeDocumentDBInstanceList(v *[]types.DBInstance, decoder smithyxml.NodeDecoder) error { 13809 if v == nil { 13810 return fmt.Errorf("unexpected nil of type %T", v) 13811 } 13812 var sv []types.DBInstance 13813 if *v == nil { 13814 sv = make([]types.DBInstance, 0) 13815 } else { 13816 sv = *v 13817 } 13818 13819 originalDecoder := decoder 13820 for { 13821 t, done, err := decoder.Token() 13822 if err != nil { 13823 return err 13824 } 13825 if done { 13826 break 13827 } 13828 switch { 13829 case strings.EqualFold("DBInstance", t.Name.Local): 13830 var col types.DBInstance 13831 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13832 destAddr := &col 13833 if err := awsAwsquery_deserializeDocumentDBInstance(&destAddr, nodeDecoder); err != nil { 13834 return err 13835 } 13836 col = *destAddr 13837 sv = append(sv, col) 13838 13839 default: 13840 err = decoder.Decoder.Skip() 13841 if err != nil { 13842 return err 13843 } 13844 13845 } 13846 decoder = originalDecoder 13847 } 13848 *v = sv 13849 return nil 13850} 13851 13852func awsAwsquery_deserializeDocumentDBInstanceListUnwrapped(v *[]types.DBInstance, decoder smithyxml.NodeDecoder) error { 13853 var sv []types.DBInstance 13854 if *v == nil { 13855 sv = make([]types.DBInstance, 0) 13856 } else { 13857 sv = *v 13858 } 13859 13860 switch { 13861 default: 13862 var mv types.DBInstance 13863 t := decoder.StartEl 13864 _ = t 13865 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13866 destAddr := &mv 13867 if err := awsAwsquery_deserializeDocumentDBInstance(&destAddr, nodeDecoder); err != nil { 13868 return err 13869 } 13870 mv = *destAddr 13871 sv = append(sv, mv) 13872 } 13873 *v = sv 13874 return nil 13875} 13876func awsAwsquery_deserializeDocumentDBInstanceNotFoundFault(v **types.DBInstanceNotFoundFault, decoder smithyxml.NodeDecoder) error { 13877 if v == nil { 13878 return fmt.Errorf("unexpected nil of type %T", v) 13879 } 13880 var sv *types.DBInstanceNotFoundFault 13881 if *v == nil { 13882 sv = &types.DBInstanceNotFoundFault{} 13883 } else { 13884 sv = *v 13885 } 13886 13887 for { 13888 t, done, err := decoder.Token() 13889 if err != nil { 13890 return err 13891 } 13892 if done { 13893 break 13894 } 13895 originalDecoder := decoder 13896 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13897 switch { 13898 case strings.EqualFold("message", t.Name.Local): 13899 val, err := decoder.Value() 13900 if err != nil { 13901 return err 13902 } 13903 if val == nil { 13904 break 13905 } 13906 { 13907 xtv := string(val) 13908 sv.Message = ptr.String(xtv) 13909 } 13910 13911 default: 13912 // Do nothing and ignore the unexpected tag element 13913 err = decoder.Decoder.Skip() 13914 if err != nil { 13915 return err 13916 } 13917 13918 } 13919 decoder = originalDecoder 13920 } 13921 *v = sv 13922 return nil 13923} 13924 13925func awsAwsquery_deserializeDocumentDBInstanceStatusInfo(v **types.DBInstanceStatusInfo, decoder smithyxml.NodeDecoder) error { 13926 if v == nil { 13927 return fmt.Errorf("unexpected nil of type %T", v) 13928 } 13929 var sv *types.DBInstanceStatusInfo 13930 if *v == nil { 13931 sv = &types.DBInstanceStatusInfo{} 13932 } else { 13933 sv = *v 13934 } 13935 13936 for { 13937 t, done, err := decoder.Token() 13938 if err != nil { 13939 return err 13940 } 13941 if done { 13942 break 13943 } 13944 originalDecoder := decoder 13945 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13946 switch { 13947 case strings.EqualFold("Message", t.Name.Local): 13948 val, err := decoder.Value() 13949 if err != nil { 13950 return err 13951 } 13952 if val == nil { 13953 break 13954 } 13955 { 13956 xtv := string(val) 13957 sv.Message = ptr.String(xtv) 13958 } 13959 13960 case strings.EqualFold("Normal", t.Name.Local): 13961 val, err := decoder.Value() 13962 if err != nil { 13963 return err 13964 } 13965 if val == nil { 13966 break 13967 } 13968 { 13969 xtv, err := strconv.ParseBool(string(val)) 13970 if err != nil { 13971 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 13972 } 13973 sv.Normal = xtv 13974 } 13975 13976 case strings.EqualFold("Status", t.Name.Local): 13977 val, err := decoder.Value() 13978 if err != nil { 13979 return err 13980 } 13981 if val == nil { 13982 break 13983 } 13984 { 13985 xtv := string(val) 13986 sv.Status = ptr.String(xtv) 13987 } 13988 13989 case strings.EqualFold("StatusType", t.Name.Local): 13990 val, err := decoder.Value() 13991 if err != nil { 13992 return err 13993 } 13994 if val == nil { 13995 break 13996 } 13997 { 13998 xtv := string(val) 13999 sv.StatusType = ptr.String(xtv) 14000 } 14001 14002 default: 14003 // Do nothing and ignore the unexpected tag element 14004 err = decoder.Decoder.Skip() 14005 if err != nil { 14006 return err 14007 } 14008 14009 } 14010 decoder = originalDecoder 14011 } 14012 *v = sv 14013 return nil 14014} 14015 14016func awsAwsquery_deserializeDocumentDBInstanceStatusInfoList(v *[]types.DBInstanceStatusInfo, decoder smithyxml.NodeDecoder) error { 14017 if v == nil { 14018 return fmt.Errorf("unexpected nil of type %T", v) 14019 } 14020 var sv []types.DBInstanceStatusInfo 14021 if *v == nil { 14022 sv = make([]types.DBInstanceStatusInfo, 0) 14023 } else { 14024 sv = *v 14025 } 14026 14027 originalDecoder := decoder 14028 for { 14029 t, done, err := decoder.Token() 14030 if err != nil { 14031 return err 14032 } 14033 if done { 14034 break 14035 } 14036 switch { 14037 case strings.EqualFold("DBInstanceStatusInfo", t.Name.Local): 14038 var col types.DBInstanceStatusInfo 14039 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14040 destAddr := &col 14041 if err := awsAwsquery_deserializeDocumentDBInstanceStatusInfo(&destAddr, nodeDecoder); err != nil { 14042 return err 14043 } 14044 col = *destAddr 14045 sv = append(sv, col) 14046 14047 default: 14048 err = decoder.Decoder.Skip() 14049 if err != nil { 14050 return err 14051 } 14052 14053 } 14054 decoder = originalDecoder 14055 } 14056 *v = sv 14057 return nil 14058} 14059 14060func awsAwsquery_deserializeDocumentDBInstanceStatusInfoListUnwrapped(v *[]types.DBInstanceStatusInfo, decoder smithyxml.NodeDecoder) error { 14061 var sv []types.DBInstanceStatusInfo 14062 if *v == nil { 14063 sv = make([]types.DBInstanceStatusInfo, 0) 14064 } else { 14065 sv = *v 14066 } 14067 14068 switch { 14069 default: 14070 var mv types.DBInstanceStatusInfo 14071 t := decoder.StartEl 14072 _ = t 14073 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14074 destAddr := &mv 14075 if err := awsAwsquery_deserializeDocumentDBInstanceStatusInfo(&destAddr, nodeDecoder); err != nil { 14076 return err 14077 } 14078 mv = *destAddr 14079 sv = append(sv, mv) 14080 } 14081 *v = sv 14082 return nil 14083} 14084func awsAwsquery_deserializeDocumentDBParameterGroup(v **types.DBParameterGroup, decoder smithyxml.NodeDecoder) error { 14085 if v == nil { 14086 return fmt.Errorf("unexpected nil of type %T", v) 14087 } 14088 var sv *types.DBParameterGroup 14089 if *v == nil { 14090 sv = &types.DBParameterGroup{} 14091 } else { 14092 sv = *v 14093 } 14094 14095 for { 14096 t, done, err := decoder.Token() 14097 if err != nil { 14098 return err 14099 } 14100 if done { 14101 break 14102 } 14103 originalDecoder := decoder 14104 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14105 switch { 14106 case strings.EqualFold("DBParameterGroupArn", t.Name.Local): 14107 val, err := decoder.Value() 14108 if err != nil { 14109 return err 14110 } 14111 if val == nil { 14112 break 14113 } 14114 { 14115 xtv := string(val) 14116 sv.DBParameterGroupArn = ptr.String(xtv) 14117 } 14118 14119 case strings.EqualFold("DBParameterGroupFamily", t.Name.Local): 14120 val, err := decoder.Value() 14121 if err != nil { 14122 return err 14123 } 14124 if val == nil { 14125 break 14126 } 14127 { 14128 xtv := string(val) 14129 sv.DBParameterGroupFamily = ptr.String(xtv) 14130 } 14131 14132 case strings.EqualFold("DBParameterGroupName", t.Name.Local): 14133 val, err := decoder.Value() 14134 if err != nil { 14135 return err 14136 } 14137 if val == nil { 14138 break 14139 } 14140 { 14141 xtv := string(val) 14142 sv.DBParameterGroupName = ptr.String(xtv) 14143 } 14144 14145 case strings.EqualFold("Description", t.Name.Local): 14146 val, err := decoder.Value() 14147 if err != nil { 14148 return err 14149 } 14150 if val == nil { 14151 break 14152 } 14153 { 14154 xtv := string(val) 14155 sv.Description = ptr.String(xtv) 14156 } 14157 14158 default: 14159 // Do nothing and ignore the unexpected tag element 14160 err = decoder.Decoder.Skip() 14161 if err != nil { 14162 return err 14163 } 14164 14165 } 14166 decoder = originalDecoder 14167 } 14168 *v = sv 14169 return nil 14170} 14171 14172func awsAwsquery_deserializeDocumentDBParameterGroupAlreadyExistsFault(v **types.DBParameterGroupAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 14173 if v == nil { 14174 return fmt.Errorf("unexpected nil of type %T", v) 14175 } 14176 var sv *types.DBParameterGroupAlreadyExistsFault 14177 if *v == nil { 14178 sv = &types.DBParameterGroupAlreadyExistsFault{} 14179 } else { 14180 sv = *v 14181 } 14182 14183 for { 14184 t, done, err := decoder.Token() 14185 if err != nil { 14186 return err 14187 } 14188 if done { 14189 break 14190 } 14191 originalDecoder := decoder 14192 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14193 switch { 14194 case strings.EqualFold("message", t.Name.Local): 14195 val, err := decoder.Value() 14196 if err != nil { 14197 return err 14198 } 14199 if val == nil { 14200 break 14201 } 14202 { 14203 xtv := string(val) 14204 sv.Message = ptr.String(xtv) 14205 } 14206 14207 default: 14208 // Do nothing and ignore the unexpected tag element 14209 err = decoder.Decoder.Skip() 14210 if err != nil { 14211 return err 14212 } 14213 14214 } 14215 decoder = originalDecoder 14216 } 14217 *v = sv 14218 return nil 14219} 14220 14221func awsAwsquery_deserializeDocumentDBParameterGroupList(v *[]types.DBParameterGroup, decoder smithyxml.NodeDecoder) error { 14222 if v == nil { 14223 return fmt.Errorf("unexpected nil of type %T", v) 14224 } 14225 var sv []types.DBParameterGroup 14226 if *v == nil { 14227 sv = make([]types.DBParameterGroup, 0) 14228 } else { 14229 sv = *v 14230 } 14231 14232 originalDecoder := decoder 14233 for { 14234 t, done, err := decoder.Token() 14235 if err != nil { 14236 return err 14237 } 14238 if done { 14239 break 14240 } 14241 switch { 14242 case strings.EqualFold("DBParameterGroup", t.Name.Local): 14243 var col types.DBParameterGroup 14244 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14245 destAddr := &col 14246 if err := awsAwsquery_deserializeDocumentDBParameterGroup(&destAddr, nodeDecoder); err != nil { 14247 return err 14248 } 14249 col = *destAddr 14250 sv = append(sv, col) 14251 14252 default: 14253 err = decoder.Decoder.Skip() 14254 if err != nil { 14255 return err 14256 } 14257 14258 } 14259 decoder = originalDecoder 14260 } 14261 *v = sv 14262 return nil 14263} 14264 14265func awsAwsquery_deserializeDocumentDBParameterGroupListUnwrapped(v *[]types.DBParameterGroup, decoder smithyxml.NodeDecoder) error { 14266 var sv []types.DBParameterGroup 14267 if *v == nil { 14268 sv = make([]types.DBParameterGroup, 0) 14269 } else { 14270 sv = *v 14271 } 14272 14273 switch { 14274 default: 14275 var mv types.DBParameterGroup 14276 t := decoder.StartEl 14277 _ = t 14278 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14279 destAddr := &mv 14280 if err := awsAwsquery_deserializeDocumentDBParameterGroup(&destAddr, nodeDecoder); err != nil { 14281 return err 14282 } 14283 mv = *destAddr 14284 sv = append(sv, mv) 14285 } 14286 *v = sv 14287 return nil 14288} 14289func awsAwsquery_deserializeDocumentDBParameterGroupNotFoundFault(v **types.DBParameterGroupNotFoundFault, decoder smithyxml.NodeDecoder) error { 14290 if v == nil { 14291 return fmt.Errorf("unexpected nil of type %T", v) 14292 } 14293 var sv *types.DBParameterGroupNotFoundFault 14294 if *v == nil { 14295 sv = &types.DBParameterGroupNotFoundFault{} 14296 } else { 14297 sv = *v 14298 } 14299 14300 for { 14301 t, done, err := decoder.Token() 14302 if err != nil { 14303 return err 14304 } 14305 if done { 14306 break 14307 } 14308 originalDecoder := decoder 14309 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14310 switch { 14311 case strings.EqualFold("message", t.Name.Local): 14312 val, err := decoder.Value() 14313 if err != nil { 14314 return err 14315 } 14316 if val == nil { 14317 break 14318 } 14319 { 14320 xtv := string(val) 14321 sv.Message = ptr.String(xtv) 14322 } 14323 14324 default: 14325 // Do nothing and ignore the unexpected tag element 14326 err = decoder.Decoder.Skip() 14327 if err != nil { 14328 return err 14329 } 14330 14331 } 14332 decoder = originalDecoder 14333 } 14334 *v = sv 14335 return nil 14336} 14337 14338func awsAwsquery_deserializeDocumentDBParameterGroupQuotaExceededFault(v **types.DBParameterGroupQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 14339 if v == nil { 14340 return fmt.Errorf("unexpected nil of type %T", v) 14341 } 14342 var sv *types.DBParameterGroupQuotaExceededFault 14343 if *v == nil { 14344 sv = &types.DBParameterGroupQuotaExceededFault{} 14345 } else { 14346 sv = *v 14347 } 14348 14349 for { 14350 t, done, err := decoder.Token() 14351 if err != nil { 14352 return err 14353 } 14354 if done { 14355 break 14356 } 14357 originalDecoder := decoder 14358 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14359 switch { 14360 case strings.EqualFold("message", t.Name.Local): 14361 val, err := decoder.Value() 14362 if err != nil { 14363 return err 14364 } 14365 if val == nil { 14366 break 14367 } 14368 { 14369 xtv := string(val) 14370 sv.Message = ptr.String(xtv) 14371 } 14372 14373 default: 14374 // Do nothing and ignore the unexpected tag element 14375 err = decoder.Decoder.Skip() 14376 if err != nil { 14377 return err 14378 } 14379 14380 } 14381 decoder = originalDecoder 14382 } 14383 *v = sv 14384 return nil 14385} 14386 14387func awsAwsquery_deserializeDocumentDBParameterGroupStatus(v **types.DBParameterGroupStatus, decoder smithyxml.NodeDecoder) error { 14388 if v == nil { 14389 return fmt.Errorf("unexpected nil of type %T", v) 14390 } 14391 var sv *types.DBParameterGroupStatus 14392 if *v == nil { 14393 sv = &types.DBParameterGroupStatus{} 14394 } else { 14395 sv = *v 14396 } 14397 14398 for { 14399 t, done, err := decoder.Token() 14400 if err != nil { 14401 return err 14402 } 14403 if done { 14404 break 14405 } 14406 originalDecoder := decoder 14407 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14408 switch { 14409 case strings.EqualFold("DBParameterGroupName", t.Name.Local): 14410 val, err := decoder.Value() 14411 if err != nil { 14412 return err 14413 } 14414 if val == nil { 14415 break 14416 } 14417 { 14418 xtv := string(val) 14419 sv.DBParameterGroupName = ptr.String(xtv) 14420 } 14421 14422 case strings.EqualFold("ParameterApplyStatus", t.Name.Local): 14423 val, err := decoder.Value() 14424 if err != nil { 14425 return err 14426 } 14427 if val == nil { 14428 break 14429 } 14430 { 14431 xtv := string(val) 14432 sv.ParameterApplyStatus = ptr.String(xtv) 14433 } 14434 14435 default: 14436 // Do nothing and ignore the unexpected tag element 14437 err = decoder.Decoder.Skip() 14438 if err != nil { 14439 return err 14440 } 14441 14442 } 14443 decoder = originalDecoder 14444 } 14445 *v = sv 14446 return nil 14447} 14448 14449func awsAwsquery_deserializeDocumentDBParameterGroupStatusList(v *[]types.DBParameterGroupStatus, decoder smithyxml.NodeDecoder) error { 14450 if v == nil { 14451 return fmt.Errorf("unexpected nil of type %T", v) 14452 } 14453 var sv []types.DBParameterGroupStatus 14454 if *v == nil { 14455 sv = make([]types.DBParameterGroupStatus, 0) 14456 } else { 14457 sv = *v 14458 } 14459 14460 originalDecoder := decoder 14461 for { 14462 t, done, err := decoder.Token() 14463 if err != nil { 14464 return err 14465 } 14466 if done { 14467 break 14468 } 14469 switch { 14470 case strings.EqualFold("DBParameterGroup", t.Name.Local): 14471 var col types.DBParameterGroupStatus 14472 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14473 destAddr := &col 14474 if err := awsAwsquery_deserializeDocumentDBParameterGroupStatus(&destAddr, nodeDecoder); err != nil { 14475 return err 14476 } 14477 col = *destAddr 14478 sv = append(sv, col) 14479 14480 default: 14481 err = decoder.Decoder.Skip() 14482 if err != nil { 14483 return err 14484 } 14485 14486 } 14487 decoder = originalDecoder 14488 } 14489 *v = sv 14490 return nil 14491} 14492 14493func awsAwsquery_deserializeDocumentDBParameterGroupStatusListUnwrapped(v *[]types.DBParameterGroupStatus, decoder smithyxml.NodeDecoder) error { 14494 var sv []types.DBParameterGroupStatus 14495 if *v == nil { 14496 sv = make([]types.DBParameterGroupStatus, 0) 14497 } else { 14498 sv = *v 14499 } 14500 14501 switch { 14502 default: 14503 var mv types.DBParameterGroupStatus 14504 t := decoder.StartEl 14505 _ = t 14506 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14507 destAddr := &mv 14508 if err := awsAwsquery_deserializeDocumentDBParameterGroupStatus(&destAddr, nodeDecoder); err != nil { 14509 return err 14510 } 14511 mv = *destAddr 14512 sv = append(sv, mv) 14513 } 14514 *v = sv 14515 return nil 14516} 14517func awsAwsquery_deserializeDocumentDBSecurityGroupMembership(v **types.DBSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 14518 if v == nil { 14519 return fmt.Errorf("unexpected nil of type %T", v) 14520 } 14521 var sv *types.DBSecurityGroupMembership 14522 if *v == nil { 14523 sv = &types.DBSecurityGroupMembership{} 14524 } else { 14525 sv = *v 14526 } 14527 14528 for { 14529 t, done, err := decoder.Token() 14530 if err != nil { 14531 return err 14532 } 14533 if done { 14534 break 14535 } 14536 originalDecoder := decoder 14537 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14538 switch { 14539 case strings.EqualFold("DBSecurityGroupName", t.Name.Local): 14540 val, err := decoder.Value() 14541 if err != nil { 14542 return err 14543 } 14544 if val == nil { 14545 break 14546 } 14547 { 14548 xtv := string(val) 14549 sv.DBSecurityGroupName = ptr.String(xtv) 14550 } 14551 14552 case strings.EqualFold("Status", t.Name.Local): 14553 val, err := decoder.Value() 14554 if err != nil { 14555 return err 14556 } 14557 if val == nil { 14558 break 14559 } 14560 { 14561 xtv := string(val) 14562 sv.Status = ptr.String(xtv) 14563 } 14564 14565 default: 14566 // Do nothing and ignore the unexpected tag element 14567 err = decoder.Decoder.Skip() 14568 if err != nil { 14569 return err 14570 } 14571 14572 } 14573 decoder = originalDecoder 14574 } 14575 *v = sv 14576 return nil 14577} 14578 14579func awsAwsquery_deserializeDocumentDBSecurityGroupMembershipList(v *[]types.DBSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 14580 if v == nil { 14581 return fmt.Errorf("unexpected nil of type %T", v) 14582 } 14583 var sv []types.DBSecurityGroupMembership 14584 if *v == nil { 14585 sv = make([]types.DBSecurityGroupMembership, 0) 14586 } else { 14587 sv = *v 14588 } 14589 14590 originalDecoder := decoder 14591 for { 14592 t, done, err := decoder.Token() 14593 if err != nil { 14594 return err 14595 } 14596 if done { 14597 break 14598 } 14599 switch { 14600 case strings.EqualFold("DBSecurityGroup", t.Name.Local): 14601 var col types.DBSecurityGroupMembership 14602 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14603 destAddr := &col 14604 if err := awsAwsquery_deserializeDocumentDBSecurityGroupMembership(&destAddr, nodeDecoder); err != nil { 14605 return err 14606 } 14607 col = *destAddr 14608 sv = append(sv, col) 14609 14610 default: 14611 err = decoder.Decoder.Skip() 14612 if err != nil { 14613 return err 14614 } 14615 14616 } 14617 decoder = originalDecoder 14618 } 14619 *v = sv 14620 return nil 14621} 14622 14623func awsAwsquery_deserializeDocumentDBSecurityGroupMembershipListUnwrapped(v *[]types.DBSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 14624 var sv []types.DBSecurityGroupMembership 14625 if *v == nil { 14626 sv = make([]types.DBSecurityGroupMembership, 0) 14627 } else { 14628 sv = *v 14629 } 14630 14631 switch { 14632 default: 14633 var mv types.DBSecurityGroupMembership 14634 t := decoder.StartEl 14635 _ = t 14636 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14637 destAddr := &mv 14638 if err := awsAwsquery_deserializeDocumentDBSecurityGroupMembership(&destAddr, nodeDecoder); err != nil { 14639 return err 14640 } 14641 mv = *destAddr 14642 sv = append(sv, mv) 14643 } 14644 *v = sv 14645 return nil 14646} 14647func awsAwsquery_deserializeDocumentDBSecurityGroupNotFoundFault(v **types.DBSecurityGroupNotFoundFault, decoder smithyxml.NodeDecoder) error { 14648 if v == nil { 14649 return fmt.Errorf("unexpected nil of type %T", v) 14650 } 14651 var sv *types.DBSecurityGroupNotFoundFault 14652 if *v == nil { 14653 sv = &types.DBSecurityGroupNotFoundFault{} 14654 } else { 14655 sv = *v 14656 } 14657 14658 for { 14659 t, done, err := decoder.Token() 14660 if err != nil { 14661 return err 14662 } 14663 if done { 14664 break 14665 } 14666 originalDecoder := decoder 14667 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14668 switch { 14669 case strings.EqualFold("message", t.Name.Local): 14670 val, err := decoder.Value() 14671 if err != nil { 14672 return err 14673 } 14674 if val == nil { 14675 break 14676 } 14677 { 14678 xtv := string(val) 14679 sv.Message = ptr.String(xtv) 14680 } 14681 14682 default: 14683 // Do nothing and ignore the unexpected tag element 14684 err = decoder.Decoder.Skip() 14685 if err != nil { 14686 return err 14687 } 14688 14689 } 14690 decoder = originalDecoder 14691 } 14692 *v = sv 14693 return nil 14694} 14695 14696func awsAwsquery_deserializeDocumentDBSnapshotAlreadyExistsFault(v **types.DBSnapshotAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 14697 if v == nil { 14698 return fmt.Errorf("unexpected nil of type %T", v) 14699 } 14700 var sv *types.DBSnapshotAlreadyExistsFault 14701 if *v == nil { 14702 sv = &types.DBSnapshotAlreadyExistsFault{} 14703 } else { 14704 sv = *v 14705 } 14706 14707 for { 14708 t, done, err := decoder.Token() 14709 if err != nil { 14710 return err 14711 } 14712 if done { 14713 break 14714 } 14715 originalDecoder := decoder 14716 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14717 switch { 14718 case strings.EqualFold("message", t.Name.Local): 14719 val, err := decoder.Value() 14720 if err != nil { 14721 return err 14722 } 14723 if val == nil { 14724 break 14725 } 14726 { 14727 xtv := string(val) 14728 sv.Message = ptr.String(xtv) 14729 } 14730 14731 default: 14732 // Do nothing and ignore the unexpected tag element 14733 err = decoder.Decoder.Skip() 14734 if err != nil { 14735 return err 14736 } 14737 14738 } 14739 decoder = originalDecoder 14740 } 14741 *v = sv 14742 return nil 14743} 14744 14745func awsAwsquery_deserializeDocumentDBSnapshotNotFoundFault(v **types.DBSnapshotNotFoundFault, decoder smithyxml.NodeDecoder) error { 14746 if v == nil { 14747 return fmt.Errorf("unexpected nil of type %T", v) 14748 } 14749 var sv *types.DBSnapshotNotFoundFault 14750 if *v == nil { 14751 sv = &types.DBSnapshotNotFoundFault{} 14752 } else { 14753 sv = *v 14754 } 14755 14756 for { 14757 t, done, err := decoder.Token() 14758 if err != nil { 14759 return err 14760 } 14761 if done { 14762 break 14763 } 14764 originalDecoder := decoder 14765 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14766 switch { 14767 case strings.EqualFold("message", t.Name.Local): 14768 val, err := decoder.Value() 14769 if err != nil { 14770 return err 14771 } 14772 if val == nil { 14773 break 14774 } 14775 { 14776 xtv := string(val) 14777 sv.Message = ptr.String(xtv) 14778 } 14779 14780 default: 14781 // Do nothing and ignore the unexpected tag element 14782 err = decoder.Decoder.Skip() 14783 if err != nil { 14784 return err 14785 } 14786 14787 } 14788 decoder = originalDecoder 14789 } 14790 *v = sv 14791 return nil 14792} 14793 14794func awsAwsquery_deserializeDocumentDBSubnetGroup(v **types.DBSubnetGroup, decoder smithyxml.NodeDecoder) error { 14795 if v == nil { 14796 return fmt.Errorf("unexpected nil of type %T", v) 14797 } 14798 var sv *types.DBSubnetGroup 14799 if *v == nil { 14800 sv = &types.DBSubnetGroup{} 14801 } else { 14802 sv = *v 14803 } 14804 14805 for { 14806 t, done, err := decoder.Token() 14807 if err != nil { 14808 return err 14809 } 14810 if done { 14811 break 14812 } 14813 originalDecoder := decoder 14814 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14815 switch { 14816 case strings.EqualFold("DBSubnetGroupArn", t.Name.Local): 14817 val, err := decoder.Value() 14818 if err != nil { 14819 return err 14820 } 14821 if val == nil { 14822 break 14823 } 14824 { 14825 xtv := string(val) 14826 sv.DBSubnetGroupArn = ptr.String(xtv) 14827 } 14828 14829 case strings.EqualFold("DBSubnetGroupDescription", t.Name.Local): 14830 val, err := decoder.Value() 14831 if err != nil { 14832 return err 14833 } 14834 if val == nil { 14835 break 14836 } 14837 { 14838 xtv := string(val) 14839 sv.DBSubnetGroupDescription = ptr.String(xtv) 14840 } 14841 14842 case strings.EqualFold("DBSubnetGroupName", t.Name.Local): 14843 val, err := decoder.Value() 14844 if err != nil { 14845 return err 14846 } 14847 if val == nil { 14848 break 14849 } 14850 { 14851 xtv := string(val) 14852 sv.DBSubnetGroupName = ptr.String(xtv) 14853 } 14854 14855 case strings.EqualFold("SubnetGroupStatus", t.Name.Local): 14856 val, err := decoder.Value() 14857 if err != nil { 14858 return err 14859 } 14860 if val == nil { 14861 break 14862 } 14863 { 14864 xtv := string(val) 14865 sv.SubnetGroupStatus = ptr.String(xtv) 14866 } 14867 14868 case strings.EqualFold("Subnets", t.Name.Local): 14869 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14870 if err := awsAwsquery_deserializeDocumentSubnetList(&sv.Subnets, nodeDecoder); err != nil { 14871 return err 14872 } 14873 14874 case strings.EqualFold("VpcId", t.Name.Local): 14875 val, err := decoder.Value() 14876 if err != nil { 14877 return err 14878 } 14879 if val == nil { 14880 break 14881 } 14882 { 14883 xtv := string(val) 14884 sv.VpcId = ptr.String(xtv) 14885 } 14886 14887 default: 14888 // Do nothing and ignore the unexpected tag element 14889 err = decoder.Decoder.Skip() 14890 if err != nil { 14891 return err 14892 } 14893 14894 } 14895 decoder = originalDecoder 14896 } 14897 *v = sv 14898 return nil 14899} 14900 14901func awsAwsquery_deserializeDocumentDBSubnetGroupAlreadyExistsFault(v **types.DBSubnetGroupAlreadyExistsFault, decoder smithyxml.NodeDecoder) error { 14902 if v == nil { 14903 return fmt.Errorf("unexpected nil of type %T", v) 14904 } 14905 var sv *types.DBSubnetGroupAlreadyExistsFault 14906 if *v == nil { 14907 sv = &types.DBSubnetGroupAlreadyExistsFault{} 14908 } else { 14909 sv = *v 14910 } 14911 14912 for { 14913 t, done, err := decoder.Token() 14914 if err != nil { 14915 return err 14916 } 14917 if done { 14918 break 14919 } 14920 originalDecoder := decoder 14921 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14922 switch { 14923 case strings.EqualFold("message", t.Name.Local): 14924 val, err := decoder.Value() 14925 if err != nil { 14926 return err 14927 } 14928 if val == nil { 14929 break 14930 } 14931 { 14932 xtv := string(val) 14933 sv.Message = ptr.String(xtv) 14934 } 14935 14936 default: 14937 // Do nothing and ignore the unexpected tag element 14938 err = decoder.Decoder.Skip() 14939 if err != nil { 14940 return err 14941 } 14942 14943 } 14944 decoder = originalDecoder 14945 } 14946 *v = sv 14947 return nil 14948} 14949 14950func awsAwsquery_deserializeDocumentDBSubnetGroupDoesNotCoverEnoughAZs(v **types.DBSubnetGroupDoesNotCoverEnoughAZs, decoder smithyxml.NodeDecoder) error { 14951 if v == nil { 14952 return fmt.Errorf("unexpected nil of type %T", v) 14953 } 14954 var sv *types.DBSubnetGroupDoesNotCoverEnoughAZs 14955 if *v == nil { 14956 sv = &types.DBSubnetGroupDoesNotCoverEnoughAZs{} 14957 } else { 14958 sv = *v 14959 } 14960 14961 for { 14962 t, done, err := decoder.Token() 14963 if err != nil { 14964 return err 14965 } 14966 if done { 14967 break 14968 } 14969 originalDecoder := decoder 14970 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14971 switch { 14972 case strings.EqualFold("message", t.Name.Local): 14973 val, err := decoder.Value() 14974 if err != nil { 14975 return err 14976 } 14977 if val == nil { 14978 break 14979 } 14980 { 14981 xtv := string(val) 14982 sv.Message = ptr.String(xtv) 14983 } 14984 14985 default: 14986 // Do nothing and ignore the unexpected tag element 14987 err = decoder.Decoder.Skip() 14988 if err != nil { 14989 return err 14990 } 14991 14992 } 14993 decoder = originalDecoder 14994 } 14995 *v = sv 14996 return nil 14997} 14998 14999func awsAwsquery_deserializeDocumentDBSubnetGroupNotFoundFault(v **types.DBSubnetGroupNotFoundFault, decoder smithyxml.NodeDecoder) error { 15000 if v == nil { 15001 return fmt.Errorf("unexpected nil of type %T", v) 15002 } 15003 var sv *types.DBSubnetGroupNotFoundFault 15004 if *v == nil { 15005 sv = &types.DBSubnetGroupNotFoundFault{} 15006 } else { 15007 sv = *v 15008 } 15009 15010 for { 15011 t, done, err := decoder.Token() 15012 if err != nil { 15013 return err 15014 } 15015 if done { 15016 break 15017 } 15018 originalDecoder := decoder 15019 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15020 switch { 15021 case strings.EqualFold("message", t.Name.Local): 15022 val, err := decoder.Value() 15023 if err != nil { 15024 return err 15025 } 15026 if val == nil { 15027 break 15028 } 15029 { 15030 xtv := string(val) 15031 sv.Message = ptr.String(xtv) 15032 } 15033 15034 default: 15035 // Do nothing and ignore the unexpected tag element 15036 err = decoder.Decoder.Skip() 15037 if err != nil { 15038 return err 15039 } 15040 15041 } 15042 decoder = originalDecoder 15043 } 15044 *v = sv 15045 return nil 15046} 15047 15048func awsAwsquery_deserializeDocumentDBSubnetGroupQuotaExceededFault(v **types.DBSubnetGroupQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 15049 if v == nil { 15050 return fmt.Errorf("unexpected nil of type %T", v) 15051 } 15052 var sv *types.DBSubnetGroupQuotaExceededFault 15053 if *v == nil { 15054 sv = &types.DBSubnetGroupQuotaExceededFault{} 15055 } else { 15056 sv = *v 15057 } 15058 15059 for { 15060 t, done, err := decoder.Token() 15061 if err != nil { 15062 return err 15063 } 15064 if done { 15065 break 15066 } 15067 originalDecoder := decoder 15068 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15069 switch { 15070 case strings.EqualFold("message", t.Name.Local): 15071 val, err := decoder.Value() 15072 if err != nil { 15073 return err 15074 } 15075 if val == nil { 15076 break 15077 } 15078 { 15079 xtv := string(val) 15080 sv.Message = ptr.String(xtv) 15081 } 15082 15083 default: 15084 // Do nothing and ignore the unexpected tag element 15085 err = decoder.Decoder.Skip() 15086 if err != nil { 15087 return err 15088 } 15089 15090 } 15091 decoder = originalDecoder 15092 } 15093 *v = sv 15094 return nil 15095} 15096 15097func awsAwsquery_deserializeDocumentDBSubnetGroups(v *[]types.DBSubnetGroup, decoder smithyxml.NodeDecoder) error { 15098 if v == nil { 15099 return fmt.Errorf("unexpected nil of type %T", v) 15100 } 15101 var sv []types.DBSubnetGroup 15102 if *v == nil { 15103 sv = make([]types.DBSubnetGroup, 0) 15104 } else { 15105 sv = *v 15106 } 15107 15108 originalDecoder := decoder 15109 for { 15110 t, done, err := decoder.Token() 15111 if err != nil { 15112 return err 15113 } 15114 if done { 15115 break 15116 } 15117 switch { 15118 case strings.EqualFold("DBSubnetGroup", t.Name.Local): 15119 var col types.DBSubnetGroup 15120 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15121 destAddr := &col 15122 if err := awsAwsquery_deserializeDocumentDBSubnetGroup(&destAddr, nodeDecoder); err != nil { 15123 return err 15124 } 15125 col = *destAddr 15126 sv = append(sv, col) 15127 15128 default: 15129 err = decoder.Decoder.Skip() 15130 if err != nil { 15131 return err 15132 } 15133 15134 } 15135 decoder = originalDecoder 15136 } 15137 *v = sv 15138 return nil 15139} 15140 15141func awsAwsquery_deserializeDocumentDBSubnetGroupsUnwrapped(v *[]types.DBSubnetGroup, decoder smithyxml.NodeDecoder) error { 15142 var sv []types.DBSubnetGroup 15143 if *v == nil { 15144 sv = make([]types.DBSubnetGroup, 0) 15145 } else { 15146 sv = *v 15147 } 15148 15149 switch { 15150 default: 15151 var mv types.DBSubnetGroup 15152 t := decoder.StartEl 15153 _ = t 15154 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15155 destAddr := &mv 15156 if err := awsAwsquery_deserializeDocumentDBSubnetGroup(&destAddr, nodeDecoder); err != nil { 15157 return err 15158 } 15159 mv = *destAddr 15160 sv = append(sv, mv) 15161 } 15162 *v = sv 15163 return nil 15164} 15165func awsAwsquery_deserializeDocumentDBSubnetQuotaExceededFault(v **types.DBSubnetQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 15166 if v == nil { 15167 return fmt.Errorf("unexpected nil of type %T", v) 15168 } 15169 var sv *types.DBSubnetQuotaExceededFault 15170 if *v == nil { 15171 sv = &types.DBSubnetQuotaExceededFault{} 15172 } else { 15173 sv = *v 15174 } 15175 15176 for { 15177 t, done, err := decoder.Token() 15178 if err != nil { 15179 return err 15180 } 15181 if done { 15182 break 15183 } 15184 originalDecoder := decoder 15185 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15186 switch { 15187 case strings.EqualFold("message", t.Name.Local): 15188 val, err := decoder.Value() 15189 if err != nil { 15190 return err 15191 } 15192 if val == nil { 15193 break 15194 } 15195 { 15196 xtv := string(val) 15197 sv.Message = ptr.String(xtv) 15198 } 15199 15200 default: 15201 // Do nothing and ignore the unexpected tag element 15202 err = decoder.Decoder.Skip() 15203 if err != nil { 15204 return err 15205 } 15206 15207 } 15208 decoder = originalDecoder 15209 } 15210 *v = sv 15211 return nil 15212} 15213 15214func awsAwsquery_deserializeDocumentDBUpgradeDependencyFailureFault(v **types.DBUpgradeDependencyFailureFault, decoder smithyxml.NodeDecoder) error { 15215 if v == nil { 15216 return fmt.Errorf("unexpected nil of type %T", v) 15217 } 15218 var sv *types.DBUpgradeDependencyFailureFault 15219 if *v == nil { 15220 sv = &types.DBUpgradeDependencyFailureFault{} 15221 } else { 15222 sv = *v 15223 } 15224 15225 for { 15226 t, done, err := decoder.Token() 15227 if err != nil { 15228 return err 15229 } 15230 if done { 15231 break 15232 } 15233 originalDecoder := decoder 15234 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15235 switch { 15236 case strings.EqualFold("message", t.Name.Local): 15237 val, err := decoder.Value() 15238 if err != nil { 15239 return err 15240 } 15241 if val == nil { 15242 break 15243 } 15244 { 15245 xtv := string(val) 15246 sv.Message = ptr.String(xtv) 15247 } 15248 15249 default: 15250 // Do nothing and ignore the unexpected tag element 15251 err = decoder.Decoder.Skip() 15252 if err != nil { 15253 return err 15254 } 15255 15256 } 15257 decoder = originalDecoder 15258 } 15259 *v = sv 15260 return nil 15261} 15262 15263func awsAwsquery_deserializeDocumentDomainMembership(v **types.DomainMembership, decoder smithyxml.NodeDecoder) error { 15264 if v == nil { 15265 return fmt.Errorf("unexpected nil of type %T", v) 15266 } 15267 var sv *types.DomainMembership 15268 if *v == nil { 15269 sv = &types.DomainMembership{} 15270 } else { 15271 sv = *v 15272 } 15273 15274 for { 15275 t, done, err := decoder.Token() 15276 if err != nil { 15277 return err 15278 } 15279 if done { 15280 break 15281 } 15282 originalDecoder := decoder 15283 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15284 switch { 15285 case strings.EqualFold("Domain", t.Name.Local): 15286 val, err := decoder.Value() 15287 if err != nil { 15288 return err 15289 } 15290 if val == nil { 15291 break 15292 } 15293 { 15294 xtv := string(val) 15295 sv.Domain = ptr.String(xtv) 15296 } 15297 15298 case strings.EqualFold("FQDN", t.Name.Local): 15299 val, err := decoder.Value() 15300 if err != nil { 15301 return err 15302 } 15303 if val == nil { 15304 break 15305 } 15306 { 15307 xtv := string(val) 15308 sv.FQDN = ptr.String(xtv) 15309 } 15310 15311 case strings.EqualFold("IAMRoleName", t.Name.Local): 15312 val, err := decoder.Value() 15313 if err != nil { 15314 return err 15315 } 15316 if val == nil { 15317 break 15318 } 15319 { 15320 xtv := string(val) 15321 sv.IAMRoleName = ptr.String(xtv) 15322 } 15323 15324 case strings.EqualFold("Status", t.Name.Local): 15325 val, err := decoder.Value() 15326 if err != nil { 15327 return err 15328 } 15329 if val == nil { 15330 break 15331 } 15332 { 15333 xtv := string(val) 15334 sv.Status = ptr.String(xtv) 15335 } 15336 15337 default: 15338 // Do nothing and ignore the unexpected tag element 15339 err = decoder.Decoder.Skip() 15340 if err != nil { 15341 return err 15342 } 15343 15344 } 15345 decoder = originalDecoder 15346 } 15347 *v = sv 15348 return nil 15349} 15350 15351func awsAwsquery_deserializeDocumentDomainMembershipList(v *[]types.DomainMembership, decoder smithyxml.NodeDecoder) error { 15352 if v == nil { 15353 return fmt.Errorf("unexpected nil of type %T", v) 15354 } 15355 var sv []types.DomainMembership 15356 if *v == nil { 15357 sv = make([]types.DomainMembership, 0) 15358 } else { 15359 sv = *v 15360 } 15361 15362 originalDecoder := decoder 15363 for { 15364 t, done, err := decoder.Token() 15365 if err != nil { 15366 return err 15367 } 15368 if done { 15369 break 15370 } 15371 switch { 15372 case strings.EqualFold("DomainMembership", t.Name.Local): 15373 var col types.DomainMembership 15374 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15375 destAddr := &col 15376 if err := awsAwsquery_deserializeDocumentDomainMembership(&destAddr, nodeDecoder); err != nil { 15377 return err 15378 } 15379 col = *destAddr 15380 sv = append(sv, col) 15381 15382 default: 15383 err = decoder.Decoder.Skip() 15384 if err != nil { 15385 return err 15386 } 15387 15388 } 15389 decoder = originalDecoder 15390 } 15391 *v = sv 15392 return nil 15393} 15394 15395func awsAwsquery_deserializeDocumentDomainMembershipListUnwrapped(v *[]types.DomainMembership, decoder smithyxml.NodeDecoder) error { 15396 var sv []types.DomainMembership 15397 if *v == nil { 15398 sv = make([]types.DomainMembership, 0) 15399 } else { 15400 sv = *v 15401 } 15402 15403 switch { 15404 default: 15405 var mv types.DomainMembership 15406 t := decoder.StartEl 15407 _ = t 15408 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15409 destAddr := &mv 15410 if err := awsAwsquery_deserializeDocumentDomainMembership(&destAddr, nodeDecoder); err != nil { 15411 return err 15412 } 15413 mv = *destAddr 15414 sv = append(sv, mv) 15415 } 15416 *v = sv 15417 return nil 15418} 15419func awsAwsquery_deserializeDocumentDomainNotFoundFault(v **types.DomainNotFoundFault, decoder smithyxml.NodeDecoder) error { 15420 if v == nil { 15421 return fmt.Errorf("unexpected nil of type %T", v) 15422 } 15423 var sv *types.DomainNotFoundFault 15424 if *v == nil { 15425 sv = &types.DomainNotFoundFault{} 15426 } else { 15427 sv = *v 15428 } 15429 15430 for { 15431 t, done, err := decoder.Token() 15432 if err != nil { 15433 return err 15434 } 15435 if done { 15436 break 15437 } 15438 originalDecoder := decoder 15439 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15440 switch { 15441 case strings.EqualFold("message", t.Name.Local): 15442 val, err := decoder.Value() 15443 if err != nil { 15444 return err 15445 } 15446 if val == nil { 15447 break 15448 } 15449 { 15450 xtv := string(val) 15451 sv.Message = ptr.String(xtv) 15452 } 15453 15454 default: 15455 // Do nothing and ignore the unexpected tag element 15456 err = decoder.Decoder.Skip() 15457 if err != nil { 15458 return err 15459 } 15460 15461 } 15462 decoder = originalDecoder 15463 } 15464 *v = sv 15465 return nil 15466} 15467 15468func awsAwsquery_deserializeDocumentDoubleRange(v **types.DoubleRange, decoder smithyxml.NodeDecoder) error { 15469 if v == nil { 15470 return fmt.Errorf("unexpected nil of type %T", v) 15471 } 15472 var sv *types.DoubleRange 15473 if *v == nil { 15474 sv = &types.DoubleRange{} 15475 } else { 15476 sv = *v 15477 } 15478 15479 for { 15480 t, done, err := decoder.Token() 15481 if err != nil { 15482 return err 15483 } 15484 if done { 15485 break 15486 } 15487 originalDecoder := decoder 15488 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15489 switch { 15490 case strings.EqualFold("From", t.Name.Local): 15491 val, err := decoder.Value() 15492 if err != nil { 15493 return err 15494 } 15495 if val == nil { 15496 break 15497 } 15498 { 15499 xtv := string(val) 15500 f64, err := strconv.ParseFloat(xtv, 64) 15501 if err != nil { 15502 return err 15503 } 15504 sv.From = f64 15505 } 15506 15507 case strings.EqualFold("To", t.Name.Local): 15508 val, err := decoder.Value() 15509 if err != nil { 15510 return err 15511 } 15512 if val == nil { 15513 break 15514 } 15515 { 15516 xtv := string(val) 15517 f64, err := strconv.ParseFloat(xtv, 64) 15518 if err != nil { 15519 return err 15520 } 15521 sv.To = f64 15522 } 15523 15524 default: 15525 // Do nothing and ignore the unexpected tag element 15526 err = decoder.Decoder.Skip() 15527 if err != nil { 15528 return err 15529 } 15530 15531 } 15532 decoder = originalDecoder 15533 } 15534 *v = sv 15535 return nil 15536} 15537 15538func awsAwsquery_deserializeDocumentDoubleRangeList(v *[]types.DoubleRange, decoder smithyxml.NodeDecoder) error { 15539 if v == nil { 15540 return fmt.Errorf("unexpected nil of type %T", v) 15541 } 15542 var sv []types.DoubleRange 15543 if *v == nil { 15544 sv = make([]types.DoubleRange, 0) 15545 } else { 15546 sv = *v 15547 } 15548 15549 originalDecoder := decoder 15550 for { 15551 t, done, err := decoder.Token() 15552 if err != nil { 15553 return err 15554 } 15555 if done { 15556 break 15557 } 15558 switch { 15559 case strings.EqualFold("DoubleRange", t.Name.Local): 15560 var col types.DoubleRange 15561 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15562 destAddr := &col 15563 if err := awsAwsquery_deserializeDocumentDoubleRange(&destAddr, nodeDecoder); err != nil { 15564 return err 15565 } 15566 col = *destAddr 15567 sv = append(sv, col) 15568 15569 default: 15570 err = decoder.Decoder.Skip() 15571 if err != nil { 15572 return err 15573 } 15574 15575 } 15576 decoder = originalDecoder 15577 } 15578 *v = sv 15579 return nil 15580} 15581 15582func awsAwsquery_deserializeDocumentDoubleRangeListUnwrapped(v *[]types.DoubleRange, decoder smithyxml.NodeDecoder) error { 15583 var sv []types.DoubleRange 15584 if *v == nil { 15585 sv = make([]types.DoubleRange, 0) 15586 } else { 15587 sv = *v 15588 } 15589 15590 switch { 15591 default: 15592 var mv types.DoubleRange 15593 t := decoder.StartEl 15594 _ = t 15595 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15596 destAddr := &mv 15597 if err := awsAwsquery_deserializeDocumentDoubleRange(&destAddr, nodeDecoder); err != nil { 15598 return err 15599 } 15600 mv = *destAddr 15601 sv = append(sv, mv) 15602 } 15603 *v = sv 15604 return nil 15605} 15606func awsAwsquery_deserializeDocumentEndpoint(v **types.Endpoint, decoder smithyxml.NodeDecoder) error { 15607 if v == nil { 15608 return fmt.Errorf("unexpected nil of type %T", v) 15609 } 15610 var sv *types.Endpoint 15611 if *v == nil { 15612 sv = &types.Endpoint{} 15613 } else { 15614 sv = *v 15615 } 15616 15617 for { 15618 t, done, err := decoder.Token() 15619 if err != nil { 15620 return err 15621 } 15622 if done { 15623 break 15624 } 15625 originalDecoder := decoder 15626 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15627 switch { 15628 case strings.EqualFold("Address", t.Name.Local): 15629 val, err := decoder.Value() 15630 if err != nil { 15631 return err 15632 } 15633 if val == nil { 15634 break 15635 } 15636 { 15637 xtv := string(val) 15638 sv.Address = ptr.String(xtv) 15639 } 15640 15641 case strings.EqualFold("HostedZoneId", t.Name.Local): 15642 val, err := decoder.Value() 15643 if err != nil { 15644 return err 15645 } 15646 if val == nil { 15647 break 15648 } 15649 { 15650 xtv := string(val) 15651 sv.HostedZoneId = ptr.String(xtv) 15652 } 15653 15654 case strings.EqualFold("Port", t.Name.Local): 15655 val, err := decoder.Value() 15656 if err != nil { 15657 return err 15658 } 15659 if val == nil { 15660 break 15661 } 15662 { 15663 xtv := string(val) 15664 i64, err := strconv.ParseInt(xtv, 10, 64) 15665 if err != nil { 15666 return err 15667 } 15668 sv.Port = int32(i64) 15669 } 15670 15671 default: 15672 // Do nothing and ignore the unexpected tag element 15673 err = decoder.Decoder.Skip() 15674 if err != nil { 15675 return err 15676 } 15677 15678 } 15679 decoder = originalDecoder 15680 } 15681 *v = sv 15682 return nil 15683} 15684 15685func awsAwsquery_deserializeDocumentEngineDefaults(v **types.EngineDefaults, decoder smithyxml.NodeDecoder) error { 15686 if v == nil { 15687 return fmt.Errorf("unexpected nil of type %T", v) 15688 } 15689 var sv *types.EngineDefaults 15690 if *v == nil { 15691 sv = &types.EngineDefaults{} 15692 } else { 15693 sv = *v 15694 } 15695 15696 for { 15697 t, done, err := decoder.Token() 15698 if err != nil { 15699 return err 15700 } 15701 if done { 15702 break 15703 } 15704 originalDecoder := decoder 15705 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15706 switch { 15707 case strings.EqualFold("DBParameterGroupFamily", t.Name.Local): 15708 val, err := decoder.Value() 15709 if err != nil { 15710 return err 15711 } 15712 if val == nil { 15713 break 15714 } 15715 { 15716 xtv := string(val) 15717 sv.DBParameterGroupFamily = ptr.String(xtv) 15718 } 15719 15720 case strings.EqualFold("Marker", t.Name.Local): 15721 val, err := decoder.Value() 15722 if err != nil { 15723 return err 15724 } 15725 if val == nil { 15726 break 15727 } 15728 { 15729 xtv := string(val) 15730 sv.Marker = ptr.String(xtv) 15731 } 15732 15733 case strings.EqualFold("Parameters", t.Name.Local): 15734 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15735 if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil { 15736 return err 15737 } 15738 15739 default: 15740 // Do nothing and ignore the unexpected tag element 15741 err = decoder.Decoder.Skip() 15742 if err != nil { 15743 return err 15744 } 15745 15746 } 15747 decoder = originalDecoder 15748 } 15749 *v = sv 15750 return nil 15751} 15752 15753func awsAwsquery_deserializeDocumentEvent(v **types.Event, decoder smithyxml.NodeDecoder) error { 15754 if v == nil { 15755 return fmt.Errorf("unexpected nil of type %T", v) 15756 } 15757 var sv *types.Event 15758 if *v == nil { 15759 sv = &types.Event{} 15760 } else { 15761 sv = *v 15762 } 15763 15764 for { 15765 t, done, err := decoder.Token() 15766 if err != nil { 15767 return err 15768 } 15769 if done { 15770 break 15771 } 15772 originalDecoder := decoder 15773 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15774 switch { 15775 case strings.EqualFold("Date", t.Name.Local): 15776 val, err := decoder.Value() 15777 if err != nil { 15778 return err 15779 } 15780 if val == nil { 15781 break 15782 } 15783 { 15784 xtv := string(val) 15785 t, err := smithytime.ParseDateTime(xtv) 15786 if err != nil { 15787 return err 15788 } 15789 sv.Date = ptr.Time(t) 15790 } 15791 15792 case strings.EqualFold("EventCategories", t.Name.Local): 15793 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15794 if err := awsAwsquery_deserializeDocumentEventCategoriesList(&sv.EventCategories, nodeDecoder); err != nil { 15795 return err 15796 } 15797 15798 case strings.EqualFold("Message", t.Name.Local): 15799 val, err := decoder.Value() 15800 if err != nil { 15801 return err 15802 } 15803 if val == nil { 15804 break 15805 } 15806 { 15807 xtv := string(val) 15808 sv.Message = ptr.String(xtv) 15809 } 15810 15811 case strings.EqualFold("SourceArn", t.Name.Local): 15812 val, err := decoder.Value() 15813 if err != nil { 15814 return err 15815 } 15816 if val == nil { 15817 break 15818 } 15819 { 15820 xtv := string(val) 15821 sv.SourceArn = ptr.String(xtv) 15822 } 15823 15824 case strings.EqualFold("SourceIdentifier", t.Name.Local): 15825 val, err := decoder.Value() 15826 if err != nil { 15827 return err 15828 } 15829 if val == nil { 15830 break 15831 } 15832 { 15833 xtv := string(val) 15834 sv.SourceIdentifier = ptr.String(xtv) 15835 } 15836 15837 case strings.EqualFold("SourceType", t.Name.Local): 15838 val, err := decoder.Value() 15839 if err != nil { 15840 return err 15841 } 15842 if val == nil { 15843 break 15844 } 15845 { 15846 xtv := string(val) 15847 sv.SourceType = types.SourceType(xtv) 15848 } 15849 15850 default: 15851 // Do nothing and ignore the unexpected tag element 15852 err = decoder.Decoder.Skip() 15853 if err != nil { 15854 return err 15855 } 15856 15857 } 15858 decoder = originalDecoder 15859 } 15860 *v = sv 15861 return nil 15862} 15863 15864func awsAwsquery_deserializeDocumentEventCategoriesList(v *[]string, decoder smithyxml.NodeDecoder) error { 15865 if v == nil { 15866 return fmt.Errorf("unexpected nil of type %T", v) 15867 } 15868 var sv []string 15869 if *v == nil { 15870 sv = make([]string, 0) 15871 } else { 15872 sv = *v 15873 } 15874 15875 originalDecoder := decoder 15876 for { 15877 t, done, err := decoder.Token() 15878 if err != nil { 15879 return err 15880 } 15881 if done { 15882 break 15883 } 15884 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15885 decoder = memberDecoder 15886 switch { 15887 case strings.EqualFold("EventCategory", t.Name.Local): 15888 var col string 15889 val, err := decoder.Value() 15890 if err != nil { 15891 return err 15892 } 15893 if val == nil { 15894 break 15895 } 15896 { 15897 xtv := string(val) 15898 col = xtv 15899 } 15900 sv = append(sv, col) 15901 15902 default: 15903 err = decoder.Decoder.Skip() 15904 if err != nil { 15905 return err 15906 } 15907 15908 } 15909 decoder = originalDecoder 15910 } 15911 *v = sv 15912 return nil 15913} 15914 15915func awsAwsquery_deserializeDocumentEventCategoriesListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 15916 var sv []string 15917 if *v == nil { 15918 sv = make([]string, 0) 15919 } else { 15920 sv = *v 15921 } 15922 15923 switch { 15924 default: 15925 var mv string 15926 t := decoder.StartEl 15927 _ = t 15928 val, err := decoder.Value() 15929 if err != nil { 15930 return err 15931 } 15932 if val == nil { 15933 break 15934 } 15935 { 15936 xtv := string(val) 15937 mv = xtv 15938 } 15939 sv = append(sv, mv) 15940 } 15941 *v = sv 15942 return nil 15943} 15944func awsAwsquery_deserializeDocumentEventCategoriesMap(v **types.EventCategoriesMap, decoder smithyxml.NodeDecoder) error { 15945 if v == nil { 15946 return fmt.Errorf("unexpected nil of type %T", v) 15947 } 15948 var sv *types.EventCategoriesMap 15949 if *v == nil { 15950 sv = &types.EventCategoriesMap{} 15951 } else { 15952 sv = *v 15953 } 15954 15955 for { 15956 t, done, err := decoder.Token() 15957 if err != nil { 15958 return err 15959 } 15960 if done { 15961 break 15962 } 15963 originalDecoder := decoder 15964 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15965 switch { 15966 case strings.EqualFold("EventCategories", t.Name.Local): 15967 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15968 if err := awsAwsquery_deserializeDocumentEventCategoriesList(&sv.EventCategories, nodeDecoder); err != nil { 15969 return err 15970 } 15971 15972 case strings.EqualFold("SourceType", t.Name.Local): 15973 val, err := decoder.Value() 15974 if err != nil { 15975 return err 15976 } 15977 if val == nil { 15978 break 15979 } 15980 { 15981 xtv := string(val) 15982 sv.SourceType = ptr.String(xtv) 15983 } 15984 15985 default: 15986 // Do nothing and ignore the unexpected tag element 15987 err = decoder.Decoder.Skip() 15988 if err != nil { 15989 return err 15990 } 15991 15992 } 15993 decoder = originalDecoder 15994 } 15995 *v = sv 15996 return nil 15997} 15998 15999func awsAwsquery_deserializeDocumentEventCategoriesMapList(v *[]types.EventCategoriesMap, decoder smithyxml.NodeDecoder) error { 16000 if v == nil { 16001 return fmt.Errorf("unexpected nil of type %T", v) 16002 } 16003 var sv []types.EventCategoriesMap 16004 if *v == nil { 16005 sv = make([]types.EventCategoriesMap, 0) 16006 } else { 16007 sv = *v 16008 } 16009 16010 originalDecoder := decoder 16011 for { 16012 t, done, err := decoder.Token() 16013 if err != nil { 16014 return err 16015 } 16016 if done { 16017 break 16018 } 16019 switch { 16020 case strings.EqualFold("EventCategoriesMap", t.Name.Local): 16021 var col types.EventCategoriesMap 16022 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16023 destAddr := &col 16024 if err := awsAwsquery_deserializeDocumentEventCategoriesMap(&destAddr, nodeDecoder); err != nil { 16025 return err 16026 } 16027 col = *destAddr 16028 sv = append(sv, col) 16029 16030 default: 16031 err = decoder.Decoder.Skip() 16032 if err != nil { 16033 return err 16034 } 16035 16036 } 16037 decoder = originalDecoder 16038 } 16039 *v = sv 16040 return nil 16041} 16042 16043func awsAwsquery_deserializeDocumentEventCategoriesMapListUnwrapped(v *[]types.EventCategoriesMap, decoder smithyxml.NodeDecoder) error { 16044 var sv []types.EventCategoriesMap 16045 if *v == nil { 16046 sv = make([]types.EventCategoriesMap, 0) 16047 } else { 16048 sv = *v 16049 } 16050 16051 switch { 16052 default: 16053 var mv types.EventCategoriesMap 16054 t := decoder.StartEl 16055 _ = t 16056 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16057 destAddr := &mv 16058 if err := awsAwsquery_deserializeDocumentEventCategoriesMap(&destAddr, nodeDecoder); err != nil { 16059 return err 16060 } 16061 mv = *destAddr 16062 sv = append(sv, mv) 16063 } 16064 *v = sv 16065 return nil 16066} 16067func awsAwsquery_deserializeDocumentEventList(v *[]types.Event, decoder smithyxml.NodeDecoder) error { 16068 if v == nil { 16069 return fmt.Errorf("unexpected nil of type %T", v) 16070 } 16071 var sv []types.Event 16072 if *v == nil { 16073 sv = make([]types.Event, 0) 16074 } else { 16075 sv = *v 16076 } 16077 16078 originalDecoder := decoder 16079 for { 16080 t, done, err := decoder.Token() 16081 if err != nil { 16082 return err 16083 } 16084 if done { 16085 break 16086 } 16087 switch { 16088 case strings.EqualFold("Event", t.Name.Local): 16089 var col types.Event 16090 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16091 destAddr := &col 16092 if err := awsAwsquery_deserializeDocumentEvent(&destAddr, nodeDecoder); err != nil { 16093 return err 16094 } 16095 col = *destAddr 16096 sv = append(sv, col) 16097 16098 default: 16099 err = decoder.Decoder.Skip() 16100 if err != nil { 16101 return err 16102 } 16103 16104 } 16105 decoder = originalDecoder 16106 } 16107 *v = sv 16108 return nil 16109} 16110 16111func awsAwsquery_deserializeDocumentEventListUnwrapped(v *[]types.Event, decoder smithyxml.NodeDecoder) error { 16112 var sv []types.Event 16113 if *v == nil { 16114 sv = make([]types.Event, 0) 16115 } else { 16116 sv = *v 16117 } 16118 16119 switch { 16120 default: 16121 var mv types.Event 16122 t := decoder.StartEl 16123 _ = t 16124 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16125 destAddr := &mv 16126 if err := awsAwsquery_deserializeDocumentEvent(&destAddr, nodeDecoder); err != nil { 16127 return err 16128 } 16129 mv = *destAddr 16130 sv = append(sv, mv) 16131 } 16132 *v = sv 16133 return nil 16134} 16135func awsAwsquery_deserializeDocumentEventSubscription(v **types.EventSubscription, decoder smithyxml.NodeDecoder) error { 16136 if v == nil { 16137 return fmt.Errorf("unexpected nil of type %T", v) 16138 } 16139 var sv *types.EventSubscription 16140 if *v == nil { 16141 sv = &types.EventSubscription{} 16142 } else { 16143 sv = *v 16144 } 16145 16146 for { 16147 t, done, err := decoder.Token() 16148 if err != nil { 16149 return err 16150 } 16151 if done { 16152 break 16153 } 16154 originalDecoder := decoder 16155 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16156 switch { 16157 case strings.EqualFold("CustomerAwsId", t.Name.Local): 16158 val, err := decoder.Value() 16159 if err != nil { 16160 return err 16161 } 16162 if val == nil { 16163 break 16164 } 16165 { 16166 xtv := string(val) 16167 sv.CustomerAwsId = ptr.String(xtv) 16168 } 16169 16170 case strings.EqualFold("CustSubscriptionId", t.Name.Local): 16171 val, err := decoder.Value() 16172 if err != nil { 16173 return err 16174 } 16175 if val == nil { 16176 break 16177 } 16178 { 16179 xtv := string(val) 16180 sv.CustSubscriptionId = ptr.String(xtv) 16181 } 16182 16183 case strings.EqualFold("Enabled", t.Name.Local): 16184 val, err := decoder.Value() 16185 if err != nil { 16186 return err 16187 } 16188 if val == nil { 16189 break 16190 } 16191 { 16192 xtv, err := strconv.ParseBool(string(val)) 16193 if err != nil { 16194 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 16195 } 16196 sv.Enabled = xtv 16197 } 16198 16199 case strings.EqualFold("EventCategoriesList", t.Name.Local): 16200 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16201 if err := awsAwsquery_deserializeDocumentEventCategoriesList(&sv.EventCategoriesList, nodeDecoder); err != nil { 16202 return err 16203 } 16204 16205 case strings.EqualFold("EventSubscriptionArn", t.Name.Local): 16206 val, err := decoder.Value() 16207 if err != nil { 16208 return err 16209 } 16210 if val == nil { 16211 break 16212 } 16213 { 16214 xtv := string(val) 16215 sv.EventSubscriptionArn = ptr.String(xtv) 16216 } 16217 16218 case strings.EqualFold("SnsTopicArn", t.Name.Local): 16219 val, err := decoder.Value() 16220 if err != nil { 16221 return err 16222 } 16223 if val == nil { 16224 break 16225 } 16226 { 16227 xtv := string(val) 16228 sv.SnsTopicArn = ptr.String(xtv) 16229 } 16230 16231 case strings.EqualFold("SourceIdsList", t.Name.Local): 16232 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16233 if err := awsAwsquery_deserializeDocumentSourceIdsList(&sv.SourceIdsList, nodeDecoder); err != nil { 16234 return err 16235 } 16236 16237 case strings.EqualFold("SourceType", t.Name.Local): 16238 val, err := decoder.Value() 16239 if err != nil { 16240 return err 16241 } 16242 if val == nil { 16243 break 16244 } 16245 { 16246 xtv := string(val) 16247 sv.SourceType = ptr.String(xtv) 16248 } 16249 16250 case strings.EqualFold("Status", t.Name.Local): 16251 val, err := decoder.Value() 16252 if err != nil { 16253 return err 16254 } 16255 if val == nil { 16256 break 16257 } 16258 { 16259 xtv := string(val) 16260 sv.Status = ptr.String(xtv) 16261 } 16262 16263 case strings.EqualFold("SubscriptionCreationTime", t.Name.Local): 16264 val, err := decoder.Value() 16265 if err != nil { 16266 return err 16267 } 16268 if val == nil { 16269 break 16270 } 16271 { 16272 xtv := string(val) 16273 sv.SubscriptionCreationTime = ptr.String(xtv) 16274 } 16275 16276 default: 16277 // Do nothing and ignore the unexpected tag element 16278 err = decoder.Decoder.Skip() 16279 if err != nil { 16280 return err 16281 } 16282 16283 } 16284 decoder = originalDecoder 16285 } 16286 *v = sv 16287 return nil 16288} 16289 16290func awsAwsquery_deserializeDocumentEventSubscriptionQuotaExceededFault(v **types.EventSubscriptionQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 16291 if v == nil { 16292 return fmt.Errorf("unexpected nil of type %T", v) 16293 } 16294 var sv *types.EventSubscriptionQuotaExceededFault 16295 if *v == nil { 16296 sv = &types.EventSubscriptionQuotaExceededFault{} 16297 } else { 16298 sv = *v 16299 } 16300 16301 for { 16302 t, done, err := decoder.Token() 16303 if err != nil { 16304 return err 16305 } 16306 if done { 16307 break 16308 } 16309 originalDecoder := decoder 16310 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16311 switch { 16312 case strings.EqualFold("message", t.Name.Local): 16313 val, err := decoder.Value() 16314 if err != nil { 16315 return err 16316 } 16317 if val == nil { 16318 break 16319 } 16320 { 16321 xtv := string(val) 16322 sv.Message = ptr.String(xtv) 16323 } 16324 16325 default: 16326 // Do nothing and ignore the unexpected tag element 16327 err = decoder.Decoder.Skip() 16328 if err != nil { 16329 return err 16330 } 16331 16332 } 16333 decoder = originalDecoder 16334 } 16335 *v = sv 16336 return nil 16337} 16338 16339func awsAwsquery_deserializeDocumentEventSubscriptionsList(v *[]types.EventSubscription, decoder smithyxml.NodeDecoder) error { 16340 if v == nil { 16341 return fmt.Errorf("unexpected nil of type %T", v) 16342 } 16343 var sv []types.EventSubscription 16344 if *v == nil { 16345 sv = make([]types.EventSubscription, 0) 16346 } else { 16347 sv = *v 16348 } 16349 16350 originalDecoder := decoder 16351 for { 16352 t, done, err := decoder.Token() 16353 if err != nil { 16354 return err 16355 } 16356 if done { 16357 break 16358 } 16359 switch { 16360 case strings.EqualFold("EventSubscription", t.Name.Local): 16361 var col types.EventSubscription 16362 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16363 destAddr := &col 16364 if err := awsAwsquery_deserializeDocumentEventSubscription(&destAddr, nodeDecoder); err != nil { 16365 return err 16366 } 16367 col = *destAddr 16368 sv = append(sv, col) 16369 16370 default: 16371 err = decoder.Decoder.Skip() 16372 if err != nil { 16373 return err 16374 } 16375 16376 } 16377 decoder = originalDecoder 16378 } 16379 *v = sv 16380 return nil 16381} 16382 16383func awsAwsquery_deserializeDocumentEventSubscriptionsListUnwrapped(v *[]types.EventSubscription, decoder smithyxml.NodeDecoder) error { 16384 var sv []types.EventSubscription 16385 if *v == nil { 16386 sv = make([]types.EventSubscription, 0) 16387 } else { 16388 sv = *v 16389 } 16390 16391 switch { 16392 default: 16393 var mv types.EventSubscription 16394 t := decoder.StartEl 16395 _ = t 16396 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16397 destAddr := &mv 16398 if err := awsAwsquery_deserializeDocumentEventSubscription(&destAddr, nodeDecoder); err != nil { 16399 return err 16400 } 16401 mv = *destAddr 16402 sv = append(sv, mv) 16403 } 16404 *v = sv 16405 return nil 16406} 16407func awsAwsquery_deserializeDocumentInstanceQuotaExceededFault(v **types.InstanceQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 16408 if v == nil { 16409 return fmt.Errorf("unexpected nil of type %T", v) 16410 } 16411 var sv *types.InstanceQuotaExceededFault 16412 if *v == nil { 16413 sv = &types.InstanceQuotaExceededFault{} 16414 } else { 16415 sv = *v 16416 } 16417 16418 for { 16419 t, done, err := decoder.Token() 16420 if err != nil { 16421 return err 16422 } 16423 if done { 16424 break 16425 } 16426 originalDecoder := decoder 16427 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16428 switch { 16429 case strings.EqualFold("message", t.Name.Local): 16430 val, err := decoder.Value() 16431 if err != nil { 16432 return err 16433 } 16434 if val == nil { 16435 break 16436 } 16437 { 16438 xtv := string(val) 16439 sv.Message = ptr.String(xtv) 16440 } 16441 16442 default: 16443 // Do nothing and ignore the unexpected tag element 16444 err = decoder.Decoder.Skip() 16445 if err != nil { 16446 return err 16447 } 16448 16449 } 16450 decoder = originalDecoder 16451 } 16452 *v = sv 16453 return nil 16454} 16455 16456func awsAwsquery_deserializeDocumentInsufficientDBClusterCapacityFault(v **types.InsufficientDBClusterCapacityFault, decoder smithyxml.NodeDecoder) error { 16457 if v == nil { 16458 return fmt.Errorf("unexpected nil of type %T", v) 16459 } 16460 var sv *types.InsufficientDBClusterCapacityFault 16461 if *v == nil { 16462 sv = &types.InsufficientDBClusterCapacityFault{} 16463 } else { 16464 sv = *v 16465 } 16466 16467 for { 16468 t, done, err := decoder.Token() 16469 if err != nil { 16470 return err 16471 } 16472 if done { 16473 break 16474 } 16475 originalDecoder := decoder 16476 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16477 switch { 16478 case strings.EqualFold("message", t.Name.Local): 16479 val, err := decoder.Value() 16480 if err != nil { 16481 return err 16482 } 16483 if val == nil { 16484 break 16485 } 16486 { 16487 xtv := string(val) 16488 sv.Message = ptr.String(xtv) 16489 } 16490 16491 default: 16492 // Do nothing and ignore the unexpected tag element 16493 err = decoder.Decoder.Skip() 16494 if err != nil { 16495 return err 16496 } 16497 16498 } 16499 decoder = originalDecoder 16500 } 16501 *v = sv 16502 return nil 16503} 16504 16505func awsAwsquery_deserializeDocumentInsufficientDBInstanceCapacityFault(v **types.InsufficientDBInstanceCapacityFault, decoder smithyxml.NodeDecoder) error { 16506 if v == nil { 16507 return fmt.Errorf("unexpected nil of type %T", v) 16508 } 16509 var sv *types.InsufficientDBInstanceCapacityFault 16510 if *v == nil { 16511 sv = &types.InsufficientDBInstanceCapacityFault{} 16512 } else { 16513 sv = *v 16514 } 16515 16516 for { 16517 t, done, err := decoder.Token() 16518 if err != nil { 16519 return err 16520 } 16521 if done { 16522 break 16523 } 16524 originalDecoder := decoder 16525 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16526 switch { 16527 case strings.EqualFold("message", t.Name.Local): 16528 val, err := decoder.Value() 16529 if err != nil { 16530 return err 16531 } 16532 if val == nil { 16533 break 16534 } 16535 { 16536 xtv := string(val) 16537 sv.Message = ptr.String(xtv) 16538 } 16539 16540 default: 16541 // Do nothing and ignore the unexpected tag element 16542 err = decoder.Decoder.Skip() 16543 if err != nil { 16544 return err 16545 } 16546 16547 } 16548 decoder = originalDecoder 16549 } 16550 *v = sv 16551 return nil 16552} 16553 16554func awsAwsquery_deserializeDocumentInsufficientStorageClusterCapacityFault(v **types.InsufficientStorageClusterCapacityFault, decoder smithyxml.NodeDecoder) error { 16555 if v == nil { 16556 return fmt.Errorf("unexpected nil of type %T", v) 16557 } 16558 var sv *types.InsufficientStorageClusterCapacityFault 16559 if *v == nil { 16560 sv = &types.InsufficientStorageClusterCapacityFault{} 16561 } else { 16562 sv = *v 16563 } 16564 16565 for { 16566 t, done, err := decoder.Token() 16567 if err != nil { 16568 return err 16569 } 16570 if done { 16571 break 16572 } 16573 originalDecoder := decoder 16574 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16575 switch { 16576 case strings.EqualFold("message", t.Name.Local): 16577 val, err := decoder.Value() 16578 if err != nil { 16579 return err 16580 } 16581 if val == nil { 16582 break 16583 } 16584 { 16585 xtv := string(val) 16586 sv.Message = ptr.String(xtv) 16587 } 16588 16589 default: 16590 // Do nothing and ignore the unexpected tag element 16591 err = decoder.Decoder.Skip() 16592 if err != nil { 16593 return err 16594 } 16595 16596 } 16597 decoder = originalDecoder 16598 } 16599 *v = sv 16600 return nil 16601} 16602 16603func awsAwsquery_deserializeDocumentInvalidDBClusterEndpointStateFault(v **types.InvalidDBClusterEndpointStateFault, decoder smithyxml.NodeDecoder) error { 16604 if v == nil { 16605 return fmt.Errorf("unexpected nil of type %T", v) 16606 } 16607 var sv *types.InvalidDBClusterEndpointStateFault 16608 if *v == nil { 16609 sv = &types.InvalidDBClusterEndpointStateFault{} 16610 } else { 16611 sv = *v 16612 } 16613 16614 for { 16615 t, done, err := decoder.Token() 16616 if err != nil { 16617 return err 16618 } 16619 if done { 16620 break 16621 } 16622 originalDecoder := decoder 16623 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16624 switch { 16625 case strings.EqualFold("message", t.Name.Local): 16626 val, err := decoder.Value() 16627 if err != nil { 16628 return err 16629 } 16630 if val == nil { 16631 break 16632 } 16633 { 16634 xtv := string(val) 16635 sv.Message = ptr.String(xtv) 16636 } 16637 16638 default: 16639 // Do nothing and ignore the unexpected tag element 16640 err = decoder.Decoder.Skip() 16641 if err != nil { 16642 return err 16643 } 16644 16645 } 16646 decoder = originalDecoder 16647 } 16648 *v = sv 16649 return nil 16650} 16651 16652func awsAwsquery_deserializeDocumentInvalidDBClusterSnapshotStateFault(v **types.InvalidDBClusterSnapshotStateFault, decoder smithyxml.NodeDecoder) error { 16653 if v == nil { 16654 return fmt.Errorf("unexpected nil of type %T", v) 16655 } 16656 var sv *types.InvalidDBClusterSnapshotStateFault 16657 if *v == nil { 16658 sv = &types.InvalidDBClusterSnapshotStateFault{} 16659 } else { 16660 sv = *v 16661 } 16662 16663 for { 16664 t, done, err := decoder.Token() 16665 if err != nil { 16666 return err 16667 } 16668 if done { 16669 break 16670 } 16671 originalDecoder := decoder 16672 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16673 switch { 16674 case strings.EqualFold("message", t.Name.Local): 16675 val, err := decoder.Value() 16676 if err != nil { 16677 return err 16678 } 16679 if val == nil { 16680 break 16681 } 16682 { 16683 xtv := string(val) 16684 sv.Message = ptr.String(xtv) 16685 } 16686 16687 default: 16688 // Do nothing and ignore the unexpected tag element 16689 err = decoder.Decoder.Skip() 16690 if err != nil { 16691 return err 16692 } 16693 16694 } 16695 decoder = originalDecoder 16696 } 16697 *v = sv 16698 return nil 16699} 16700 16701func awsAwsquery_deserializeDocumentInvalidDBClusterStateFault(v **types.InvalidDBClusterStateFault, decoder smithyxml.NodeDecoder) error { 16702 if v == nil { 16703 return fmt.Errorf("unexpected nil of type %T", v) 16704 } 16705 var sv *types.InvalidDBClusterStateFault 16706 if *v == nil { 16707 sv = &types.InvalidDBClusterStateFault{} 16708 } else { 16709 sv = *v 16710 } 16711 16712 for { 16713 t, done, err := decoder.Token() 16714 if err != nil { 16715 return err 16716 } 16717 if done { 16718 break 16719 } 16720 originalDecoder := decoder 16721 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16722 switch { 16723 case strings.EqualFold("message", t.Name.Local): 16724 val, err := decoder.Value() 16725 if err != nil { 16726 return err 16727 } 16728 if val == nil { 16729 break 16730 } 16731 { 16732 xtv := string(val) 16733 sv.Message = ptr.String(xtv) 16734 } 16735 16736 default: 16737 // Do nothing and ignore the unexpected tag element 16738 err = decoder.Decoder.Skip() 16739 if err != nil { 16740 return err 16741 } 16742 16743 } 16744 decoder = originalDecoder 16745 } 16746 *v = sv 16747 return nil 16748} 16749 16750func awsAwsquery_deserializeDocumentInvalidDBInstanceStateFault(v **types.InvalidDBInstanceStateFault, decoder smithyxml.NodeDecoder) error { 16751 if v == nil { 16752 return fmt.Errorf("unexpected nil of type %T", v) 16753 } 16754 var sv *types.InvalidDBInstanceStateFault 16755 if *v == nil { 16756 sv = &types.InvalidDBInstanceStateFault{} 16757 } else { 16758 sv = *v 16759 } 16760 16761 for { 16762 t, done, err := decoder.Token() 16763 if err != nil { 16764 return err 16765 } 16766 if done { 16767 break 16768 } 16769 originalDecoder := decoder 16770 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16771 switch { 16772 case strings.EqualFold("message", t.Name.Local): 16773 val, err := decoder.Value() 16774 if err != nil { 16775 return err 16776 } 16777 if val == nil { 16778 break 16779 } 16780 { 16781 xtv := string(val) 16782 sv.Message = ptr.String(xtv) 16783 } 16784 16785 default: 16786 // Do nothing and ignore the unexpected tag element 16787 err = decoder.Decoder.Skip() 16788 if err != nil { 16789 return err 16790 } 16791 16792 } 16793 decoder = originalDecoder 16794 } 16795 *v = sv 16796 return nil 16797} 16798 16799func awsAwsquery_deserializeDocumentInvalidDBParameterGroupStateFault(v **types.InvalidDBParameterGroupStateFault, decoder smithyxml.NodeDecoder) error { 16800 if v == nil { 16801 return fmt.Errorf("unexpected nil of type %T", v) 16802 } 16803 var sv *types.InvalidDBParameterGroupStateFault 16804 if *v == nil { 16805 sv = &types.InvalidDBParameterGroupStateFault{} 16806 } else { 16807 sv = *v 16808 } 16809 16810 for { 16811 t, done, err := decoder.Token() 16812 if err != nil { 16813 return err 16814 } 16815 if done { 16816 break 16817 } 16818 originalDecoder := decoder 16819 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16820 switch { 16821 case strings.EqualFold("message", t.Name.Local): 16822 val, err := decoder.Value() 16823 if err != nil { 16824 return err 16825 } 16826 if val == nil { 16827 break 16828 } 16829 { 16830 xtv := string(val) 16831 sv.Message = ptr.String(xtv) 16832 } 16833 16834 default: 16835 // Do nothing and ignore the unexpected tag element 16836 err = decoder.Decoder.Skip() 16837 if err != nil { 16838 return err 16839 } 16840 16841 } 16842 decoder = originalDecoder 16843 } 16844 *v = sv 16845 return nil 16846} 16847 16848func awsAwsquery_deserializeDocumentInvalidDBSecurityGroupStateFault(v **types.InvalidDBSecurityGroupStateFault, decoder smithyxml.NodeDecoder) error { 16849 if v == nil { 16850 return fmt.Errorf("unexpected nil of type %T", v) 16851 } 16852 var sv *types.InvalidDBSecurityGroupStateFault 16853 if *v == nil { 16854 sv = &types.InvalidDBSecurityGroupStateFault{} 16855 } else { 16856 sv = *v 16857 } 16858 16859 for { 16860 t, done, err := decoder.Token() 16861 if err != nil { 16862 return err 16863 } 16864 if done { 16865 break 16866 } 16867 originalDecoder := decoder 16868 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16869 switch { 16870 case strings.EqualFold("message", t.Name.Local): 16871 val, err := decoder.Value() 16872 if err != nil { 16873 return err 16874 } 16875 if val == nil { 16876 break 16877 } 16878 { 16879 xtv := string(val) 16880 sv.Message = ptr.String(xtv) 16881 } 16882 16883 default: 16884 // Do nothing and ignore the unexpected tag element 16885 err = decoder.Decoder.Skip() 16886 if err != nil { 16887 return err 16888 } 16889 16890 } 16891 decoder = originalDecoder 16892 } 16893 *v = sv 16894 return nil 16895} 16896 16897func awsAwsquery_deserializeDocumentInvalidDBSnapshotStateFault(v **types.InvalidDBSnapshotStateFault, decoder smithyxml.NodeDecoder) error { 16898 if v == nil { 16899 return fmt.Errorf("unexpected nil of type %T", v) 16900 } 16901 var sv *types.InvalidDBSnapshotStateFault 16902 if *v == nil { 16903 sv = &types.InvalidDBSnapshotStateFault{} 16904 } else { 16905 sv = *v 16906 } 16907 16908 for { 16909 t, done, err := decoder.Token() 16910 if err != nil { 16911 return err 16912 } 16913 if done { 16914 break 16915 } 16916 originalDecoder := decoder 16917 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16918 switch { 16919 case strings.EqualFold("message", t.Name.Local): 16920 val, err := decoder.Value() 16921 if err != nil { 16922 return err 16923 } 16924 if val == nil { 16925 break 16926 } 16927 { 16928 xtv := string(val) 16929 sv.Message = ptr.String(xtv) 16930 } 16931 16932 default: 16933 // Do nothing and ignore the unexpected tag element 16934 err = decoder.Decoder.Skip() 16935 if err != nil { 16936 return err 16937 } 16938 16939 } 16940 decoder = originalDecoder 16941 } 16942 *v = sv 16943 return nil 16944} 16945 16946func awsAwsquery_deserializeDocumentInvalidDBSubnetGroupStateFault(v **types.InvalidDBSubnetGroupStateFault, decoder smithyxml.NodeDecoder) error { 16947 if v == nil { 16948 return fmt.Errorf("unexpected nil of type %T", v) 16949 } 16950 var sv *types.InvalidDBSubnetGroupStateFault 16951 if *v == nil { 16952 sv = &types.InvalidDBSubnetGroupStateFault{} 16953 } else { 16954 sv = *v 16955 } 16956 16957 for { 16958 t, done, err := decoder.Token() 16959 if err != nil { 16960 return err 16961 } 16962 if done { 16963 break 16964 } 16965 originalDecoder := decoder 16966 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16967 switch { 16968 case strings.EqualFold("message", t.Name.Local): 16969 val, err := decoder.Value() 16970 if err != nil { 16971 return err 16972 } 16973 if val == nil { 16974 break 16975 } 16976 { 16977 xtv := string(val) 16978 sv.Message = ptr.String(xtv) 16979 } 16980 16981 default: 16982 // Do nothing and ignore the unexpected tag element 16983 err = decoder.Decoder.Skip() 16984 if err != nil { 16985 return err 16986 } 16987 16988 } 16989 decoder = originalDecoder 16990 } 16991 *v = sv 16992 return nil 16993} 16994 16995func awsAwsquery_deserializeDocumentInvalidDBSubnetStateFault(v **types.InvalidDBSubnetStateFault, decoder smithyxml.NodeDecoder) error { 16996 if v == nil { 16997 return fmt.Errorf("unexpected nil of type %T", v) 16998 } 16999 var sv *types.InvalidDBSubnetStateFault 17000 if *v == nil { 17001 sv = &types.InvalidDBSubnetStateFault{} 17002 } else { 17003 sv = *v 17004 } 17005 17006 for { 17007 t, done, err := decoder.Token() 17008 if err != nil { 17009 return err 17010 } 17011 if done { 17012 break 17013 } 17014 originalDecoder := decoder 17015 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17016 switch { 17017 case strings.EqualFold("message", t.Name.Local): 17018 val, err := decoder.Value() 17019 if err != nil { 17020 return err 17021 } 17022 if val == nil { 17023 break 17024 } 17025 { 17026 xtv := string(val) 17027 sv.Message = ptr.String(xtv) 17028 } 17029 17030 default: 17031 // Do nothing and ignore the unexpected tag element 17032 err = decoder.Decoder.Skip() 17033 if err != nil { 17034 return err 17035 } 17036 17037 } 17038 decoder = originalDecoder 17039 } 17040 *v = sv 17041 return nil 17042} 17043 17044func awsAwsquery_deserializeDocumentInvalidEventSubscriptionStateFault(v **types.InvalidEventSubscriptionStateFault, decoder smithyxml.NodeDecoder) error { 17045 if v == nil { 17046 return fmt.Errorf("unexpected nil of type %T", v) 17047 } 17048 var sv *types.InvalidEventSubscriptionStateFault 17049 if *v == nil { 17050 sv = &types.InvalidEventSubscriptionStateFault{} 17051 } else { 17052 sv = *v 17053 } 17054 17055 for { 17056 t, done, err := decoder.Token() 17057 if err != nil { 17058 return err 17059 } 17060 if done { 17061 break 17062 } 17063 originalDecoder := decoder 17064 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17065 switch { 17066 case strings.EqualFold("message", t.Name.Local): 17067 val, err := decoder.Value() 17068 if err != nil { 17069 return err 17070 } 17071 if val == nil { 17072 break 17073 } 17074 { 17075 xtv := string(val) 17076 sv.Message = ptr.String(xtv) 17077 } 17078 17079 default: 17080 // Do nothing and ignore the unexpected tag element 17081 err = decoder.Decoder.Skip() 17082 if err != nil { 17083 return err 17084 } 17085 17086 } 17087 decoder = originalDecoder 17088 } 17089 *v = sv 17090 return nil 17091} 17092 17093func awsAwsquery_deserializeDocumentInvalidRestoreFault(v **types.InvalidRestoreFault, decoder smithyxml.NodeDecoder) error { 17094 if v == nil { 17095 return fmt.Errorf("unexpected nil of type %T", v) 17096 } 17097 var sv *types.InvalidRestoreFault 17098 if *v == nil { 17099 sv = &types.InvalidRestoreFault{} 17100 } else { 17101 sv = *v 17102 } 17103 17104 for { 17105 t, done, err := decoder.Token() 17106 if err != nil { 17107 return err 17108 } 17109 if done { 17110 break 17111 } 17112 originalDecoder := decoder 17113 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17114 switch { 17115 case strings.EqualFold("message", t.Name.Local): 17116 val, err := decoder.Value() 17117 if err != nil { 17118 return err 17119 } 17120 if val == nil { 17121 break 17122 } 17123 { 17124 xtv := string(val) 17125 sv.Message = ptr.String(xtv) 17126 } 17127 17128 default: 17129 // Do nothing and ignore the unexpected tag element 17130 err = decoder.Decoder.Skip() 17131 if err != nil { 17132 return err 17133 } 17134 17135 } 17136 decoder = originalDecoder 17137 } 17138 *v = sv 17139 return nil 17140} 17141 17142func awsAwsquery_deserializeDocumentInvalidSubnet(v **types.InvalidSubnet, decoder smithyxml.NodeDecoder) error { 17143 if v == nil { 17144 return fmt.Errorf("unexpected nil of type %T", v) 17145 } 17146 var sv *types.InvalidSubnet 17147 if *v == nil { 17148 sv = &types.InvalidSubnet{} 17149 } else { 17150 sv = *v 17151 } 17152 17153 for { 17154 t, done, err := decoder.Token() 17155 if err != nil { 17156 return err 17157 } 17158 if done { 17159 break 17160 } 17161 originalDecoder := decoder 17162 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17163 switch { 17164 case strings.EqualFold("message", t.Name.Local): 17165 val, err := decoder.Value() 17166 if err != nil { 17167 return err 17168 } 17169 if val == nil { 17170 break 17171 } 17172 { 17173 xtv := string(val) 17174 sv.Message = ptr.String(xtv) 17175 } 17176 17177 default: 17178 // Do nothing and ignore the unexpected tag element 17179 err = decoder.Decoder.Skip() 17180 if err != nil { 17181 return err 17182 } 17183 17184 } 17185 decoder = originalDecoder 17186 } 17187 *v = sv 17188 return nil 17189} 17190 17191func awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(v **types.InvalidVPCNetworkStateFault, decoder smithyxml.NodeDecoder) error { 17192 if v == nil { 17193 return fmt.Errorf("unexpected nil of type %T", v) 17194 } 17195 var sv *types.InvalidVPCNetworkStateFault 17196 if *v == nil { 17197 sv = &types.InvalidVPCNetworkStateFault{} 17198 } else { 17199 sv = *v 17200 } 17201 17202 for { 17203 t, done, err := decoder.Token() 17204 if err != nil { 17205 return err 17206 } 17207 if done { 17208 break 17209 } 17210 originalDecoder := decoder 17211 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17212 switch { 17213 case strings.EqualFold("message", t.Name.Local): 17214 val, err := decoder.Value() 17215 if err != nil { 17216 return err 17217 } 17218 if val == nil { 17219 break 17220 } 17221 { 17222 xtv := string(val) 17223 sv.Message = ptr.String(xtv) 17224 } 17225 17226 default: 17227 // Do nothing and ignore the unexpected tag element 17228 err = decoder.Decoder.Skip() 17229 if err != nil { 17230 return err 17231 } 17232 17233 } 17234 decoder = originalDecoder 17235 } 17236 *v = sv 17237 return nil 17238} 17239 17240func awsAwsquery_deserializeDocumentKMSKeyNotAccessibleFault(v **types.KMSKeyNotAccessibleFault, decoder smithyxml.NodeDecoder) error { 17241 if v == nil { 17242 return fmt.Errorf("unexpected nil of type %T", v) 17243 } 17244 var sv *types.KMSKeyNotAccessibleFault 17245 if *v == nil { 17246 sv = &types.KMSKeyNotAccessibleFault{} 17247 } else { 17248 sv = *v 17249 } 17250 17251 for { 17252 t, done, err := decoder.Token() 17253 if err != nil { 17254 return err 17255 } 17256 if done { 17257 break 17258 } 17259 originalDecoder := decoder 17260 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17261 switch { 17262 case strings.EqualFold("message", t.Name.Local): 17263 val, err := decoder.Value() 17264 if err != nil { 17265 return err 17266 } 17267 if val == nil { 17268 break 17269 } 17270 { 17271 xtv := string(val) 17272 sv.Message = ptr.String(xtv) 17273 } 17274 17275 default: 17276 // Do nothing and ignore the unexpected tag element 17277 err = decoder.Decoder.Skip() 17278 if err != nil { 17279 return err 17280 } 17281 17282 } 17283 decoder = originalDecoder 17284 } 17285 *v = sv 17286 return nil 17287} 17288 17289func awsAwsquery_deserializeDocumentLogTypeList(v *[]string, decoder smithyxml.NodeDecoder) error { 17290 if v == nil { 17291 return fmt.Errorf("unexpected nil of type %T", v) 17292 } 17293 var sv []string 17294 if *v == nil { 17295 sv = make([]string, 0) 17296 } else { 17297 sv = *v 17298 } 17299 17300 originalDecoder := decoder 17301 for { 17302 t, done, err := decoder.Token() 17303 if err != nil { 17304 return err 17305 } 17306 if done { 17307 break 17308 } 17309 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17310 decoder = memberDecoder 17311 switch { 17312 case strings.EqualFold("member", t.Name.Local): 17313 var col string 17314 val, err := decoder.Value() 17315 if err != nil { 17316 return err 17317 } 17318 if val == nil { 17319 break 17320 } 17321 { 17322 xtv := string(val) 17323 col = xtv 17324 } 17325 sv = append(sv, col) 17326 17327 default: 17328 err = decoder.Decoder.Skip() 17329 if err != nil { 17330 return err 17331 } 17332 17333 } 17334 decoder = originalDecoder 17335 } 17336 *v = sv 17337 return nil 17338} 17339 17340func awsAwsquery_deserializeDocumentLogTypeListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 17341 var sv []string 17342 if *v == nil { 17343 sv = make([]string, 0) 17344 } else { 17345 sv = *v 17346 } 17347 17348 switch { 17349 default: 17350 var mv string 17351 t := decoder.StartEl 17352 _ = t 17353 val, err := decoder.Value() 17354 if err != nil { 17355 return err 17356 } 17357 if val == nil { 17358 break 17359 } 17360 { 17361 xtv := string(val) 17362 mv = xtv 17363 } 17364 sv = append(sv, mv) 17365 } 17366 *v = sv 17367 return nil 17368} 17369func awsAwsquery_deserializeDocumentOptionGroupMembership(v **types.OptionGroupMembership, decoder smithyxml.NodeDecoder) error { 17370 if v == nil { 17371 return fmt.Errorf("unexpected nil of type %T", v) 17372 } 17373 var sv *types.OptionGroupMembership 17374 if *v == nil { 17375 sv = &types.OptionGroupMembership{} 17376 } else { 17377 sv = *v 17378 } 17379 17380 for { 17381 t, done, err := decoder.Token() 17382 if err != nil { 17383 return err 17384 } 17385 if done { 17386 break 17387 } 17388 originalDecoder := decoder 17389 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17390 switch { 17391 case strings.EqualFold("OptionGroupName", t.Name.Local): 17392 val, err := decoder.Value() 17393 if err != nil { 17394 return err 17395 } 17396 if val == nil { 17397 break 17398 } 17399 { 17400 xtv := string(val) 17401 sv.OptionGroupName = ptr.String(xtv) 17402 } 17403 17404 case strings.EqualFold("Status", t.Name.Local): 17405 val, err := decoder.Value() 17406 if err != nil { 17407 return err 17408 } 17409 if val == nil { 17410 break 17411 } 17412 { 17413 xtv := string(val) 17414 sv.Status = ptr.String(xtv) 17415 } 17416 17417 default: 17418 // Do nothing and ignore the unexpected tag element 17419 err = decoder.Decoder.Skip() 17420 if err != nil { 17421 return err 17422 } 17423 17424 } 17425 decoder = originalDecoder 17426 } 17427 *v = sv 17428 return nil 17429} 17430 17431func awsAwsquery_deserializeDocumentOptionGroupMembershipList(v *[]types.OptionGroupMembership, decoder smithyxml.NodeDecoder) error { 17432 if v == nil { 17433 return fmt.Errorf("unexpected nil of type %T", v) 17434 } 17435 var sv []types.OptionGroupMembership 17436 if *v == nil { 17437 sv = make([]types.OptionGroupMembership, 0) 17438 } else { 17439 sv = *v 17440 } 17441 17442 originalDecoder := decoder 17443 for { 17444 t, done, err := decoder.Token() 17445 if err != nil { 17446 return err 17447 } 17448 if done { 17449 break 17450 } 17451 switch { 17452 case strings.EqualFold("OptionGroupMembership", t.Name.Local): 17453 var col types.OptionGroupMembership 17454 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17455 destAddr := &col 17456 if err := awsAwsquery_deserializeDocumentOptionGroupMembership(&destAddr, nodeDecoder); err != nil { 17457 return err 17458 } 17459 col = *destAddr 17460 sv = append(sv, col) 17461 17462 default: 17463 err = decoder.Decoder.Skip() 17464 if err != nil { 17465 return err 17466 } 17467 17468 } 17469 decoder = originalDecoder 17470 } 17471 *v = sv 17472 return nil 17473} 17474 17475func awsAwsquery_deserializeDocumentOptionGroupMembershipListUnwrapped(v *[]types.OptionGroupMembership, decoder smithyxml.NodeDecoder) error { 17476 var sv []types.OptionGroupMembership 17477 if *v == nil { 17478 sv = make([]types.OptionGroupMembership, 0) 17479 } else { 17480 sv = *v 17481 } 17482 17483 switch { 17484 default: 17485 var mv types.OptionGroupMembership 17486 t := decoder.StartEl 17487 _ = t 17488 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17489 destAddr := &mv 17490 if err := awsAwsquery_deserializeDocumentOptionGroupMembership(&destAddr, nodeDecoder); err != nil { 17491 return err 17492 } 17493 mv = *destAddr 17494 sv = append(sv, mv) 17495 } 17496 *v = sv 17497 return nil 17498} 17499func awsAwsquery_deserializeDocumentOptionGroupNotFoundFault(v **types.OptionGroupNotFoundFault, decoder smithyxml.NodeDecoder) error { 17500 if v == nil { 17501 return fmt.Errorf("unexpected nil of type %T", v) 17502 } 17503 var sv *types.OptionGroupNotFoundFault 17504 if *v == nil { 17505 sv = &types.OptionGroupNotFoundFault{} 17506 } else { 17507 sv = *v 17508 } 17509 17510 for { 17511 t, done, err := decoder.Token() 17512 if err != nil { 17513 return err 17514 } 17515 if done { 17516 break 17517 } 17518 originalDecoder := decoder 17519 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17520 switch { 17521 case strings.EqualFold("message", t.Name.Local): 17522 val, err := decoder.Value() 17523 if err != nil { 17524 return err 17525 } 17526 if val == nil { 17527 break 17528 } 17529 { 17530 xtv := string(val) 17531 sv.Message = ptr.String(xtv) 17532 } 17533 17534 default: 17535 // Do nothing and ignore the unexpected tag element 17536 err = decoder.Decoder.Skip() 17537 if err != nil { 17538 return err 17539 } 17540 17541 } 17542 decoder = originalDecoder 17543 } 17544 *v = sv 17545 return nil 17546} 17547 17548func awsAwsquery_deserializeDocumentOrderableDBInstanceOption(v **types.OrderableDBInstanceOption, decoder smithyxml.NodeDecoder) error { 17549 if v == nil { 17550 return fmt.Errorf("unexpected nil of type %T", v) 17551 } 17552 var sv *types.OrderableDBInstanceOption 17553 if *v == nil { 17554 sv = &types.OrderableDBInstanceOption{} 17555 } else { 17556 sv = *v 17557 } 17558 17559 for { 17560 t, done, err := decoder.Token() 17561 if err != nil { 17562 return err 17563 } 17564 if done { 17565 break 17566 } 17567 originalDecoder := decoder 17568 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17569 switch { 17570 case strings.EqualFold("AvailabilityZones", t.Name.Local): 17571 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17572 if err := awsAwsquery_deserializeDocumentAvailabilityZoneList(&sv.AvailabilityZones, nodeDecoder); err != nil { 17573 return err 17574 } 17575 17576 case strings.EqualFold("DBInstanceClass", t.Name.Local): 17577 val, err := decoder.Value() 17578 if err != nil { 17579 return err 17580 } 17581 if val == nil { 17582 break 17583 } 17584 { 17585 xtv := string(val) 17586 sv.DBInstanceClass = ptr.String(xtv) 17587 } 17588 17589 case strings.EqualFold("Engine", t.Name.Local): 17590 val, err := decoder.Value() 17591 if err != nil { 17592 return err 17593 } 17594 if val == nil { 17595 break 17596 } 17597 { 17598 xtv := string(val) 17599 sv.Engine = ptr.String(xtv) 17600 } 17601 17602 case strings.EqualFold("EngineVersion", t.Name.Local): 17603 val, err := decoder.Value() 17604 if err != nil { 17605 return err 17606 } 17607 if val == nil { 17608 break 17609 } 17610 { 17611 xtv := string(val) 17612 sv.EngineVersion = ptr.String(xtv) 17613 } 17614 17615 case strings.EqualFold("LicenseModel", t.Name.Local): 17616 val, err := decoder.Value() 17617 if err != nil { 17618 return err 17619 } 17620 if val == nil { 17621 break 17622 } 17623 { 17624 xtv := string(val) 17625 sv.LicenseModel = ptr.String(xtv) 17626 } 17627 17628 case strings.EqualFold("MaxIopsPerDbInstance", t.Name.Local): 17629 val, err := decoder.Value() 17630 if err != nil { 17631 return err 17632 } 17633 if val == nil { 17634 break 17635 } 17636 { 17637 xtv := string(val) 17638 i64, err := strconv.ParseInt(xtv, 10, 64) 17639 if err != nil { 17640 return err 17641 } 17642 sv.MaxIopsPerDbInstance = ptr.Int32(int32(i64)) 17643 } 17644 17645 case strings.EqualFold("MaxIopsPerGib", t.Name.Local): 17646 val, err := decoder.Value() 17647 if err != nil { 17648 return err 17649 } 17650 if val == nil { 17651 break 17652 } 17653 { 17654 xtv := string(val) 17655 f64, err := strconv.ParseFloat(xtv, 64) 17656 if err != nil { 17657 return err 17658 } 17659 sv.MaxIopsPerGib = ptr.Float64(f64) 17660 } 17661 17662 case strings.EqualFold("MaxStorageSize", t.Name.Local): 17663 val, err := decoder.Value() 17664 if err != nil { 17665 return err 17666 } 17667 if val == nil { 17668 break 17669 } 17670 { 17671 xtv := string(val) 17672 i64, err := strconv.ParseInt(xtv, 10, 64) 17673 if err != nil { 17674 return err 17675 } 17676 sv.MaxStorageSize = ptr.Int32(int32(i64)) 17677 } 17678 17679 case strings.EqualFold("MinIopsPerDbInstance", t.Name.Local): 17680 val, err := decoder.Value() 17681 if err != nil { 17682 return err 17683 } 17684 if val == nil { 17685 break 17686 } 17687 { 17688 xtv := string(val) 17689 i64, err := strconv.ParseInt(xtv, 10, 64) 17690 if err != nil { 17691 return err 17692 } 17693 sv.MinIopsPerDbInstance = ptr.Int32(int32(i64)) 17694 } 17695 17696 case strings.EqualFold("MinIopsPerGib", t.Name.Local): 17697 val, err := decoder.Value() 17698 if err != nil { 17699 return err 17700 } 17701 if val == nil { 17702 break 17703 } 17704 { 17705 xtv := string(val) 17706 f64, err := strconv.ParseFloat(xtv, 64) 17707 if err != nil { 17708 return err 17709 } 17710 sv.MinIopsPerGib = ptr.Float64(f64) 17711 } 17712 17713 case strings.EqualFold("MinStorageSize", t.Name.Local): 17714 val, err := decoder.Value() 17715 if err != nil { 17716 return err 17717 } 17718 if val == nil { 17719 break 17720 } 17721 { 17722 xtv := string(val) 17723 i64, err := strconv.ParseInt(xtv, 10, 64) 17724 if err != nil { 17725 return err 17726 } 17727 sv.MinStorageSize = ptr.Int32(int32(i64)) 17728 } 17729 17730 case strings.EqualFold("MultiAZCapable", t.Name.Local): 17731 val, err := decoder.Value() 17732 if err != nil { 17733 return err 17734 } 17735 if val == nil { 17736 break 17737 } 17738 { 17739 xtv, err := strconv.ParseBool(string(val)) 17740 if err != nil { 17741 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17742 } 17743 sv.MultiAZCapable = xtv 17744 } 17745 17746 case strings.EqualFold("ReadReplicaCapable", t.Name.Local): 17747 val, err := decoder.Value() 17748 if err != nil { 17749 return err 17750 } 17751 if val == nil { 17752 break 17753 } 17754 { 17755 xtv, err := strconv.ParseBool(string(val)) 17756 if err != nil { 17757 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17758 } 17759 sv.ReadReplicaCapable = xtv 17760 } 17761 17762 case strings.EqualFold("StorageType", t.Name.Local): 17763 val, err := decoder.Value() 17764 if err != nil { 17765 return err 17766 } 17767 if val == nil { 17768 break 17769 } 17770 { 17771 xtv := string(val) 17772 sv.StorageType = ptr.String(xtv) 17773 } 17774 17775 case strings.EqualFold("SupportsEnhancedMonitoring", t.Name.Local): 17776 val, err := decoder.Value() 17777 if err != nil { 17778 return err 17779 } 17780 if val == nil { 17781 break 17782 } 17783 { 17784 xtv, err := strconv.ParseBool(string(val)) 17785 if err != nil { 17786 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17787 } 17788 sv.SupportsEnhancedMonitoring = xtv 17789 } 17790 17791 case strings.EqualFold("SupportsIAMDatabaseAuthentication", t.Name.Local): 17792 val, err := decoder.Value() 17793 if err != nil { 17794 return err 17795 } 17796 if val == nil { 17797 break 17798 } 17799 { 17800 xtv, err := strconv.ParseBool(string(val)) 17801 if err != nil { 17802 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17803 } 17804 sv.SupportsIAMDatabaseAuthentication = xtv 17805 } 17806 17807 case strings.EqualFold("SupportsIops", t.Name.Local): 17808 val, err := decoder.Value() 17809 if err != nil { 17810 return err 17811 } 17812 if val == nil { 17813 break 17814 } 17815 { 17816 xtv, err := strconv.ParseBool(string(val)) 17817 if err != nil { 17818 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17819 } 17820 sv.SupportsIops = xtv 17821 } 17822 17823 case strings.EqualFold("SupportsPerformanceInsights", t.Name.Local): 17824 val, err := decoder.Value() 17825 if err != nil { 17826 return err 17827 } 17828 if val == nil { 17829 break 17830 } 17831 { 17832 xtv, err := strconv.ParseBool(string(val)) 17833 if err != nil { 17834 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17835 } 17836 sv.SupportsPerformanceInsights = xtv 17837 } 17838 17839 case strings.EqualFold("SupportsStorageEncryption", t.Name.Local): 17840 val, err := decoder.Value() 17841 if err != nil { 17842 return err 17843 } 17844 if val == nil { 17845 break 17846 } 17847 { 17848 xtv, err := strconv.ParseBool(string(val)) 17849 if err != nil { 17850 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17851 } 17852 sv.SupportsStorageEncryption = xtv 17853 } 17854 17855 case strings.EqualFold("Vpc", t.Name.Local): 17856 val, err := decoder.Value() 17857 if err != nil { 17858 return err 17859 } 17860 if val == nil { 17861 break 17862 } 17863 { 17864 xtv, err := strconv.ParseBool(string(val)) 17865 if err != nil { 17866 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 17867 } 17868 sv.Vpc = xtv 17869 } 17870 17871 default: 17872 // Do nothing and ignore the unexpected tag element 17873 err = decoder.Decoder.Skip() 17874 if err != nil { 17875 return err 17876 } 17877 17878 } 17879 decoder = originalDecoder 17880 } 17881 *v = sv 17882 return nil 17883} 17884 17885func awsAwsquery_deserializeDocumentOrderableDBInstanceOptionsList(v *[]types.OrderableDBInstanceOption, decoder smithyxml.NodeDecoder) error { 17886 if v == nil { 17887 return fmt.Errorf("unexpected nil of type %T", v) 17888 } 17889 var sv []types.OrderableDBInstanceOption 17890 if *v == nil { 17891 sv = make([]types.OrderableDBInstanceOption, 0) 17892 } else { 17893 sv = *v 17894 } 17895 17896 originalDecoder := decoder 17897 for { 17898 t, done, err := decoder.Token() 17899 if err != nil { 17900 return err 17901 } 17902 if done { 17903 break 17904 } 17905 switch { 17906 case strings.EqualFold("OrderableDBInstanceOption", t.Name.Local): 17907 var col types.OrderableDBInstanceOption 17908 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17909 destAddr := &col 17910 if err := awsAwsquery_deserializeDocumentOrderableDBInstanceOption(&destAddr, nodeDecoder); err != nil { 17911 return err 17912 } 17913 col = *destAddr 17914 sv = append(sv, col) 17915 17916 default: 17917 err = decoder.Decoder.Skip() 17918 if err != nil { 17919 return err 17920 } 17921 17922 } 17923 decoder = originalDecoder 17924 } 17925 *v = sv 17926 return nil 17927} 17928 17929func awsAwsquery_deserializeDocumentOrderableDBInstanceOptionsListUnwrapped(v *[]types.OrderableDBInstanceOption, decoder smithyxml.NodeDecoder) error { 17930 var sv []types.OrderableDBInstanceOption 17931 if *v == nil { 17932 sv = make([]types.OrderableDBInstanceOption, 0) 17933 } else { 17934 sv = *v 17935 } 17936 17937 switch { 17938 default: 17939 var mv types.OrderableDBInstanceOption 17940 t := decoder.StartEl 17941 _ = t 17942 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17943 destAddr := &mv 17944 if err := awsAwsquery_deserializeDocumentOrderableDBInstanceOption(&destAddr, nodeDecoder); err != nil { 17945 return err 17946 } 17947 mv = *destAddr 17948 sv = append(sv, mv) 17949 } 17950 *v = sv 17951 return nil 17952} 17953func awsAwsquery_deserializeDocumentParameter(v **types.Parameter, decoder smithyxml.NodeDecoder) error { 17954 if v == nil { 17955 return fmt.Errorf("unexpected nil of type %T", v) 17956 } 17957 var sv *types.Parameter 17958 if *v == nil { 17959 sv = &types.Parameter{} 17960 } else { 17961 sv = *v 17962 } 17963 17964 for { 17965 t, done, err := decoder.Token() 17966 if err != nil { 17967 return err 17968 } 17969 if done { 17970 break 17971 } 17972 originalDecoder := decoder 17973 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17974 switch { 17975 case strings.EqualFold("AllowedValues", t.Name.Local): 17976 val, err := decoder.Value() 17977 if err != nil { 17978 return err 17979 } 17980 if val == nil { 17981 break 17982 } 17983 { 17984 xtv := string(val) 17985 sv.AllowedValues = ptr.String(xtv) 17986 } 17987 17988 case strings.EqualFold("ApplyMethod", t.Name.Local): 17989 val, err := decoder.Value() 17990 if err != nil { 17991 return err 17992 } 17993 if val == nil { 17994 break 17995 } 17996 { 17997 xtv := string(val) 17998 sv.ApplyMethod = types.ApplyMethod(xtv) 17999 } 18000 18001 case strings.EqualFold("ApplyType", t.Name.Local): 18002 val, err := decoder.Value() 18003 if err != nil { 18004 return err 18005 } 18006 if val == nil { 18007 break 18008 } 18009 { 18010 xtv := string(val) 18011 sv.ApplyType = ptr.String(xtv) 18012 } 18013 18014 case strings.EqualFold("DataType", t.Name.Local): 18015 val, err := decoder.Value() 18016 if err != nil { 18017 return err 18018 } 18019 if val == nil { 18020 break 18021 } 18022 { 18023 xtv := string(val) 18024 sv.DataType = ptr.String(xtv) 18025 } 18026 18027 case strings.EqualFold("Description", t.Name.Local): 18028 val, err := decoder.Value() 18029 if err != nil { 18030 return err 18031 } 18032 if val == nil { 18033 break 18034 } 18035 { 18036 xtv := string(val) 18037 sv.Description = ptr.String(xtv) 18038 } 18039 18040 case strings.EqualFold("IsModifiable", t.Name.Local): 18041 val, err := decoder.Value() 18042 if err != nil { 18043 return err 18044 } 18045 if val == nil { 18046 break 18047 } 18048 { 18049 xtv, err := strconv.ParseBool(string(val)) 18050 if err != nil { 18051 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 18052 } 18053 sv.IsModifiable = xtv 18054 } 18055 18056 case strings.EqualFold("MinimumEngineVersion", t.Name.Local): 18057 val, err := decoder.Value() 18058 if err != nil { 18059 return err 18060 } 18061 if val == nil { 18062 break 18063 } 18064 { 18065 xtv := string(val) 18066 sv.MinimumEngineVersion = ptr.String(xtv) 18067 } 18068 18069 case strings.EqualFold("ParameterName", t.Name.Local): 18070 val, err := decoder.Value() 18071 if err != nil { 18072 return err 18073 } 18074 if val == nil { 18075 break 18076 } 18077 { 18078 xtv := string(val) 18079 sv.ParameterName = ptr.String(xtv) 18080 } 18081 18082 case strings.EqualFold("ParameterValue", t.Name.Local): 18083 val, err := decoder.Value() 18084 if err != nil { 18085 return err 18086 } 18087 if val == nil { 18088 break 18089 } 18090 { 18091 xtv := string(val) 18092 sv.ParameterValue = ptr.String(xtv) 18093 } 18094 18095 case strings.EqualFold("Source", t.Name.Local): 18096 val, err := decoder.Value() 18097 if err != nil { 18098 return err 18099 } 18100 if val == nil { 18101 break 18102 } 18103 { 18104 xtv := string(val) 18105 sv.Source = ptr.String(xtv) 18106 } 18107 18108 default: 18109 // Do nothing and ignore the unexpected tag element 18110 err = decoder.Decoder.Skip() 18111 if err != nil { 18112 return err 18113 } 18114 18115 } 18116 decoder = originalDecoder 18117 } 18118 *v = sv 18119 return nil 18120} 18121 18122func awsAwsquery_deserializeDocumentParametersList(v *[]types.Parameter, decoder smithyxml.NodeDecoder) error { 18123 if v == nil { 18124 return fmt.Errorf("unexpected nil of type %T", v) 18125 } 18126 var sv []types.Parameter 18127 if *v == nil { 18128 sv = make([]types.Parameter, 0) 18129 } else { 18130 sv = *v 18131 } 18132 18133 originalDecoder := decoder 18134 for { 18135 t, done, err := decoder.Token() 18136 if err != nil { 18137 return err 18138 } 18139 if done { 18140 break 18141 } 18142 switch { 18143 case strings.EqualFold("Parameter", t.Name.Local): 18144 var col types.Parameter 18145 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18146 destAddr := &col 18147 if err := awsAwsquery_deserializeDocumentParameter(&destAddr, nodeDecoder); err != nil { 18148 return err 18149 } 18150 col = *destAddr 18151 sv = append(sv, col) 18152 18153 default: 18154 err = decoder.Decoder.Skip() 18155 if err != nil { 18156 return err 18157 } 18158 18159 } 18160 decoder = originalDecoder 18161 } 18162 *v = sv 18163 return nil 18164} 18165 18166func awsAwsquery_deserializeDocumentParametersListUnwrapped(v *[]types.Parameter, decoder smithyxml.NodeDecoder) error { 18167 var sv []types.Parameter 18168 if *v == nil { 18169 sv = make([]types.Parameter, 0) 18170 } else { 18171 sv = *v 18172 } 18173 18174 switch { 18175 default: 18176 var mv types.Parameter 18177 t := decoder.StartEl 18178 _ = t 18179 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18180 destAddr := &mv 18181 if err := awsAwsquery_deserializeDocumentParameter(&destAddr, nodeDecoder); err != nil { 18182 return err 18183 } 18184 mv = *destAddr 18185 sv = append(sv, mv) 18186 } 18187 *v = sv 18188 return nil 18189} 18190func awsAwsquery_deserializeDocumentPendingCloudwatchLogsExports(v **types.PendingCloudwatchLogsExports, decoder smithyxml.NodeDecoder) error { 18191 if v == nil { 18192 return fmt.Errorf("unexpected nil of type %T", v) 18193 } 18194 var sv *types.PendingCloudwatchLogsExports 18195 if *v == nil { 18196 sv = &types.PendingCloudwatchLogsExports{} 18197 } else { 18198 sv = *v 18199 } 18200 18201 for { 18202 t, done, err := decoder.Token() 18203 if err != nil { 18204 return err 18205 } 18206 if done { 18207 break 18208 } 18209 originalDecoder := decoder 18210 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18211 switch { 18212 case strings.EqualFold("LogTypesToDisable", t.Name.Local): 18213 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18214 if err := awsAwsquery_deserializeDocumentLogTypeList(&sv.LogTypesToDisable, nodeDecoder); err != nil { 18215 return err 18216 } 18217 18218 case strings.EqualFold("LogTypesToEnable", t.Name.Local): 18219 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18220 if err := awsAwsquery_deserializeDocumentLogTypeList(&sv.LogTypesToEnable, nodeDecoder); err != nil { 18221 return err 18222 } 18223 18224 default: 18225 // Do nothing and ignore the unexpected tag element 18226 err = decoder.Decoder.Skip() 18227 if err != nil { 18228 return err 18229 } 18230 18231 } 18232 decoder = originalDecoder 18233 } 18234 *v = sv 18235 return nil 18236} 18237 18238func awsAwsquery_deserializeDocumentPendingMaintenanceAction(v **types.PendingMaintenanceAction, decoder smithyxml.NodeDecoder) error { 18239 if v == nil { 18240 return fmt.Errorf("unexpected nil of type %T", v) 18241 } 18242 var sv *types.PendingMaintenanceAction 18243 if *v == nil { 18244 sv = &types.PendingMaintenanceAction{} 18245 } else { 18246 sv = *v 18247 } 18248 18249 for { 18250 t, done, err := decoder.Token() 18251 if err != nil { 18252 return err 18253 } 18254 if done { 18255 break 18256 } 18257 originalDecoder := decoder 18258 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18259 switch { 18260 case strings.EqualFold("Action", t.Name.Local): 18261 val, err := decoder.Value() 18262 if err != nil { 18263 return err 18264 } 18265 if val == nil { 18266 break 18267 } 18268 { 18269 xtv := string(val) 18270 sv.Action = ptr.String(xtv) 18271 } 18272 18273 case strings.EqualFold("AutoAppliedAfterDate", t.Name.Local): 18274 val, err := decoder.Value() 18275 if err != nil { 18276 return err 18277 } 18278 if val == nil { 18279 break 18280 } 18281 { 18282 xtv := string(val) 18283 t, err := smithytime.ParseDateTime(xtv) 18284 if err != nil { 18285 return err 18286 } 18287 sv.AutoAppliedAfterDate = ptr.Time(t) 18288 } 18289 18290 case strings.EqualFold("CurrentApplyDate", t.Name.Local): 18291 val, err := decoder.Value() 18292 if err != nil { 18293 return err 18294 } 18295 if val == nil { 18296 break 18297 } 18298 { 18299 xtv := string(val) 18300 t, err := smithytime.ParseDateTime(xtv) 18301 if err != nil { 18302 return err 18303 } 18304 sv.CurrentApplyDate = ptr.Time(t) 18305 } 18306 18307 case strings.EqualFold("Description", t.Name.Local): 18308 val, err := decoder.Value() 18309 if err != nil { 18310 return err 18311 } 18312 if val == nil { 18313 break 18314 } 18315 { 18316 xtv := string(val) 18317 sv.Description = ptr.String(xtv) 18318 } 18319 18320 case strings.EqualFold("ForcedApplyDate", t.Name.Local): 18321 val, err := decoder.Value() 18322 if err != nil { 18323 return err 18324 } 18325 if val == nil { 18326 break 18327 } 18328 { 18329 xtv := string(val) 18330 t, err := smithytime.ParseDateTime(xtv) 18331 if err != nil { 18332 return err 18333 } 18334 sv.ForcedApplyDate = ptr.Time(t) 18335 } 18336 18337 case strings.EqualFold("OptInStatus", t.Name.Local): 18338 val, err := decoder.Value() 18339 if err != nil { 18340 return err 18341 } 18342 if val == nil { 18343 break 18344 } 18345 { 18346 xtv := string(val) 18347 sv.OptInStatus = ptr.String(xtv) 18348 } 18349 18350 default: 18351 // Do nothing and ignore the unexpected tag element 18352 err = decoder.Decoder.Skip() 18353 if err != nil { 18354 return err 18355 } 18356 18357 } 18358 decoder = originalDecoder 18359 } 18360 *v = sv 18361 return nil 18362} 18363 18364func awsAwsquery_deserializeDocumentPendingMaintenanceActionDetails(v *[]types.PendingMaintenanceAction, decoder smithyxml.NodeDecoder) error { 18365 if v == nil { 18366 return fmt.Errorf("unexpected nil of type %T", v) 18367 } 18368 var sv []types.PendingMaintenanceAction 18369 if *v == nil { 18370 sv = make([]types.PendingMaintenanceAction, 0) 18371 } else { 18372 sv = *v 18373 } 18374 18375 originalDecoder := decoder 18376 for { 18377 t, done, err := decoder.Token() 18378 if err != nil { 18379 return err 18380 } 18381 if done { 18382 break 18383 } 18384 switch { 18385 case strings.EqualFold("PendingMaintenanceAction", t.Name.Local): 18386 var col types.PendingMaintenanceAction 18387 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18388 destAddr := &col 18389 if err := awsAwsquery_deserializeDocumentPendingMaintenanceAction(&destAddr, nodeDecoder); err != nil { 18390 return err 18391 } 18392 col = *destAddr 18393 sv = append(sv, col) 18394 18395 default: 18396 err = decoder.Decoder.Skip() 18397 if err != nil { 18398 return err 18399 } 18400 18401 } 18402 decoder = originalDecoder 18403 } 18404 *v = sv 18405 return nil 18406} 18407 18408func awsAwsquery_deserializeDocumentPendingMaintenanceActionDetailsUnwrapped(v *[]types.PendingMaintenanceAction, decoder smithyxml.NodeDecoder) error { 18409 var sv []types.PendingMaintenanceAction 18410 if *v == nil { 18411 sv = make([]types.PendingMaintenanceAction, 0) 18412 } else { 18413 sv = *v 18414 } 18415 18416 switch { 18417 default: 18418 var mv types.PendingMaintenanceAction 18419 t := decoder.StartEl 18420 _ = t 18421 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18422 destAddr := &mv 18423 if err := awsAwsquery_deserializeDocumentPendingMaintenanceAction(&destAddr, nodeDecoder); err != nil { 18424 return err 18425 } 18426 mv = *destAddr 18427 sv = append(sv, mv) 18428 } 18429 *v = sv 18430 return nil 18431} 18432func awsAwsquery_deserializeDocumentPendingMaintenanceActions(v *[]types.ResourcePendingMaintenanceActions, decoder smithyxml.NodeDecoder) error { 18433 if v == nil { 18434 return fmt.Errorf("unexpected nil of type %T", v) 18435 } 18436 var sv []types.ResourcePendingMaintenanceActions 18437 if *v == nil { 18438 sv = make([]types.ResourcePendingMaintenanceActions, 0) 18439 } else { 18440 sv = *v 18441 } 18442 18443 originalDecoder := decoder 18444 for { 18445 t, done, err := decoder.Token() 18446 if err != nil { 18447 return err 18448 } 18449 if done { 18450 break 18451 } 18452 switch { 18453 case strings.EqualFold("ResourcePendingMaintenanceActions", t.Name.Local): 18454 var col types.ResourcePendingMaintenanceActions 18455 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18456 destAddr := &col 18457 if err := awsAwsquery_deserializeDocumentResourcePendingMaintenanceActions(&destAddr, nodeDecoder); err != nil { 18458 return err 18459 } 18460 col = *destAddr 18461 sv = append(sv, col) 18462 18463 default: 18464 err = decoder.Decoder.Skip() 18465 if err != nil { 18466 return err 18467 } 18468 18469 } 18470 decoder = originalDecoder 18471 } 18472 *v = sv 18473 return nil 18474} 18475 18476func awsAwsquery_deserializeDocumentPendingMaintenanceActionsUnwrapped(v *[]types.ResourcePendingMaintenanceActions, decoder smithyxml.NodeDecoder) error { 18477 var sv []types.ResourcePendingMaintenanceActions 18478 if *v == nil { 18479 sv = make([]types.ResourcePendingMaintenanceActions, 0) 18480 } else { 18481 sv = *v 18482 } 18483 18484 switch { 18485 default: 18486 var mv types.ResourcePendingMaintenanceActions 18487 t := decoder.StartEl 18488 _ = t 18489 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18490 destAddr := &mv 18491 if err := awsAwsquery_deserializeDocumentResourcePendingMaintenanceActions(&destAddr, nodeDecoder); err != nil { 18492 return err 18493 } 18494 mv = *destAddr 18495 sv = append(sv, mv) 18496 } 18497 *v = sv 18498 return nil 18499} 18500func awsAwsquery_deserializeDocumentPendingModifiedValues(v **types.PendingModifiedValues, decoder smithyxml.NodeDecoder) error { 18501 if v == nil { 18502 return fmt.Errorf("unexpected nil of type %T", v) 18503 } 18504 var sv *types.PendingModifiedValues 18505 if *v == nil { 18506 sv = &types.PendingModifiedValues{} 18507 } else { 18508 sv = *v 18509 } 18510 18511 for { 18512 t, done, err := decoder.Token() 18513 if err != nil { 18514 return err 18515 } 18516 if done { 18517 break 18518 } 18519 originalDecoder := decoder 18520 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18521 switch { 18522 case strings.EqualFold("AllocatedStorage", t.Name.Local): 18523 val, err := decoder.Value() 18524 if err != nil { 18525 return err 18526 } 18527 if val == nil { 18528 break 18529 } 18530 { 18531 xtv := string(val) 18532 i64, err := strconv.ParseInt(xtv, 10, 64) 18533 if err != nil { 18534 return err 18535 } 18536 sv.AllocatedStorage = ptr.Int32(int32(i64)) 18537 } 18538 18539 case strings.EqualFold("BackupRetentionPeriod", t.Name.Local): 18540 val, err := decoder.Value() 18541 if err != nil { 18542 return err 18543 } 18544 if val == nil { 18545 break 18546 } 18547 { 18548 xtv := string(val) 18549 i64, err := strconv.ParseInt(xtv, 10, 64) 18550 if err != nil { 18551 return err 18552 } 18553 sv.BackupRetentionPeriod = ptr.Int32(int32(i64)) 18554 } 18555 18556 case strings.EqualFold("CACertificateIdentifier", t.Name.Local): 18557 val, err := decoder.Value() 18558 if err != nil { 18559 return err 18560 } 18561 if val == nil { 18562 break 18563 } 18564 { 18565 xtv := string(val) 18566 sv.CACertificateIdentifier = ptr.String(xtv) 18567 } 18568 18569 case strings.EqualFold("DBInstanceClass", t.Name.Local): 18570 val, err := decoder.Value() 18571 if err != nil { 18572 return err 18573 } 18574 if val == nil { 18575 break 18576 } 18577 { 18578 xtv := string(val) 18579 sv.DBInstanceClass = ptr.String(xtv) 18580 } 18581 18582 case strings.EqualFold("DBInstanceIdentifier", t.Name.Local): 18583 val, err := decoder.Value() 18584 if err != nil { 18585 return err 18586 } 18587 if val == nil { 18588 break 18589 } 18590 { 18591 xtv := string(val) 18592 sv.DBInstanceIdentifier = ptr.String(xtv) 18593 } 18594 18595 case strings.EqualFold("DBSubnetGroupName", t.Name.Local): 18596 val, err := decoder.Value() 18597 if err != nil { 18598 return err 18599 } 18600 if val == nil { 18601 break 18602 } 18603 { 18604 xtv := string(val) 18605 sv.DBSubnetGroupName = ptr.String(xtv) 18606 } 18607 18608 case strings.EqualFold("EngineVersion", t.Name.Local): 18609 val, err := decoder.Value() 18610 if err != nil { 18611 return err 18612 } 18613 if val == nil { 18614 break 18615 } 18616 { 18617 xtv := string(val) 18618 sv.EngineVersion = ptr.String(xtv) 18619 } 18620 18621 case strings.EqualFold("Iops", t.Name.Local): 18622 val, err := decoder.Value() 18623 if err != nil { 18624 return err 18625 } 18626 if val == nil { 18627 break 18628 } 18629 { 18630 xtv := string(val) 18631 i64, err := strconv.ParseInt(xtv, 10, 64) 18632 if err != nil { 18633 return err 18634 } 18635 sv.Iops = ptr.Int32(int32(i64)) 18636 } 18637 18638 case strings.EqualFold("LicenseModel", t.Name.Local): 18639 val, err := decoder.Value() 18640 if err != nil { 18641 return err 18642 } 18643 if val == nil { 18644 break 18645 } 18646 { 18647 xtv := string(val) 18648 sv.LicenseModel = ptr.String(xtv) 18649 } 18650 18651 case strings.EqualFold("MasterUserPassword", t.Name.Local): 18652 val, err := decoder.Value() 18653 if err != nil { 18654 return err 18655 } 18656 if val == nil { 18657 break 18658 } 18659 { 18660 xtv := string(val) 18661 sv.MasterUserPassword = ptr.String(xtv) 18662 } 18663 18664 case strings.EqualFold("MultiAZ", t.Name.Local): 18665 val, err := decoder.Value() 18666 if err != nil { 18667 return err 18668 } 18669 if val == nil { 18670 break 18671 } 18672 { 18673 xtv, err := strconv.ParseBool(string(val)) 18674 if err != nil { 18675 return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val) 18676 } 18677 sv.MultiAZ = ptr.Bool(xtv) 18678 } 18679 18680 case strings.EqualFold("PendingCloudwatchLogsExports", t.Name.Local): 18681 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18682 if err := awsAwsquery_deserializeDocumentPendingCloudwatchLogsExports(&sv.PendingCloudwatchLogsExports, nodeDecoder); err != nil { 18683 return err 18684 } 18685 18686 case strings.EqualFold("Port", t.Name.Local): 18687 val, err := decoder.Value() 18688 if err != nil { 18689 return err 18690 } 18691 if val == nil { 18692 break 18693 } 18694 { 18695 xtv := string(val) 18696 i64, err := strconv.ParseInt(xtv, 10, 64) 18697 if err != nil { 18698 return err 18699 } 18700 sv.Port = ptr.Int32(int32(i64)) 18701 } 18702 18703 case strings.EqualFold("StorageType", t.Name.Local): 18704 val, err := decoder.Value() 18705 if err != nil { 18706 return err 18707 } 18708 if val == nil { 18709 break 18710 } 18711 { 18712 xtv := string(val) 18713 sv.StorageType = ptr.String(xtv) 18714 } 18715 18716 default: 18717 // Do nothing and ignore the unexpected tag element 18718 err = decoder.Decoder.Skip() 18719 if err != nil { 18720 return err 18721 } 18722 18723 } 18724 decoder = originalDecoder 18725 } 18726 *v = sv 18727 return nil 18728} 18729 18730func awsAwsquery_deserializeDocumentProvisionedIopsNotAvailableInAZFault(v **types.ProvisionedIopsNotAvailableInAZFault, decoder smithyxml.NodeDecoder) error { 18731 if v == nil { 18732 return fmt.Errorf("unexpected nil of type %T", v) 18733 } 18734 var sv *types.ProvisionedIopsNotAvailableInAZFault 18735 if *v == nil { 18736 sv = &types.ProvisionedIopsNotAvailableInAZFault{} 18737 } else { 18738 sv = *v 18739 } 18740 18741 for { 18742 t, done, err := decoder.Token() 18743 if err != nil { 18744 return err 18745 } 18746 if done { 18747 break 18748 } 18749 originalDecoder := decoder 18750 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18751 switch { 18752 case strings.EqualFold("message", t.Name.Local): 18753 val, err := decoder.Value() 18754 if err != nil { 18755 return err 18756 } 18757 if val == nil { 18758 break 18759 } 18760 { 18761 xtv := string(val) 18762 sv.Message = ptr.String(xtv) 18763 } 18764 18765 default: 18766 // Do nothing and ignore the unexpected tag element 18767 err = decoder.Decoder.Skip() 18768 if err != nil { 18769 return err 18770 } 18771 18772 } 18773 decoder = originalDecoder 18774 } 18775 *v = sv 18776 return nil 18777} 18778 18779func awsAwsquery_deserializeDocumentRange(v **types.Range, decoder smithyxml.NodeDecoder) error { 18780 if v == nil { 18781 return fmt.Errorf("unexpected nil of type %T", v) 18782 } 18783 var sv *types.Range 18784 if *v == nil { 18785 sv = &types.Range{} 18786 } else { 18787 sv = *v 18788 } 18789 18790 for { 18791 t, done, err := decoder.Token() 18792 if err != nil { 18793 return err 18794 } 18795 if done { 18796 break 18797 } 18798 originalDecoder := decoder 18799 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18800 switch { 18801 case strings.EqualFold("From", t.Name.Local): 18802 val, err := decoder.Value() 18803 if err != nil { 18804 return err 18805 } 18806 if val == nil { 18807 break 18808 } 18809 { 18810 xtv := string(val) 18811 i64, err := strconv.ParseInt(xtv, 10, 64) 18812 if err != nil { 18813 return err 18814 } 18815 sv.From = int32(i64) 18816 } 18817 18818 case strings.EqualFold("Step", t.Name.Local): 18819 val, err := decoder.Value() 18820 if err != nil { 18821 return err 18822 } 18823 if val == nil { 18824 break 18825 } 18826 { 18827 xtv := string(val) 18828 i64, err := strconv.ParseInt(xtv, 10, 64) 18829 if err != nil { 18830 return err 18831 } 18832 sv.Step = ptr.Int32(int32(i64)) 18833 } 18834 18835 case strings.EqualFold("To", t.Name.Local): 18836 val, err := decoder.Value() 18837 if err != nil { 18838 return err 18839 } 18840 if val == nil { 18841 break 18842 } 18843 { 18844 xtv := string(val) 18845 i64, err := strconv.ParseInt(xtv, 10, 64) 18846 if err != nil { 18847 return err 18848 } 18849 sv.To = int32(i64) 18850 } 18851 18852 default: 18853 // Do nothing and ignore the unexpected tag element 18854 err = decoder.Decoder.Skip() 18855 if err != nil { 18856 return err 18857 } 18858 18859 } 18860 decoder = originalDecoder 18861 } 18862 *v = sv 18863 return nil 18864} 18865 18866func awsAwsquery_deserializeDocumentRangeList(v *[]types.Range, decoder smithyxml.NodeDecoder) error { 18867 if v == nil { 18868 return fmt.Errorf("unexpected nil of type %T", v) 18869 } 18870 var sv []types.Range 18871 if *v == nil { 18872 sv = make([]types.Range, 0) 18873 } else { 18874 sv = *v 18875 } 18876 18877 originalDecoder := decoder 18878 for { 18879 t, done, err := decoder.Token() 18880 if err != nil { 18881 return err 18882 } 18883 if done { 18884 break 18885 } 18886 switch { 18887 case strings.EqualFold("Range", t.Name.Local): 18888 var col types.Range 18889 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18890 destAddr := &col 18891 if err := awsAwsquery_deserializeDocumentRange(&destAddr, nodeDecoder); err != nil { 18892 return err 18893 } 18894 col = *destAddr 18895 sv = append(sv, col) 18896 18897 default: 18898 err = decoder.Decoder.Skip() 18899 if err != nil { 18900 return err 18901 } 18902 18903 } 18904 decoder = originalDecoder 18905 } 18906 *v = sv 18907 return nil 18908} 18909 18910func awsAwsquery_deserializeDocumentRangeListUnwrapped(v *[]types.Range, decoder smithyxml.NodeDecoder) error { 18911 var sv []types.Range 18912 if *v == nil { 18913 sv = make([]types.Range, 0) 18914 } else { 18915 sv = *v 18916 } 18917 18918 switch { 18919 default: 18920 var mv types.Range 18921 t := decoder.StartEl 18922 _ = t 18923 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18924 destAddr := &mv 18925 if err := awsAwsquery_deserializeDocumentRange(&destAddr, nodeDecoder); err != nil { 18926 return err 18927 } 18928 mv = *destAddr 18929 sv = append(sv, mv) 18930 } 18931 *v = sv 18932 return nil 18933} 18934func awsAwsquery_deserializeDocumentReadReplicaDBClusterIdentifierList(v *[]string, decoder smithyxml.NodeDecoder) error { 18935 if v == nil { 18936 return fmt.Errorf("unexpected nil of type %T", v) 18937 } 18938 var sv []string 18939 if *v == nil { 18940 sv = make([]string, 0) 18941 } else { 18942 sv = *v 18943 } 18944 18945 originalDecoder := decoder 18946 for { 18947 t, done, err := decoder.Token() 18948 if err != nil { 18949 return err 18950 } 18951 if done { 18952 break 18953 } 18954 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18955 decoder = memberDecoder 18956 switch { 18957 case strings.EqualFold("ReadReplicaDBClusterIdentifier", t.Name.Local): 18958 var col string 18959 val, err := decoder.Value() 18960 if err != nil { 18961 return err 18962 } 18963 if val == nil { 18964 break 18965 } 18966 { 18967 xtv := string(val) 18968 col = xtv 18969 } 18970 sv = append(sv, col) 18971 18972 default: 18973 err = decoder.Decoder.Skip() 18974 if err != nil { 18975 return err 18976 } 18977 18978 } 18979 decoder = originalDecoder 18980 } 18981 *v = sv 18982 return nil 18983} 18984 18985func awsAwsquery_deserializeDocumentReadReplicaDBClusterIdentifierListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 18986 var sv []string 18987 if *v == nil { 18988 sv = make([]string, 0) 18989 } else { 18990 sv = *v 18991 } 18992 18993 switch { 18994 default: 18995 var mv string 18996 t := decoder.StartEl 18997 _ = t 18998 val, err := decoder.Value() 18999 if err != nil { 19000 return err 19001 } 19002 if val == nil { 19003 break 19004 } 19005 { 19006 xtv := string(val) 19007 mv = xtv 19008 } 19009 sv = append(sv, mv) 19010 } 19011 *v = sv 19012 return nil 19013} 19014func awsAwsquery_deserializeDocumentReadReplicaDBInstanceIdentifierList(v *[]string, decoder smithyxml.NodeDecoder) error { 19015 if v == nil { 19016 return fmt.Errorf("unexpected nil of type %T", v) 19017 } 19018 var sv []string 19019 if *v == nil { 19020 sv = make([]string, 0) 19021 } else { 19022 sv = *v 19023 } 19024 19025 originalDecoder := decoder 19026 for { 19027 t, done, err := decoder.Token() 19028 if err != nil { 19029 return err 19030 } 19031 if done { 19032 break 19033 } 19034 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19035 decoder = memberDecoder 19036 switch { 19037 case strings.EqualFold("ReadReplicaDBInstanceIdentifier", t.Name.Local): 19038 var col string 19039 val, err := decoder.Value() 19040 if err != nil { 19041 return err 19042 } 19043 if val == nil { 19044 break 19045 } 19046 { 19047 xtv := string(val) 19048 col = xtv 19049 } 19050 sv = append(sv, col) 19051 19052 default: 19053 err = decoder.Decoder.Skip() 19054 if err != nil { 19055 return err 19056 } 19057 19058 } 19059 decoder = originalDecoder 19060 } 19061 *v = sv 19062 return nil 19063} 19064 19065func awsAwsquery_deserializeDocumentReadReplicaDBInstanceIdentifierListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 19066 var sv []string 19067 if *v == nil { 19068 sv = make([]string, 0) 19069 } else { 19070 sv = *v 19071 } 19072 19073 switch { 19074 default: 19075 var mv string 19076 t := decoder.StartEl 19077 _ = t 19078 val, err := decoder.Value() 19079 if err != nil { 19080 return err 19081 } 19082 if val == nil { 19083 break 19084 } 19085 { 19086 xtv := string(val) 19087 mv = xtv 19088 } 19089 sv = append(sv, mv) 19090 } 19091 *v = sv 19092 return nil 19093} 19094func awsAwsquery_deserializeDocumentReadReplicaIdentifierList(v *[]string, decoder smithyxml.NodeDecoder) error { 19095 if v == nil { 19096 return fmt.Errorf("unexpected nil of type %T", v) 19097 } 19098 var sv []string 19099 if *v == nil { 19100 sv = make([]string, 0) 19101 } else { 19102 sv = *v 19103 } 19104 19105 originalDecoder := decoder 19106 for { 19107 t, done, err := decoder.Token() 19108 if err != nil { 19109 return err 19110 } 19111 if done { 19112 break 19113 } 19114 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19115 decoder = memberDecoder 19116 switch { 19117 case strings.EqualFold("ReadReplicaIdentifier", t.Name.Local): 19118 var col string 19119 val, err := decoder.Value() 19120 if err != nil { 19121 return err 19122 } 19123 if val == nil { 19124 break 19125 } 19126 { 19127 xtv := string(val) 19128 col = xtv 19129 } 19130 sv = append(sv, col) 19131 19132 default: 19133 err = decoder.Decoder.Skip() 19134 if err != nil { 19135 return err 19136 } 19137 19138 } 19139 decoder = originalDecoder 19140 } 19141 *v = sv 19142 return nil 19143} 19144 19145func awsAwsquery_deserializeDocumentReadReplicaIdentifierListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 19146 var sv []string 19147 if *v == nil { 19148 sv = make([]string, 0) 19149 } else { 19150 sv = *v 19151 } 19152 19153 switch { 19154 default: 19155 var mv string 19156 t := decoder.StartEl 19157 _ = t 19158 val, err := decoder.Value() 19159 if err != nil { 19160 return err 19161 } 19162 if val == nil { 19163 break 19164 } 19165 { 19166 xtv := string(val) 19167 mv = xtv 19168 } 19169 sv = append(sv, mv) 19170 } 19171 *v = sv 19172 return nil 19173} 19174func awsAwsquery_deserializeDocumentResourceNotFoundFault(v **types.ResourceNotFoundFault, decoder smithyxml.NodeDecoder) error { 19175 if v == nil { 19176 return fmt.Errorf("unexpected nil of type %T", v) 19177 } 19178 var sv *types.ResourceNotFoundFault 19179 if *v == nil { 19180 sv = &types.ResourceNotFoundFault{} 19181 } else { 19182 sv = *v 19183 } 19184 19185 for { 19186 t, done, err := decoder.Token() 19187 if err != nil { 19188 return err 19189 } 19190 if done { 19191 break 19192 } 19193 originalDecoder := decoder 19194 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19195 switch { 19196 case strings.EqualFold("message", t.Name.Local): 19197 val, err := decoder.Value() 19198 if err != nil { 19199 return err 19200 } 19201 if val == nil { 19202 break 19203 } 19204 { 19205 xtv := string(val) 19206 sv.Message = ptr.String(xtv) 19207 } 19208 19209 default: 19210 // Do nothing and ignore the unexpected tag element 19211 err = decoder.Decoder.Skip() 19212 if err != nil { 19213 return err 19214 } 19215 19216 } 19217 decoder = originalDecoder 19218 } 19219 *v = sv 19220 return nil 19221} 19222 19223func awsAwsquery_deserializeDocumentResourcePendingMaintenanceActions(v **types.ResourcePendingMaintenanceActions, decoder smithyxml.NodeDecoder) error { 19224 if v == nil { 19225 return fmt.Errorf("unexpected nil of type %T", v) 19226 } 19227 var sv *types.ResourcePendingMaintenanceActions 19228 if *v == nil { 19229 sv = &types.ResourcePendingMaintenanceActions{} 19230 } else { 19231 sv = *v 19232 } 19233 19234 for { 19235 t, done, err := decoder.Token() 19236 if err != nil { 19237 return err 19238 } 19239 if done { 19240 break 19241 } 19242 originalDecoder := decoder 19243 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19244 switch { 19245 case strings.EqualFold("PendingMaintenanceActionDetails", t.Name.Local): 19246 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19247 if err := awsAwsquery_deserializeDocumentPendingMaintenanceActionDetails(&sv.PendingMaintenanceActionDetails, nodeDecoder); err != nil { 19248 return err 19249 } 19250 19251 case strings.EqualFold("ResourceIdentifier", t.Name.Local): 19252 val, err := decoder.Value() 19253 if err != nil { 19254 return err 19255 } 19256 if val == nil { 19257 break 19258 } 19259 { 19260 xtv := string(val) 19261 sv.ResourceIdentifier = ptr.String(xtv) 19262 } 19263 19264 default: 19265 // Do nothing and ignore the unexpected tag element 19266 err = decoder.Decoder.Skip() 19267 if err != nil { 19268 return err 19269 } 19270 19271 } 19272 decoder = originalDecoder 19273 } 19274 *v = sv 19275 return nil 19276} 19277 19278func awsAwsquery_deserializeDocumentSharedSnapshotQuotaExceededFault(v **types.SharedSnapshotQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 19279 if v == nil { 19280 return fmt.Errorf("unexpected nil of type %T", v) 19281 } 19282 var sv *types.SharedSnapshotQuotaExceededFault 19283 if *v == nil { 19284 sv = &types.SharedSnapshotQuotaExceededFault{} 19285 } else { 19286 sv = *v 19287 } 19288 19289 for { 19290 t, done, err := decoder.Token() 19291 if err != nil { 19292 return err 19293 } 19294 if done { 19295 break 19296 } 19297 originalDecoder := decoder 19298 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19299 switch { 19300 case strings.EqualFold("message", t.Name.Local): 19301 val, err := decoder.Value() 19302 if err != nil { 19303 return err 19304 } 19305 if val == nil { 19306 break 19307 } 19308 { 19309 xtv := string(val) 19310 sv.Message = ptr.String(xtv) 19311 } 19312 19313 default: 19314 // Do nothing and ignore the unexpected tag element 19315 err = decoder.Decoder.Skip() 19316 if err != nil { 19317 return err 19318 } 19319 19320 } 19321 decoder = originalDecoder 19322 } 19323 *v = sv 19324 return nil 19325} 19326 19327func awsAwsquery_deserializeDocumentSnapshotQuotaExceededFault(v **types.SnapshotQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 19328 if v == nil { 19329 return fmt.Errorf("unexpected nil of type %T", v) 19330 } 19331 var sv *types.SnapshotQuotaExceededFault 19332 if *v == nil { 19333 sv = &types.SnapshotQuotaExceededFault{} 19334 } else { 19335 sv = *v 19336 } 19337 19338 for { 19339 t, done, err := decoder.Token() 19340 if err != nil { 19341 return err 19342 } 19343 if done { 19344 break 19345 } 19346 originalDecoder := decoder 19347 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19348 switch { 19349 case strings.EqualFold("message", t.Name.Local): 19350 val, err := decoder.Value() 19351 if err != nil { 19352 return err 19353 } 19354 if val == nil { 19355 break 19356 } 19357 { 19358 xtv := string(val) 19359 sv.Message = ptr.String(xtv) 19360 } 19361 19362 default: 19363 // Do nothing and ignore the unexpected tag element 19364 err = decoder.Decoder.Skip() 19365 if err != nil { 19366 return err 19367 } 19368 19369 } 19370 decoder = originalDecoder 19371 } 19372 *v = sv 19373 return nil 19374} 19375 19376func awsAwsquery_deserializeDocumentSNSInvalidTopicFault(v **types.SNSInvalidTopicFault, decoder smithyxml.NodeDecoder) error { 19377 if v == nil { 19378 return fmt.Errorf("unexpected nil of type %T", v) 19379 } 19380 var sv *types.SNSInvalidTopicFault 19381 if *v == nil { 19382 sv = &types.SNSInvalidTopicFault{} 19383 } else { 19384 sv = *v 19385 } 19386 19387 for { 19388 t, done, err := decoder.Token() 19389 if err != nil { 19390 return err 19391 } 19392 if done { 19393 break 19394 } 19395 originalDecoder := decoder 19396 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19397 switch { 19398 case strings.EqualFold("message", t.Name.Local): 19399 val, err := decoder.Value() 19400 if err != nil { 19401 return err 19402 } 19403 if val == nil { 19404 break 19405 } 19406 { 19407 xtv := string(val) 19408 sv.Message = ptr.String(xtv) 19409 } 19410 19411 default: 19412 // Do nothing and ignore the unexpected tag element 19413 err = decoder.Decoder.Skip() 19414 if err != nil { 19415 return err 19416 } 19417 19418 } 19419 decoder = originalDecoder 19420 } 19421 *v = sv 19422 return nil 19423} 19424 19425func awsAwsquery_deserializeDocumentSNSNoAuthorizationFault(v **types.SNSNoAuthorizationFault, decoder smithyxml.NodeDecoder) error { 19426 if v == nil { 19427 return fmt.Errorf("unexpected nil of type %T", v) 19428 } 19429 var sv *types.SNSNoAuthorizationFault 19430 if *v == nil { 19431 sv = &types.SNSNoAuthorizationFault{} 19432 } else { 19433 sv = *v 19434 } 19435 19436 for { 19437 t, done, err := decoder.Token() 19438 if err != nil { 19439 return err 19440 } 19441 if done { 19442 break 19443 } 19444 originalDecoder := decoder 19445 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19446 switch { 19447 case strings.EqualFold("message", t.Name.Local): 19448 val, err := decoder.Value() 19449 if err != nil { 19450 return err 19451 } 19452 if val == nil { 19453 break 19454 } 19455 { 19456 xtv := string(val) 19457 sv.Message = ptr.String(xtv) 19458 } 19459 19460 default: 19461 // Do nothing and ignore the unexpected tag element 19462 err = decoder.Decoder.Skip() 19463 if err != nil { 19464 return err 19465 } 19466 19467 } 19468 decoder = originalDecoder 19469 } 19470 *v = sv 19471 return nil 19472} 19473 19474func awsAwsquery_deserializeDocumentSNSTopicArnNotFoundFault(v **types.SNSTopicArnNotFoundFault, decoder smithyxml.NodeDecoder) error { 19475 if v == nil { 19476 return fmt.Errorf("unexpected nil of type %T", v) 19477 } 19478 var sv *types.SNSTopicArnNotFoundFault 19479 if *v == nil { 19480 sv = &types.SNSTopicArnNotFoundFault{} 19481 } else { 19482 sv = *v 19483 } 19484 19485 for { 19486 t, done, err := decoder.Token() 19487 if err != nil { 19488 return err 19489 } 19490 if done { 19491 break 19492 } 19493 originalDecoder := decoder 19494 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19495 switch { 19496 case strings.EqualFold("message", t.Name.Local): 19497 val, err := decoder.Value() 19498 if err != nil { 19499 return err 19500 } 19501 if val == nil { 19502 break 19503 } 19504 { 19505 xtv := string(val) 19506 sv.Message = ptr.String(xtv) 19507 } 19508 19509 default: 19510 // Do nothing and ignore the unexpected tag element 19511 err = decoder.Decoder.Skip() 19512 if err != nil { 19513 return err 19514 } 19515 19516 } 19517 decoder = originalDecoder 19518 } 19519 *v = sv 19520 return nil 19521} 19522 19523func awsAwsquery_deserializeDocumentSourceIdsList(v *[]string, decoder smithyxml.NodeDecoder) error { 19524 if v == nil { 19525 return fmt.Errorf("unexpected nil of type %T", v) 19526 } 19527 var sv []string 19528 if *v == nil { 19529 sv = make([]string, 0) 19530 } else { 19531 sv = *v 19532 } 19533 19534 originalDecoder := decoder 19535 for { 19536 t, done, err := decoder.Token() 19537 if err != nil { 19538 return err 19539 } 19540 if done { 19541 break 19542 } 19543 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19544 decoder = memberDecoder 19545 switch { 19546 case strings.EqualFold("SourceId", t.Name.Local): 19547 var col string 19548 val, err := decoder.Value() 19549 if err != nil { 19550 return err 19551 } 19552 if val == nil { 19553 break 19554 } 19555 { 19556 xtv := string(val) 19557 col = xtv 19558 } 19559 sv = append(sv, col) 19560 19561 default: 19562 err = decoder.Decoder.Skip() 19563 if err != nil { 19564 return err 19565 } 19566 19567 } 19568 decoder = originalDecoder 19569 } 19570 *v = sv 19571 return nil 19572} 19573 19574func awsAwsquery_deserializeDocumentSourceIdsListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 19575 var sv []string 19576 if *v == nil { 19577 sv = make([]string, 0) 19578 } else { 19579 sv = *v 19580 } 19581 19582 switch { 19583 default: 19584 var mv string 19585 t := decoder.StartEl 19586 _ = t 19587 val, err := decoder.Value() 19588 if err != nil { 19589 return err 19590 } 19591 if val == nil { 19592 break 19593 } 19594 { 19595 xtv := string(val) 19596 mv = xtv 19597 } 19598 sv = append(sv, mv) 19599 } 19600 *v = sv 19601 return nil 19602} 19603func awsAwsquery_deserializeDocumentSourceNotFoundFault(v **types.SourceNotFoundFault, decoder smithyxml.NodeDecoder) error { 19604 if v == nil { 19605 return fmt.Errorf("unexpected nil of type %T", v) 19606 } 19607 var sv *types.SourceNotFoundFault 19608 if *v == nil { 19609 sv = &types.SourceNotFoundFault{} 19610 } else { 19611 sv = *v 19612 } 19613 19614 for { 19615 t, done, err := decoder.Token() 19616 if err != nil { 19617 return err 19618 } 19619 if done { 19620 break 19621 } 19622 originalDecoder := decoder 19623 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19624 switch { 19625 case strings.EqualFold("message", t.Name.Local): 19626 val, err := decoder.Value() 19627 if err != nil { 19628 return err 19629 } 19630 if val == nil { 19631 break 19632 } 19633 { 19634 xtv := string(val) 19635 sv.Message = ptr.String(xtv) 19636 } 19637 19638 default: 19639 // Do nothing and ignore the unexpected tag element 19640 err = decoder.Decoder.Skip() 19641 if err != nil { 19642 return err 19643 } 19644 19645 } 19646 decoder = originalDecoder 19647 } 19648 *v = sv 19649 return nil 19650} 19651 19652func awsAwsquery_deserializeDocumentStorageQuotaExceededFault(v **types.StorageQuotaExceededFault, decoder smithyxml.NodeDecoder) error { 19653 if v == nil { 19654 return fmt.Errorf("unexpected nil of type %T", v) 19655 } 19656 var sv *types.StorageQuotaExceededFault 19657 if *v == nil { 19658 sv = &types.StorageQuotaExceededFault{} 19659 } else { 19660 sv = *v 19661 } 19662 19663 for { 19664 t, done, err := decoder.Token() 19665 if err != nil { 19666 return err 19667 } 19668 if done { 19669 break 19670 } 19671 originalDecoder := decoder 19672 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19673 switch { 19674 case strings.EqualFold("message", t.Name.Local): 19675 val, err := decoder.Value() 19676 if err != nil { 19677 return err 19678 } 19679 if val == nil { 19680 break 19681 } 19682 { 19683 xtv := string(val) 19684 sv.Message = ptr.String(xtv) 19685 } 19686 19687 default: 19688 // Do nothing and ignore the unexpected tag element 19689 err = decoder.Decoder.Skip() 19690 if err != nil { 19691 return err 19692 } 19693 19694 } 19695 decoder = originalDecoder 19696 } 19697 *v = sv 19698 return nil 19699} 19700 19701func awsAwsquery_deserializeDocumentStorageTypeNotSupportedFault(v **types.StorageTypeNotSupportedFault, decoder smithyxml.NodeDecoder) error { 19702 if v == nil { 19703 return fmt.Errorf("unexpected nil of type %T", v) 19704 } 19705 var sv *types.StorageTypeNotSupportedFault 19706 if *v == nil { 19707 sv = &types.StorageTypeNotSupportedFault{} 19708 } else { 19709 sv = *v 19710 } 19711 19712 for { 19713 t, done, err := decoder.Token() 19714 if err != nil { 19715 return err 19716 } 19717 if done { 19718 break 19719 } 19720 originalDecoder := decoder 19721 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19722 switch { 19723 case strings.EqualFold("message", t.Name.Local): 19724 val, err := decoder.Value() 19725 if err != nil { 19726 return err 19727 } 19728 if val == nil { 19729 break 19730 } 19731 { 19732 xtv := string(val) 19733 sv.Message = ptr.String(xtv) 19734 } 19735 19736 default: 19737 // Do nothing and ignore the unexpected tag element 19738 err = decoder.Decoder.Skip() 19739 if err != nil { 19740 return err 19741 } 19742 19743 } 19744 decoder = originalDecoder 19745 } 19746 *v = sv 19747 return nil 19748} 19749 19750func awsAwsquery_deserializeDocumentStringList(v *[]string, decoder smithyxml.NodeDecoder) error { 19751 if v == nil { 19752 return fmt.Errorf("unexpected nil of type %T", v) 19753 } 19754 var sv []string 19755 if *v == nil { 19756 sv = make([]string, 0) 19757 } else { 19758 sv = *v 19759 } 19760 19761 originalDecoder := decoder 19762 for { 19763 t, done, err := decoder.Token() 19764 if err != nil { 19765 return err 19766 } 19767 if done { 19768 break 19769 } 19770 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19771 decoder = memberDecoder 19772 switch { 19773 case strings.EqualFold("member", t.Name.Local): 19774 var col string 19775 val, err := decoder.Value() 19776 if err != nil { 19777 return err 19778 } 19779 if val == nil { 19780 break 19781 } 19782 { 19783 xtv := string(val) 19784 col = xtv 19785 } 19786 sv = append(sv, col) 19787 19788 default: 19789 err = decoder.Decoder.Skip() 19790 if err != nil { 19791 return err 19792 } 19793 19794 } 19795 decoder = originalDecoder 19796 } 19797 *v = sv 19798 return nil 19799} 19800 19801func awsAwsquery_deserializeDocumentStringListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 19802 var sv []string 19803 if *v == nil { 19804 sv = make([]string, 0) 19805 } else { 19806 sv = *v 19807 } 19808 19809 switch { 19810 default: 19811 var mv string 19812 t := decoder.StartEl 19813 _ = t 19814 val, err := decoder.Value() 19815 if err != nil { 19816 return err 19817 } 19818 if val == nil { 19819 break 19820 } 19821 { 19822 xtv := string(val) 19823 mv = xtv 19824 } 19825 sv = append(sv, mv) 19826 } 19827 *v = sv 19828 return nil 19829} 19830func awsAwsquery_deserializeDocumentSubnet(v **types.Subnet, decoder smithyxml.NodeDecoder) error { 19831 if v == nil { 19832 return fmt.Errorf("unexpected nil of type %T", v) 19833 } 19834 var sv *types.Subnet 19835 if *v == nil { 19836 sv = &types.Subnet{} 19837 } else { 19838 sv = *v 19839 } 19840 19841 for { 19842 t, done, err := decoder.Token() 19843 if err != nil { 19844 return err 19845 } 19846 if done { 19847 break 19848 } 19849 originalDecoder := decoder 19850 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19851 switch { 19852 case strings.EqualFold("SubnetAvailabilityZone", t.Name.Local): 19853 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19854 if err := awsAwsquery_deserializeDocumentAvailabilityZone(&sv.SubnetAvailabilityZone, nodeDecoder); err != nil { 19855 return err 19856 } 19857 19858 case strings.EqualFold("SubnetIdentifier", t.Name.Local): 19859 val, err := decoder.Value() 19860 if err != nil { 19861 return err 19862 } 19863 if val == nil { 19864 break 19865 } 19866 { 19867 xtv := string(val) 19868 sv.SubnetIdentifier = ptr.String(xtv) 19869 } 19870 19871 case strings.EqualFold("SubnetStatus", t.Name.Local): 19872 val, err := decoder.Value() 19873 if err != nil { 19874 return err 19875 } 19876 if val == nil { 19877 break 19878 } 19879 { 19880 xtv := string(val) 19881 sv.SubnetStatus = ptr.String(xtv) 19882 } 19883 19884 default: 19885 // Do nothing and ignore the unexpected tag element 19886 err = decoder.Decoder.Skip() 19887 if err != nil { 19888 return err 19889 } 19890 19891 } 19892 decoder = originalDecoder 19893 } 19894 *v = sv 19895 return nil 19896} 19897 19898func awsAwsquery_deserializeDocumentSubnetAlreadyInUse(v **types.SubnetAlreadyInUse, decoder smithyxml.NodeDecoder) error { 19899 if v == nil { 19900 return fmt.Errorf("unexpected nil of type %T", v) 19901 } 19902 var sv *types.SubnetAlreadyInUse 19903 if *v == nil { 19904 sv = &types.SubnetAlreadyInUse{} 19905 } else { 19906 sv = *v 19907 } 19908 19909 for { 19910 t, done, err := decoder.Token() 19911 if err != nil { 19912 return err 19913 } 19914 if done { 19915 break 19916 } 19917 originalDecoder := decoder 19918 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19919 switch { 19920 case strings.EqualFold("message", t.Name.Local): 19921 val, err := decoder.Value() 19922 if err != nil { 19923 return err 19924 } 19925 if val == nil { 19926 break 19927 } 19928 { 19929 xtv := string(val) 19930 sv.Message = ptr.String(xtv) 19931 } 19932 19933 default: 19934 // Do nothing and ignore the unexpected tag element 19935 err = decoder.Decoder.Skip() 19936 if err != nil { 19937 return err 19938 } 19939 19940 } 19941 decoder = originalDecoder 19942 } 19943 *v = sv 19944 return nil 19945} 19946 19947func awsAwsquery_deserializeDocumentSubnetList(v *[]types.Subnet, decoder smithyxml.NodeDecoder) error { 19948 if v == nil { 19949 return fmt.Errorf("unexpected nil of type %T", v) 19950 } 19951 var sv []types.Subnet 19952 if *v == nil { 19953 sv = make([]types.Subnet, 0) 19954 } else { 19955 sv = *v 19956 } 19957 19958 originalDecoder := decoder 19959 for { 19960 t, done, err := decoder.Token() 19961 if err != nil { 19962 return err 19963 } 19964 if done { 19965 break 19966 } 19967 switch { 19968 case strings.EqualFold("Subnet", t.Name.Local): 19969 var col types.Subnet 19970 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19971 destAddr := &col 19972 if err := awsAwsquery_deserializeDocumentSubnet(&destAddr, nodeDecoder); err != nil { 19973 return err 19974 } 19975 col = *destAddr 19976 sv = append(sv, col) 19977 19978 default: 19979 err = decoder.Decoder.Skip() 19980 if err != nil { 19981 return err 19982 } 19983 19984 } 19985 decoder = originalDecoder 19986 } 19987 *v = sv 19988 return nil 19989} 19990 19991func awsAwsquery_deserializeDocumentSubnetListUnwrapped(v *[]types.Subnet, decoder smithyxml.NodeDecoder) error { 19992 var sv []types.Subnet 19993 if *v == nil { 19994 sv = make([]types.Subnet, 0) 19995 } else { 19996 sv = *v 19997 } 19998 19999 switch { 20000 default: 20001 var mv types.Subnet 20002 t := decoder.StartEl 20003 _ = t 20004 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20005 destAddr := &mv 20006 if err := awsAwsquery_deserializeDocumentSubnet(&destAddr, nodeDecoder); err != nil { 20007 return err 20008 } 20009 mv = *destAddr 20010 sv = append(sv, mv) 20011 } 20012 *v = sv 20013 return nil 20014} 20015func awsAwsquery_deserializeDocumentSubscriptionAlreadyExistFault(v **types.SubscriptionAlreadyExistFault, decoder smithyxml.NodeDecoder) error { 20016 if v == nil { 20017 return fmt.Errorf("unexpected nil of type %T", v) 20018 } 20019 var sv *types.SubscriptionAlreadyExistFault 20020 if *v == nil { 20021 sv = &types.SubscriptionAlreadyExistFault{} 20022 } else { 20023 sv = *v 20024 } 20025 20026 for { 20027 t, done, err := decoder.Token() 20028 if err != nil { 20029 return err 20030 } 20031 if done { 20032 break 20033 } 20034 originalDecoder := decoder 20035 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20036 switch { 20037 case strings.EqualFold("message", t.Name.Local): 20038 val, err := decoder.Value() 20039 if err != nil { 20040 return err 20041 } 20042 if val == nil { 20043 break 20044 } 20045 { 20046 xtv := string(val) 20047 sv.Message = ptr.String(xtv) 20048 } 20049 20050 default: 20051 // Do nothing and ignore the unexpected tag element 20052 err = decoder.Decoder.Skip() 20053 if err != nil { 20054 return err 20055 } 20056 20057 } 20058 decoder = originalDecoder 20059 } 20060 *v = sv 20061 return nil 20062} 20063 20064func awsAwsquery_deserializeDocumentSubscriptionCategoryNotFoundFault(v **types.SubscriptionCategoryNotFoundFault, decoder smithyxml.NodeDecoder) error { 20065 if v == nil { 20066 return fmt.Errorf("unexpected nil of type %T", v) 20067 } 20068 var sv *types.SubscriptionCategoryNotFoundFault 20069 if *v == nil { 20070 sv = &types.SubscriptionCategoryNotFoundFault{} 20071 } else { 20072 sv = *v 20073 } 20074 20075 for { 20076 t, done, err := decoder.Token() 20077 if err != nil { 20078 return err 20079 } 20080 if done { 20081 break 20082 } 20083 originalDecoder := decoder 20084 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20085 switch { 20086 case strings.EqualFold("message", t.Name.Local): 20087 val, err := decoder.Value() 20088 if err != nil { 20089 return err 20090 } 20091 if val == nil { 20092 break 20093 } 20094 { 20095 xtv := string(val) 20096 sv.Message = ptr.String(xtv) 20097 } 20098 20099 default: 20100 // Do nothing and ignore the unexpected tag element 20101 err = decoder.Decoder.Skip() 20102 if err != nil { 20103 return err 20104 } 20105 20106 } 20107 decoder = originalDecoder 20108 } 20109 *v = sv 20110 return nil 20111} 20112 20113func awsAwsquery_deserializeDocumentSubscriptionNotFoundFault(v **types.SubscriptionNotFoundFault, decoder smithyxml.NodeDecoder) error { 20114 if v == nil { 20115 return fmt.Errorf("unexpected nil of type %T", v) 20116 } 20117 var sv *types.SubscriptionNotFoundFault 20118 if *v == nil { 20119 sv = &types.SubscriptionNotFoundFault{} 20120 } else { 20121 sv = *v 20122 } 20123 20124 for { 20125 t, done, err := decoder.Token() 20126 if err != nil { 20127 return err 20128 } 20129 if done { 20130 break 20131 } 20132 originalDecoder := decoder 20133 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20134 switch { 20135 case strings.EqualFold("message", t.Name.Local): 20136 val, err := decoder.Value() 20137 if err != nil { 20138 return err 20139 } 20140 if val == nil { 20141 break 20142 } 20143 { 20144 xtv := string(val) 20145 sv.Message = ptr.String(xtv) 20146 } 20147 20148 default: 20149 // Do nothing and ignore the unexpected tag element 20150 err = decoder.Decoder.Skip() 20151 if err != nil { 20152 return err 20153 } 20154 20155 } 20156 decoder = originalDecoder 20157 } 20158 *v = sv 20159 return nil 20160} 20161 20162func awsAwsquery_deserializeDocumentSupportedCharacterSetsList(v *[]types.CharacterSet, decoder smithyxml.NodeDecoder) error { 20163 if v == nil { 20164 return fmt.Errorf("unexpected nil of type %T", v) 20165 } 20166 var sv []types.CharacterSet 20167 if *v == nil { 20168 sv = make([]types.CharacterSet, 0) 20169 } else { 20170 sv = *v 20171 } 20172 20173 originalDecoder := decoder 20174 for { 20175 t, done, err := decoder.Token() 20176 if err != nil { 20177 return err 20178 } 20179 if done { 20180 break 20181 } 20182 switch { 20183 case strings.EqualFold("CharacterSet", t.Name.Local): 20184 var col types.CharacterSet 20185 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20186 destAddr := &col 20187 if err := awsAwsquery_deserializeDocumentCharacterSet(&destAddr, nodeDecoder); err != nil { 20188 return err 20189 } 20190 col = *destAddr 20191 sv = append(sv, col) 20192 20193 default: 20194 err = decoder.Decoder.Skip() 20195 if err != nil { 20196 return err 20197 } 20198 20199 } 20200 decoder = originalDecoder 20201 } 20202 *v = sv 20203 return nil 20204} 20205 20206func awsAwsquery_deserializeDocumentSupportedCharacterSetsListUnwrapped(v *[]types.CharacterSet, decoder smithyxml.NodeDecoder) error { 20207 var sv []types.CharacterSet 20208 if *v == nil { 20209 sv = make([]types.CharacterSet, 0) 20210 } else { 20211 sv = *v 20212 } 20213 20214 switch { 20215 default: 20216 var mv types.CharacterSet 20217 t := decoder.StartEl 20218 _ = t 20219 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20220 destAddr := &mv 20221 if err := awsAwsquery_deserializeDocumentCharacterSet(&destAddr, nodeDecoder); err != nil { 20222 return err 20223 } 20224 mv = *destAddr 20225 sv = append(sv, mv) 20226 } 20227 *v = sv 20228 return nil 20229} 20230func awsAwsquery_deserializeDocumentSupportedTimezonesList(v *[]types.Timezone, decoder smithyxml.NodeDecoder) error { 20231 if v == nil { 20232 return fmt.Errorf("unexpected nil of type %T", v) 20233 } 20234 var sv []types.Timezone 20235 if *v == nil { 20236 sv = make([]types.Timezone, 0) 20237 } else { 20238 sv = *v 20239 } 20240 20241 originalDecoder := decoder 20242 for { 20243 t, done, err := decoder.Token() 20244 if err != nil { 20245 return err 20246 } 20247 if done { 20248 break 20249 } 20250 switch { 20251 case strings.EqualFold("Timezone", t.Name.Local): 20252 var col types.Timezone 20253 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20254 destAddr := &col 20255 if err := awsAwsquery_deserializeDocumentTimezone(&destAddr, nodeDecoder); err != nil { 20256 return err 20257 } 20258 col = *destAddr 20259 sv = append(sv, col) 20260 20261 default: 20262 err = decoder.Decoder.Skip() 20263 if err != nil { 20264 return err 20265 } 20266 20267 } 20268 decoder = originalDecoder 20269 } 20270 *v = sv 20271 return nil 20272} 20273 20274func awsAwsquery_deserializeDocumentSupportedTimezonesListUnwrapped(v *[]types.Timezone, decoder smithyxml.NodeDecoder) error { 20275 var sv []types.Timezone 20276 if *v == nil { 20277 sv = make([]types.Timezone, 0) 20278 } else { 20279 sv = *v 20280 } 20281 20282 switch { 20283 default: 20284 var mv types.Timezone 20285 t := decoder.StartEl 20286 _ = t 20287 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20288 destAddr := &mv 20289 if err := awsAwsquery_deserializeDocumentTimezone(&destAddr, nodeDecoder); err != nil { 20290 return err 20291 } 20292 mv = *destAddr 20293 sv = append(sv, mv) 20294 } 20295 *v = sv 20296 return nil 20297} 20298func awsAwsquery_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error { 20299 if v == nil { 20300 return fmt.Errorf("unexpected nil of type %T", v) 20301 } 20302 var sv *types.Tag 20303 if *v == nil { 20304 sv = &types.Tag{} 20305 } else { 20306 sv = *v 20307 } 20308 20309 for { 20310 t, done, err := decoder.Token() 20311 if err != nil { 20312 return err 20313 } 20314 if done { 20315 break 20316 } 20317 originalDecoder := decoder 20318 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20319 switch { 20320 case strings.EqualFold("Key", t.Name.Local): 20321 val, err := decoder.Value() 20322 if err != nil { 20323 return err 20324 } 20325 if val == nil { 20326 break 20327 } 20328 { 20329 xtv := string(val) 20330 sv.Key = ptr.String(xtv) 20331 } 20332 20333 case strings.EqualFold("Value", t.Name.Local): 20334 val, err := decoder.Value() 20335 if err != nil { 20336 return err 20337 } 20338 if val == nil { 20339 break 20340 } 20341 { 20342 xtv := string(val) 20343 sv.Value = ptr.String(xtv) 20344 } 20345 20346 default: 20347 // Do nothing and ignore the unexpected tag element 20348 err = decoder.Decoder.Skip() 20349 if err != nil { 20350 return err 20351 } 20352 20353 } 20354 decoder = originalDecoder 20355 } 20356 *v = sv 20357 return nil 20358} 20359 20360func awsAwsquery_deserializeDocumentTagList(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 20361 if v == nil { 20362 return fmt.Errorf("unexpected nil of type %T", v) 20363 } 20364 var sv []types.Tag 20365 if *v == nil { 20366 sv = make([]types.Tag, 0) 20367 } else { 20368 sv = *v 20369 } 20370 20371 originalDecoder := decoder 20372 for { 20373 t, done, err := decoder.Token() 20374 if err != nil { 20375 return err 20376 } 20377 if done { 20378 break 20379 } 20380 switch { 20381 case strings.EqualFold("Tag", t.Name.Local): 20382 var col types.Tag 20383 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20384 destAddr := &col 20385 if err := awsAwsquery_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 20386 return err 20387 } 20388 col = *destAddr 20389 sv = append(sv, col) 20390 20391 default: 20392 err = decoder.Decoder.Skip() 20393 if err != nil { 20394 return err 20395 } 20396 20397 } 20398 decoder = originalDecoder 20399 } 20400 *v = sv 20401 return nil 20402} 20403 20404func awsAwsquery_deserializeDocumentTagListUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 20405 var sv []types.Tag 20406 if *v == nil { 20407 sv = make([]types.Tag, 0) 20408 } else { 20409 sv = *v 20410 } 20411 20412 switch { 20413 default: 20414 var mv types.Tag 20415 t := decoder.StartEl 20416 _ = t 20417 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20418 destAddr := &mv 20419 if err := awsAwsquery_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 20420 return err 20421 } 20422 mv = *destAddr 20423 sv = append(sv, mv) 20424 } 20425 *v = sv 20426 return nil 20427} 20428func awsAwsquery_deserializeDocumentTimezone(v **types.Timezone, decoder smithyxml.NodeDecoder) error { 20429 if v == nil { 20430 return fmt.Errorf("unexpected nil of type %T", v) 20431 } 20432 var sv *types.Timezone 20433 if *v == nil { 20434 sv = &types.Timezone{} 20435 } else { 20436 sv = *v 20437 } 20438 20439 for { 20440 t, done, err := decoder.Token() 20441 if err != nil { 20442 return err 20443 } 20444 if done { 20445 break 20446 } 20447 originalDecoder := decoder 20448 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20449 switch { 20450 case strings.EqualFold("TimezoneName", t.Name.Local): 20451 val, err := decoder.Value() 20452 if err != nil { 20453 return err 20454 } 20455 if val == nil { 20456 break 20457 } 20458 { 20459 xtv := string(val) 20460 sv.TimezoneName = ptr.String(xtv) 20461 } 20462 20463 default: 20464 // Do nothing and ignore the unexpected tag element 20465 err = decoder.Decoder.Skip() 20466 if err != nil { 20467 return err 20468 } 20469 20470 } 20471 decoder = originalDecoder 20472 } 20473 *v = sv 20474 return nil 20475} 20476 20477func awsAwsquery_deserializeDocumentUpgradeTarget(v **types.UpgradeTarget, decoder smithyxml.NodeDecoder) error { 20478 if v == nil { 20479 return fmt.Errorf("unexpected nil of type %T", v) 20480 } 20481 var sv *types.UpgradeTarget 20482 if *v == nil { 20483 sv = &types.UpgradeTarget{} 20484 } else { 20485 sv = *v 20486 } 20487 20488 for { 20489 t, done, err := decoder.Token() 20490 if err != nil { 20491 return err 20492 } 20493 if done { 20494 break 20495 } 20496 originalDecoder := decoder 20497 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20498 switch { 20499 case strings.EqualFold("AutoUpgrade", t.Name.Local): 20500 val, err := decoder.Value() 20501 if err != nil { 20502 return err 20503 } 20504 if val == nil { 20505 break 20506 } 20507 { 20508 xtv, err := strconv.ParseBool(string(val)) 20509 if err != nil { 20510 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 20511 } 20512 sv.AutoUpgrade = xtv 20513 } 20514 20515 case strings.EqualFold("Description", t.Name.Local): 20516 val, err := decoder.Value() 20517 if err != nil { 20518 return err 20519 } 20520 if val == nil { 20521 break 20522 } 20523 { 20524 xtv := string(val) 20525 sv.Description = ptr.String(xtv) 20526 } 20527 20528 case strings.EqualFold("Engine", t.Name.Local): 20529 val, err := decoder.Value() 20530 if err != nil { 20531 return err 20532 } 20533 if val == nil { 20534 break 20535 } 20536 { 20537 xtv := string(val) 20538 sv.Engine = ptr.String(xtv) 20539 } 20540 20541 case strings.EqualFold("EngineVersion", t.Name.Local): 20542 val, err := decoder.Value() 20543 if err != nil { 20544 return err 20545 } 20546 if val == nil { 20547 break 20548 } 20549 { 20550 xtv := string(val) 20551 sv.EngineVersion = ptr.String(xtv) 20552 } 20553 20554 case strings.EqualFold("IsMajorVersionUpgrade", t.Name.Local): 20555 val, err := decoder.Value() 20556 if err != nil { 20557 return err 20558 } 20559 if val == nil { 20560 break 20561 } 20562 { 20563 xtv, err := strconv.ParseBool(string(val)) 20564 if err != nil { 20565 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 20566 } 20567 sv.IsMajorVersionUpgrade = xtv 20568 } 20569 20570 default: 20571 // Do nothing and ignore the unexpected tag element 20572 err = decoder.Decoder.Skip() 20573 if err != nil { 20574 return err 20575 } 20576 20577 } 20578 decoder = originalDecoder 20579 } 20580 *v = sv 20581 return nil 20582} 20583 20584func awsAwsquery_deserializeDocumentValidDBInstanceModificationsMessage(v **types.ValidDBInstanceModificationsMessage, decoder smithyxml.NodeDecoder) error { 20585 if v == nil { 20586 return fmt.Errorf("unexpected nil of type %T", v) 20587 } 20588 var sv *types.ValidDBInstanceModificationsMessage 20589 if *v == nil { 20590 sv = &types.ValidDBInstanceModificationsMessage{} 20591 } else { 20592 sv = *v 20593 } 20594 20595 for { 20596 t, done, err := decoder.Token() 20597 if err != nil { 20598 return err 20599 } 20600 if done { 20601 break 20602 } 20603 originalDecoder := decoder 20604 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20605 switch { 20606 case strings.EqualFold("Storage", t.Name.Local): 20607 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20608 if err := awsAwsquery_deserializeDocumentValidStorageOptionsList(&sv.Storage, nodeDecoder); err != nil { 20609 return err 20610 } 20611 20612 default: 20613 // Do nothing and ignore the unexpected tag element 20614 err = decoder.Decoder.Skip() 20615 if err != nil { 20616 return err 20617 } 20618 20619 } 20620 decoder = originalDecoder 20621 } 20622 *v = sv 20623 return nil 20624} 20625 20626func awsAwsquery_deserializeDocumentValidStorageOptions(v **types.ValidStorageOptions, decoder smithyxml.NodeDecoder) error { 20627 if v == nil { 20628 return fmt.Errorf("unexpected nil of type %T", v) 20629 } 20630 var sv *types.ValidStorageOptions 20631 if *v == nil { 20632 sv = &types.ValidStorageOptions{} 20633 } else { 20634 sv = *v 20635 } 20636 20637 for { 20638 t, done, err := decoder.Token() 20639 if err != nil { 20640 return err 20641 } 20642 if done { 20643 break 20644 } 20645 originalDecoder := decoder 20646 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20647 switch { 20648 case strings.EqualFold("IopsToStorageRatio", t.Name.Local): 20649 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20650 if err := awsAwsquery_deserializeDocumentDoubleRangeList(&sv.IopsToStorageRatio, nodeDecoder); err != nil { 20651 return err 20652 } 20653 20654 case strings.EqualFold("ProvisionedIops", t.Name.Local): 20655 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20656 if err := awsAwsquery_deserializeDocumentRangeList(&sv.ProvisionedIops, nodeDecoder); err != nil { 20657 return err 20658 } 20659 20660 case strings.EqualFold("StorageSize", t.Name.Local): 20661 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20662 if err := awsAwsquery_deserializeDocumentRangeList(&sv.StorageSize, nodeDecoder); err != nil { 20663 return err 20664 } 20665 20666 case strings.EqualFold("StorageType", t.Name.Local): 20667 val, err := decoder.Value() 20668 if err != nil { 20669 return err 20670 } 20671 if val == nil { 20672 break 20673 } 20674 { 20675 xtv := string(val) 20676 sv.StorageType = ptr.String(xtv) 20677 } 20678 20679 default: 20680 // Do nothing and ignore the unexpected tag element 20681 err = decoder.Decoder.Skip() 20682 if err != nil { 20683 return err 20684 } 20685 20686 } 20687 decoder = originalDecoder 20688 } 20689 *v = sv 20690 return nil 20691} 20692 20693func awsAwsquery_deserializeDocumentValidStorageOptionsList(v *[]types.ValidStorageOptions, decoder smithyxml.NodeDecoder) error { 20694 if v == nil { 20695 return fmt.Errorf("unexpected nil of type %T", v) 20696 } 20697 var sv []types.ValidStorageOptions 20698 if *v == nil { 20699 sv = make([]types.ValidStorageOptions, 0) 20700 } else { 20701 sv = *v 20702 } 20703 20704 originalDecoder := decoder 20705 for { 20706 t, done, err := decoder.Token() 20707 if err != nil { 20708 return err 20709 } 20710 if done { 20711 break 20712 } 20713 switch { 20714 case strings.EqualFold("ValidStorageOptions", t.Name.Local): 20715 var col types.ValidStorageOptions 20716 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20717 destAddr := &col 20718 if err := awsAwsquery_deserializeDocumentValidStorageOptions(&destAddr, nodeDecoder); err != nil { 20719 return err 20720 } 20721 col = *destAddr 20722 sv = append(sv, col) 20723 20724 default: 20725 err = decoder.Decoder.Skip() 20726 if err != nil { 20727 return err 20728 } 20729 20730 } 20731 decoder = originalDecoder 20732 } 20733 *v = sv 20734 return nil 20735} 20736 20737func awsAwsquery_deserializeDocumentValidStorageOptionsListUnwrapped(v *[]types.ValidStorageOptions, decoder smithyxml.NodeDecoder) error { 20738 var sv []types.ValidStorageOptions 20739 if *v == nil { 20740 sv = make([]types.ValidStorageOptions, 0) 20741 } else { 20742 sv = *v 20743 } 20744 20745 switch { 20746 default: 20747 var mv types.ValidStorageOptions 20748 t := decoder.StartEl 20749 _ = t 20750 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20751 destAddr := &mv 20752 if err := awsAwsquery_deserializeDocumentValidStorageOptions(&destAddr, nodeDecoder); err != nil { 20753 return err 20754 } 20755 mv = *destAddr 20756 sv = append(sv, mv) 20757 } 20758 *v = sv 20759 return nil 20760} 20761func awsAwsquery_deserializeDocumentValidUpgradeTargetList(v *[]types.UpgradeTarget, decoder smithyxml.NodeDecoder) error { 20762 if v == nil { 20763 return fmt.Errorf("unexpected nil of type %T", v) 20764 } 20765 var sv []types.UpgradeTarget 20766 if *v == nil { 20767 sv = make([]types.UpgradeTarget, 0) 20768 } else { 20769 sv = *v 20770 } 20771 20772 originalDecoder := decoder 20773 for { 20774 t, done, err := decoder.Token() 20775 if err != nil { 20776 return err 20777 } 20778 if done { 20779 break 20780 } 20781 switch { 20782 case strings.EqualFold("UpgradeTarget", t.Name.Local): 20783 var col types.UpgradeTarget 20784 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20785 destAddr := &col 20786 if err := awsAwsquery_deserializeDocumentUpgradeTarget(&destAddr, nodeDecoder); err != nil { 20787 return err 20788 } 20789 col = *destAddr 20790 sv = append(sv, col) 20791 20792 default: 20793 err = decoder.Decoder.Skip() 20794 if err != nil { 20795 return err 20796 } 20797 20798 } 20799 decoder = originalDecoder 20800 } 20801 *v = sv 20802 return nil 20803} 20804 20805func awsAwsquery_deserializeDocumentValidUpgradeTargetListUnwrapped(v *[]types.UpgradeTarget, decoder smithyxml.NodeDecoder) error { 20806 var sv []types.UpgradeTarget 20807 if *v == nil { 20808 sv = make([]types.UpgradeTarget, 0) 20809 } else { 20810 sv = *v 20811 } 20812 20813 switch { 20814 default: 20815 var mv types.UpgradeTarget 20816 t := decoder.StartEl 20817 _ = t 20818 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20819 destAddr := &mv 20820 if err := awsAwsquery_deserializeDocumentUpgradeTarget(&destAddr, nodeDecoder); err != nil { 20821 return err 20822 } 20823 mv = *destAddr 20824 sv = append(sv, mv) 20825 } 20826 *v = sv 20827 return nil 20828} 20829func awsAwsquery_deserializeDocumentVpcSecurityGroupMembership(v **types.VpcSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 20830 if v == nil { 20831 return fmt.Errorf("unexpected nil of type %T", v) 20832 } 20833 var sv *types.VpcSecurityGroupMembership 20834 if *v == nil { 20835 sv = &types.VpcSecurityGroupMembership{} 20836 } else { 20837 sv = *v 20838 } 20839 20840 for { 20841 t, done, err := decoder.Token() 20842 if err != nil { 20843 return err 20844 } 20845 if done { 20846 break 20847 } 20848 originalDecoder := decoder 20849 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20850 switch { 20851 case strings.EqualFold("Status", t.Name.Local): 20852 val, err := decoder.Value() 20853 if err != nil { 20854 return err 20855 } 20856 if val == nil { 20857 break 20858 } 20859 { 20860 xtv := string(val) 20861 sv.Status = ptr.String(xtv) 20862 } 20863 20864 case strings.EqualFold("VpcSecurityGroupId", t.Name.Local): 20865 val, err := decoder.Value() 20866 if err != nil { 20867 return err 20868 } 20869 if val == nil { 20870 break 20871 } 20872 { 20873 xtv := string(val) 20874 sv.VpcSecurityGroupId = ptr.String(xtv) 20875 } 20876 20877 default: 20878 // Do nothing and ignore the unexpected tag element 20879 err = decoder.Decoder.Skip() 20880 if err != nil { 20881 return err 20882 } 20883 20884 } 20885 decoder = originalDecoder 20886 } 20887 *v = sv 20888 return nil 20889} 20890 20891func awsAwsquery_deserializeDocumentVpcSecurityGroupMembershipList(v *[]types.VpcSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 20892 if v == nil { 20893 return fmt.Errorf("unexpected nil of type %T", v) 20894 } 20895 var sv []types.VpcSecurityGroupMembership 20896 if *v == nil { 20897 sv = make([]types.VpcSecurityGroupMembership, 0) 20898 } else { 20899 sv = *v 20900 } 20901 20902 originalDecoder := decoder 20903 for { 20904 t, done, err := decoder.Token() 20905 if err != nil { 20906 return err 20907 } 20908 if done { 20909 break 20910 } 20911 switch { 20912 case strings.EqualFold("VpcSecurityGroupMembership", t.Name.Local): 20913 var col types.VpcSecurityGroupMembership 20914 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20915 destAddr := &col 20916 if err := awsAwsquery_deserializeDocumentVpcSecurityGroupMembership(&destAddr, nodeDecoder); err != nil { 20917 return err 20918 } 20919 col = *destAddr 20920 sv = append(sv, col) 20921 20922 default: 20923 err = decoder.Decoder.Skip() 20924 if err != nil { 20925 return err 20926 } 20927 20928 } 20929 decoder = originalDecoder 20930 } 20931 *v = sv 20932 return nil 20933} 20934 20935func awsAwsquery_deserializeDocumentVpcSecurityGroupMembershipListUnwrapped(v *[]types.VpcSecurityGroupMembership, decoder smithyxml.NodeDecoder) error { 20936 var sv []types.VpcSecurityGroupMembership 20937 if *v == nil { 20938 sv = make([]types.VpcSecurityGroupMembership, 0) 20939 } else { 20940 sv = *v 20941 } 20942 20943 switch { 20944 default: 20945 var mv types.VpcSecurityGroupMembership 20946 t := decoder.StartEl 20947 _ = t 20948 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20949 destAddr := &mv 20950 if err := awsAwsquery_deserializeDocumentVpcSecurityGroupMembership(&destAddr, nodeDecoder); err != nil { 20951 return err 20952 } 20953 mv = *destAddr 20954 sv = append(sv, mv) 20955 } 20956 *v = sv 20957 return nil 20958} 20959func awsAwsquery_deserializeOpDocumentAddSourceIdentifierToSubscriptionOutput(v **AddSourceIdentifierToSubscriptionOutput, decoder smithyxml.NodeDecoder) error { 20960 if v == nil { 20961 return fmt.Errorf("unexpected nil of type %T", v) 20962 } 20963 var sv *AddSourceIdentifierToSubscriptionOutput 20964 if *v == nil { 20965 sv = &AddSourceIdentifierToSubscriptionOutput{} 20966 } else { 20967 sv = *v 20968 } 20969 20970 for { 20971 t, done, err := decoder.Token() 20972 if err != nil { 20973 return err 20974 } 20975 if done { 20976 break 20977 } 20978 originalDecoder := decoder 20979 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20980 switch { 20981 case strings.EqualFold("EventSubscription", t.Name.Local): 20982 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20983 if err := awsAwsquery_deserializeDocumentEventSubscription(&sv.EventSubscription, nodeDecoder); err != nil { 20984 return err 20985 } 20986 20987 default: 20988 // Do nothing and ignore the unexpected tag element 20989 err = decoder.Decoder.Skip() 20990 if err != nil { 20991 return err 20992 } 20993 20994 } 20995 decoder = originalDecoder 20996 } 20997 *v = sv 20998 return nil 20999} 21000 21001func awsAwsquery_deserializeOpDocumentApplyPendingMaintenanceActionOutput(v **ApplyPendingMaintenanceActionOutput, decoder smithyxml.NodeDecoder) error { 21002 if v == nil { 21003 return fmt.Errorf("unexpected nil of type %T", v) 21004 } 21005 var sv *ApplyPendingMaintenanceActionOutput 21006 if *v == nil { 21007 sv = &ApplyPendingMaintenanceActionOutput{} 21008 } else { 21009 sv = *v 21010 } 21011 21012 for { 21013 t, done, err := decoder.Token() 21014 if err != nil { 21015 return err 21016 } 21017 if done { 21018 break 21019 } 21020 originalDecoder := decoder 21021 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21022 switch { 21023 case strings.EqualFold("ResourcePendingMaintenanceActions", t.Name.Local): 21024 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21025 if err := awsAwsquery_deserializeDocumentResourcePendingMaintenanceActions(&sv.ResourcePendingMaintenanceActions, nodeDecoder); err != nil { 21026 return err 21027 } 21028 21029 default: 21030 // Do nothing and ignore the unexpected tag element 21031 err = decoder.Decoder.Skip() 21032 if err != nil { 21033 return err 21034 } 21035 21036 } 21037 decoder = originalDecoder 21038 } 21039 *v = sv 21040 return nil 21041} 21042 21043func awsAwsquery_deserializeOpDocumentCopyDBClusterParameterGroupOutput(v **CopyDBClusterParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 21044 if v == nil { 21045 return fmt.Errorf("unexpected nil of type %T", v) 21046 } 21047 var sv *CopyDBClusterParameterGroupOutput 21048 if *v == nil { 21049 sv = &CopyDBClusterParameterGroupOutput{} 21050 } else { 21051 sv = *v 21052 } 21053 21054 for { 21055 t, done, err := decoder.Token() 21056 if err != nil { 21057 return err 21058 } 21059 if done { 21060 break 21061 } 21062 originalDecoder := decoder 21063 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21064 switch { 21065 case strings.EqualFold("DBClusterParameterGroup", t.Name.Local): 21066 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21067 if err := awsAwsquery_deserializeDocumentDBClusterParameterGroup(&sv.DBClusterParameterGroup, nodeDecoder); err != nil { 21068 return err 21069 } 21070 21071 default: 21072 // Do nothing and ignore the unexpected tag element 21073 err = decoder.Decoder.Skip() 21074 if err != nil { 21075 return err 21076 } 21077 21078 } 21079 decoder = originalDecoder 21080 } 21081 *v = sv 21082 return nil 21083} 21084 21085func awsAwsquery_deserializeOpDocumentCopyDBClusterSnapshotOutput(v **CopyDBClusterSnapshotOutput, decoder smithyxml.NodeDecoder) error { 21086 if v == nil { 21087 return fmt.Errorf("unexpected nil of type %T", v) 21088 } 21089 var sv *CopyDBClusterSnapshotOutput 21090 if *v == nil { 21091 sv = &CopyDBClusterSnapshotOutput{} 21092 } else { 21093 sv = *v 21094 } 21095 21096 for { 21097 t, done, err := decoder.Token() 21098 if err != nil { 21099 return err 21100 } 21101 if done { 21102 break 21103 } 21104 originalDecoder := decoder 21105 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21106 switch { 21107 case strings.EqualFold("DBClusterSnapshot", t.Name.Local): 21108 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21109 if err := awsAwsquery_deserializeDocumentDBClusterSnapshot(&sv.DBClusterSnapshot, nodeDecoder); err != nil { 21110 return err 21111 } 21112 21113 default: 21114 // Do nothing and ignore the unexpected tag element 21115 err = decoder.Decoder.Skip() 21116 if err != nil { 21117 return err 21118 } 21119 21120 } 21121 decoder = originalDecoder 21122 } 21123 *v = sv 21124 return nil 21125} 21126 21127func awsAwsquery_deserializeOpDocumentCopyDBParameterGroupOutput(v **CopyDBParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 21128 if v == nil { 21129 return fmt.Errorf("unexpected nil of type %T", v) 21130 } 21131 var sv *CopyDBParameterGroupOutput 21132 if *v == nil { 21133 sv = &CopyDBParameterGroupOutput{} 21134 } else { 21135 sv = *v 21136 } 21137 21138 for { 21139 t, done, err := decoder.Token() 21140 if err != nil { 21141 return err 21142 } 21143 if done { 21144 break 21145 } 21146 originalDecoder := decoder 21147 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21148 switch { 21149 case strings.EqualFold("DBParameterGroup", t.Name.Local): 21150 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21151 if err := awsAwsquery_deserializeDocumentDBParameterGroup(&sv.DBParameterGroup, nodeDecoder); err != nil { 21152 return err 21153 } 21154 21155 default: 21156 // Do nothing and ignore the unexpected tag element 21157 err = decoder.Decoder.Skip() 21158 if err != nil { 21159 return err 21160 } 21161 21162 } 21163 decoder = originalDecoder 21164 } 21165 *v = sv 21166 return nil 21167} 21168 21169func awsAwsquery_deserializeOpDocumentCreateDBClusterEndpointOutput(v **CreateDBClusterEndpointOutput, decoder smithyxml.NodeDecoder) error { 21170 if v == nil { 21171 return fmt.Errorf("unexpected nil of type %T", v) 21172 } 21173 var sv *CreateDBClusterEndpointOutput 21174 if *v == nil { 21175 sv = &CreateDBClusterEndpointOutput{} 21176 } else { 21177 sv = *v 21178 } 21179 21180 for { 21181 t, done, err := decoder.Token() 21182 if err != nil { 21183 return err 21184 } 21185 if done { 21186 break 21187 } 21188 originalDecoder := decoder 21189 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21190 switch { 21191 case strings.EqualFold("CustomEndpointType", t.Name.Local): 21192 val, err := decoder.Value() 21193 if err != nil { 21194 return err 21195 } 21196 if val == nil { 21197 break 21198 } 21199 { 21200 xtv := string(val) 21201 sv.CustomEndpointType = ptr.String(xtv) 21202 } 21203 21204 case strings.EqualFold("DBClusterEndpointArn", t.Name.Local): 21205 val, err := decoder.Value() 21206 if err != nil { 21207 return err 21208 } 21209 if val == nil { 21210 break 21211 } 21212 { 21213 xtv := string(val) 21214 sv.DBClusterEndpointArn = ptr.String(xtv) 21215 } 21216 21217 case strings.EqualFold("DBClusterEndpointIdentifier", t.Name.Local): 21218 val, err := decoder.Value() 21219 if err != nil { 21220 return err 21221 } 21222 if val == nil { 21223 break 21224 } 21225 { 21226 xtv := string(val) 21227 sv.DBClusterEndpointIdentifier = ptr.String(xtv) 21228 } 21229 21230 case strings.EqualFold("DBClusterEndpointResourceIdentifier", t.Name.Local): 21231 val, err := decoder.Value() 21232 if err != nil { 21233 return err 21234 } 21235 if val == nil { 21236 break 21237 } 21238 { 21239 xtv := string(val) 21240 sv.DBClusterEndpointResourceIdentifier = ptr.String(xtv) 21241 } 21242 21243 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 21244 val, err := decoder.Value() 21245 if err != nil { 21246 return err 21247 } 21248 if val == nil { 21249 break 21250 } 21251 { 21252 xtv := string(val) 21253 sv.DBClusterIdentifier = ptr.String(xtv) 21254 } 21255 21256 case strings.EqualFold("Endpoint", t.Name.Local): 21257 val, err := decoder.Value() 21258 if err != nil { 21259 return err 21260 } 21261 if val == nil { 21262 break 21263 } 21264 { 21265 xtv := string(val) 21266 sv.Endpoint = ptr.String(xtv) 21267 } 21268 21269 case strings.EqualFold("EndpointType", t.Name.Local): 21270 val, err := decoder.Value() 21271 if err != nil { 21272 return err 21273 } 21274 if val == nil { 21275 break 21276 } 21277 { 21278 xtv := string(val) 21279 sv.EndpointType = ptr.String(xtv) 21280 } 21281 21282 case strings.EqualFold("ExcludedMembers", t.Name.Local): 21283 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21284 if err := awsAwsquery_deserializeDocumentStringList(&sv.ExcludedMembers, nodeDecoder); err != nil { 21285 return err 21286 } 21287 21288 case strings.EqualFold("StaticMembers", t.Name.Local): 21289 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21290 if err := awsAwsquery_deserializeDocumentStringList(&sv.StaticMembers, nodeDecoder); err != nil { 21291 return err 21292 } 21293 21294 case strings.EqualFold("Status", t.Name.Local): 21295 val, err := decoder.Value() 21296 if err != nil { 21297 return err 21298 } 21299 if val == nil { 21300 break 21301 } 21302 { 21303 xtv := string(val) 21304 sv.Status = ptr.String(xtv) 21305 } 21306 21307 default: 21308 // Do nothing and ignore the unexpected tag element 21309 err = decoder.Decoder.Skip() 21310 if err != nil { 21311 return err 21312 } 21313 21314 } 21315 decoder = originalDecoder 21316 } 21317 *v = sv 21318 return nil 21319} 21320 21321func awsAwsquery_deserializeOpDocumentCreateDBClusterOutput(v **CreateDBClusterOutput, decoder smithyxml.NodeDecoder) error { 21322 if v == nil { 21323 return fmt.Errorf("unexpected nil of type %T", v) 21324 } 21325 var sv *CreateDBClusterOutput 21326 if *v == nil { 21327 sv = &CreateDBClusterOutput{} 21328 } else { 21329 sv = *v 21330 } 21331 21332 for { 21333 t, done, err := decoder.Token() 21334 if err != nil { 21335 return err 21336 } 21337 if done { 21338 break 21339 } 21340 originalDecoder := decoder 21341 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21342 switch { 21343 case strings.EqualFold("DBCluster", t.Name.Local): 21344 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21345 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 21346 return err 21347 } 21348 21349 default: 21350 // Do nothing and ignore the unexpected tag element 21351 err = decoder.Decoder.Skip() 21352 if err != nil { 21353 return err 21354 } 21355 21356 } 21357 decoder = originalDecoder 21358 } 21359 *v = sv 21360 return nil 21361} 21362 21363func awsAwsquery_deserializeOpDocumentCreateDBClusterParameterGroupOutput(v **CreateDBClusterParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 21364 if v == nil { 21365 return fmt.Errorf("unexpected nil of type %T", v) 21366 } 21367 var sv *CreateDBClusterParameterGroupOutput 21368 if *v == nil { 21369 sv = &CreateDBClusterParameterGroupOutput{} 21370 } else { 21371 sv = *v 21372 } 21373 21374 for { 21375 t, done, err := decoder.Token() 21376 if err != nil { 21377 return err 21378 } 21379 if done { 21380 break 21381 } 21382 originalDecoder := decoder 21383 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21384 switch { 21385 case strings.EqualFold("DBClusterParameterGroup", t.Name.Local): 21386 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21387 if err := awsAwsquery_deserializeDocumentDBClusterParameterGroup(&sv.DBClusterParameterGroup, nodeDecoder); err != nil { 21388 return err 21389 } 21390 21391 default: 21392 // Do nothing and ignore the unexpected tag element 21393 err = decoder.Decoder.Skip() 21394 if err != nil { 21395 return err 21396 } 21397 21398 } 21399 decoder = originalDecoder 21400 } 21401 *v = sv 21402 return nil 21403} 21404 21405func awsAwsquery_deserializeOpDocumentCreateDBClusterSnapshotOutput(v **CreateDBClusterSnapshotOutput, decoder smithyxml.NodeDecoder) error { 21406 if v == nil { 21407 return fmt.Errorf("unexpected nil of type %T", v) 21408 } 21409 var sv *CreateDBClusterSnapshotOutput 21410 if *v == nil { 21411 sv = &CreateDBClusterSnapshotOutput{} 21412 } else { 21413 sv = *v 21414 } 21415 21416 for { 21417 t, done, err := decoder.Token() 21418 if err != nil { 21419 return err 21420 } 21421 if done { 21422 break 21423 } 21424 originalDecoder := decoder 21425 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21426 switch { 21427 case strings.EqualFold("DBClusterSnapshot", t.Name.Local): 21428 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21429 if err := awsAwsquery_deserializeDocumentDBClusterSnapshot(&sv.DBClusterSnapshot, nodeDecoder); err != nil { 21430 return err 21431 } 21432 21433 default: 21434 // Do nothing and ignore the unexpected tag element 21435 err = decoder.Decoder.Skip() 21436 if err != nil { 21437 return err 21438 } 21439 21440 } 21441 decoder = originalDecoder 21442 } 21443 *v = sv 21444 return nil 21445} 21446 21447func awsAwsquery_deserializeOpDocumentCreateDBInstanceOutput(v **CreateDBInstanceOutput, decoder smithyxml.NodeDecoder) error { 21448 if v == nil { 21449 return fmt.Errorf("unexpected nil of type %T", v) 21450 } 21451 var sv *CreateDBInstanceOutput 21452 if *v == nil { 21453 sv = &CreateDBInstanceOutput{} 21454 } else { 21455 sv = *v 21456 } 21457 21458 for { 21459 t, done, err := decoder.Token() 21460 if err != nil { 21461 return err 21462 } 21463 if done { 21464 break 21465 } 21466 originalDecoder := decoder 21467 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21468 switch { 21469 case strings.EqualFold("DBInstance", t.Name.Local): 21470 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21471 if err := awsAwsquery_deserializeDocumentDBInstance(&sv.DBInstance, nodeDecoder); err != nil { 21472 return err 21473 } 21474 21475 default: 21476 // Do nothing and ignore the unexpected tag element 21477 err = decoder.Decoder.Skip() 21478 if err != nil { 21479 return err 21480 } 21481 21482 } 21483 decoder = originalDecoder 21484 } 21485 *v = sv 21486 return nil 21487} 21488 21489func awsAwsquery_deserializeOpDocumentCreateDBParameterGroupOutput(v **CreateDBParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 21490 if v == nil { 21491 return fmt.Errorf("unexpected nil of type %T", v) 21492 } 21493 var sv *CreateDBParameterGroupOutput 21494 if *v == nil { 21495 sv = &CreateDBParameterGroupOutput{} 21496 } else { 21497 sv = *v 21498 } 21499 21500 for { 21501 t, done, err := decoder.Token() 21502 if err != nil { 21503 return err 21504 } 21505 if done { 21506 break 21507 } 21508 originalDecoder := decoder 21509 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21510 switch { 21511 case strings.EqualFold("DBParameterGroup", t.Name.Local): 21512 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21513 if err := awsAwsquery_deserializeDocumentDBParameterGroup(&sv.DBParameterGroup, nodeDecoder); err != nil { 21514 return err 21515 } 21516 21517 default: 21518 // Do nothing and ignore the unexpected tag element 21519 err = decoder.Decoder.Skip() 21520 if err != nil { 21521 return err 21522 } 21523 21524 } 21525 decoder = originalDecoder 21526 } 21527 *v = sv 21528 return nil 21529} 21530 21531func awsAwsquery_deserializeOpDocumentCreateDBSubnetGroupOutput(v **CreateDBSubnetGroupOutput, decoder smithyxml.NodeDecoder) error { 21532 if v == nil { 21533 return fmt.Errorf("unexpected nil of type %T", v) 21534 } 21535 var sv *CreateDBSubnetGroupOutput 21536 if *v == nil { 21537 sv = &CreateDBSubnetGroupOutput{} 21538 } else { 21539 sv = *v 21540 } 21541 21542 for { 21543 t, done, err := decoder.Token() 21544 if err != nil { 21545 return err 21546 } 21547 if done { 21548 break 21549 } 21550 originalDecoder := decoder 21551 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21552 switch { 21553 case strings.EqualFold("DBSubnetGroup", t.Name.Local): 21554 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21555 if err := awsAwsquery_deserializeDocumentDBSubnetGroup(&sv.DBSubnetGroup, nodeDecoder); err != nil { 21556 return err 21557 } 21558 21559 default: 21560 // Do nothing and ignore the unexpected tag element 21561 err = decoder.Decoder.Skip() 21562 if err != nil { 21563 return err 21564 } 21565 21566 } 21567 decoder = originalDecoder 21568 } 21569 *v = sv 21570 return nil 21571} 21572 21573func awsAwsquery_deserializeOpDocumentCreateEventSubscriptionOutput(v **CreateEventSubscriptionOutput, decoder smithyxml.NodeDecoder) error { 21574 if v == nil { 21575 return fmt.Errorf("unexpected nil of type %T", v) 21576 } 21577 var sv *CreateEventSubscriptionOutput 21578 if *v == nil { 21579 sv = &CreateEventSubscriptionOutput{} 21580 } else { 21581 sv = *v 21582 } 21583 21584 for { 21585 t, done, err := decoder.Token() 21586 if err != nil { 21587 return err 21588 } 21589 if done { 21590 break 21591 } 21592 originalDecoder := decoder 21593 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21594 switch { 21595 case strings.EqualFold("EventSubscription", t.Name.Local): 21596 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21597 if err := awsAwsquery_deserializeDocumentEventSubscription(&sv.EventSubscription, nodeDecoder); err != nil { 21598 return err 21599 } 21600 21601 default: 21602 // Do nothing and ignore the unexpected tag element 21603 err = decoder.Decoder.Skip() 21604 if err != nil { 21605 return err 21606 } 21607 21608 } 21609 decoder = originalDecoder 21610 } 21611 *v = sv 21612 return nil 21613} 21614 21615func awsAwsquery_deserializeOpDocumentDeleteDBClusterEndpointOutput(v **DeleteDBClusterEndpointOutput, decoder smithyxml.NodeDecoder) error { 21616 if v == nil { 21617 return fmt.Errorf("unexpected nil of type %T", v) 21618 } 21619 var sv *DeleteDBClusterEndpointOutput 21620 if *v == nil { 21621 sv = &DeleteDBClusterEndpointOutput{} 21622 } else { 21623 sv = *v 21624 } 21625 21626 for { 21627 t, done, err := decoder.Token() 21628 if err != nil { 21629 return err 21630 } 21631 if done { 21632 break 21633 } 21634 originalDecoder := decoder 21635 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21636 switch { 21637 case strings.EqualFold("CustomEndpointType", t.Name.Local): 21638 val, err := decoder.Value() 21639 if err != nil { 21640 return err 21641 } 21642 if val == nil { 21643 break 21644 } 21645 { 21646 xtv := string(val) 21647 sv.CustomEndpointType = ptr.String(xtv) 21648 } 21649 21650 case strings.EqualFold("DBClusterEndpointArn", t.Name.Local): 21651 val, err := decoder.Value() 21652 if err != nil { 21653 return err 21654 } 21655 if val == nil { 21656 break 21657 } 21658 { 21659 xtv := string(val) 21660 sv.DBClusterEndpointArn = ptr.String(xtv) 21661 } 21662 21663 case strings.EqualFold("DBClusterEndpointIdentifier", t.Name.Local): 21664 val, err := decoder.Value() 21665 if err != nil { 21666 return err 21667 } 21668 if val == nil { 21669 break 21670 } 21671 { 21672 xtv := string(val) 21673 sv.DBClusterEndpointIdentifier = ptr.String(xtv) 21674 } 21675 21676 case strings.EqualFold("DBClusterEndpointResourceIdentifier", t.Name.Local): 21677 val, err := decoder.Value() 21678 if err != nil { 21679 return err 21680 } 21681 if val == nil { 21682 break 21683 } 21684 { 21685 xtv := string(val) 21686 sv.DBClusterEndpointResourceIdentifier = ptr.String(xtv) 21687 } 21688 21689 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 21690 val, err := decoder.Value() 21691 if err != nil { 21692 return err 21693 } 21694 if val == nil { 21695 break 21696 } 21697 { 21698 xtv := string(val) 21699 sv.DBClusterIdentifier = ptr.String(xtv) 21700 } 21701 21702 case strings.EqualFold("Endpoint", t.Name.Local): 21703 val, err := decoder.Value() 21704 if err != nil { 21705 return err 21706 } 21707 if val == nil { 21708 break 21709 } 21710 { 21711 xtv := string(val) 21712 sv.Endpoint = ptr.String(xtv) 21713 } 21714 21715 case strings.EqualFold("EndpointType", t.Name.Local): 21716 val, err := decoder.Value() 21717 if err != nil { 21718 return err 21719 } 21720 if val == nil { 21721 break 21722 } 21723 { 21724 xtv := string(val) 21725 sv.EndpointType = ptr.String(xtv) 21726 } 21727 21728 case strings.EqualFold("ExcludedMembers", t.Name.Local): 21729 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21730 if err := awsAwsquery_deserializeDocumentStringList(&sv.ExcludedMembers, nodeDecoder); err != nil { 21731 return err 21732 } 21733 21734 case strings.EqualFold("StaticMembers", t.Name.Local): 21735 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21736 if err := awsAwsquery_deserializeDocumentStringList(&sv.StaticMembers, nodeDecoder); err != nil { 21737 return err 21738 } 21739 21740 case strings.EqualFold("Status", t.Name.Local): 21741 val, err := decoder.Value() 21742 if err != nil { 21743 return err 21744 } 21745 if val == nil { 21746 break 21747 } 21748 { 21749 xtv := string(val) 21750 sv.Status = ptr.String(xtv) 21751 } 21752 21753 default: 21754 // Do nothing and ignore the unexpected tag element 21755 err = decoder.Decoder.Skip() 21756 if err != nil { 21757 return err 21758 } 21759 21760 } 21761 decoder = originalDecoder 21762 } 21763 *v = sv 21764 return nil 21765} 21766 21767func awsAwsquery_deserializeOpDocumentDeleteDBClusterOutput(v **DeleteDBClusterOutput, decoder smithyxml.NodeDecoder) error { 21768 if v == nil { 21769 return fmt.Errorf("unexpected nil of type %T", v) 21770 } 21771 var sv *DeleteDBClusterOutput 21772 if *v == nil { 21773 sv = &DeleteDBClusterOutput{} 21774 } else { 21775 sv = *v 21776 } 21777 21778 for { 21779 t, done, err := decoder.Token() 21780 if err != nil { 21781 return err 21782 } 21783 if done { 21784 break 21785 } 21786 originalDecoder := decoder 21787 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21788 switch { 21789 case strings.EqualFold("DBCluster", t.Name.Local): 21790 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21791 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 21792 return err 21793 } 21794 21795 default: 21796 // Do nothing and ignore the unexpected tag element 21797 err = decoder.Decoder.Skip() 21798 if err != nil { 21799 return err 21800 } 21801 21802 } 21803 decoder = originalDecoder 21804 } 21805 *v = sv 21806 return nil 21807} 21808 21809func awsAwsquery_deserializeOpDocumentDeleteDBClusterSnapshotOutput(v **DeleteDBClusterSnapshotOutput, decoder smithyxml.NodeDecoder) error { 21810 if v == nil { 21811 return fmt.Errorf("unexpected nil of type %T", v) 21812 } 21813 var sv *DeleteDBClusterSnapshotOutput 21814 if *v == nil { 21815 sv = &DeleteDBClusterSnapshotOutput{} 21816 } else { 21817 sv = *v 21818 } 21819 21820 for { 21821 t, done, err := decoder.Token() 21822 if err != nil { 21823 return err 21824 } 21825 if done { 21826 break 21827 } 21828 originalDecoder := decoder 21829 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21830 switch { 21831 case strings.EqualFold("DBClusterSnapshot", t.Name.Local): 21832 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21833 if err := awsAwsquery_deserializeDocumentDBClusterSnapshot(&sv.DBClusterSnapshot, nodeDecoder); err != nil { 21834 return err 21835 } 21836 21837 default: 21838 // Do nothing and ignore the unexpected tag element 21839 err = decoder.Decoder.Skip() 21840 if err != nil { 21841 return err 21842 } 21843 21844 } 21845 decoder = originalDecoder 21846 } 21847 *v = sv 21848 return nil 21849} 21850 21851func awsAwsquery_deserializeOpDocumentDeleteDBInstanceOutput(v **DeleteDBInstanceOutput, decoder smithyxml.NodeDecoder) error { 21852 if v == nil { 21853 return fmt.Errorf("unexpected nil of type %T", v) 21854 } 21855 var sv *DeleteDBInstanceOutput 21856 if *v == nil { 21857 sv = &DeleteDBInstanceOutput{} 21858 } else { 21859 sv = *v 21860 } 21861 21862 for { 21863 t, done, err := decoder.Token() 21864 if err != nil { 21865 return err 21866 } 21867 if done { 21868 break 21869 } 21870 originalDecoder := decoder 21871 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21872 switch { 21873 case strings.EqualFold("DBInstance", t.Name.Local): 21874 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21875 if err := awsAwsquery_deserializeDocumentDBInstance(&sv.DBInstance, nodeDecoder); err != nil { 21876 return err 21877 } 21878 21879 default: 21880 // Do nothing and ignore the unexpected tag element 21881 err = decoder.Decoder.Skip() 21882 if err != nil { 21883 return err 21884 } 21885 21886 } 21887 decoder = originalDecoder 21888 } 21889 *v = sv 21890 return nil 21891} 21892 21893func awsAwsquery_deserializeOpDocumentDeleteEventSubscriptionOutput(v **DeleteEventSubscriptionOutput, decoder smithyxml.NodeDecoder) error { 21894 if v == nil { 21895 return fmt.Errorf("unexpected nil of type %T", v) 21896 } 21897 var sv *DeleteEventSubscriptionOutput 21898 if *v == nil { 21899 sv = &DeleteEventSubscriptionOutput{} 21900 } else { 21901 sv = *v 21902 } 21903 21904 for { 21905 t, done, err := decoder.Token() 21906 if err != nil { 21907 return err 21908 } 21909 if done { 21910 break 21911 } 21912 originalDecoder := decoder 21913 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21914 switch { 21915 case strings.EqualFold("EventSubscription", t.Name.Local): 21916 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21917 if err := awsAwsquery_deserializeDocumentEventSubscription(&sv.EventSubscription, nodeDecoder); err != nil { 21918 return err 21919 } 21920 21921 default: 21922 // Do nothing and ignore the unexpected tag element 21923 err = decoder.Decoder.Skip() 21924 if err != nil { 21925 return err 21926 } 21927 21928 } 21929 decoder = originalDecoder 21930 } 21931 *v = sv 21932 return nil 21933} 21934 21935func awsAwsquery_deserializeOpDocumentDescribeDBClusterEndpointsOutput(v **DescribeDBClusterEndpointsOutput, decoder smithyxml.NodeDecoder) error { 21936 if v == nil { 21937 return fmt.Errorf("unexpected nil of type %T", v) 21938 } 21939 var sv *DescribeDBClusterEndpointsOutput 21940 if *v == nil { 21941 sv = &DescribeDBClusterEndpointsOutput{} 21942 } else { 21943 sv = *v 21944 } 21945 21946 for { 21947 t, done, err := decoder.Token() 21948 if err != nil { 21949 return err 21950 } 21951 if done { 21952 break 21953 } 21954 originalDecoder := decoder 21955 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 21956 switch { 21957 case strings.EqualFold("DBClusterEndpoints", t.Name.Local): 21958 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 21959 if err := awsAwsquery_deserializeDocumentDBClusterEndpointList(&sv.DBClusterEndpoints, nodeDecoder); err != nil { 21960 return err 21961 } 21962 21963 case strings.EqualFold("Marker", t.Name.Local): 21964 val, err := decoder.Value() 21965 if err != nil { 21966 return err 21967 } 21968 if val == nil { 21969 break 21970 } 21971 { 21972 xtv := string(val) 21973 sv.Marker = ptr.String(xtv) 21974 } 21975 21976 default: 21977 // Do nothing and ignore the unexpected tag element 21978 err = decoder.Decoder.Skip() 21979 if err != nil { 21980 return err 21981 } 21982 21983 } 21984 decoder = originalDecoder 21985 } 21986 *v = sv 21987 return nil 21988} 21989 21990func awsAwsquery_deserializeOpDocumentDescribeDBClusterParameterGroupsOutput(v **DescribeDBClusterParameterGroupsOutput, decoder smithyxml.NodeDecoder) error { 21991 if v == nil { 21992 return fmt.Errorf("unexpected nil of type %T", v) 21993 } 21994 var sv *DescribeDBClusterParameterGroupsOutput 21995 if *v == nil { 21996 sv = &DescribeDBClusterParameterGroupsOutput{} 21997 } else { 21998 sv = *v 21999 } 22000 22001 for { 22002 t, done, err := decoder.Token() 22003 if err != nil { 22004 return err 22005 } 22006 if done { 22007 break 22008 } 22009 originalDecoder := decoder 22010 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22011 switch { 22012 case strings.EqualFold("DBClusterParameterGroups", t.Name.Local): 22013 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22014 if err := awsAwsquery_deserializeDocumentDBClusterParameterGroupList(&sv.DBClusterParameterGroups, nodeDecoder); err != nil { 22015 return err 22016 } 22017 22018 case strings.EqualFold("Marker", t.Name.Local): 22019 val, err := decoder.Value() 22020 if err != nil { 22021 return err 22022 } 22023 if val == nil { 22024 break 22025 } 22026 { 22027 xtv := string(val) 22028 sv.Marker = ptr.String(xtv) 22029 } 22030 22031 default: 22032 // Do nothing and ignore the unexpected tag element 22033 err = decoder.Decoder.Skip() 22034 if err != nil { 22035 return err 22036 } 22037 22038 } 22039 decoder = originalDecoder 22040 } 22041 *v = sv 22042 return nil 22043} 22044 22045func awsAwsquery_deserializeOpDocumentDescribeDBClusterParametersOutput(v **DescribeDBClusterParametersOutput, decoder smithyxml.NodeDecoder) error { 22046 if v == nil { 22047 return fmt.Errorf("unexpected nil of type %T", v) 22048 } 22049 var sv *DescribeDBClusterParametersOutput 22050 if *v == nil { 22051 sv = &DescribeDBClusterParametersOutput{} 22052 } else { 22053 sv = *v 22054 } 22055 22056 for { 22057 t, done, err := decoder.Token() 22058 if err != nil { 22059 return err 22060 } 22061 if done { 22062 break 22063 } 22064 originalDecoder := decoder 22065 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22066 switch { 22067 case strings.EqualFold("Marker", t.Name.Local): 22068 val, err := decoder.Value() 22069 if err != nil { 22070 return err 22071 } 22072 if val == nil { 22073 break 22074 } 22075 { 22076 xtv := string(val) 22077 sv.Marker = ptr.String(xtv) 22078 } 22079 22080 case strings.EqualFold("Parameters", t.Name.Local): 22081 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22082 if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil { 22083 return err 22084 } 22085 22086 default: 22087 // Do nothing and ignore the unexpected tag element 22088 err = decoder.Decoder.Skip() 22089 if err != nil { 22090 return err 22091 } 22092 22093 } 22094 decoder = originalDecoder 22095 } 22096 *v = sv 22097 return nil 22098} 22099 22100func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotAttributesOutput(v **DescribeDBClusterSnapshotAttributesOutput, decoder smithyxml.NodeDecoder) error { 22101 if v == nil { 22102 return fmt.Errorf("unexpected nil of type %T", v) 22103 } 22104 var sv *DescribeDBClusterSnapshotAttributesOutput 22105 if *v == nil { 22106 sv = &DescribeDBClusterSnapshotAttributesOutput{} 22107 } else { 22108 sv = *v 22109 } 22110 22111 for { 22112 t, done, err := decoder.Token() 22113 if err != nil { 22114 return err 22115 } 22116 if done { 22117 break 22118 } 22119 originalDecoder := decoder 22120 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22121 switch { 22122 case strings.EqualFold("DBClusterSnapshotAttributesResult", t.Name.Local): 22123 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22124 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttributesResult(&sv.DBClusterSnapshotAttributesResult, nodeDecoder); err != nil { 22125 return err 22126 } 22127 22128 default: 22129 // Do nothing and ignore the unexpected tag element 22130 err = decoder.Decoder.Skip() 22131 if err != nil { 22132 return err 22133 } 22134 22135 } 22136 decoder = originalDecoder 22137 } 22138 *v = sv 22139 return nil 22140} 22141 22142func awsAwsquery_deserializeOpDocumentDescribeDBClusterSnapshotsOutput(v **DescribeDBClusterSnapshotsOutput, decoder smithyxml.NodeDecoder) error { 22143 if v == nil { 22144 return fmt.Errorf("unexpected nil of type %T", v) 22145 } 22146 var sv *DescribeDBClusterSnapshotsOutput 22147 if *v == nil { 22148 sv = &DescribeDBClusterSnapshotsOutput{} 22149 } else { 22150 sv = *v 22151 } 22152 22153 for { 22154 t, done, err := decoder.Token() 22155 if err != nil { 22156 return err 22157 } 22158 if done { 22159 break 22160 } 22161 originalDecoder := decoder 22162 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22163 switch { 22164 case strings.EqualFold("DBClusterSnapshots", t.Name.Local): 22165 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22166 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotList(&sv.DBClusterSnapshots, nodeDecoder); err != nil { 22167 return err 22168 } 22169 22170 case strings.EqualFold("Marker", t.Name.Local): 22171 val, err := decoder.Value() 22172 if err != nil { 22173 return err 22174 } 22175 if val == nil { 22176 break 22177 } 22178 { 22179 xtv := string(val) 22180 sv.Marker = ptr.String(xtv) 22181 } 22182 22183 default: 22184 // Do nothing and ignore the unexpected tag element 22185 err = decoder.Decoder.Skip() 22186 if err != nil { 22187 return err 22188 } 22189 22190 } 22191 decoder = originalDecoder 22192 } 22193 *v = sv 22194 return nil 22195} 22196 22197func awsAwsquery_deserializeOpDocumentDescribeDBClustersOutput(v **DescribeDBClustersOutput, decoder smithyxml.NodeDecoder) error { 22198 if v == nil { 22199 return fmt.Errorf("unexpected nil of type %T", v) 22200 } 22201 var sv *DescribeDBClustersOutput 22202 if *v == nil { 22203 sv = &DescribeDBClustersOutput{} 22204 } else { 22205 sv = *v 22206 } 22207 22208 for { 22209 t, done, err := decoder.Token() 22210 if err != nil { 22211 return err 22212 } 22213 if done { 22214 break 22215 } 22216 originalDecoder := decoder 22217 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22218 switch { 22219 case strings.EqualFold("DBClusters", t.Name.Local): 22220 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22221 if err := awsAwsquery_deserializeDocumentDBClusterList(&sv.DBClusters, nodeDecoder); err != nil { 22222 return err 22223 } 22224 22225 case strings.EqualFold("Marker", t.Name.Local): 22226 val, err := decoder.Value() 22227 if err != nil { 22228 return err 22229 } 22230 if val == nil { 22231 break 22232 } 22233 { 22234 xtv := string(val) 22235 sv.Marker = ptr.String(xtv) 22236 } 22237 22238 default: 22239 // Do nothing and ignore the unexpected tag element 22240 err = decoder.Decoder.Skip() 22241 if err != nil { 22242 return err 22243 } 22244 22245 } 22246 decoder = originalDecoder 22247 } 22248 *v = sv 22249 return nil 22250} 22251 22252func awsAwsquery_deserializeOpDocumentDescribeDBEngineVersionsOutput(v **DescribeDBEngineVersionsOutput, decoder smithyxml.NodeDecoder) error { 22253 if v == nil { 22254 return fmt.Errorf("unexpected nil of type %T", v) 22255 } 22256 var sv *DescribeDBEngineVersionsOutput 22257 if *v == nil { 22258 sv = &DescribeDBEngineVersionsOutput{} 22259 } else { 22260 sv = *v 22261 } 22262 22263 for { 22264 t, done, err := decoder.Token() 22265 if err != nil { 22266 return err 22267 } 22268 if done { 22269 break 22270 } 22271 originalDecoder := decoder 22272 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22273 switch { 22274 case strings.EqualFold("DBEngineVersions", t.Name.Local): 22275 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22276 if err := awsAwsquery_deserializeDocumentDBEngineVersionList(&sv.DBEngineVersions, nodeDecoder); err != nil { 22277 return err 22278 } 22279 22280 case strings.EqualFold("Marker", t.Name.Local): 22281 val, err := decoder.Value() 22282 if err != nil { 22283 return err 22284 } 22285 if val == nil { 22286 break 22287 } 22288 { 22289 xtv := string(val) 22290 sv.Marker = ptr.String(xtv) 22291 } 22292 22293 default: 22294 // Do nothing and ignore the unexpected tag element 22295 err = decoder.Decoder.Skip() 22296 if err != nil { 22297 return err 22298 } 22299 22300 } 22301 decoder = originalDecoder 22302 } 22303 *v = sv 22304 return nil 22305} 22306 22307func awsAwsquery_deserializeOpDocumentDescribeDBInstancesOutput(v **DescribeDBInstancesOutput, decoder smithyxml.NodeDecoder) error { 22308 if v == nil { 22309 return fmt.Errorf("unexpected nil of type %T", v) 22310 } 22311 var sv *DescribeDBInstancesOutput 22312 if *v == nil { 22313 sv = &DescribeDBInstancesOutput{} 22314 } else { 22315 sv = *v 22316 } 22317 22318 for { 22319 t, done, err := decoder.Token() 22320 if err != nil { 22321 return err 22322 } 22323 if done { 22324 break 22325 } 22326 originalDecoder := decoder 22327 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22328 switch { 22329 case strings.EqualFold("DBInstances", t.Name.Local): 22330 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22331 if err := awsAwsquery_deserializeDocumentDBInstanceList(&sv.DBInstances, nodeDecoder); err != nil { 22332 return err 22333 } 22334 22335 case strings.EqualFold("Marker", t.Name.Local): 22336 val, err := decoder.Value() 22337 if err != nil { 22338 return err 22339 } 22340 if val == nil { 22341 break 22342 } 22343 { 22344 xtv := string(val) 22345 sv.Marker = ptr.String(xtv) 22346 } 22347 22348 default: 22349 // Do nothing and ignore the unexpected tag element 22350 err = decoder.Decoder.Skip() 22351 if err != nil { 22352 return err 22353 } 22354 22355 } 22356 decoder = originalDecoder 22357 } 22358 *v = sv 22359 return nil 22360} 22361 22362func awsAwsquery_deserializeOpDocumentDescribeDBParameterGroupsOutput(v **DescribeDBParameterGroupsOutput, decoder smithyxml.NodeDecoder) error { 22363 if v == nil { 22364 return fmt.Errorf("unexpected nil of type %T", v) 22365 } 22366 var sv *DescribeDBParameterGroupsOutput 22367 if *v == nil { 22368 sv = &DescribeDBParameterGroupsOutput{} 22369 } else { 22370 sv = *v 22371 } 22372 22373 for { 22374 t, done, err := decoder.Token() 22375 if err != nil { 22376 return err 22377 } 22378 if done { 22379 break 22380 } 22381 originalDecoder := decoder 22382 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22383 switch { 22384 case strings.EqualFold("DBParameterGroups", t.Name.Local): 22385 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22386 if err := awsAwsquery_deserializeDocumentDBParameterGroupList(&sv.DBParameterGroups, nodeDecoder); err != nil { 22387 return err 22388 } 22389 22390 case strings.EqualFold("Marker", t.Name.Local): 22391 val, err := decoder.Value() 22392 if err != nil { 22393 return err 22394 } 22395 if val == nil { 22396 break 22397 } 22398 { 22399 xtv := string(val) 22400 sv.Marker = ptr.String(xtv) 22401 } 22402 22403 default: 22404 // Do nothing and ignore the unexpected tag element 22405 err = decoder.Decoder.Skip() 22406 if err != nil { 22407 return err 22408 } 22409 22410 } 22411 decoder = originalDecoder 22412 } 22413 *v = sv 22414 return nil 22415} 22416 22417func awsAwsquery_deserializeOpDocumentDescribeDBParametersOutput(v **DescribeDBParametersOutput, decoder smithyxml.NodeDecoder) error { 22418 if v == nil { 22419 return fmt.Errorf("unexpected nil of type %T", v) 22420 } 22421 var sv *DescribeDBParametersOutput 22422 if *v == nil { 22423 sv = &DescribeDBParametersOutput{} 22424 } else { 22425 sv = *v 22426 } 22427 22428 for { 22429 t, done, err := decoder.Token() 22430 if err != nil { 22431 return err 22432 } 22433 if done { 22434 break 22435 } 22436 originalDecoder := decoder 22437 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22438 switch { 22439 case strings.EqualFold("Marker", t.Name.Local): 22440 val, err := decoder.Value() 22441 if err != nil { 22442 return err 22443 } 22444 if val == nil { 22445 break 22446 } 22447 { 22448 xtv := string(val) 22449 sv.Marker = ptr.String(xtv) 22450 } 22451 22452 case strings.EqualFold("Parameters", t.Name.Local): 22453 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22454 if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil { 22455 return err 22456 } 22457 22458 default: 22459 // Do nothing and ignore the unexpected tag element 22460 err = decoder.Decoder.Skip() 22461 if err != nil { 22462 return err 22463 } 22464 22465 } 22466 decoder = originalDecoder 22467 } 22468 *v = sv 22469 return nil 22470} 22471 22472func awsAwsquery_deserializeOpDocumentDescribeDBSubnetGroupsOutput(v **DescribeDBSubnetGroupsOutput, decoder smithyxml.NodeDecoder) error { 22473 if v == nil { 22474 return fmt.Errorf("unexpected nil of type %T", v) 22475 } 22476 var sv *DescribeDBSubnetGroupsOutput 22477 if *v == nil { 22478 sv = &DescribeDBSubnetGroupsOutput{} 22479 } else { 22480 sv = *v 22481 } 22482 22483 for { 22484 t, done, err := decoder.Token() 22485 if err != nil { 22486 return err 22487 } 22488 if done { 22489 break 22490 } 22491 originalDecoder := decoder 22492 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22493 switch { 22494 case strings.EqualFold("DBSubnetGroups", t.Name.Local): 22495 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22496 if err := awsAwsquery_deserializeDocumentDBSubnetGroups(&sv.DBSubnetGroups, nodeDecoder); err != nil { 22497 return err 22498 } 22499 22500 case strings.EqualFold("Marker", t.Name.Local): 22501 val, err := decoder.Value() 22502 if err != nil { 22503 return err 22504 } 22505 if val == nil { 22506 break 22507 } 22508 { 22509 xtv := string(val) 22510 sv.Marker = ptr.String(xtv) 22511 } 22512 22513 default: 22514 // Do nothing and ignore the unexpected tag element 22515 err = decoder.Decoder.Skip() 22516 if err != nil { 22517 return err 22518 } 22519 22520 } 22521 decoder = originalDecoder 22522 } 22523 *v = sv 22524 return nil 22525} 22526 22527func awsAwsquery_deserializeOpDocumentDescribeEngineDefaultClusterParametersOutput(v **DescribeEngineDefaultClusterParametersOutput, decoder smithyxml.NodeDecoder) error { 22528 if v == nil { 22529 return fmt.Errorf("unexpected nil of type %T", v) 22530 } 22531 var sv *DescribeEngineDefaultClusterParametersOutput 22532 if *v == nil { 22533 sv = &DescribeEngineDefaultClusterParametersOutput{} 22534 } else { 22535 sv = *v 22536 } 22537 22538 for { 22539 t, done, err := decoder.Token() 22540 if err != nil { 22541 return err 22542 } 22543 if done { 22544 break 22545 } 22546 originalDecoder := decoder 22547 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22548 switch { 22549 case strings.EqualFold("EngineDefaults", t.Name.Local): 22550 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22551 if err := awsAwsquery_deserializeDocumentEngineDefaults(&sv.EngineDefaults, nodeDecoder); err != nil { 22552 return err 22553 } 22554 22555 default: 22556 // Do nothing and ignore the unexpected tag element 22557 err = decoder.Decoder.Skip() 22558 if err != nil { 22559 return err 22560 } 22561 22562 } 22563 decoder = originalDecoder 22564 } 22565 *v = sv 22566 return nil 22567} 22568 22569func awsAwsquery_deserializeOpDocumentDescribeEngineDefaultParametersOutput(v **DescribeEngineDefaultParametersOutput, decoder smithyxml.NodeDecoder) error { 22570 if v == nil { 22571 return fmt.Errorf("unexpected nil of type %T", v) 22572 } 22573 var sv *DescribeEngineDefaultParametersOutput 22574 if *v == nil { 22575 sv = &DescribeEngineDefaultParametersOutput{} 22576 } else { 22577 sv = *v 22578 } 22579 22580 for { 22581 t, done, err := decoder.Token() 22582 if err != nil { 22583 return err 22584 } 22585 if done { 22586 break 22587 } 22588 originalDecoder := decoder 22589 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22590 switch { 22591 case strings.EqualFold("EngineDefaults", t.Name.Local): 22592 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22593 if err := awsAwsquery_deserializeDocumentEngineDefaults(&sv.EngineDefaults, nodeDecoder); err != nil { 22594 return err 22595 } 22596 22597 default: 22598 // Do nothing and ignore the unexpected tag element 22599 err = decoder.Decoder.Skip() 22600 if err != nil { 22601 return err 22602 } 22603 22604 } 22605 decoder = originalDecoder 22606 } 22607 *v = sv 22608 return nil 22609} 22610 22611func awsAwsquery_deserializeOpDocumentDescribeEventCategoriesOutput(v **DescribeEventCategoriesOutput, decoder smithyxml.NodeDecoder) error { 22612 if v == nil { 22613 return fmt.Errorf("unexpected nil of type %T", v) 22614 } 22615 var sv *DescribeEventCategoriesOutput 22616 if *v == nil { 22617 sv = &DescribeEventCategoriesOutput{} 22618 } else { 22619 sv = *v 22620 } 22621 22622 for { 22623 t, done, err := decoder.Token() 22624 if err != nil { 22625 return err 22626 } 22627 if done { 22628 break 22629 } 22630 originalDecoder := decoder 22631 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22632 switch { 22633 case strings.EqualFold("EventCategoriesMapList", t.Name.Local): 22634 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22635 if err := awsAwsquery_deserializeDocumentEventCategoriesMapList(&sv.EventCategoriesMapList, nodeDecoder); err != nil { 22636 return err 22637 } 22638 22639 default: 22640 // Do nothing and ignore the unexpected tag element 22641 err = decoder.Decoder.Skip() 22642 if err != nil { 22643 return err 22644 } 22645 22646 } 22647 decoder = originalDecoder 22648 } 22649 *v = sv 22650 return nil 22651} 22652 22653func awsAwsquery_deserializeOpDocumentDescribeEventsOutput(v **DescribeEventsOutput, decoder smithyxml.NodeDecoder) error { 22654 if v == nil { 22655 return fmt.Errorf("unexpected nil of type %T", v) 22656 } 22657 var sv *DescribeEventsOutput 22658 if *v == nil { 22659 sv = &DescribeEventsOutput{} 22660 } else { 22661 sv = *v 22662 } 22663 22664 for { 22665 t, done, err := decoder.Token() 22666 if err != nil { 22667 return err 22668 } 22669 if done { 22670 break 22671 } 22672 originalDecoder := decoder 22673 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22674 switch { 22675 case strings.EqualFold("Events", t.Name.Local): 22676 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22677 if err := awsAwsquery_deserializeDocumentEventList(&sv.Events, nodeDecoder); err != nil { 22678 return err 22679 } 22680 22681 case strings.EqualFold("Marker", t.Name.Local): 22682 val, err := decoder.Value() 22683 if err != nil { 22684 return err 22685 } 22686 if val == nil { 22687 break 22688 } 22689 { 22690 xtv := string(val) 22691 sv.Marker = ptr.String(xtv) 22692 } 22693 22694 default: 22695 // Do nothing and ignore the unexpected tag element 22696 err = decoder.Decoder.Skip() 22697 if err != nil { 22698 return err 22699 } 22700 22701 } 22702 decoder = originalDecoder 22703 } 22704 *v = sv 22705 return nil 22706} 22707 22708func awsAwsquery_deserializeOpDocumentDescribeEventSubscriptionsOutput(v **DescribeEventSubscriptionsOutput, decoder smithyxml.NodeDecoder) error { 22709 if v == nil { 22710 return fmt.Errorf("unexpected nil of type %T", v) 22711 } 22712 var sv *DescribeEventSubscriptionsOutput 22713 if *v == nil { 22714 sv = &DescribeEventSubscriptionsOutput{} 22715 } else { 22716 sv = *v 22717 } 22718 22719 for { 22720 t, done, err := decoder.Token() 22721 if err != nil { 22722 return err 22723 } 22724 if done { 22725 break 22726 } 22727 originalDecoder := decoder 22728 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22729 switch { 22730 case strings.EqualFold("EventSubscriptionsList", t.Name.Local): 22731 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22732 if err := awsAwsquery_deserializeDocumentEventSubscriptionsList(&sv.EventSubscriptionsList, nodeDecoder); err != nil { 22733 return err 22734 } 22735 22736 case strings.EqualFold("Marker", t.Name.Local): 22737 val, err := decoder.Value() 22738 if err != nil { 22739 return err 22740 } 22741 if val == nil { 22742 break 22743 } 22744 { 22745 xtv := string(val) 22746 sv.Marker = ptr.String(xtv) 22747 } 22748 22749 default: 22750 // Do nothing and ignore the unexpected tag element 22751 err = decoder.Decoder.Skip() 22752 if err != nil { 22753 return err 22754 } 22755 22756 } 22757 decoder = originalDecoder 22758 } 22759 *v = sv 22760 return nil 22761} 22762 22763func awsAwsquery_deserializeOpDocumentDescribeOrderableDBInstanceOptionsOutput(v **DescribeOrderableDBInstanceOptionsOutput, decoder smithyxml.NodeDecoder) error { 22764 if v == nil { 22765 return fmt.Errorf("unexpected nil of type %T", v) 22766 } 22767 var sv *DescribeOrderableDBInstanceOptionsOutput 22768 if *v == nil { 22769 sv = &DescribeOrderableDBInstanceOptionsOutput{} 22770 } else { 22771 sv = *v 22772 } 22773 22774 for { 22775 t, done, err := decoder.Token() 22776 if err != nil { 22777 return err 22778 } 22779 if done { 22780 break 22781 } 22782 originalDecoder := decoder 22783 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22784 switch { 22785 case strings.EqualFold("Marker", t.Name.Local): 22786 val, err := decoder.Value() 22787 if err != nil { 22788 return err 22789 } 22790 if val == nil { 22791 break 22792 } 22793 { 22794 xtv := string(val) 22795 sv.Marker = ptr.String(xtv) 22796 } 22797 22798 case strings.EqualFold("OrderableDBInstanceOptions", t.Name.Local): 22799 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22800 if err := awsAwsquery_deserializeDocumentOrderableDBInstanceOptionsList(&sv.OrderableDBInstanceOptions, nodeDecoder); err != nil { 22801 return err 22802 } 22803 22804 default: 22805 // Do nothing and ignore the unexpected tag element 22806 err = decoder.Decoder.Skip() 22807 if err != nil { 22808 return err 22809 } 22810 22811 } 22812 decoder = originalDecoder 22813 } 22814 *v = sv 22815 return nil 22816} 22817 22818func awsAwsquery_deserializeOpDocumentDescribePendingMaintenanceActionsOutput(v **DescribePendingMaintenanceActionsOutput, decoder smithyxml.NodeDecoder) error { 22819 if v == nil { 22820 return fmt.Errorf("unexpected nil of type %T", v) 22821 } 22822 var sv *DescribePendingMaintenanceActionsOutput 22823 if *v == nil { 22824 sv = &DescribePendingMaintenanceActionsOutput{} 22825 } else { 22826 sv = *v 22827 } 22828 22829 for { 22830 t, done, err := decoder.Token() 22831 if err != nil { 22832 return err 22833 } 22834 if done { 22835 break 22836 } 22837 originalDecoder := decoder 22838 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22839 switch { 22840 case strings.EqualFold("Marker", t.Name.Local): 22841 val, err := decoder.Value() 22842 if err != nil { 22843 return err 22844 } 22845 if val == nil { 22846 break 22847 } 22848 { 22849 xtv := string(val) 22850 sv.Marker = ptr.String(xtv) 22851 } 22852 22853 case strings.EqualFold("PendingMaintenanceActions", t.Name.Local): 22854 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22855 if err := awsAwsquery_deserializeDocumentPendingMaintenanceActions(&sv.PendingMaintenanceActions, nodeDecoder); err != nil { 22856 return err 22857 } 22858 22859 default: 22860 // Do nothing and ignore the unexpected tag element 22861 err = decoder.Decoder.Skip() 22862 if err != nil { 22863 return err 22864 } 22865 22866 } 22867 decoder = originalDecoder 22868 } 22869 *v = sv 22870 return nil 22871} 22872 22873func awsAwsquery_deserializeOpDocumentDescribeValidDBInstanceModificationsOutput(v **DescribeValidDBInstanceModificationsOutput, decoder smithyxml.NodeDecoder) error { 22874 if v == nil { 22875 return fmt.Errorf("unexpected nil of type %T", v) 22876 } 22877 var sv *DescribeValidDBInstanceModificationsOutput 22878 if *v == nil { 22879 sv = &DescribeValidDBInstanceModificationsOutput{} 22880 } else { 22881 sv = *v 22882 } 22883 22884 for { 22885 t, done, err := decoder.Token() 22886 if err != nil { 22887 return err 22888 } 22889 if done { 22890 break 22891 } 22892 originalDecoder := decoder 22893 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22894 switch { 22895 case strings.EqualFold("ValidDBInstanceModificationsMessage", t.Name.Local): 22896 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22897 if err := awsAwsquery_deserializeDocumentValidDBInstanceModificationsMessage(&sv.ValidDBInstanceModificationsMessage, nodeDecoder); err != nil { 22898 return err 22899 } 22900 22901 default: 22902 // Do nothing and ignore the unexpected tag element 22903 err = decoder.Decoder.Skip() 22904 if err != nil { 22905 return err 22906 } 22907 22908 } 22909 decoder = originalDecoder 22910 } 22911 *v = sv 22912 return nil 22913} 22914 22915func awsAwsquery_deserializeOpDocumentFailoverDBClusterOutput(v **FailoverDBClusterOutput, decoder smithyxml.NodeDecoder) error { 22916 if v == nil { 22917 return fmt.Errorf("unexpected nil of type %T", v) 22918 } 22919 var sv *FailoverDBClusterOutput 22920 if *v == nil { 22921 sv = &FailoverDBClusterOutput{} 22922 } else { 22923 sv = *v 22924 } 22925 22926 for { 22927 t, done, err := decoder.Token() 22928 if err != nil { 22929 return err 22930 } 22931 if done { 22932 break 22933 } 22934 originalDecoder := decoder 22935 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22936 switch { 22937 case strings.EqualFold("DBCluster", t.Name.Local): 22938 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22939 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 22940 return err 22941 } 22942 22943 default: 22944 // Do nothing and ignore the unexpected tag element 22945 err = decoder.Decoder.Skip() 22946 if err != nil { 22947 return err 22948 } 22949 22950 } 22951 decoder = originalDecoder 22952 } 22953 *v = sv 22954 return nil 22955} 22956 22957func awsAwsquery_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, decoder smithyxml.NodeDecoder) error { 22958 if v == nil { 22959 return fmt.Errorf("unexpected nil of type %T", v) 22960 } 22961 var sv *ListTagsForResourceOutput 22962 if *v == nil { 22963 sv = &ListTagsForResourceOutput{} 22964 } else { 22965 sv = *v 22966 } 22967 22968 for { 22969 t, done, err := decoder.Token() 22970 if err != nil { 22971 return err 22972 } 22973 if done { 22974 break 22975 } 22976 originalDecoder := decoder 22977 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 22978 switch { 22979 case strings.EqualFold("TagList", t.Name.Local): 22980 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 22981 if err := awsAwsquery_deserializeDocumentTagList(&sv.TagList, nodeDecoder); err != nil { 22982 return err 22983 } 22984 22985 default: 22986 // Do nothing and ignore the unexpected tag element 22987 err = decoder.Decoder.Skip() 22988 if err != nil { 22989 return err 22990 } 22991 22992 } 22993 decoder = originalDecoder 22994 } 22995 *v = sv 22996 return nil 22997} 22998 22999func awsAwsquery_deserializeOpDocumentModifyDBClusterEndpointOutput(v **ModifyDBClusterEndpointOutput, decoder smithyxml.NodeDecoder) error { 23000 if v == nil { 23001 return fmt.Errorf("unexpected nil of type %T", v) 23002 } 23003 var sv *ModifyDBClusterEndpointOutput 23004 if *v == nil { 23005 sv = &ModifyDBClusterEndpointOutput{} 23006 } else { 23007 sv = *v 23008 } 23009 23010 for { 23011 t, done, err := decoder.Token() 23012 if err != nil { 23013 return err 23014 } 23015 if done { 23016 break 23017 } 23018 originalDecoder := decoder 23019 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23020 switch { 23021 case strings.EqualFold("CustomEndpointType", t.Name.Local): 23022 val, err := decoder.Value() 23023 if err != nil { 23024 return err 23025 } 23026 if val == nil { 23027 break 23028 } 23029 { 23030 xtv := string(val) 23031 sv.CustomEndpointType = ptr.String(xtv) 23032 } 23033 23034 case strings.EqualFold("DBClusterEndpointArn", t.Name.Local): 23035 val, err := decoder.Value() 23036 if err != nil { 23037 return err 23038 } 23039 if val == nil { 23040 break 23041 } 23042 { 23043 xtv := string(val) 23044 sv.DBClusterEndpointArn = ptr.String(xtv) 23045 } 23046 23047 case strings.EqualFold("DBClusterEndpointIdentifier", t.Name.Local): 23048 val, err := decoder.Value() 23049 if err != nil { 23050 return err 23051 } 23052 if val == nil { 23053 break 23054 } 23055 { 23056 xtv := string(val) 23057 sv.DBClusterEndpointIdentifier = ptr.String(xtv) 23058 } 23059 23060 case strings.EqualFold("DBClusterEndpointResourceIdentifier", t.Name.Local): 23061 val, err := decoder.Value() 23062 if err != nil { 23063 return err 23064 } 23065 if val == nil { 23066 break 23067 } 23068 { 23069 xtv := string(val) 23070 sv.DBClusterEndpointResourceIdentifier = ptr.String(xtv) 23071 } 23072 23073 case strings.EqualFold("DBClusterIdentifier", t.Name.Local): 23074 val, err := decoder.Value() 23075 if err != nil { 23076 return err 23077 } 23078 if val == nil { 23079 break 23080 } 23081 { 23082 xtv := string(val) 23083 sv.DBClusterIdentifier = ptr.String(xtv) 23084 } 23085 23086 case strings.EqualFold("Endpoint", t.Name.Local): 23087 val, err := decoder.Value() 23088 if err != nil { 23089 return err 23090 } 23091 if val == nil { 23092 break 23093 } 23094 { 23095 xtv := string(val) 23096 sv.Endpoint = ptr.String(xtv) 23097 } 23098 23099 case strings.EqualFold("EndpointType", t.Name.Local): 23100 val, err := decoder.Value() 23101 if err != nil { 23102 return err 23103 } 23104 if val == nil { 23105 break 23106 } 23107 { 23108 xtv := string(val) 23109 sv.EndpointType = ptr.String(xtv) 23110 } 23111 23112 case strings.EqualFold("ExcludedMembers", t.Name.Local): 23113 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23114 if err := awsAwsquery_deserializeDocumentStringList(&sv.ExcludedMembers, nodeDecoder); err != nil { 23115 return err 23116 } 23117 23118 case strings.EqualFold("StaticMembers", t.Name.Local): 23119 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23120 if err := awsAwsquery_deserializeDocumentStringList(&sv.StaticMembers, nodeDecoder); err != nil { 23121 return err 23122 } 23123 23124 case strings.EqualFold("Status", t.Name.Local): 23125 val, err := decoder.Value() 23126 if err != nil { 23127 return err 23128 } 23129 if val == nil { 23130 break 23131 } 23132 { 23133 xtv := string(val) 23134 sv.Status = ptr.String(xtv) 23135 } 23136 23137 default: 23138 // Do nothing and ignore the unexpected tag element 23139 err = decoder.Decoder.Skip() 23140 if err != nil { 23141 return err 23142 } 23143 23144 } 23145 decoder = originalDecoder 23146 } 23147 *v = sv 23148 return nil 23149} 23150 23151func awsAwsquery_deserializeOpDocumentModifyDBClusterOutput(v **ModifyDBClusterOutput, decoder smithyxml.NodeDecoder) error { 23152 if v == nil { 23153 return fmt.Errorf("unexpected nil of type %T", v) 23154 } 23155 var sv *ModifyDBClusterOutput 23156 if *v == nil { 23157 sv = &ModifyDBClusterOutput{} 23158 } else { 23159 sv = *v 23160 } 23161 23162 for { 23163 t, done, err := decoder.Token() 23164 if err != nil { 23165 return err 23166 } 23167 if done { 23168 break 23169 } 23170 originalDecoder := decoder 23171 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23172 switch { 23173 case strings.EqualFold("DBCluster", t.Name.Local): 23174 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23175 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23176 return err 23177 } 23178 23179 default: 23180 // Do nothing and ignore the unexpected tag element 23181 err = decoder.Decoder.Skip() 23182 if err != nil { 23183 return err 23184 } 23185 23186 } 23187 decoder = originalDecoder 23188 } 23189 *v = sv 23190 return nil 23191} 23192 23193func awsAwsquery_deserializeOpDocumentModifyDBClusterParameterGroupOutput(v **ModifyDBClusterParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 23194 if v == nil { 23195 return fmt.Errorf("unexpected nil of type %T", v) 23196 } 23197 var sv *ModifyDBClusterParameterGroupOutput 23198 if *v == nil { 23199 sv = &ModifyDBClusterParameterGroupOutput{} 23200 } else { 23201 sv = *v 23202 } 23203 23204 for { 23205 t, done, err := decoder.Token() 23206 if err != nil { 23207 return err 23208 } 23209 if done { 23210 break 23211 } 23212 originalDecoder := decoder 23213 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23214 switch { 23215 case strings.EqualFold("DBClusterParameterGroupName", t.Name.Local): 23216 val, err := decoder.Value() 23217 if err != nil { 23218 return err 23219 } 23220 if val == nil { 23221 break 23222 } 23223 { 23224 xtv := string(val) 23225 sv.DBClusterParameterGroupName = ptr.String(xtv) 23226 } 23227 23228 default: 23229 // Do nothing and ignore the unexpected tag element 23230 err = decoder.Decoder.Skip() 23231 if err != nil { 23232 return err 23233 } 23234 23235 } 23236 decoder = originalDecoder 23237 } 23238 *v = sv 23239 return nil 23240} 23241 23242func awsAwsquery_deserializeOpDocumentModifyDBClusterSnapshotAttributeOutput(v **ModifyDBClusterSnapshotAttributeOutput, decoder smithyxml.NodeDecoder) error { 23243 if v == nil { 23244 return fmt.Errorf("unexpected nil of type %T", v) 23245 } 23246 var sv *ModifyDBClusterSnapshotAttributeOutput 23247 if *v == nil { 23248 sv = &ModifyDBClusterSnapshotAttributeOutput{} 23249 } else { 23250 sv = *v 23251 } 23252 23253 for { 23254 t, done, err := decoder.Token() 23255 if err != nil { 23256 return err 23257 } 23258 if done { 23259 break 23260 } 23261 originalDecoder := decoder 23262 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23263 switch { 23264 case strings.EqualFold("DBClusterSnapshotAttributesResult", t.Name.Local): 23265 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23266 if err := awsAwsquery_deserializeDocumentDBClusterSnapshotAttributesResult(&sv.DBClusterSnapshotAttributesResult, nodeDecoder); err != nil { 23267 return err 23268 } 23269 23270 default: 23271 // Do nothing and ignore the unexpected tag element 23272 err = decoder.Decoder.Skip() 23273 if err != nil { 23274 return err 23275 } 23276 23277 } 23278 decoder = originalDecoder 23279 } 23280 *v = sv 23281 return nil 23282} 23283 23284func awsAwsquery_deserializeOpDocumentModifyDBInstanceOutput(v **ModifyDBInstanceOutput, decoder smithyxml.NodeDecoder) error { 23285 if v == nil { 23286 return fmt.Errorf("unexpected nil of type %T", v) 23287 } 23288 var sv *ModifyDBInstanceOutput 23289 if *v == nil { 23290 sv = &ModifyDBInstanceOutput{} 23291 } else { 23292 sv = *v 23293 } 23294 23295 for { 23296 t, done, err := decoder.Token() 23297 if err != nil { 23298 return err 23299 } 23300 if done { 23301 break 23302 } 23303 originalDecoder := decoder 23304 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23305 switch { 23306 case strings.EqualFold("DBInstance", t.Name.Local): 23307 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23308 if err := awsAwsquery_deserializeDocumentDBInstance(&sv.DBInstance, nodeDecoder); err != nil { 23309 return err 23310 } 23311 23312 default: 23313 // Do nothing and ignore the unexpected tag element 23314 err = decoder.Decoder.Skip() 23315 if err != nil { 23316 return err 23317 } 23318 23319 } 23320 decoder = originalDecoder 23321 } 23322 *v = sv 23323 return nil 23324} 23325 23326func awsAwsquery_deserializeOpDocumentModifyDBParameterGroupOutput(v **ModifyDBParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 23327 if v == nil { 23328 return fmt.Errorf("unexpected nil of type %T", v) 23329 } 23330 var sv *ModifyDBParameterGroupOutput 23331 if *v == nil { 23332 sv = &ModifyDBParameterGroupOutput{} 23333 } else { 23334 sv = *v 23335 } 23336 23337 for { 23338 t, done, err := decoder.Token() 23339 if err != nil { 23340 return err 23341 } 23342 if done { 23343 break 23344 } 23345 originalDecoder := decoder 23346 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23347 switch { 23348 case strings.EqualFold("DBParameterGroupName", t.Name.Local): 23349 val, err := decoder.Value() 23350 if err != nil { 23351 return err 23352 } 23353 if val == nil { 23354 break 23355 } 23356 { 23357 xtv := string(val) 23358 sv.DBParameterGroupName = ptr.String(xtv) 23359 } 23360 23361 default: 23362 // Do nothing and ignore the unexpected tag element 23363 err = decoder.Decoder.Skip() 23364 if err != nil { 23365 return err 23366 } 23367 23368 } 23369 decoder = originalDecoder 23370 } 23371 *v = sv 23372 return nil 23373} 23374 23375func awsAwsquery_deserializeOpDocumentModifyDBSubnetGroupOutput(v **ModifyDBSubnetGroupOutput, decoder smithyxml.NodeDecoder) error { 23376 if v == nil { 23377 return fmt.Errorf("unexpected nil of type %T", v) 23378 } 23379 var sv *ModifyDBSubnetGroupOutput 23380 if *v == nil { 23381 sv = &ModifyDBSubnetGroupOutput{} 23382 } else { 23383 sv = *v 23384 } 23385 23386 for { 23387 t, done, err := decoder.Token() 23388 if err != nil { 23389 return err 23390 } 23391 if done { 23392 break 23393 } 23394 originalDecoder := decoder 23395 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23396 switch { 23397 case strings.EqualFold("DBSubnetGroup", t.Name.Local): 23398 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23399 if err := awsAwsquery_deserializeDocumentDBSubnetGroup(&sv.DBSubnetGroup, nodeDecoder); err != nil { 23400 return err 23401 } 23402 23403 default: 23404 // Do nothing and ignore the unexpected tag element 23405 err = decoder.Decoder.Skip() 23406 if err != nil { 23407 return err 23408 } 23409 23410 } 23411 decoder = originalDecoder 23412 } 23413 *v = sv 23414 return nil 23415} 23416 23417func awsAwsquery_deserializeOpDocumentModifyEventSubscriptionOutput(v **ModifyEventSubscriptionOutput, decoder smithyxml.NodeDecoder) error { 23418 if v == nil { 23419 return fmt.Errorf("unexpected nil of type %T", v) 23420 } 23421 var sv *ModifyEventSubscriptionOutput 23422 if *v == nil { 23423 sv = &ModifyEventSubscriptionOutput{} 23424 } else { 23425 sv = *v 23426 } 23427 23428 for { 23429 t, done, err := decoder.Token() 23430 if err != nil { 23431 return err 23432 } 23433 if done { 23434 break 23435 } 23436 originalDecoder := decoder 23437 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23438 switch { 23439 case strings.EqualFold("EventSubscription", t.Name.Local): 23440 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23441 if err := awsAwsquery_deserializeDocumentEventSubscription(&sv.EventSubscription, nodeDecoder); err != nil { 23442 return err 23443 } 23444 23445 default: 23446 // Do nothing and ignore the unexpected tag element 23447 err = decoder.Decoder.Skip() 23448 if err != nil { 23449 return err 23450 } 23451 23452 } 23453 decoder = originalDecoder 23454 } 23455 *v = sv 23456 return nil 23457} 23458 23459func awsAwsquery_deserializeOpDocumentPromoteReadReplicaDBClusterOutput(v **PromoteReadReplicaDBClusterOutput, decoder smithyxml.NodeDecoder) error { 23460 if v == nil { 23461 return fmt.Errorf("unexpected nil of type %T", v) 23462 } 23463 var sv *PromoteReadReplicaDBClusterOutput 23464 if *v == nil { 23465 sv = &PromoteReadReplicaDBClusterOutput{} 23466 } else { 23467 sv = *v 23468 } 23469 23470 for { 23471 t, done, err := decoder.Token() 23472 if err != nil { 23473 return err 23474 } 23475 if done { 23476 break 23477 } 23478 originalDecoder := decoder 23479 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23480 switch { 23481 case strings.EqualFold("DBCluster", t.Name.Local): 23482 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23483 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23484 return err 23485 } 23486 23487 default: 23488 // Do nothing and ignore the unexpected tag element 23489 err = decoder.Decoder.Skip() 23490 if err != nil { 23491 return err 23492 } 23493 23494 } 23495 decoder = originalDecoder 23496 } 23497 *v = sv 23498 return nil 23499} 23500 23501func awsAwsquery_deserializeOpDocumentRebootDBInstanceOutput(v **RebootDBInstanceOutput, decoder smithyxml.NodeDecoder) error { 23502 if v == nil { 23503 return fmt.Errorf("unexpected nil of type %T", v) 23504 } 23505 var sv *RebootDBInstanceOutput 23506 if *v == nil { 23507 sv = &RebootDBInstanceOutput{} 23508 } else { 23509 sv = *v 23510 } 23511 23512 for { 23513 t, done, err := decoder.Token() 23514 if err != nil { 23515 return err 23516 } 23517 if done { 23518 break 23519 } 23520 originalDecoder := decoder 23521 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23522 switch { 23523 case strings.EqualFold("DBInstance", t.Name.Local): 23524 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23525 if err := awsAwsquery_deserializeDocumentDBInstance(&sv.DBInstance, nodeDecoder); err != nil { 23526 return err 23527 } 23528 23529 default: 23530 // Do nothing and ignore the unexpected tag element 23531 err = decoder.Decoder.Skip() 23532 if err != nil { 23533 return err 23534 } 23535 23536 } 23537 decoder = originalDecoder 23538 } 23539 *v = sv 23540 return nil 23541} 23542 23543func awsAwsquery_deserializeOpDocumentRemoveSourceIdentifierFromSubscriptionOutput(v **RemoveSourceIdentifierFromSubscriptionOutput, decoder smithyxml.NodeDecoder) error { 23544 if v == nil { 23545 return fmt.Errorf("unexpected nil of type %T", v) 23546 } 23547 var sv *RemoveSourceIdentifierFromSubscriptionOutput 23548 if *v == nil { 23549 sv = &RemoveSourceIdentifierFromSubscriptionOutput{} 23550 } else { 23551 sv = *v 23552 } 23553 23554 for { 23555 t, done, err := decoder.Token() 23556 if err != nil { 23557 return err 23558 } 23559 if done { 23560 break 23561 } 23562 originalDecoder := decoder 23563 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23564 switch { 23565 case strings.EqualFold("EventSubscription", t.Name.Local): 23566 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23567 if err := awsAwsquery_deserializeDocumentEventSubscription(&sv.EventSubscription, nodeDecoder); err != nil { 23568 return err 23569 } 23570 23571 default: 23572 // Do nothing and ignore the unexpected tag element 23573 err = decoder.Decoder.Skip() 23574 if err != nil { 23575 return err 23576 } 23577 23578 } 23579 decoder = originalDecoder 23580 } 23581 *v = sv 23582 return nil 23583} 23584 23585func awsAwsquery_deserializeOpDocumentResetDBClusterParameterGroupOutput(v **ResetDBClusterParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 23586 if v == nil { 23587 return fmt.Errorf("unexpected nil of type %T", v) 23588 } 23589 var sv *ResetDBClusterParameterGroupOutput 23590 if *v == nil { 23591 sv = &ResetDBClusterParameterGroupOutput{} 23592 } else { 23593 sv = *v 23594 } 23595 23596 for { 23597 t, done, err := decoder.Token() 23598 if err != nil { 23599 return err 23600 } 23601 if done { 23602 break 23603 } 23604 originalDecoder := decoder 23605 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23606 switch { 23607 case strings.EqualFold("DBClusterParameterGroupName", t.Name.Local): 23608 val, err := decoder.Value() 23609 if err != nil { 23610 return err 23611 } 23612 if val == nil { 23613 break 23614 } 23615 { 23616 xtv := string(val) 23617 sv.DBClusterParameterGroupName = ptr.String(xtv) 23618 } 23619 23620 default: 23621 // Do nothing and ignore the unexpected tag element 23622 err = decoder.Decoder.Skip() 23623 if err != nil { 23624 return err 23625 } 23626 23627 } 23628 decoder = originalDecoder 23629 } 23630 *v = sv 23631 return nil 23632} 23633 23634func awsAwsquery_deserializeOpDocumentResetDBParameterGroupOutput(v **ResetDBParameterGroupOutput, decoder smithyxml.NodeDecoder) error { 23635 if v == nil { 23636 return fmt.Errorf("unexpected nil of type %T", v) 23637 } 23638 var sv *ResetDBParameterGroupOutput 23639 if *v == nil { 23640 sv = &ResetDBParameterGroupOutput{} 23641 } else { 23642 sv = *v 23643 } 23644 23645 for { 23646 t, done, err := decoder.Token() 23647 if err != nil { 23648 return err 23649 } 23650 if done { 23651 break 23652 } 23653 originalDecoder := decoder 23654 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23655 switch { 23656 case strings.EqualFold("DBParameterGroupName", t.Name.Local): 23657 val, err := decoder.Value() 23658 if err != nil { 23659 return err 23660 } 23661 if val == nil { 23662 break 23663 } 23664 { 23665 xtv := string(val) 23666 sv.DBParameterGroupName = ptr.String(xtv) 23667 } 23668 23669 default: 23670 // Do nothing and ignore the unexpected tag element 23671 err = decoder.Decoder.Skip() 23672 if err != nil { 23673 return err 23674 } 23675 23676 } 23677 decoder = originalDecoder 23678 } 23679 *v = sv 23680 return nil 23681} 23682 23683func awsAwsquery_deserializeOpDocumentRestoreDBClusterFromSnapshotOutput(v **RestoreDBClusterFromSnapshotOutput, decoder smithyxml.NodeDecoder) error { 23684 if v == nil { 23685 return fmt.Errorf("unexpected nil of type %T", v) 23686 } 23687 var sv *RestoreDBClusterFromSnapshotOutput 23688 if *v == nil { 23689 sv = &RestoreDBClusterFromSnapshotOutput{} 23690 } else { 23691 sv = *v 23692 } 23693 23694 for { 23695 t, done, err := decoder.Token() 23696 if err != nil { 23697 return err 23698 } 23699 if done { 23700 break 23701 } 23702 originalDecoder := decoder 23703 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23704 switch { 23705 case strings.EqualFold("DBCluster", t.Name.Local): 23706 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23707 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23708 return err 23709 } 23710 23711 default: 23712 // Do nothing and ignore the unexpected tag element 23713 err = decoder.Decoder.Skip() 23714 if err != nil { 23715 return err 23716 } 23717 23718 } 23719 decoder = originalDecoder 23720 } 23721 *v = sv 23722 return nil 23723} 23724 23725func awsAwsquery_deserializeOpDocumentRestoreDBClusterToPointInTimeOutput(v **RestoreDBClusterToPointInTimeOutput, decoder smithyxml.NodeDecoder) error { 23726 if v == nil { 23727 return fmt.Errorf("unexpected nil of type %T", v) 23728 } 23729 var sv *RestoreDBClusterToPointInTimeOutput 23730 if *v == nil { 23731 sv = &RestoreDBClusterToPointInTimeOutput{} 23732 } else { 23733 sv = *v 23734 } 23735 23736 for { 23737 t, done, err := decoder.Token() 23738 if err != nil { 23739 return err 23740 } 23741 if done { 23742 break 23743 } 23744 originalDecoder := decoder 23745 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23746 switch { 23747 case strings.EqualFold("DBCluster", t.Name.Local): 23748 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23749 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23750 return err 23751 } 23752 23753 default: 23754 // Do nothing and ignore the unexpected tag element 23755 err = decoder.Decoder.Skip() 23756 if err != nil { 23757 return err 23758 } 23759 23760 } 23761 decoder = originalDecoder 23762 } 23763 *v = sv 23764 return nil 23765} 23766 23767func awsAwsquery_deserializeOpDocumentStartDBClusterOutput(v **StartDBClusterOutput, decoder smithyxml.NodeDecoder) error { 23768 if v == nil { 23769 return fmt.Errorf("unexpected nil of type %T", v) 23770 } 23771 var sv *StartDBClusterOutput 23772 if *v == nil { 23773 sv = &StartDBClusterOutput{} 23774 } else { 23775 sv = *v 23776 } 23777 23778 for { 23779 t, done, err := decoder.Token() 23780 if err != nil { 23781 return err 23782 } 23783 if done { 23784 break 23785 } 23786 originalDecoder := decoder 23787 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23788 switch { 23789 case strings.EqualFold("DBCluster", t.Name.Local): 23790 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23791 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23792 return err 23793 } 23794 23795 default: 23796 // Do nothing and ignore the unexpected tag element 23797 err = decoder.Decoder.Skip() 23798 if err != nil { 23799 return err 23800 } 23801 23802 } 23803 decoder = originalDecoder 23804 } 23805 *v = sv 23806 return nil 23807} 23808 23809func awsAwsquery_deserializeOpDocumentStopDBClusterOutput(v **StopDBClusterOutput, decoder smithyxml.NodeDecoder) error { 23810 if v == nil { 23811 return fmt.Errorf("unexpected nil of type %T", v) 23812 } 23813 var sv *StopDBClusterOutput 23814 if *v == nil { 23815 sv = &StopDBClusterOutput{} 23816 } else { 23817 sv = *v 23818 } 23819 23820 for { 23821 t, done, err := decoder.Token() 23822 if err != nil { 23823 return err 23824 } 23825 if done { 23826 break 23827 } 23828 originalDecoder := decoder 23829 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 23830 switch { 23831 case strings.EqualFold("DBCluster", t.Name.Local): 23832 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 23833 if err := awsAwsquery_deserializeDocumentDBCluster(&sv.DBCluster, nodeDecoder); err != nil { 23834 return err 23835 } 23836 23837 default: 23838 // Do nothing and ignore the unexpected tag element 23839 err = decoder.Decoder.Skip() 23840 if err != nil { 23841 return err 23842 } 23843 23844 } 23845 decoder = originalDecoder 23846 } 23847 *v = sv 23848 return nil 23849} 23850