deserializers.go raw
1 // Code generated by smithy-go-codegen DO NOT EDIT.
2
3 package route53
4
5 import (
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/route53/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 "github.com/aws/smithy-go/tracing"
20 smithyhttp "github.com/aws/smithy-go/transport/http"
21 "io"
22 "strconv"
23 "strings"
24 )
25
26 type awsRestxml_deserializeOpActivateKeySigningKey struct {
27 }
28
29 func (*awsRestxml_deserializeOpActivateKeySigningKey) ID() string {
30 return "OperationDeserializer"
31 }
32
33 func (m *awsRestxml_deserializeOpActivateKeySigningKey) 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 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
42 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
43 defer endTimer()
44 defer span.End()
45 response, ok := out.RawResponse.(*smithyhttp.Response)
46 if !ok {
47 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
48 }
49
50 if response.StatusCode < 200 || response.StatusCode >= 300 {
51 return out, metadata, awsRestxml_deserializeOpErrorActivateKeySigningKey(response, &metadata)
52 }
53 output := &ActivateKeySigningKeyOutput{}
54 out.Result = output
55
56 var buff [1024]byte
57 ringBuffer := smithyio.NewRingBuffer(buff[:])
58 body := io.TeeReader(response.Body, ringBuffer)
59 rootDecoder := xml.NewDecoder(body)
60 t, err := smithyxml.FetchRootElement(rootDecoder)
61 if err == io.EOF {
62 return out, metadata, nil
63 }
64 if err != nil {
65 var snapshot bytes.Buffer
66 io.Copy(&snapshot, ringBuffer)
67 return out, metadata, &smithy.DeserializationError{
68 Err: fmt.Errorf("failed to decode response body, %w", err),
69 Snapshot: snapshot.Bytes(),
70 }
71 }
72
73 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
74 err = awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(&output, decoder)
75 if err != nil {
76 var snapshot bytes.Buffer
77 io.Copy(&snapshot, ringBuffer)
78 return out, metadata, &smithy.DeserializationError{
79 Err: fmt.Errorf("failed to decode response body, %w", err),
80 Snapshot: snapshot.Bytes(),
81 }
82 }
83
84 span.End()
85 return out, metadata, err
86 }
87
88 func awsRestxml_deserializeOpErrorActivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
89 var errorBuffer bytes.Buffer
90 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
91 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
92 }
93 errorBody := bytes.NewReader(errorBuffer.Bytes())
94
95 errorCode := "UnknownError"
96 errorMessage := errorCode
97
98 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
99 if err != nil {
100 return err
101 }
102 if reqID := errorComponents.RequestID; len(reqID) != 0 {
103 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
104 }
105 if len(errorComponents.Code) != 0 {
106 errorCode = errorComponents.Code
107 }
108 if len(errorComponents.Message) != 0 {
109 errorMessage = errorComponents.Message
110 }
111 errorBody.Seek(0, io.SeekStart)
112 switch {
113 case strings.EqualFold("ConcurrentModification", errorCode):
114 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
115
116 case strings.EqualFold("InvalidInput", errorCode):
117 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
118
119 case strings.EqualFold("InvalidKMSArn", errorCode):
120 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
121
122 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
123 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
124
125 case strings.EqualFold("InvalidSigningStatus", errorCode):
126 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
127
128 case strings.EqualFold("NoSuchKeySigningKey", errorCode):
129 return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
130
131 default:
132 genericError := &smithy.GenericAPIError{
133 Code: errorCode,
134 Message: errorMessage,
135 }
136 return genericError
137
138 }
139 }
140
141 func awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(v **ActivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
142 if v == nil {
143 return fmt.Errorf("unexpected nil of type %T", v)
144 }
145 var sv *ActivateKeySigningKeyOutput
146 if *v == nil {
147 sv = &ActivateKeySigningKeyOutput{}
148 } else {
149 sv = *v
150 }
151
152 for {
153 t, done, err := decoder.Token()
154 if err != nil {
155 return err
156 }
157 if done {
158 break
159 }
160 originalDecoder := decoder
161 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
162 switch {
163 case strings.EqualFold("ChangeInfo", t.Name.Local):
164 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
165 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
166 return err
167 }
168
169 default:
170 // Do nothing and ignore the unexpected tag element
171 err = decoder.Decoder.Skip()
172 if err != nil {
173 return err
174 }
175
176 }
177 decoder = originalDecoder
178 }
179 *v = sv
180 return nil
181 }
182
183 type awsRestxml_deserializeOpAssociateVPCWithHostedZone struct {
184 }
185
186 func (*awsRestxml_deserializeOpAssociateVPCWithHostedZone) ID() string {
187 return "OperationDeserializer"
188 }
189
190 func (m *awsRestxml_deserializeOpAssociateVPCWithHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
191 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
192 ) {
193 out, metadata, err = next.HandleDeserialize(ctx, in)
194 if err != nil {
195 return out, metadata, err
196 }
197
198 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
199 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
200 defer endTimer()
201 defer span.End()
202 response, ok := out.RawResponse.(*smithyhttp.Response)
203 if !ok {
204 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
205 }
206
207 if response.StatusCode < 200 || response.StatusCode >= 300 {
208 return out, metadata, awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response, &metadata)
209 }
210 output := &AssociateVPCWithHostedZoneOutput{}
211 out.Result = output
212
213 var buff [1024]byte
214 ringBuffer := smithyio.NewRingBuffer(buff[:])
215 body := io.TeeReader(response.Body, ringBuffer)
216 rootDecoder := xml.NewDecoder(body)
217 t, err := smithyxml.FetchRootElement(rootDecoder)
218 if err == io.EOF {
219 return out, metadata, nil
220 }
221 if err != nil {
222 var snapshot bytes.Buffer
223 io.Copy(&snapshot, ringBuffer)
224 return out, metadata, &smithy.DeserializationError{
225 Err: fmt.Errorf("failed to decode response body, %w", err),
226 Snapshot: snapshot.Bytes(),
227 }
228 }
229
230 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
231 err = awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(&output, decoder)
232 if err != nil {
233 var snapshot bytes.Buffer
234 io.Copy(&snapshot, ringBuffer)
235 return out, metadata, &smithy.DeserializationError{
236 Err: fmt.Errorf("failed to decode response body, %w", err),
237 Snapshot: snapshot.Bytes(),
238 }
239 }
240
241 span.End()
242 return out, metadata, err
243 }
244
245 func awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
246 var errorBuffer bytes.Buffer
247 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
248 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
249 }
250 errorBody := bytes.NewReader(errorBuffer.Bytes())
251
252 errorCode := "UnknownError"
253 errorMessage := errorCode
254
255 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
256 if err != nil {
257 return err
258 }
259 if reqID := errorComponents.RequestID; len(reqID) != 0 {
260 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
261 }
262 if len(errorComponents.Code) != 0 {
263 errorCode = errorComponents.Code
264 }
265 if len(errorComponents.Message) != 0 {
266 errorMessage = errorComponents.Message
267 }
268 errorBody.Seek(0, io.SeekStart)
269 switch {
270 case strings.EqualFold("ConflictingDomainExists", errorCode):
271 return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody)
272
273 case strings.EqualFold("InvalidInput", errorCode):
274 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
275
276 case strings.EqualFold("InvalidVPCId", errorCode):
277 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
278
279 case strings.EqualFold("LimitsExceeded", errorCode):
280 return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
281
282 case strings.EqualFold("NoSuchHostedZone", errorCode):
283 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
284
285 case strings.EqualFold("NotAuthorizedException", errorCode):
286 return awsRestxml_deserializeErrorNotAuthorizedException(response, errorBody)
287
288 case strings.EqualFold("PriorRequestNotComplete", errorCode):
289 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
290
291 case strings.EqualFold("PublicZoneVPCAssociation", errorCode):
292 return awsRestxml_deserializeErrorPublicZoneVPCAssociation(response, errorBody)
293
294 default:
295 genericError := &smithy.GenericAPIError{
296 Code: errorCode,
297 Message: errorMessage,
298 }
299 return genericError
300
301 }
302 }
303
304 func awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(v **AssociateVPCWithHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
305 if v == nil {
306 return fmt.Errorf("unexpected nil of type %T", v)
307 }
308 var sv *AssociateVPCWithHostedZoneOutput
309 if *v == nil {
310 sv = &AssociateVPCWithHostedZoneOutput{}
311 } else {
312 sv = *v
313 }
314
315 for {
316 t, done, err := decoder.Token()
317 if err != nil {
318 return err
319 }
320 if done {
321 break
322 }
323 originalDecoder := decoder
324 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
325 switch {
326 case strings.EqualFold("ChangeInfo", t.Name.Local):
327 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
328 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
329 return err
330 }
331
332 default:
333 // Do nothing and ignore the unexpected tag element
334 err = decoder.Decoder.Skip()
335 if err != nil {
336 return err
337 }
338
339 }
340 decoder = originalDecoder
341 }
342 *v = sv
343 return nil
344 }
345
346 type awsRestxml_deserializeOpChangeCidrCollection struct {
347 }
348
349 func (*awsRestxml_deserializeOpChangeCidrCollection) ID() string {
350 return "OperationDeserializer"
351 }
352
353 func (m *awsRestxml_deserializeOpChangeCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
354 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
355 ) {
356 out, metadata, err = next.HandleDeserialize(ctx, in)
357 if err != nil {
358 return out, metadata, err
359 }
360
361 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
362 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
363 defer endTimer()
364 defer span.End()
365 response, ok := out.RawResponse.(*smithyhttp.Response)
366 if !ok {
367 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
368 }
369
370 if response.StatusCode < 200 || response.StatusCode >= 300 {
371 return out, metadata, awsRestxml_deserializeOpErrorChangeCidrCollection(response, &metadata)
372 }
373 output := &ChangeCidrCollectionOutput{}
374 out.Result = output
375
376 var buff [1024]byte
377 ringBuffer := smithyio.NewRingBuffer(buff[:])
378 body := io.TeeReader(response.Body, ringBuffer)
379 rootDecoder := xml.NewDecoder(body)
380 t, err := smithyxml.FetchRootElement(rootDecoder)
381 if err == io.EOF {
382 return out, metadata, nil
383 }
384 if err != nil {
385 var snapshot bytes.Buffer
386 io.Copy(&snapshot, ringBuffer)
387 return out, metadata, &smithy.DeserializationError{
388 Err: fmt.Errorf("failed to decode response body, %w", err),
389 Snapshot: snapshot.Bytes(),
390 }
391 }
392
393 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
394 err = awsRestxml_deserializeOpDocumentChangeCidrCollectionOutput(&output, decoder)
395 if err != nil {
396 var snapshot bytes.Buffer
397 io.Copy(&snapshot, ringBuffer)
398 return out, metadata, &smithy.DeserializationError{
399 Err: fmt.Errorf("failed to decode response body, %w", err),
400 Snapshot: snapshot.Bytes(),
401 }
402 }
403
404 span.End()
405 return out, metadata, err
406 }
407
408 func awsRestxml_deserializeOpErrorChangeCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
409 var errorBuffer bytes.Buffer
410 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
411 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
412 }
413 errorBody := bytes.NewReader(errorBuffer.Bytes())
414
415 errorCode := "UnknownError"
416 errorMessage := errorCode
417
418 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
419 if err != nil {
420 return err
421 }
422 if reqID := errorComponents.RequestID; len(reqID) != 0 {
423 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
424 }
425 if len(errorComponents.Code) != 0 {
426 errorCode = errorComponents.Code
427 }
428 if len(errorComponents.Message) != 0 {
429 errorMessage = errorComponents.Message
430 }
431 errorBody.Seek(0, io.SeekStart)
432 switch {
433 case strings.EqualFold("CidrBlockInUseException", errorCode):
434 return awsRestxml_deserializeErrorCidrBlockInUseException(response, errorBody)
435
436 case strings.EqualFold("CidrCollectionVersionMismatchException", errorCode):
437 return awsRestxml_deserializeErrorCidrCollectionVersionMismatchException(response, errorBody)
438
439 case strings.EqualFold("ConcurrentModification", errorCode):
440 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
441
442 case strings.EqualFold("InvalidInput", errorCode):
443 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
444
445 case strings.EqualFold("LimitsExceeded", errorCode):
446 return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
447
448 case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
449 return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
450
451 default:
452 genericError := &smithy.GenericAPIError{
453 Code: errorCode,
454 Message: errorMessage,
455 }
456 return genericError
457
458 }
459 }
460
461 func awsRestxml_deserializeOpDocumentChangeCidrCollectionOutput(v **ChangeCidrCollectionOutput, decoder smithyxml.NodeDecoder) error {
462 if v == nil {
463 return fmt.Errorf("unexpected nil of type %T", v)
464 }
465 var sv *ChangeCidrCollectionOutput
466 if *v == nil {
467 sv = &ChangeCidrCollectionOutput{}
468 } else {
469 sv = *v
470 }
471
472 for {
473 t, done, err := decoder.Token()
474 if err != nil {
475 return err
476 }
477 if done {
478 break
479 }
480 originalDecoder := decoder
481 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
482 switch {
483 case strings.EqualFold("Id", t.Name.Local):
484 val, err := decoder.Value()
485 if err != nil {
486 return err
487 }
488 if val == nil {
489 break
490 }
491 {
492 xtv := string(val)
493 sv.Id = ptr.String(xtv)
494 }
495
496 default:
497 // Do nothing and ignore the unexpected tag element
498 err = decoder.Decoder.Skip()
499 if err != nil {
500 return err
501 }
502
503 }
504 decoder = originalDecoder
505 }
506 *v = sv
507 return nil
508 }
509
510 type awsRestxml_deserializeOpChangeResourceRecordSets struct {
511 }
512
513 func (*awsRestxml_deserializeOpChangeResourceRecordSets) ID() string {
514 return "OperationDeserializer"
515 }
516
517 func (m *awsRestxml_deserializeOpChangeResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
518 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
519 ) {
520 out, metadata, err = next.HandleDeserialize(ctx, in)
521 if err != nil {
522 return out, metadata, err
523 }
524
525 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
526 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
527 defer endTimer()
528 defer span.End()
529 response, ok := out.RawResponse.(*smithyhttp.Response)
530 if !ok {
531 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
532 }
533
534 if response.StatusCode < 200 || response.StatusCode >= 300 {
535 return out, metadata, awsRestxml_deserializeOpErrorChangeResourceRecordSets(response, &metadata)
536 }
537 output := &ChangeResourceRecordSetsOutput{}
538 out.Result = output
539
540 var buff [1024]byte
541 ringBuffer := smithyio.NewRingBuffer(buff[:])
542 body := io.TeeReader(response.Body, ringBuffer)
543 rootDecoder := xml.NewDecoder(body)
544 t, err := smithyxml.FetchRootElement(rootDecoder)
545 if err == io.EOF {
546 return out, metadata, nil
547 }
548 if err != nil {
549 var snapshot bytes.Buffer
550 io.Copy(&snapshot, ringBuffer)
551 return out, metadata, &smithy.DeserializationError{
552 Err: fmt.Errorf("failed to decode response body, %w", err),
553 Snapshot: snapshot.Bytes(),
554 }
555 }
556
557 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
558 err = awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(&output, decoder)
559 if err != nil {
560 var snapshot bytes.Buffer
561 io.Copy(&snapshot, ringBuffer)
562 return out, metadata, &smithy.DeserializationError{
563 Err: fmt.Errorf("failed to decode response body, %w", err),
564 Snapshot: snapshot.Bytes(),
565 }
566 }
567
568 span.End()
569 return out, metadata, err
570 }
571
572 func awsRestxml_deserializeOpErrorChangeResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
573 var errorBuffer bytes.Buffer
574 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
575 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
576 }
577 errorBody := bytes.NewReader(errorBuffer.Bytes())
578
579 errorCode := "UnknownError"
580 errorMessage := errorCode
581
582 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
583 if err != nil {
584 return err
585 }
586 if reqID := errorComponents.RequestID; len(reqID) != 0 {
587 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
588 }
589 if len(errorComponents.Code) != 0 {
590 errorCode = errorComponents.Code
591 }
592 if len(errorComponents.Message) != 0 {
593 errorMessage = errorComponents.Message
594 }
595 errorBody.Seek(0, io.SeekStart)
596 switch {
597 case strings.EqualFold("InvalidChangeBatch", errorCode):
598 return awsRestxml_deserializeErrorInvalidChangeBatch(response, errorBody)
599
600 case strings.EqualFold("InvalidInput", errorCode):
601 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
602
603 case strings.EqualFold("NoSuchHealthCheck", errorCode):
604 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
605
606 case strings.EqualFold("NoSuchHostedZone", errorCode):
607 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
608
609 case strings.EqualFold("PriorRequestNotComplete", errorCode):
610 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
611
612 default:
613 genericError := &smithy.GenericAPIError{
614 Code: errorCode,
615 Message: errorMessage,
616 }
617 return genericError
618
619 }
620 }
621
622 func awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(v **ChangeResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error {
623 if v == nil {
624 return fmt.Errorf("unexpected nil of type %T", v)
625 }
626 var sv *ChangeResourceRecordSetsOutput
627 if *v == nil {
628 sv = &ChangeResourceRecordSetsOutput{}
629 } else {
630 sv = *v
631 }
632
633 for {
634 t, done, err := decoder.Token()
635 if err != nil {
636 return err
637 }
638 if done {
639 break
640 }
641 originalDecoder := decoder
642 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
643 switch {
644 case strings.EqualFold("ChangeInfo", t.Name.Local):
645 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
646 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
647 return err
648 }
649
650 default:
651 // Do nothing and ignore the unexpected tag element
652 err = decoder.Decoder.Skip()
653 if err != nil {
654 return err
655 }
656
657 }
658 decoder = originalDecoder
659 }
660 *v = sv
661 return nil
662 }
663
664 type awsRestxml_deserializeOpChangeTagsForResource struct {
665 }
666
667 func (*awsRestxml_deserializeOpChangeTagsForResource) ID() string {
668 return "OperationDeserializer"
669 }
670
671 func (m *awsRestxml_deserializeOpChangeTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
672 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
673 ) {
674 out, metadata, err = next.HandleDeserialize(ctx, in)
675 if err != nil {
676 return out, metadata, err
677 }
678
679 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
680 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
681 defer endTimer()
682 defer span.End()
683 response, ok := out.RawResponse.(*smithyhttp.Response)
684 if !ok {
685 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
686 }
687
688 if response.StatusCode < 200 || response.StatusCode >= 300 {
689 return out, metadata, awsRestxml_deserializeOpErrorChangeTagsForResource(response, &metadata)
690 }
691 output := &ChangeTagsForResourceOutput{}
692 out.Result = output
693
694 span.End()
695 return out, metadata, err
696 }
697
698 func awsRestxml_deserializeOpErrorChangeTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
699 var errorBuffer bytes.Buffer
700 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
701 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
702 }
703 errorBody := bytes.NewReader(errorBuffer.Bytes())
704
705 errorCode := "UnknownError"
706 errorMessage := errorCode
707
708 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
709 if err != nil {
710 return err
711 }
712 if reqID := errorComponents.RequestID; len(reqID) != 0 {
713 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
714 }
715 if len(errorComponents.Code) != 0 {
716 errorCode = errorComponents.Code
717 }
718 if len(errorComponents.Message) != 0 {
719 errorMessage = errorComponents.Message
720 }
721 errorBody.Seek(0, io.SeekStart)
722 switch {
723 case strings.EqualFold("InvalidInput", errorCode):
724 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
725
726 case strings.EqualFold("NoSuchHealthCheck", errorCode):
727 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
728
729 case strings.EqualFold("NoSuchHostedZone", errorCode):
730 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
731
732 case strings.EqualFold("PriorRequestNotComplete", errorCode):
733 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
734
735 case strings.EqualFold("ThrottlingException", errorCode):
736 return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
737
738 default:
739 genericError := &smithy.GenericAPIError{
740 Code: errorCode,
741 Message: errorMessage,
742 }
743 return genericError
744
745 }
746 }
747
748 type awsRestxml_deserializeOpCreateCidrCollection struct {
749 }
750
751 func (*awsRestxml_deserializeOpCreateCidrCollection) ID() string {
752 return "OperationDeserializer"
753 }
754
755 func (m *awsRestxml_deserializeOpCreateCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
756 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
757 ) {
758 out, metadata, err = next.HandleDeserialize(ctx, in)
759 if err != nil {
760 return out, metadata, err
761 }
762
763 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
764 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
765 defer endTimer()
766 defer span.End()
767 response, ok := out.RawResponse.(*smithyhttp.Response)
768 if !ok {
769 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
770 }
771
772 if response.StatusCode < 200 || response.StatusCode >= 300 {
773 return out, metadata, awsRestxml_deserializeOpErrorCreateCidrCollection(response, &metadata)
774 }
775 output := &CreateCidrCollectionOutput{}
776 out.Result = output
777
778 err = awsRestxml_deserializeOpHttpBindingsCreateCidrCollectionOutput(output, response)
779 if err != nil {
780 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
781 }
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 err = awsRestxml_deserializeOpDocumentCreateCidrCollectionOutput(&output, decoder)
802 if err != nil {
803 var snapshot bytes.Buffer
804 io.Copy(&snapshot, ringBuffer)
805 return out, metadata, &smithy.DeserializationError{
806 Err: fmt.Errorf("failed to decode response body, %w", err),
807 Snapshot: snapshot.Bytes(),
808 }
809 }
810
811 span.End()
812 return out, metadata, err
813 }
814
815 func awsRestxml_deserializeOpErrorCreateCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
816 var errorBuffer bytes.Buffer
817 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
818 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
819 }
820 errorBody := bytes.NewReader(errorBuffer.Bytes())
821
822 errorCode := "UnknownError"
823 errorMessage := errorCode
824
825 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
826 if err != nil {
827 return err
828 }
829 if reqID := errorComponents.RequestID; len(reqID) != 0 {
830 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
831 }
832 if len(errorComponents.Code) != 0 {
833 errorCode = errorComponents.Code
834 }
835 if len(errorComponents.Message) != 0 {
836 errorMessage = errorComponents.Message
837 }
838 errorBody.Seek(0, io.SeekStart)
839 switch {
840 case strings.EqualFold("CidrCollectionAlreadyExistsException", errorCode):
841 return awsRestxml_deserializeErrorCidrCollectionAlreadyExistsException(response, errorBody)
842
843 case strings.EqualFold("ConcurrentModification", errorCode):
844 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
845
846 case strings.EqualFold("InvalidInput", errorCode):
847 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
848
849 case strings.EqualFold("LimitsExceeded", errorCode):
850 return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
851
852 default:
853 genericError := &smithy.GenericAPIError{
854 Code: errorCode,
855 Message: errorMessage,
856 }
857 return genericError
858
859 }
860 }
861
862 func awsRestxml_deserializeOpHttpBindingsCreateCidrCollectionOutput(v *CreateCidrCollectionOutput, response *smithyhttp.Response) error {
863 if v == nil {
864 return fmt.Errorf("unsupported deserialization for nil %T", v)
865 }
866
867 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
868 headerValues[0] = strings.TrimSpace(headerValues[0])
869 v.Location = ptr.String(headerValues[0])
870 }
871
872 return nil
873 }
874 func awsRestxml_deserializeOpDocumentCreateCidrCollectionOutput(v **CreateCidrCollectionOutput, decoder smithyxml.NodeDecoder) error {
875 if v == nil {
876 return fmt.Errorf("unexpected nil of type %T", v)
877 }
878 var sv *CreateCidrCollectionOutput
879 if *v == nil {
880 sv = &CreateCidrCollectionOutput{}
881 } else {
882 sv = *v
883 }
884
885 for {
886 t, done, err := decoder.Token()
887 if err != nil {
888 return err
889 }
890 if done {
891 break
892 }
893 originalDecoder := decoder
894 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
895 switch {
896 case strings.EqualFold("Collection", t.Name.Local):
897 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
898 if err := awsRestxml_deserializeDocumentCidrCollection(&sv.Collection, nodeDecoder); err != nil {
899 return err
900 }
901
902 default:
903 // Do nothing and ignore the unexpected tag element
904 err = decoder.Decoder.Skip()
905 if err != nil {
906 return err
907 }
908
909 }
910 decoder = originalDecoder
911 }
912 *v = sv
913 return nil
914 }
915
916 type awsRestxml_deserializeOpCreateHealthCheck struct {
917 }
918
919 func (*awsRestxml_deserializeOpCreateHealthCheck) ID() string {
920 return "OperationDeserializer"
921 }
922
923 func (m *awsRestxml_deserializeOpCreateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
924 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
925 ) {
926 out, metadata, err = next.HandleDeserialize(ctx, in)
927 if err != nil {
928 return out, metadata, err
929 }
930
931 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
932 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
933 defer endTimer()
934 defer span.End()
935 response, ok := out.RawResponse.(*smithyhttp.Response)
936 if !ok {
937 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
938 }
939
940 if response.StatusCode < 200 || response.StatusCode >= 300 {
941 return out, metadata, awsRestxml_deserializeOpErrorCreateHealthCheck(response, &metadata)
942 }
943 output := &CreateHealthCheckOutput{}
944 out.Result = output
945
946 err = awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(output, response)
947 if err != nil {
948 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
949 }
950
951 var buff [1024]byte
952 ringBuffer := smithyio.NewRingBuffer(buff[:])
953 body := io.TeeReader(response.Body, ringBuffer)
954 rootDecoder := xml.NewDecoder(body)
955 t, err := smithyxml.FetchRootElement(rootDecoder)
956 if err == io.EOF {
957 return out, metadata, nil
958 }
959 if err != nil {
960 var snapshot bytes.Buffer
961 io.Copy(&snapshot, ringBuffer)
962 return out, metadata, &smithy.DeserializationError{
963 Err: fmt.Errorf("failed to decode response body, %w", err),
964 Snapshot: snapshot.Bytes(),
965 }
966 }
967
968 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
969 err = awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(&output, decoder)
970 if err != nil {
971 var snapshot bytes.Buffer
972 io.Copy(&snapshot, ringBuffer)
973 return out, metadata, &smithy.DeserializationError{
974 Err: fmt.Errorf("failed to decode response body, %w", err),
975 Snapshot: snapshot.Bytes(),
976 }
977 }
978
979 span.End()
980 return out, metadata, err
981 }
982
983 func awsRestxml_deserializeOpErrorCreateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
984 var errorBuffer bytes.Buffer
985 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
986 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
987 }
988 errorBody := bytes.NewReader(errorBuffer.Bytes())
989
990 errorCode := "UnknownError"
991 errorMessage := errorCode
992
993 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
994 if err != nil {
995 return err
996 }
997 if reqID := errorComponents.RequestID; len(reqID) != 0 {
998 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
999 }
1000 if len(errorComponents.Code) != 0 {
1001 errorCode = errorComponents.Code
1002 }
1003 if len(errorComponents.Message) != 0 {
1004 errorMessage = errorComponents.Message
1005 }
1006 errorBody.Seek(0, io.SeekStart)
1007 switch {
1008 case strings.EqualFold("HealthCheckAlreadyExists", errorCode):
1009 return awsRestxml_deserializeErrorHealthCheckAlreadyExists(response, errorBody)
1010
1011 case strings.EqualFold("InvalidInput", errorCode):
1012 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
1013
1014 case strings.EqualFold("TooManyHealthChecks", errorCode):
1015 return awsRestxml_deserializeErrorTooManyHealthChecks(response, errorBody)
1016
1017 default:
1018 genericError := &smithy.GenericAPIError{
1019 Code: errorCode,
1020 Message: errorMessage,
1021 }
1022 return genericError
1023
1024 }
1025 }
1026
1027 func awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(v *CreateHealthCheckOutput, response *smithyhttp.Response) error {
1028 if v == nil {
1029 return fmt.Errorf("unsupported deserialization for nil %T", v)
1030 }
1031
1032 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
1033 headerValues[0] = strings.TrimSpace(headerValues[0])
1034 v.Location = ptr.String(headerValues[0])
1035 }
1036
1037 return nil
1038 }
1039 func awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(v **CreateHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
1040 if v == nil {
1041 return fmt.Errorf("unexpected nil of type %T", v)
1042 }
1043 var sv *CreateHealthCheckOutput
1044 if *v == nil {
1045 sv = &CreateHealthCheckOutput{}
1046 } else {
1047 sv = *v
1048 }
1049
1050 for {
1051 t, done, err := decoder.Token()
1052 if err != nil {
1053 return err
1054 }
1055 if done {
1056 break
1057 }
1058 originalDecoder := decoder
1059 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
1060 switch {
1061 case strings.EqualFold("HealthCheck", t.Name.Local):
1062 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1063 if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
1064 return err
1065 }
1066
1067 default:
1068 // Do nothing and ignore the unexpected tag element
1069 err = decoder.Decoder.Skip()
1070 if err != nil {
1071 return err
1072 }
1073
1074 }
1075 decoder = originalDecoder
1076 }
1077 *v = sv
1078 return nil
1079 }
1080
1081 type awsRestxml_deserializeOpCreateHostedZone struct {
1082 }
1083
1084 func (*awsRestxml_deserializeOpCreateHostedZone) ID() string {
1085 return "OperationDeserializer"
1086 }
1087
1088 func (m *awsRestxml_deserializeOpCreateHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1089 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1090 ) {
1091 out, metadata, err = next.HandleDeserialize(ctx, in)
1092 if err != nil {
1093 return out, metadata, err
1094 }
1095
1096 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1097 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1098 defer endTimer()
1099 defer span.End()
1100 response, ok := out.RawResponse.(*smithyhttp.Response)
1101 if !ok {
1102 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1103 }
1104
1105 if response.StatusCode < 200 || response.StatusCode >= 300 {
1106 return out, metadata, awsRestxml_deserializeOpErrorCreateHostedZone(response, &metadata)
1107 }
1108 output := &CreateHostedZoneOutput{}
1109 out.Result = output
1110
1111 err = awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(output, response)
1112 if err != nil {
1113 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
1114 }
1115
1116 var buff [1024]byte
1117 ringBuffer := smithyio.NewRingBuffer(buff[:])
1118 body := io.TeeReader(response.Body, ringBuffer)
1119 rootDecoder := xml.NewDecoder(body)
1120 t, err := smithyxml.FetchRootElement(rootDecoder)
1121 if err == io.EOF {
1122 return out, metadata, nil
1123 }
1124 if err != nil {
1125 var snapshot bytes.Buffer
1126 io.Copy(&snapshot, ringBuffer)
1127 return out, metadata, &smithy.DeserializationError{
1128 Err: fmt.Errorf("failed to decode response body, %w", err),
1129 Snapshot: snapshot.Bytes(),
1130 }
1131 }
1132
1133 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1134 err = awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(&output, decoder)
1135 if err != nil {
1136 var snapshot bytes.Buffer
1137 io.Copy(&snapshot, ringBuffer)
1138 return out, metadata, &smithy.DeserializationError{
1139 Err: fmt.Errorf("failed to decode response body, %w", err),
1140 Snapshot: snapshot.Bytes(),
1141 }
1142 }
1143
1144 span.End()
1145 return out, metadata, err
1146 }
1147
1148 func awsRestxml_deserializeOpErrorCreateHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1149 var errorBuffer bytes.Buffer
1150 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1151 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1152 }
1153 errorBody := bytes.NewReader(errorBuffer.Bytes())
1154
1155 errorCode := "UnknownError"
1156 errorMessage := errorCode
1157
1158 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1159 if err != nil {
1160 return err
1161 }
1162 if reqID := errorComponents.RequestID; len(reqID) != 0 {
1163 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1164 }
1165 if len(errorComponents.Code) != 0 {
1166 errorCode = errorComponents.Code
1167 }
1168 if len(errorComponents.Message) != 0 {
1169 errorMessage = errorComponents.Message
1170 }
1171 errorBody.Seek(0, io.SeekStart)
1172 switch {
1173 case strings.EqualFold("ConflictingDomainExists", errorCode):
1174 return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody)
1175
1176 case strings.EqualFold("DelegationSetNotAvailable", errorCode):
1177 return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody)
1178
1179 case strings.EqualFold("DelegationSetNotReusable", errorCode):
1180 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
1181
1182 case strings.EqualFold("HostedZoneAlreadyExists", errorCode):
1183 return awsRestxml_deserializeErrorHostedZoneAlreadyExists(response, errorBody)
1184
1185 case strings.EqualFold("InvalidDomainName", errorCode):
1186 return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
1187
1188 case strings.EqualFold("InvalidInput", errorCode):
1189 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
1190
1191 case strings.EqualFold("InvalidVPCId", errorCode):
1192 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
1193
1194 case strings.EqualFold("NoSuchDelegationSet", errorCode):
1195 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
1196
1197 case strings.EqualFold("TooManyHostedZones", errorCode):
1198 return awsRestxml_deserializeErrorTooManyHostedZones(response, errorBody)
1199
1200 default:
1201 genericError := &smithy.GenericAPIError{
1202 Code: errorCode,
1203 Message: errorMessage,
1204 }
1205 return genericError
1206
1207 }
1208 }
1209
1210 func awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(v *CreateHostedZoneOutput, response *smithyhttp.Response) error {
1211 if v == nil {
1212 return fmt.Errorf("unsupported deserialization for nil %T", v)
1213 }
1214
1215 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
1216 headerValues[0] = strings.TrimSpace(headerValues[0])
1217 v.Location = ptr.String(headerValues[0])
1218 }
1219
1220 return nil
1221 }
1222 func awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(v **CreateHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
1223 if v == nil {
1224 return fmt.Errorf("unexpected nil of type %T", v)
1225 }
1226 var sv *CreateHostedZoneOutput
1227 if *v == nil {
1228 sv = &CreateHostedZoneOutput{}
1229 } else {
1230 sv = *v
1231 }
1232
1233 for {
1234 t, done, err := decoder.Token()
1235 if err != nil {
1236 return err
1237 }
1238 if done {
1239 break
1240 }
1241 originalDecoder := decoder
1242 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
1243 switch {
1244 case strings.EqualFold("ChangeInfo", t.Name.Local):
1245 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1246 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
1247 return err
1248 }
1249
1250 case strings.EqualFold("DelegationSet", t.Name.Local):
1251 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1252 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
1253 return err
1254 }
1255
1256 case strings.EqualFold("HostedZone", t.Name.Local):
1257 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1258 if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
1259 return err
1260 }
1261
1262 case strings.EqualFold("VPC", t.Name.Local):
1263 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1264 if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil {
1265 return err
1266 }
1267
1268 default:
1269 // Do nothing and ignore the unexpected tag element
1270 err = decoder.Decoder.Skip()
1271 if err != nil {
1272 return err
1273 }
1274
1275 }
1276 decoder = originalDecoder
1277 }
1278 *v = sv
1279 return nil
1280 }
1281
1282 type awsRestxml_deserializeOpCreateKeySigningKey struct {
1283 }
1284
1285 func (*awsRestxml_deserializeOpCreateKeySigningKey) ID() string {
1286 return "OperationDeserializer"
1287 }
1288
1289 func (m *awsRestxml_deserializeOpCreateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1290 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1291 ) {
1292 out, metadata, err = next.HandleDeserialize(ctx, in)
1293 if err != nil {
1294 return out, metadata, err
1295 }
1296
1297 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1298 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1299 defer endTimer()
1300 defer span.End()
1301 response, ok := out.RawResponse.(*smithyhttp.Response)
1302 if !ok {
1303 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1304 }
1305
1306 if response.StatusCode < 200 || response.StatusCode >= 300 {
1307 return out, metadata, awsRestxml_deserializeOpErrorCreateKeySigningKey(response, &metadata)
1308 }
1309 output := &CreateKeySigningKeyOutput{}
1310 out.Result = output
1311
1312 err = awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(output, response)
1313 if err != nil {
1314 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
1315 }
1316
1317 var buff [1024]byte
1318 ringBuffer := smithyio.NewRingBuffer(buff[:])
1319 body := io.TeeReader(response.Body, ringBuffer)
1320 rootDecoder := xml.NewDecoder(body)
1321 t, err := smithyxml.FetchRootElement(rootDecoder)
1322 if err == io.EOF {
1323 return out, metadata, nil
1324 }
1325 if err != nil {
1326 var snapshot bytes.Buffer
1327 io.Copy(&snapshot, ringBuffer)
1328 return out, metadata, &smithy.DeserializationError{
1329 Err: fmt.Errorf("failed to decode response body, %w", err),
1330 Snapshot: snapshot.Bytes(),
1331 }
1332 }
1333
1334 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1335 err = awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(&output, decoder)
1336 if err != nil {
1337 var snapshot bytes.Buffer
1338 io.Copy(&snapshot, ringBuffer)
1339 return out, metadata, &smithy.DeserializationError{
1340 Err: fmt.Errorf("failed to decode response body, %w", err),
1341 Snapshot: snapshot.Bytes(),
1342 }
1343 }
1344
1345 span.End()
1346 return out, metadata, err
1347 }
1348
1349 func awsRestxml_deserializeOpErrorCreateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1350 var errorBuffer bytes.Buffer
1351 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1352 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1353 }
1354 errorBody := bytes.NewReader(errorBuffer.Bytes())
1355
1356 errorCode := "UnknownError"
1357 errorMessage := errorCode
1358
1359 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1360 if err != nil {
1361 return err
1362 }
1363 if reqID := errorComponents.RequestID; len(reqID) != 0 {
1364 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1365 }
1366 if len(errorComponents.Code) != 0 {
1367 errorCode = errorComponents.Code
1368 }
1369 if len(errorComponents.Message) != 0 {
1370 errorMessage = errorComponents.Message
1371 }
1372 errorBody.Seek(0, io.SeekStart)
1373 switch {
1374 case strings.EqualFold("ConcurrentModification", errorCode):
1375 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
1376
1377 case strings.EqualFold("InvalidArgument", errorCode):
1378 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
1379
1380 case strings.EqualFold("InvalidInput", errorCode):
1381 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
1382
1383 case strings.EqualFold("InvalidKMSArn", errorCode):
1384 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
1385
1386 case strings.EqualFold("InvalidKeySigningKeyName", errorCode):
1387 return awsRestxml_deserializeErrorInvalidKeySigningKeyName(response, errorBody)
1388
1389 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
1390 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
1391
1392 case strings.EqualFold("InvalidSigningStatus", errorCode):
1393 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
1394
1395 case strings.EqualFold("KeySigningKeyAlreadyExists", errorCode):
1396 return awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response, errorBody)
1397
1398 case strings.EqualFold("NoSuchHostedZone", errorCode):
1399 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
1400
1401 case strings.EqualFold("TooManyKeySigningKeys", errorCode):
1402 return awsRestxml_deserializeErrorTooManyKeySigningKeys(response, errorBody)
1403
1404 default:
1405 genericError := &smithy.GenericAPIError{
1406 Code: errorCode,
1407 Message: errorMessage,
1408 }
1409 return genericError
1410
1411 }
1412 }
1413
1414 func awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(v *CreateKeySigningKeyOutput, response *smithyhttp.Response) error {
1415 if v == nil {
1416 return fmt.Errorf("unsupported deserialization for nil %T", v)
1417 }
1418
1419 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
1420 headerValues[0] = strings.TrimSpace(headerValues[0])
1421 v.Location = ptr.String(headerValues[0])
1422 }
1423
1424 return nil
1425 }
1426 func awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(v **CreateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
1427 if v == nil {
1428 return fmt.Errorf("unexpected nil of type %T", v)
1429 }
1430 var sv *CreateKeySigningKeyOutput
1431 if *v == nil {
1432 sv = &CreateKeySigningKeyOutput{}
1433 } else {
1434 sv = *v
1435 }
1436
1437 for {
1438 t, done, err := decoder.Token()
1439 if err != nil {
1440 return err
1441 }
1442 if done {
1443 break
1444 }
1445 originalDecoder := decoder
1446 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
1447 switch {
1448 case strings.EqualFold("ChangeInfo", t.Name.Local):
1449 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1450 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
1451 return err
1452 }
1453
1454 case strings.EqualFold("KeySigningKey", t.Name.Local):
1455 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1456 if err := awsRestxml_deserializeDocumentKeySigningKey(&sv.KeySigningKey, nodeDecoder); err != nil {
1457 return err
1458 }
1459
1460 default:
1461 // Do nothing and ignore the unexpected tag element
1462 err = decoder.Decoder.Skip()
1463 if err != nil {
1464 return err
1465 }
1466
1467 }
1468 decoder = originalDecoder
1469 }
1470 *v = sv
1471 return nil
1472 }
1473
1474 type awsRestxml_deserializeOpCreateQueryLoggingConfig struct {
1475 }
1476
1477 func (*awsRestxml_deserializeOpCreateQueryLoggingConfig) ID() string {
1478 return "OperationDeserializer"
1479 }
1480
1481 func (m *awsRestxml_deserializeOpCreateQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1482 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1483 ) {
1484 out, metadata, err = next.HandleDeserialize(ctx, in)
1485 if err != nil {
1486 return out, metadata, err
1487 }
1488
1489 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1490 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1491 defer endTimer()
1492 defer span.End()
1493 response, ok := out.RawResponse.(*smithyhttp.Response)
1494 if !ok {
1495 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1496 }
1497
1498 if response.StatusCode < 200 || response.StatusCode >= 300 {
1499 return out, metadata, awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response, &metadata)
1500 }
1501 output := &CreateQueryLoggingConfigOutput{}
1502 out.Result = output
1503
1504 err = awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(output, response)
1505 if err != nil {
1506 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
1507 }
1508
1509 var buff [1024]byte
1510 ringBuffer := smithyio.NewRingBuffer(buff[:])
1511 body := io.TeeReader(response.Body, ringBuffer)
1512 rootDecoder := xml.NewDecoder(body)
1513 t, err := smithyxml.FetchRootElement(rootDecoder)
1514 if err == io.EOF {
1515 return out, metadata, nil
1516 }
1517 if err != nil {
1518 var snapshot bytes.Buffer
1519 io.Copy(&snapshot, ringBuffer)
1520 return out, metadata, &smithy.DeserializationError{
1521 Err: fmt.Errorf("failed to decode response body, %w", err),
1522 Snapshot: snapshot.Bytes(),
1523 }
1524 }
1525
1526 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1527 err = awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(&output, decoder)
1528 if err != nil {
1529 var snapshot bytes.Buffer
1530 io.Copy(&snapshot, ringBuffer)
1531 return out, metadata, &smithy.DeserializationError{
1532 Err: fmt.Errorf("failed to decode response body, %w", err),
1533 Snapshot: snapshot.Bytes(),
1534 }
1535 }
1536
1537 span.End()
1538 return out, metadata, err
1539 }
1540
1541 func awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1542 var errorBuffer bytes.Buffer
1543 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1544 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1545 }
1546 errorBody := bytes.NewReader(errorBuffer.Bytes())
1547
1548 errorCode := "UnknownError"
1549 errorMessage := errorCode
1550
1551 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1552 if err != nil {
1553 return err
1554 }
1555 if reqID := errorComponents.RequestID; len(reqID) != 0 {
1556 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1557 }
1558 if len(errorComponents.Code) != 0 {
1559 errorCode = errorComponents.Code
1560 }
1561 if len(errorComponents.Message) != 0 {
1562 errorMessage = errorComponents.Message
1563 }
1564 errorBody.Seek(0, io.SeekStart)
1565 switch {
1566 case strings.EqualFold("ConcurrentModification", errorCode):
1567 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
1568
1569 case strings.EqualFold("InsufficientCloudWatchLogsResourcePolicy", errorCode):
1570 return awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response, errorBody)
1571
1572 case strings.EqualFold("InvalidInput", errorCode):
1573 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
1574
1575 case strings.EqualFold("NoSuchCloudWatchLogsLogGroup", errorCode):
1576 return awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response, errorBody)
1577
1578 case strings.EqualFold("NoSuchHostedZone", errorCode):
1579 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
1580
1581 case strings.EqualFold("QueryLoggingConfigAlreadyExists", errorCode):
1582 return awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response, errorBody)
1583
1584 default:
1585 genericError := &smithy.GenericAPIError{
1586 Code: errorCode,
1587 Message: errorMessage,
1588 }
1589 return genericError
1590
1591 }
1592 }
1593
1594 func awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(v *CreateQueryLoggingConfigOutput, response *smithyhttp.Response) error {
1595 if v == nil {
1596 return fmt.Errorf("unsupported deserialization for nil %T", v)
1597 }
1598
1599 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
1600 headerValues[0] = strings.TrimSpace(headerValues[0])
1601 v.Location = ptr.String(headerValues[0])
1602 }
1603
1604 return nil
1605 }
1606 func awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(v **CreateQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error {
1607 if v == nil {
1608 return fmt.Errorf("unexpected nil of type %T", v)
1609 }
1610 var sv *CreateQueryLoggingConfigOutput
1611 if *v == nil {
1612 sv = &CreateQueryLoggingConfigOutput{}
1613 } else {
1614 sv = *v
1615 }
1616
1617 for {
1618 t, done, err := decoder.Token()
1619 if err != nil {
1620 return err
1621 }
1622 if done {
1623 break
1624 }
1625 originalDecoder := decoder
1626 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
1627 switch {
1628 case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
1629 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1630 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil {
1631 return err
1632 }
1633
1634 default:
1635 // Do nothing and ignore the unexpected tag element
1636 err = decoder.Decoder.Skip()
1637 if err != nil {
1638 return err
1639 }
1640
1641 }
1642 decoder = originalDecoder
1643 }
1644 *v = sv
1645 return nil
1646 }
1647
1648 type awsRestxml_deserializeOpCreateReusableDelegationSet struct {
1649 }
1650
1651 func (*awsRestxml_deserializeOpCreateReusableDelegationSet) ID() string {
1652 return "OperationDeserializer"
1653 }
1654
1655 func (m *awsRestxml_deserializeOpCreateReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1656 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1657 ) {
1658 out, metadata, err = next.HandleDeserialize(ctx, in)
1659 if err != nil {
1660 return out, metadata, err
1661 }
1662
1663 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1664 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1665 defer endTimer()
1666 defer span.End()
1667 response, ok := out.RawResponse.(*smithyhttp.Response)
1668 if !ok {
1669 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1670 }
1671
1672 if response.StatusCode < 200 || response.StatusCode >= 300 {
1673 return out, metadata, awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response, &metadata)
1674 }
1675 output := &CreateReusableDelegationSetOutput{}
1676 out.Result = output
1677
1678 err = awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(output, response)
1679 if err != nil {
1680 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
1681 }
1682
1683 var buff [1024]byte
1684 ringBuffer := smithyio.NewRingBuffer(buff[:])
1685 body := io.TeeReader(response.Body, ringBuffer)
1686 rootDecoder := xml.NewDecoder(body)
1687 t, err := smithyxml.FetchRootElement(rootDecoder)
1688 if err == io.EOF {
1689 return out, metadata, nil
1690 }
1691 if err != nil {
1692 var snapshot bytes.Buffer
1693 io.Copy(&snapshot, ringBuffer)
1694 return out, metadata, &smithy.DeserializationError{
1695 Err: fmt.Errorf("failed to decode response body, %w", err),
1696 Snapshot: snapshot.Bytes(),
1697 }
1698 }
1699
1700 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1701 err = awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(&output, decoder)
1702 if err != nil {
1703 var snapshot bytes.Buffer
1704 io.Copy(&snapshot, ringBuffer)
1705 return out, metadata, &smithy.DeserializationError{
1706 Err: fmt.Errorf("failed to decode response body, %w", err),
1707 Snapshot: snapshot.Bytes(),
1708 }
1709 }
1710
1711 span.End()
1712 return out, metadata, err
1713 }
1714
1715 func awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1716 var errorBuffer bytes.Buffer
1717 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1718 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1719 }
1720 errorBody := bytes.NewReader(errorBuffer.Bytes())
1721
1722 errorCode := "UnknownError"
1723 errorMessage := errorCode
1724
1725 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1726 if err != nil {
1727 return err
1728 }
1729 if reqID := errorComponents.RequestID; len(reqID) != 0 {
1730 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1731 }
1732 if len(errorComponents.Code) != 0 {
1733 errorCode = errorComponents.Code
1734 }
1735 if len(errorComponents.Message) != 0 {
1736 errorMessage = errorComponents.Message
1737 }
1738 errorBody.Seek(0, io.SeekStart)
1739 switch {
1740 case strings.EqualFold("DelegationSetAlreadyCreated", errorCode):
1741 return awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response, errorBody)
1742
1743 case strings.EqualFold("DelegationSetAlreadyReusable", errorCode):
1744 return awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response, errorBody)
1745
1746 case strings.EqualFold("DelegationSetNotAvailable", errorCode):
1747 return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody)
1748
1749 case strings.EqualFold("HostedZoneNotFound", errorCode):
1750 return awsRestxml_deserializeErrorHostedZoneNotFound(response, errorBody)
1751
1752 case strings.EqualFold("InvalidArgument", errorCode):
1753 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
1754
1755 case strings.EqualFold("InvalidInput", errorCode):
1756 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
1757
1758 case strings.EqualFold("LimitsExceeded", errorCode):
1759 return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
1760
1761 default:
1762 genericError := &smithy.GenericAPIError{
1763 Code: errorCode,
1764 Message: errorMessage,
1765 }
1766 return genericError
1767
1768 }
1769 }
1770
1771 func awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(v *CreateReusableDelegationSetOutput, response *smithyhttp.Response) error {
1772 if v == nil {
1773 return fmt.Errorf("unsupported deserialization for nil %T", v)
1774 }
1775
1776 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
1777 headerValues[0] = strings.TrimSpace(headerValues[0])
1778 v.Location = ptr.String(headerValues[0])
1779 }
1780
1781 return nil
1782 }
1783 func awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(v **CreateReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error {
1784 if v == nil {
1785 return fmt.Errorf("unexpected nil of type %T", v)
1786 }
1787 var sv *CreateReusableDelegationSetOutput
1788 if *v == nil {
1789 sv = &CreateReusableDelegationSetOutput{}
1790 } else {
1791 sv = *v
1792 }
1793
1794 for {
1795 t, done, err := decoder.Token()
1796 if err != nil {
1797 return err
1798 }
1799 if done {
1800 break
1801 }
1802 originalDecoder := decoder
1803 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
1804 switch {
1805 case strings.EqualFold("DelegationSet", t.Name.Local):
1806 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1807 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
1808 return err
1809 }
1810
1811 default:
1812 // Do nothing and ignore the unexpected tag element
1813 err = decoder.Decoder.Skip()
1814 if err != nil {
1815 return err
1816 }
1817
1818 }
1819 decoder = originalDecoder
1820 }
1821 *v = sv
1822 return nil
1823 }
1824
1825 type awsRestxml_deserializeOpCreateTrafficPolicy struct {
1826 }
1827
1828 func (*awsRestxml_deserializeOpCreateTrafficPolicy) ID() string {
1829 return "OperationDeserializer"
1830 }
1831
1832 func (m *awsRestxml_deserializeOpCreateTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1833 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1834 ) {
1835 out, metadata, err = next.HandleDeserialize(ctx, in)
1836 if err != nil {
1837 return out, metadata, err
1838 }
1839
1840 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1841 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1842 defer endTimer()
1843 defer span.End()
1844 response, ok := out.RawResponse.(*smithyhttp.Response)
1845 if !ok {
1846 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1847 }
1848
1849 if response.StatusCode < 200 || response.StatusCode >= 300 {
1850 return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicy(response, &metadata)
1851 }
1852 output := &CreateTrafficPolicyOutput{}
1853 out.Result = output
1854
1855 err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(output, response)
1856 if err != nil {
1857 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
1858 }
1859
1860 var buff [1024]byte
1861 ringBuffer := smithyio.NewRingBuffer(buff[:])
1862 body := io.TeeReader(response.Body, ringBuffer)
1863 rootDecoder := xml.NewDecoder(body)
1864 t, err := smithyxml.FetchRootElement(rootDecoder)
1865 if err == io.EOF {
1866 return out, metadata, nil
1867 }
1868 if err != nil {
1869 var snapshot bytes.Buffer
1870 io.Copy(&snapshot, ringBuffer)
1871 return out, metadata, &smithy.DeserializationError{
1872 Err: fmt.Errorf("failed to decode response body, %w", err),
1873 Snapshot: snapshot.Bytes(),
1874 }
1875 }
1876
1877 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1878 err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(&output, decoder)
1879 if err != nil {
1880 var snapshot bytes.Buffer
1881 io.Copy(&snapshot, ringBuffer)
1882 return out, metadata, &smithy.DeserializationError{
1883 Err: fmt.Errorf("failed to decode response body, %w", err),
1884 Snapshot: snapshot.Bytes(),
1885 }
1886 }
1887
1888 span.End()
1889 return out, metadata, err
1890 }
1891
1892 func awsRestxml_deserializeOpErrorCreateTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1893 var errorBuffer bytes.Buffer
1894 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1895 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1896 }
1897 errorBody := bytes.NewReader(errorBuffer.Bytes())
1898
1899 errorCode := "UnknownError"
1900 errorMessage := errorCode
1901
1902 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1903 if err != nil {
1904 return err
1905 }
1906 if reqID := errorComponents.RequestID; len(reqID) != 0 {
1907 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1908 }
1909 if len(errorComponents.Code) != 0 {
1910 errorCode = errorComponents.Code
1911 }
1912 if len(errorComponents.Message) != 0 {
1913 errorMessage = errorComponents.Message
1914 }
1915 errorBody.Seek(0, io.SeekStart)
1916 switch {
1917 case strings.EqualFold("InvalidInput", errorCode):
1918 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
1919
1920 case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode):
1921 return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody)
1922
1923 case strings.EqualFold("TooManyTrafficPolicies", errorCode):
1924 return awsRestxml_deserializeErrorTooManyTrafficPolicies(response, errorBody)
1925
1926 case strings.EqualFold("TrafficPolicyAlreadyExists", errorCode):
1927 return awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response, errorBody)
1928
1929 default:
1930 genericError := &smithy.GenericAPIError{
1931 Code: errorCode,
1932 Message: errorMessage,
1933 }
1934 return genericError
1935
1936 }
1937 }
1938
1939 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(v *CreateTrafficPolicyOutput, response *smithyhttp.Response) error {
1940 if v == nil {
1941 return fmt.Errorf("unsupported deserialization for nil %T", v)
1942 }
1943
1944 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
1945 headerValues[0] = strings.TrimSpace(headerValues[0])
1946 v.Location = ptr.String(headerValues[0])
1947 }
1948
1949 return nil
1950 }
1951 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(v **CreateTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error {
1952 if v == nil {
1953 return fmt.Errorf("unexpected nil of type %T", v)
1954 }
1955 var sv *CreateTrafficPolicyOutput
1956 if *v == nil {
1957 sv = &CreateTrafficPolicyOutput{}
1958 } else {
1959 sv = *v
1960 }
1961
1962 for {
1963 t, done, err := decoder.Token()
1964 if err != nil {
1965 return err
1966 }
1967 if done {
1968 break
1969 }
1970 originalDecoder := decoder
1971 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
1972 switch {
1973 case strings.EqualFold("TrafficPolicy", t.Name.Local):
1974 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1975 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
1976 return err
1977 }
1978
1979 default:
1980 // Do nothing and ignore the unexpected tag element
1981 err = decoder.Decoder.Skip()
1982 if err != nil {
1983 return err
1984 }
1985
1986 }
1987 decoder = originalDecoder
1988 }
1989 *v = sv
1990 return nil
1991 }
1992
1993 type awsRestxml_deserializeOpCreateTrafficPolicyInstance struct {
1994 }
1995
1996 func (*awsRestxml_deserializeOpCreateTrafficPolicyInstance) ID() string {
1997 return "OperationDeserializer"
1998 }
1999
2000 func (m *awsRestxml_deserializeOpCreateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2001 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2002 ) {
2003 out, metadata, err = next.HandleDeserialize(ctx, in)
2004 if err != nil {
2005 return out, metadata, err
2006 }
2007
2008 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2009 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2010 defer endTimer()
2011 defer span.End()
2012 response, ok := out.RawResponse.(*smithyhttp.Response)
2013 if !ok {
2014 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2015 }
2016
2017 if response.StatusCode < 200 || response.StatusCode >= 300 {
2018 return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response, &metadata)
2019 }
2020 output := &CreateTrafficPolicyInstanceOutput{}
2021 out.Result = output
2022
2023 err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(output, response)
2024 if err != nil {
2025 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
2026 }
2027
2028 var buff [1024]byte
2029 ringBuffer := smithyio.NewRingBuffer(buff[:])
2030 body := io.TeeReader(response.Body, ringBuffer)
2031 rootDecoder := xml.NewDecoder(body)
2032 t, err := smithyxml.FetchRootElement(rootDecoder)
2033 if err == io.EOF {
2034 return out, metadata, nil
2035 }
2036 if err != nil {
2037 var snapshot bytes.Buffer
2038 io.Copy(&snapshot, ringBuffer)
2039 return out, metadata, &smithy.DeserializationError{
2040 Err: fmt.Errorf("failed to decode response body, %w", err),
2041 Snapshot: snapshot.Bytes(),
2042 }
2043 }
2044
2045 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2046 err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(&output, decoder)
2047 if err != nil {
2048 var snapshot bytes.Buffer
2049 io.Copy(&snapshot, ringBuffer)
2050 return out, metadata, &smithy.DeserializationError{
2051 Err: fmt.Errorf("failed to decode response body, %w", err),
2052 Snapshot: snapshot.Bytes(),
2053 }
2054 }
2055
2056 span.End()
2057 return out, metadata, err
2058 }
2059
2060 func awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2061 var errorBuffer bytes.Buffer
2062 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2063 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2064 }
2065 errorBody := bytes.NewReader(errorBuffer.Bytes())
2066
2067 errorCode := "UnknownError"
2068 errorMessage := errorCode
2069
2070 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2071 if err != nil {
2072 return err
2073 }
2074 if reqID := errorComponents.RequestID; len(reqID) != 0 {
2075 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2076 }
2077 if len(errorComponents.Code) != 0 {
2078 errorCode = errorComponents.Code
2079 }
2080 if len(errorComponents.Message) != 0 {
2081 errorMessage = errorComponents.Message
2082 }
2083 errorBody.Seek(0, io.SeekStart)
2084 switch {
2085 case strings.EqualFold("InvalidInput", errorCode):
2086 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
2087
2088 case strings.EqualFold("NoSuchHostedZone", errorCode):
2089 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
2090
2091 case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
2092 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
2093
2094 case strings.EqualFold("TooManyTrafficPolicyInstances", errorCode):
2095 return awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response, errorBody)
2096
2097 case strings.EqualFold("TrafficPolicyInstanceAlreadyExists", errorCode):
2098 return awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response, errorBody)
2099
2100 default:
2101 genericError := &smithy.GenericAPIError{
2102 Code: errorCode,
2103 Message: errorMessage,
2104 }
2105 return genericError
2106
2107 }
2108 }
2109
2110 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(v *CreateTrafficPolicyInstanceOutput, response *smithyhttp.Response) error {
2111 if v == nil {
2112 return fmt.Errorf("unsupported deserialization for nil %T", v)
2113 }
2114
2115 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
2116 headerValues[0] = strings.TrimSpace(headerValues[0])
2117 v.Location = ptr.String(headerValues[0])
2118 }
2119
2120 return nil
2121 }
2122 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(v **CreateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
2123 if v == nil {
2124 return fmt.Errorf("unexpected nil of type %T", v)
2125 }
2126 var sv *CreateTrafficPolicyInstanceOutput
2127 if *v == nil {
2128 sv = &CreateTrafficPolicyInstanceOutput{}
2129 } else {
2130 sv = *v
2131 }
2132
2133 for {
2134 t, done, err := decoder.Token()
2135 if err != nil {
2136 return err
2137 }
2138 if done {
2139 break
2140 }
2141 originalDecoder := decoder
2142 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2143 switch {
2144 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
2145 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2146 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
2147 return err
2148 }
2149
2150 default:
2151 // Do nothing and ignore the unexpected tag element
2152 err = decoder.Decoder.Skip()
2153 if err != nil {
2154 return err
2155 }
2156
2157 }
2158 decoder = originalDecoder
2159 }
2160 *v = sv
2161 return nil
2162 }
2163
2164 type awsRestxml_deserializeOpCreateTrafficPolicyVersion struct {
2165 }
2166
2167 func (*awsRestxml_deserializeOpCreateTrafficPolicyVersion) ID() string {
2168 return "OperationDeserializer"
2169 }
2170
2171 func (m *awsRestxml_deserializeOpCreateTrafficPolicyVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2172 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2173 ) {
2174 out, metadata, err = next.HandleDeserialize(ctx, in)
2175 if err != nil {
2176 return out, metadata, err
2177 }
2178
2179 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2180 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2181 defer endTimer()
2182 defer span.End()
2183 response, ok := out.RawResponse.(*smithyhttp.Response)
2184 if !ok {
2185 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2186 }
2187
2188 if response.StatusCode < 200 || response.StatusCode >= 300 {
2189 return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response, &metadata)
2190 }
2191 output := &CreateTrafficPolicyVersionOutput{}
2192 out.Result = output
2193
2194 err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(output, response)
2195 if err != nil {
2196 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
2197 }
2198
2199 var buff [1024]byte
2200 ringBuffer := smithyio.NewRingBuffer(buff[:])
2201 body := io.TeeReader(response.Body, ringBuffer)
2202 rootDecoder := xml.NewDecoder(body)
2203 t, err := smithyxml.FetchRootElement(rootDecoder)
2204 if err == io.EOF {
2205 return out, metadata, nil
2206 }
2207 if err != nil {
2208 var snapshot bytes.Buffer
2209 io.Copy(&snapshot, ringBuffer)
2210 return out, metadata, &smithy.DeserializationError{
2211 Err: fmt.Errorf("failed to decode response body, %w", err),
2212 Snapshot: snapshot.Bytes(),
2213 }
2214 }
2215
2216 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2217 err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(&output, decoder)
2218 if err != nil {
2219 var snapshot bytes.Buffer
2220 io.Copy(&snapshot, ringBuffer)
2221 return out, metadata, &smithy.DeserializationError{
2222 Err: fmt.Errorf("failed to decode response body, %w", err),
2223 Snapshot: snapshot.Bytes(),
2224 }
2225 }
2226
2227 span.End()
2228 return out, metadata, err
2229 }
2230
2231 func awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2232 var errorBuffer bytes.Buffer
2233 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2234 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2235 }
2236 errorBody := bytes.NewReader(errorBuffer.Bytes())
2237
2238 errorCode := "UnknownError"
2239 errorMessage := errorCode
2240
2241 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2242 if err != nil {
2243 return err
2244 }
2245 if reqID := errorComponents.RequestID; len(reqID) != 0 {
2246 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2247 }
2248 if len(errorComponents.Code) != 0 {
2249 errorCode = errorComponents.Code
2250 }
2251 if len(errorComponents.Message) != 0 {
2252 errorMessage = errorComponents.Message
2253 }
2254 errorBody.Seek(0, io.SeekStart)
2255 switch {
2256 case strings.EqualFold("ConcurrentModification", errorCode):
2257 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
2258
2259 case strings.EqualFold("InvalidInput", errorCode):
2260 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
2261
2262 case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode):
2263 return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody)
2264
2265 case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
2266 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
2267
2268 case strings.EqualFold("TooManyTrafficPolicyVersionsForCurrentPolicy", errorCode):
2269 return awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response, errorBody)
2270
2271 default:
2272 genericError := &smithy.GenericAPIError{
2273 Code: errorCode,
2274 Message: errorMessage,
2275 }
2276 return genericError
2277
2278 }
2279 }
2280
2281 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(v *CreateTrafficPolicyVersionOutput, response *smithyhttp.Response) error {
2282 if v == nil {
2283 return fmt.Errorf("unsupported deserialization for nil %T", v)
2284 }
2285
2286 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
2287 headerValues[0] = strings.TrimSpace(headerValues[0])
2288 v.Location = ptr.String(headerValues[0])
2289 }
2290
2291 return nil
2292 }
2293 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(v **CreateTrafficPolicyVersionOutput, decoder smithyxml.NodeDecoder) error {
2294 if v == nil {
2295 return fmt.Errorf("unexpected nil of type %T", v)
2296 }
2297 var sv *CreateTrafficPolicyVersionOutput
2298 if *v == nil {
2299 sv = &CreateTrafficPolicyVersionOutput{}
2300 } else {
2301 sv = *v
2302 }
2303
2304 for {
2305 t, done, err := decoder.Token()
2306 if err != nil {
2307 return err
2308 }
2309 if done {
2310 break
2311 }
2312 originalDecoder := decoder
2313 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2314 switch {
2315 case strings.EqualFold("TrafficPolicy", t.Name.Local):
2316 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2317 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
2318 return err
2319 }
2320
2321 default:
2322 // Do nothing and ignore the unexpected tag element
2323 err = decoder.Decoder.Skip()
2324 if err != nil {
2325 return err
2326 }
2327
2328 }
2329 decoder = originalDecoder
2330 }
2331 *v = sv
2332 return nil
2333 }
2334
2335 type awsRestxml_deserializeOpCreateVPCAssociationAuthorization struct {
2336 }
2337
2338 func (*awsRestxml_deserializeOpCreateVPCAssociationAuthorization) ID() string {
2339 return "OperationDeserializer"
2340 }
2341
2342 func (m *awsRestxml_deserializeOpCreateVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2343 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2344 ) {
2345 out, metadata, err = next.HandleDeserialize(ctx, in)
2346 if err != nil {
2347 return out, metadata, err
2348 }
2349
2350 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2351 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2352 defer endTimer()
2353 defer span.End()
2354 response, ok := out.RawResponse.(*smithyhttp.Response)
2355 if !ok {
2356 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2357 }
2358
2359 if response.StatusCode < 200 || response.StatusCode >= 300 {
2360 return out, metadata, awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response, &metadata)
2361 }
2362 output := &CreateVPCAssociationAuthorizationOutput{}
2363 out.Result = output
2364
2365 var buff [1024]byte
2366 ringBuffer := smithyio.NewRingBuffer(buff[:])
2367 body := io.TeeReader(response.Body, ringBuffer)
2368 rootDecoder := xml.NewDecoder(body)
2369 t, err := smithyxml.FetchRootElement(rootDecoder)
2370 if err == io.EOF {
2371 return out, metadata, nil
2372 }
2373 if err != nil {
2374 var snapshot bytes.Buffer
2375 io.Copy(&snapshot, ringBuffer)
2376 return out, metadata, &smithy.DeserializationError{
2377 Err: fmt.Errorf("failed to decode response body, %w", err),
2378 Snapshot: snapshot.Bytes(),
2379 }
2380 }
2381
2382 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2383 err = awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(&output, decoder)
2384 if err != nil {
2385 var snapshot bytes.Buffer
2386 io.Copy(&snapshot, ringBuffer)
2387 return out, metadata, &smithy.DeserializationError{
2388 Err: fmt.Errorf("failed to decode response body, %w", err),
2389 Snapshot: snapshot.Bytes(),
2390 }
2391 }
2392
2393 span.End()
2394 return out, metadata, err
2395 }
2396
2397 func awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2398 var errorBuffer bytes.Buffer
2399 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2400 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2401 }
2402 errorBody := bytes.NewReader(errorBuffer.Bytes())
2403
2404 errorCode := "UnknownError"
2405 errorMessage := errorCode
2406
2407 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2408 if err != nil {
2409 return err
2410 }
2411 if reqID := errorComponents.RequestID; len(reqID) != 0 {
2412 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2413 }
2414 if len(errorComponents.Code) != 0 {
2415 errorCode = errorComponents.Code
2416 }
2417 if len(errorComponents.Message) != 0 {
2418 errorMessage = errorComponents.Message
2419 }
2420 errorBody.Seek(0, io.SeekStart)
2421 switch {
2422 case strings.EqualFold("ConcurrentModification", errorCode):
2423 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
2424
2425 case strings.EqualFold("InvalidInput", errorCode):
2426 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
2427
2428 case strings.EqualFold("InvalidVPCId", errorCode):
2429 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
2430
2431 case strings.EqualFold("NoSuchHostedZone", errorCode):
2432 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
2433
2434 case strings.EqualFold("TooManyVPCAssociationAuthorizations", errorCode):
2435 return awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response, errorBody)
2436
2437 default:
2438 genericError := &smithy.GenericAPIError{
2439 Code: errorCode,
2440 Message: errorMessage,
2441 }
2442 return genericError
2443
2444 }
2445 }
2446
2447 func awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(v **CreateVPCAssociationAuthorizationOutput, decoder smithyxml.NodeDecoder) error {
2448 if v == nil {
2449 return fmt.Errorf("unexpected nil of type %T", v)
2450 }
2451 var sv *CreateVPCAssociationAuthorizationOutput
2452 if *v == nil {
2453 sv = &CreateVPCAssociationAuthorizationOutput{}
2454 } else {
2455 sv = *v
2456 }
2457
2458 for {
2459 t, done, err := decoder.Token()
2460 if err != nil {
2461 return err
2462 }
2463 if done {
2464 break
2465 }
2466 originalDecoder := decoder
2467 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2468 switch {
2469 case strings.EqualFold("HostedZoneId", t.Name.Local):
2470 val, err := decoder.Value()
2471 if err != nil {
2472 return err
2473 }
2474 if val == nil {
2475 break
2476 }
2477 {
2478 xtv := string(val)
2479 sv.HostedZoneId = ptr.String(xtv)
2480 }
2481
2482 case strings.EqualFold("VPC", t.Name.Local):
2483 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2484 if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil {
2485 return err
2486 }
2487
2488 default:
2489 // Do nothing and ignore the unexpected tag element
2490 err = decoder.Decoder.Skip()
2491 if err != nil {
2492 return err
2493 }
2494
2495 }
2496 decoder = originalDecoder
2497 }
2498 *v = sv
2499 return nil
2500 }
2501
2502 type awsRestxml_deserializeOpDeactivateKeySigningKey struct {
2503 }
2504
2505 func (*awsRestxml_deserializeOpDeactivateKeySigningKey) ID() string {
2506 return "OperationDeserializer"
2507 }
2508
2509 func (m *awsRestxml_deserializeOpDeactivateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2510 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2511 ) {
2512 out, metadata, err = next.HandleDeserialize(ctx, in)
2513 if err != nil {
2514 return out, metadata, err
2515 }
2516
2517 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2518 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2519 defer endTimer()
2520 defer span.End()
2521 response, ok := out.RawResponse.(*smithyhttp.Response)
2522 if !ok {
2523 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2524 }
2525
2526 if response.StatusCode < 200 || response.StatusCode >= 300 {
2527 return out, metadata, awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response, &metadata)
2528 }
2529 output := &DeactivateKeySigningKeyOutput{}
2530 out.Result = output
2531
2532 var buff [1024]byte
2533 ringBuffer := smithyio.NewRingBuffer(buff[:])
2534 body := io.TeeReader(response.Body, ringBuffer)
2535 rootDecoder := xml.NewDecoder(body)
2536 t, err := smithyxml.FetchRootElement(rootDecoder)
2537 if err == io.EOF {
2538 return out, metadata, nil
2539 }
2540 if err != nil {
2541 var snapshot bytes.Buffer
2542 io.Copy(&snapshot, ringBuffer)
2543 return out, metadata, &smithy.DeserializationError{
2544 Err: fmt.Errorf("failed to decode response body, %w", err),
2545 Snapshot: snapshot.Bytes(),
2546 }
2547 }
2548
2549 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2550 err = awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(&output, decoder)
2551 if err != nil {
2552 var snapshot bytes.Buffer
2553 io.Copy(&snapshot, ringBuffer)
2554 return out, metadata, &smithy.DeserializationError{
2555 Err: fmt.Errorf("failed to decode response body, %w", err),
2556 Snapshot: snapshot.Bytes(),
2557 }
2558 }
2559
2560 span.End()
2561 return out, metadata, err
2562 }
2563
2564 func awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2565 var errorBuffer bytes.Buffer
2566 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2567 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2568 }
2569 errorBody := bytes.NewReader(errorBuffer.Bytes())
2570
2571 errorCode := "UnknownError"
2572 errorMessage := errorCode
2573
2574 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2575 if err != nil {
2576 return err
2577 }
2578 if reqID := errorComponents.RequestID; len(reqID) != 0 {
2579 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2580 }
2581 if len(errorComponents.Code) != 0 {
2582 errorCode = errorComponents.Code
2583 }
2584 if len(errorComponents.Message) != 0 {
2585 errorMessage = errorComponents.Message
2586 }
2587 errorBody.Seek(0, io.SeekStart)
2588 switch {
2589 case strings.EqualFold("ConcurrentModification", errorCode):
2590 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
2591
2592 case strings.EqualFold("InvalidInput", errorCode):
2593 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
2594
2595 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
2596 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
2597
2598 case strings.EqualFold("InvalidSigningStatus", errorCode):
2599 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
2600
2601 case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode):
2602 return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody)
2603
2604 case strings.EqualFold("KeySigningKeyInUse", errorCode):
2605 return awsRestxml_deserializeErrorKeySigningKeyInUse(response, errorBody)
2606
2607 case strings.EqualFold("NoSuchKeySigningKey", errorCode):
2608 return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
2609
2610 default:
2611 genericError := &smithy.GenericAPIError{
2612 Code: errorCode,
2613 Message: errorMessage,
2614 }
2615 return genericError
2616
2617 }
2618 }
2619
2620 func awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(v **DeactivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
2621 if v == nil {
2622 return fmt.Errorf("unexpected nil of type %T", v)
2623 }
2624 var sv *DeactivateKeySigningKeyOutput
2625 if *v == nil {
2626 sv = &DeactivateKeySigningKeyOutput{}
2627 } else {
2628 sv = *v
2629 }
2630
2631 for {
2632 t, done, err := decoder.Token()
2633 if err != nil {
2634 return err
2635 }
2636 if done {
2637 break
2638 }
2639 originalDecoder := decoder
2640 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2641 switch {
2642 case strings.EqualFold("ChangeInfo", t.Name.Local):
2643 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2644 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
2645 return err
2646 }
2647
2648 default:
2649 // Do nothing and ignore the unexpected tag element
2650 err = decoder.Decoder.Skip()
2651 if err != nil {
2652 return err
2653 }
2654
2655 }
2656 decoder = originalDecoder
2657 }
2658 *v = sv
2659 return nil
2660 }
2661
2662 type awsRestxml_deserializeOpDeleteCidrCollection struct {
2663 }
2664
2665 func (*awsRestxml_deserializeOpDeleteCidrCollection) ID() string {
2666 return "OperationDeserializer"
2667 }
2668
2669 func (m *awsRestxml_deserializeOpDeleteCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2670 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2671 ) {
2672 out, metadata, err = next.HandleDeserialize(ctx, in)
2673 if err != nil {
2674 return out, metadata, err
2675 }
2676
2677 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2678 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2679 defer endTimer()
2680 defer span.End()
2681 response, ok := out.RawResponse.(*smithyhttp.Response)
2682 if !ok {
2683 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2684 }
2685
2686 if response.StatusCode < 200 || response.StatusCode >= 300 {
2687 return out, metadata, awsRestxml_deserializeOpErrorDeleteCidrCollection(response, &metadata)
2688 }
2689 output := &DeleteCidrCollectionOutput{}
2690 out.Result = output
2691
2692 span.End()
2693 return out, metadata, err
2694 }
2695
2696 func awsRestxml_deserializeOpErrorDeleteCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2697 var errorBuffer bytes.Buffer
2698 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2699 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2700 }
2701 errorBody := bytes.NewReader(errorBuffer.Bytes())
2702
2703 errorCode := "UnknownError"
2704 errorMessage := errorCode
2705
2706 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2707 if err != nil {
2708 return err
2709 }
2710 if reqID := errorComponents.RequestID; len(reqID) != 0 {
2711 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2712 }
2713 if len(errorComponents.Code) != 0 {
2714 errorCode = errorComponents.Code
2715 }
2716 if len(errorComponents.Message) != 0 {
2717 errorMessage = errorComponents.Message
2718 }
2719 errorBody.Seek(0, io.SeekStart)
2720 switch {
2721 case strings.EqualFold("CidrCollectionInUseException", errorCode):
2722 return awsRestxml_deserializeErrorCidrCollectionInUseException(response, errorBody)
2723
2724 case strings.EqualFold("ConcurrentModification", errorCode):
2725 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
2726
2727 case strings.EqualFold("InvalidInput", errorCode):
2728 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
2729
2730 case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
2731 return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
2732
2733 default:
2734 genericError := &smithy.GenericAPIError{
2735 Code: errorCode,
2736 Message: errorMessage,
2737 }
2738 return genericError
2739
2740 }
2741 }
2742
2743 type awsRestxml_deserializeOpDeleteHealthCheck struct {
2744 }
2745
2746 func (*awsRestxml_deserializeOpDeleteHealthCheck) ID() string {
2747 return "OperationDeserializer"
2748 }
2749
2750 func (m *awsRestxml_deserializeOpDeleteHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2751 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2752 ) {
2753 out, metadata, err = next.HandleDeserialize(ctx, in)
2754 if err != nil {
2755 return out, metadata, err
2756 }
2757
2758 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2759 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2760 defer endTimer()
2761 defer span.End()
2762 response, ok := out.RawResponse.(*smithyhttp.Response)
2763 if !ok {
2764 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2765 }
2766
2767 if response.StatusCode < 200 || response.StatusCode >= 300 {
2768 return out, metadata, awsRestxml_deserializeOpErrorDeleteHealthCheck(response, &metadata)
2769 }
2770 output := &DeleteHealthCheckOutput{}
2771 out.Result = output
2772
2773 span.End()
2774 return out, metadata, err
2775 }
2776
2777 func awsRestxml_deserializeOpErrorDeleteHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2778 var errorBuffer bytes.Buffer
2779 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2780 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2781 }
2782 errorBody := bytes.NewReader(errorBuffer.Bytes())
2783
2784 errorCode := "UnknownError"
2785 errorMessage := errorCode
2786
2787 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2788 if err != nil {
2789 return err
2790 }
2791 if reqID := errorComponents.RequestID; len(reqID) != 0 {
2792 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2793 }
2794 if len(errorComponents.Code) != 0 {
2795 errorCode = errorComponents.Code
2796 }
2797 if len(errorComponents.Message) != 0 {
2798 errorMessage = errorComponents.Message
2799 }
2800 errorBody.Seek(0, io.SeekStart)
2801 switch {
2802 case strings.EqualFold("HealthCheckInUse", errorCode):
2803 return awsRestxml_deserializeErrorHealthCheckInUse(response, errorBody)
2804
2805 case strings.EqualFold("InvalidInput", errorCode):
2806 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
2807
2808 case strings.EqualFold("NoSuchHealthCheck", errorCode):
2809 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
2810
2811 default:
2812 genericError := &smithy.GenericAPIError{
2813 Code: errorCode,
2814 Message: errorMessage,
2815 }
2816 return genericError
2817
2818 }
2819 }
2820
2821 type awsRestxml_deserializeOpDeleteHostedZone struct {
2822 }
2823
2824 func (*awsRestxml_deserializeOpDeleteHostedZone) ID() string {
2825 return "OperationDeserializer"
2826 }
2827
2828 func (m *awsRestxml_deserializeOpDeleteHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2829 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2830 ) {
2831 out, metadata, err = next.HandleDeserialize(ctx, in)
2832 if err != nil {
2833 return out, metadata, err
2834 }
2835
2836 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2837 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2838 defer endTimer()
2839 defer span.End()
2840 response, ok := out.RawResponse.(*smithyhttp.Response)
2841 if !ok {
2842 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2843 }
2844
2845 if response.StatusCode < 200 || response.StatusCode >= 300 {
2846 return out, metadata, awsRestxml_deserializeOpErrorDeleteHostedZone(response, &metadata)
2847 }
2848 output := &DeleteHostedZoneOutput{}
2849 out.Result = output
2850
2851 var buff [1024]byte
2852 ringBuffer := smithyio.NewRingBuffer(buff[:])
2853 body := io.TeeReader(response.Body, ringBuffer)
2854 rootDecoder := xml.NewDecoder(body)
2855 t, err := smithyxml.FetchRootElement(rootDecoder)
2856 if err == io.EOF {
2857 return out, metadata, nil
2858 }
2859 if err != nil {
2860 var snapshot bytes.Buffer
2861 io.Copy(&snapshot, ringBuffer)
2862 return out, metadata, &smithy.DeserializationError{
2863 Err: fmt.Errorf("failed to decode response body, %w", err),
2864 Snapshot: snapshot.Bytes(),
2865 }
2866 }
2867
2868 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2869 err = awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(&output, decoder)
2870 if err != nil {
2871 var snapshot bytes.Buffer
2872 io.Copy(&snapshot, ringBuffer)
2873 return out, metadata, &smithy.DeserializationError{
2874 Err: fmt.Errorf("failed to decode response body, %w", err),
2875 Snapshot: snapshot.Bytes(),
2876 }
2877 }
2878
2879 span.End()
2880 return out, metadata, err
2881 }
2882
2883 func awsRestxml_deserializeOpErrorDeleteHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2884 var errorBuffer bytes.Buffer
2885 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2886 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2887 }
2888 errorBody := bytes.NewReader(errorBuffer.Bytes())
2889
2890 errorCode := "UnknownError"
2891 errorMessage := errorCode
2892
2893 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2894 if err != nil {
2895 return err
2896 }
2897 if reqID := errorComponents.RequestID; len(reqID) != 0 {
2898 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2899 }
2900 if len(errorComponents.Code) != 0 {
2901 errorCode = errorComponents.Code
2902 }
2903 if len(errorComponents.Message) != 0 {
2904 errorMessage = errorComponents.Message
2905 }
2906 errorBody.Seek(0, io.SeekStart)
2907 switch {
2908 case strings.EqualFold("HostedZoneNotEmpty", errorCode):
2909 return awsRestxml_deserializeErrorHostedZoneNotEmpty(response, errorBody)
2910
2911 case strings.EqualFold("InvalidDomainName", errorCode):
2912 return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
2913
2914 case strings.EqualFold("InvalidInput", errorCode):
2915 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
2916
2917 case strings.EqualFold("NoSuchHostedZone", errorCode):
2918 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
2919
2920 case strings.EqualFold("PriorRequestNotComplete", errorCode):
2921 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
2922
2923 default:
2924 genericError := &smithy.GenericAPIError{
2925 Code: errorCode,
2926 Message: errorMessage,
2927 }
2928 return genericError
2929
2930 }
2931 }
2932
2933 func awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(v **DeleteHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
2934 if v == nil {
2935 return fmt.Errorf("unexpected nil of type %T", v)
2936 }
2937 var sv *DeleteHostedZoneOutput
2938 if *v == nil {
2939 sv = &DeleteHostedZoneOutput{}
2940 } else {
2941 sv = *v
2942 }
2943
2944 for {
2945 t, done, err := decoder.Token()
2946 if err != nil {
2947 return err
2948 }
2949 if done {
2950 break
2951 }
2952 originalDecoder := decoder
2953 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2954 switch {
2955 case strings.EqualFold("ChangeInfo", t.Name.Local):
2956 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2957 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
2958 return err
2959 }
2960
2961 default:
2962 // Do nothing and ignore the unexpected tag element
2963 err = decoder.Decoder.Skip()
2964 if err != nil {
2965 return err
2966 }
2967
2968 }
2969 decoder = originalDecoder
2970 }
2971 *v = sv
2972 return nil
2973 }
2974
2975 type awsRestxml_deserializeOpDeleteKeySigningKey struct {
2976 }
2977
2978 func (*awsRestxml_deserializeOpDeleteKeySigningKey) ID() string {
2979 return "OperationDeserializer"
2980 }
2981
2982 func (m *awsRestxml_deserializeOpDeleteKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2983 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2984 ) {
2985 out, metadata, err = next.HandleDeserialize(ctx, in)
2986 if err != nil {
2987 return out, metadata, err
2988 }
2989
2990 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2991 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2992 defer endTimer()
2993 defer span.End()
2994 response, ok := out.RawResponse.(*smithyhttp.Response)
2995 if !ok {
2996 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2997 }
2998
2999 if response.StatusCode < 200 || response.StatusCode >= 300 {
3000 return out, metadata, awsRestxml_deserializeOpErrorDeleteKeySigningKey(response, &metadata)
3001 }
3002 output := &DeleteKeySigningKeyOutput{}
3003 out.Result = output
3004
3005 var buff [1024]byte
3006 ringBuffer := smithyio.NewRingBuffer(buff[:])
3007 body := io.TeeReader(response.Body, ringBuffer)
3008 rootDecoder := xml.NewDecoder(body)
3009 t, err := smithyxml.FetchRootElement(rootDecoder)
3010 if err == io.EOF {
3011 return out, metadata, nil
3012 }
3013 if err != nil {
3014 var snapshot bytes.Buffer
3015 io.Copy(&snapshot, ringBuffer)
3016 return out, metadata, &smithy.DeserializationError{
3017 Err: fmt.Errorf("failed to decode response body, %w", err),
3018 Snapshot: snapshot.Bytes(),
3019 }
3020 }
3021
3022 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3023 err = awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(&output, decoder)
3024 if err != nil {
3025 var snapshot bytes.Buffer
3026 io.Copy(&snapshot, ringBuffer)
3027 return out, metadata, &smithy.DeserializationError{
3028 Err: fmt.Errorf("failed to decode response body, %w", err),
3029 Snapshot: snapshot.Bytes(),
3030 }
3031 }
3032
3033 span.End()
3034 return out, metadata, err
3035 }
3036
3037 func awsRestxml_deserializeOpErrorDeleteKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3038 var errorBuffer bytes.Buffer
3039 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3040 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3041 }
3042 errorBody := bytes.NewReader(errorBuffer.Bytes())
3043
3044 errorCode := "UnknownError"
3045 errorMessage := errorCode
3046
3047 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3048 if err != nil {
3049 return err
3050 }
3051 if reqID := errorComponents.RequestID; len(reqID) != 0 {
3052 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3053 }
3054 if len(errorComponents.Code) != 0 {
3055 errorCode = errorComponents.Code
3056 }
3057 if len(errorComponents.Message) != 0 {
3058 errorMessage = errorComponents.Message
3059 }
3060 errorBody.Seek(0, io.SeekStart)
3061 switch {
3062 case strings.EqualFold("ConcurrentModification", errorCode):
3063 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
3064
3065 case strings.EqualFold("InvalidInput", errorCode):
3066 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
3067
3068 case strings.EqualFold("InvalidKMSArn", errorCode):
3069 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
3070
3071 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
3072 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
3073
3074 case strings.EqualFold("InvalidSigningStatus", errorCode):
3075 return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
3076
3077 case strings.EqualFold("NoSuchKeySigningKey", errorCode):
3078 return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
3079
3080 default:
3081 genericError := &smithy.GenericAPIError{
3082 Code: errorCode,
3083 Message: errorMessage,
3084 }
3085 return genericError
3086
3087 }
3088 }
3089
3090 func awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(v **DeleteKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
3091 if v == nil {
3092 return fmt.Errorf("unexpected nil of type %T", v)
3093 }
3094 var sv *DeleteKeySigningKeyOutput
3095 if *v == nil {
3096 sv = &DeleteKeySigningKeyOutput{}
3097 } else {
3098 sv = *v
3099 }
3100
3101 for {
3102 t, done, err := decoder.Token()
3103 if err != nil {
3104 return err
3105 }
3106 if done {
3107 break
3108 }
3109 originalDecoder := decoder
3110 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3111 switch {
3112 case strings.EqualFold("ChangeInfo", t.Name.Local):
3113 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3114 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
3115 return err
3116 }
3117
3118 default:
3119 // Do nothing and ignore the unexpected tag element
3120 err = decoder.Decoder.Skip()
3121 if err != nil {
3122 return err
3123 }
3124
3125 }
3126 decoder = originalDecoder
3127 }
3128 *v = sv
3129 return nil
3130 }
3131
3132 type awsRestxml_deserializeOpDeleteQueryLoggingConfig struct {
3133 }
3134
3135 func (*awsRestxml_deserializeOpDeleteQueryLoggingConfig) ID() string {
3136 return "OperationDeserializer"
3137 }
3138
3139 func (m *awsRestxml_deserializeOpDeleteQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3140 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3141 ) {
3142 out, metadata, err = next.HandleDeserialize(ctx, in)
3143 if err != nil {
3144 return out, metadata, err
3145 }
3146
3147 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3148 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3149 defer endTimer()
3150 defer span.End()
3151 response, ok := out.RawResponse.(*smithyhttp.Response)
3152 if !ok {
3153 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3154 }
3155
3156 if response.StatusCode < 200 || response.StatusCode >= 300 {
3157 return out, metadata, awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response, &metadata)
3158 }
3159 output := &DeleteQueryLoggingConfigOutput{}
3160 out.Result = output
3161
3162 span.End()
3163 return out, metadata, err
3164 }
3165
3166 func awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3167 var errorBuffer bytes.Buffer
3168 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3169 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3170 }
3171 errorBody := bytes.NewReader(errorBuffer.Bytes())
3172
3173 errorCode := "UnknownError"
3174 errorMessage := errorCode
3175
3176 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3177 if err != nil {
3178 return err
3179 }
3180 if reqID := errorComponents.RequestID; len(reqID) != 0 {
3181 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3182 }
3183 if len(errorComponents.Code) != 0 {
3184 errorCode = errorComponents.Code
3185 }
3186 if len(errorComponents.Message) != 0 {
3187 errorMessage = errorComponents.Message
3188 }
3189 errorBody.Seek(0, io.SeekStart)
3190 switch {
3191 case strings.EqualFold("ConcurrentModification", errorCode):
3192 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
3193
3194 case strings.EqualFold("InvalidInput", errorCode):
3195 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
3196
3197 case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode):
3198 return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody)
3199
3200 default:
3201 genericError := &smithy.GenericAPIError{
3202 Code: errorCode,
3203 Message: errorMessage,
3204 }
3205 return genericError
3206
3207 }
3208 }
3209
3210 type awsRestxml_deserializeOpDeleteReusableDelegationSet struct {
3211 }
3212
3213 func (*awsRestxml_deserializeOpDeleteReusableDelegationSet) ID() string {
3214 return "OperationDeserializer"
3215 }
3216
3217 func (m *awsRestxml_deserializeOpDeleteReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3218 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3219 ) {
3220 out, metadata, err = next.HandleDeserialize(ctx, in)
3221 if err != nil {
3222 return out, metadata, err
3223 }
3224
3225 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3226 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3227 defer endTimer()
3228 defer span.End()
3229 response, ok := out.RawResponse.(*smithyhttp.Response)
3230 if !ok {
3231 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3232 }
3233
3234 if response.StatusCode < 200 || response.StatusCode >= 300 {
3235 return out, metadata, awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response, &metadata)
3236 }
3237 output := &DeleteReusableDelegationSetOutput{}
3238 out.Result = output
3239
3240 span.End()
3241 return out, metadata, err
3242 }
3243
3244 func awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3245 var errorBuffer bytes.Buffer
3246 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3247 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3248 }
3249 errorBody := bytes.NewReader(errorBuffer.Bytes())
3250
3251 errorCode := "UnknownError"
3252 errorMessage := errorCode
3253
3254 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3255 if err != nil {
3256 return err
3257 }
3258 if reqID := errorComponents.RequestID; len(reqID) != 0 {
3259 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3260 }
3261 if len(errorComponents.Code) != 0 {
3262 errorCode = errorComponents.Code
3263 }
3264 if len(errorComponents.Message) != 0 {
3265 errorMessage = errorComponents.Message
3266 }
3267 errorBody.Seek(0, io.SeekStart)
3268 switch {
3269 case strings.EqualFold("DelegationSetInUse", errorCode):
3270 return awsRestxml_deserializeErrorDelegationSetInUse(response, errorBody)
3271
3272 case strings.EqualFold("DelegationSetNotReusable", errorCode):
3273 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
3274
3275 case strings.EqualFold("InvalidInput", errorCode):
3276 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
3277
3278 case strings.EqualFold("NoSuchDelegationSet", errorCode):
3279 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
3280
3281 default:
3282 genericError := &smithy.GenericAPIError{
3283 Code: errorCode,
3284 Message: errorMessage,
3285 }
3286 return genericError
3287
3288 }
3289 }
3290
3291 type awsRestxml_deserializeOpDeleteTrafficPolicy struct {
3292 }
3293
3294 func (*awsRestxml_deserializeOpDeleteTrafficPolicy) ID() string {
3295 return "OperationDeserializer"
3296 }
3297
3298 func (m *awsRestxml_deserializeOpDeleteTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3299 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3300 ) {
3301 out, metadata, err = next.HandleDeserialize(ctx, in)
3302 if err != nil {
3303 return out, metadata, err
3304 }
3305
3306 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3307 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3308 defer endTimer()
3309 defer span.End()
3310 response, ok := out.RawResponse.(*smithyhttp.Response)
3311 if !ok {
3312 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3313 }
3314
3315 if response.StatusCode < 200 || response.StatusCode >= 300 {
3316 return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response, &metadata)
3317 }
3318 output := &DeleteTrafficPolicyOutput{}
3319 out.Result = output
3320
3321 span.End()
3322 return out, metadata, err
3323 }
3324
3325 func awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3326 var errorBuffer bytes.Buffer
3327 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3328 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3329 }
3330 errorBody := bytes.NewReader(errorBuffer.Bytes())
3331
3332 errorCode := "UnknownError"
3333 errorMessage := errorCode
3334
3335 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3336 if err != nil {
3337 return err
3338 }
3339 if reqID := errorComponents.RequestID; len(reqID) != 0 {
3340 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3341 }
3342 if len(errorComponents.Code) != 0 {
3343 errorCode = errorComponents.Code
3344 }
3345 if len(errorComponents.Message) != 0 {
3346 errorMessage = errorComponents.Message
3347 }
3348 errorBody.Seek(0, io.SeekStart)
3349 switch {
3350 case strings.EqualFold("ConcurrentModification", errorCode):
3351 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
3352
3353 case strings.EqualFold("InvalidInput", errorCode):
3354 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
3355
3356 case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
3357 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
3358
3359 case strings.EqualFold("TrafficPolicyInUse", errorCode):
3360 return awsRestxml_deserializeErrorTrafficPolicyInUse(response, errorBody)
3361
3362 default:
3363 genericError := &smithy.GenericAPIError{
3364 Code: errorCode,
3365 Message: errorMessage,
3366 }
3367 return genericError
3368
3369 }
3370 }
3371
3372 type awsRestxml_deserializeOpDeleteTrafficPolicyInstance struct {
3373 }
3374
3375 func (*awsRestxml_deserializeOpDeleteTrafficPolicyInstance) ID() string {
3376 return "OperationDeserializer"
3377 }
3378
3379 func (m *awsRestxml_deserializeOpDeleteTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3380 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3381 ) {
3382 out, metadata, err = next.HandleDeserialize(ctx, in)
3383 if err != nil {
3384 return out, metadata, err
3385 }
3386
3387 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3388 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3389 defer endTimer()
3390 defer span.End()
3391 response, ok := out.RawResponse.(*smithyhttp.Response)
3392 if !ok {
3393 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3394 }
3395
3396 if response.StatusCode < 200 || response.StatusCode >= 300 {
3397 return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response, &metadata)
3398 }
3399 output := &DeleteTrafficPolicyInstanceOutput{}
3400 out.Result = output
3401
3402 span.End()
3403 return out, metadata, err
3404 }
3405
3406 func awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3407 var errorBuffer bytes.Buffer
3408 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3409 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3410 }
3411 errorBody := bytes.NewReader(errorBuffer.Bytes())
3412
3413 errorCode := "UnknownError"
3414 errorMessage := errorCode
3415
3416 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3417 if err != nil {
3418 return err
3419 }
3420 if reqID := errorComponents.RequestID; len(reqID) != 0 {
3421 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3422 }
3423 if len(errorComponents.Code) != 0 {
3424 errorCode = errorComponents.Code
3425 }
3426 if len(errorComponents.Message) != 0 {
3427 errorMessage = errorComponents.Message
3428 }
3429 errorBody.Seek(0, io.SeekStart)
3430 switch {
3431 case strings.EqualFold("InvalidInput", errorCode):
3432 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
3433
3434 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
3435 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
3436
3437 case strings.EqualFold("PriorRequestNotComplete", errorCode):
3438 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
3439
3440 default:
3441 genericError := &smithy.GenericAPIError{
3442 Code: errorCode,
3443 Message: errorMessage,
3444 }
3445 return genericError
3446
3447 }
3448 }
3449
3450 type awsRestxml_deserializeOpDeleteVPCAssociationAuthorization struct {
3451 }
3452
3453 func (*awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) ID() string {
3454 return "OperationDeserializer"
3455 }
3456
3457 func (m *awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3458 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3459 ) {
3460 out, metadata, err = next.HandleDeserialize(ctx, in)
3461 if err != nil {
3462 return out, metadata, err
3463 }
3464
3465 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3466 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3467 defer endTimer()
3468 defer span.End()
3469 response, ok := out.RawResponse.(*smithyhttp.Response)
3470 if !ok {
3471 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3472 }
3473
3474 if response.StatusCode < 200 || response.StatusCode >= 300 {
3475 return out, metadata, awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response, &metadata)
3476 }
3477 output := &DeleteVPCAssociationAuthorizationOutput{}
3478 out.Result = output
3479
3480 span.End()
3481 return out, metadata, err
3482 }
3483
3484 func awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3485 var errorBuffer bytes.Buffer
3486 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3487 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3488 }
3489 errorBody := bytes.NewReader(errorBuffer.Bytes())
3490
3491 errorCode := "UnknownError"
3492 errorMessage := errorCode
3493
3494 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3495 if err != nil {
3496 return err
3497 }
3498 if reqID := errorComponents.RequestID; len(reqID) != 0 {
3499 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3500 }
3501 if len(errorComponents.Code) != 0 {
3502 errorCode = errorComponents.Code
3503 }
3504 if len(errorComponents.Message) != 0 {
3505 errorMessage = errorComponents.Message
3506 }
3507 errorBody.Seek(0, io.SeekStart)
3508 switch {
3509 case strings.EqualFold("ConcurrentModification", errorCode):
3510 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
3511
3512 case strings.EqualFold("InvalidInput", errorCode):
3513 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
3514
3515 case strings.EqualFold("InvalidVPCId", errorCode):
3516 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
3517
3518 case strings.EqualFold("NoSuchHostedZone", errorCode):
3519 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
3520
3521 case strings.EqualFold("VPCAssociationAuthorizationNotFound", errorCode):
3522 return awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response, errorBody)
3523
3524 default:
3525 genericError := &smithy.GenericAPIError{
3526 Code: errorCode,
3527 Message: errorMessage,
3528 }
3529 return genericError
3530
3531 }
3532 }
3533
3534 type awsRestxml_deserializeOpDisableHostedZoneDNSSEC struct {
3535 }
3536
3537 func (*awsRestxml_deserializeOpDisableHostedZoneDNSSEC) ID() string {
3538 return "OperationDeserializer"
3539 }
3540
3541 func (m *awsRestxml_deserializeOpDisableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3542 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3543 ) {
3544 out, metadata, err = next.HandleDeserialize(ctx, in)
3545 if err != nil {
3546 return out, metadata, err
3547 }
3548
3549 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3550 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3551 defer endTimer()
3552 defer span.End()
3553 response, ok := out.RawResponse.(*smithyhttp.Response)
3554 if !ok {
3555 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3556 }
3557
3558 if response.StatusCode < 200 || response.StatusCode >= 300 {
3559 return out, metadata, awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response, &metadata)
3560 }
3561 output := &DisableHostedZoneDNSSECOutput{}
3562 out.Result = output
3563
3564 var buff [1024]byte
3565 ringBuffer := smithyio.NewRingBuffer(buff[:])
3566 body := io.TeeReader(response.Body, ringBuffer)
3567 rootDecoder := xml.NewDecoder(body)
3568 t, err := smithyxml.FetchRootElement(rootDecoder)
3569 if err == io.EOF {
3570 return out, metadata, nil
3571 }
3572 if err != nil {
3573 var snapshot bytes.Buffer
3574 io.Copy(&snapshot, ringBuffer)
3575 return out, metadata, &smithy.DeserializationError{
3576 Err: fmt.Errorf("failed to decode response body, %w", err),
3577 Snapshot: snapshot.Bytes(),
3578 }
3579 }
3580
3581 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3582 err = awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(&output, decoder)
3583 if err != nil {
3584 var snapshot bytes.Buffer
3585 io.Copy(&snapshot, ringBuffer)
3586 return out, metadata, &smithy.DeserializationError{
3587 Err: fmt.Errorf("failed to decode response body, %w", err),
3588 Snapshot: snapshot.Bytes(),
3589 }
3590 }
3591
3592 span.End()
3593 return out, metadata, err
3594 }
3595
3596 func awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3597 var errorBuffer bytes.Buffer
3598 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3599 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3600 }
3601 errorBody := bytes.NewReader(errorBuffer.Bytes())
3602
3603 errorCode := "UnknownError"
3604 errorMessage := errorCode
3605
3606 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3607 if err != nil {
3608 return err
3609 }
3610 if reqID := errorComponents.RequestID; len(reqID) != 0 {
3611 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3612 }
3613 if len(errorComponents.Code) != 0 {
3614 errorCode = errorComponents.Code
3615 }
3616 if len(errorComponents.Message) != 0 {
3617 errorMessage = errorComponents.Message
3618 }
3619 errorBody.Seek(0, io.SeekStart)
3620 switch {
3621 case strings.EqualFold("ConcurrentModification", errorCode):
3622 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
3623
3624 case strings.EqualFold("DNSSECNotFound", errorCode):
3625 return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody)
3626
3627 case strings.EqualFold("InvalidArgument", errorCode):
3628 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
3629
3630 case strings.EqualFold("InvalidInput", errorCode):
3631 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
3632
3633 case strings.EqualFold("InvalidKMSArn", errorCode):
3634 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
3635
3636 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
3637 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
3638
3639 case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode):
3640 return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody)
3641
3642 case strings.EqualFold("NoSuchHostedZone", errorCode):
3643 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
3644
3645 default:
3646 genericError := &smithy.GenericAPIError{
3647 Code: errorCode,
3648 Message: errorMessage,
3649 }
3650 return genericError
3651
3652 }
3653 }
3654
3655 func awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(v **DisableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error {
3656 if v == nil {
3657 return fmt.Errorf("unexpected nil of type %T", v)
3658 }
3659 var sv *DisableHostedZoneDNSSECOutput
3660 if *v == nil {
3661 sv = &DisableHostedZoneDNSSECOutput{}
3662 } else {
3663 sv = *v
3664 }
3665
3666 for {
3667 t, done, err := decoder.Token()
3668 if err != nil {
3669 return err
3670 }
3671 if done {
3672 break
3673 }
3674 originalDecoder := decoder
3675 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3676 switch {
3677 case strings.EqualFold("ChangeInfo", t.Name.Local):
3678 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3679 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
3680 return err
3681 }
3682
3683 default:
3684 // Do nothing and ignore the unexpected tag element
3685 err = decoder.Decoder.Skip()
3686 if err != nil {
3687 return err
3688 }
3689
3690 }
3691 decoder = originalDecoder
3692 }
3693 *v = sv
3694 return nil
3695 }
3696
3697 type awsRestxml_deserializeOpDisassociateVPCFromHostedZone struct {
3698 }
3699
3700 func (*awsRestxml_deserializeOpDisassociateVPCFromHostedZone) ID() string {
3701 return "OperationDeserializer"
3702 }
3703
3704 func (m *awsRestxml_deserializeOpDisassociateVPCFromHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3705 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3706 ) {
3707 out, metadata, err = next.HandleDeserialize(ctx, in)
3708 if err != nil {
3709 return out, metadata, err
3710 }
3711
3712 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3713 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3714 defer endTimer()
3715 defer span.End()
3716 response, ok := out.RawResponse.(*smithyhttp.Response)
3717 if !ok {
3718 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3719 }
3720
3721 if response.StatusCode < 200 || response.StatusCode >= 300 {
3722 return out, metadata, awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response, &metadata)
3723 }
3724 output := &DisassociateVPCFromHostedZoneOutput{}
3725 out.Result = output
3726
3727 var buff [1024]byte
3728 ringBuffer := smithyio.NewRingBuffer(buff[:])
3729 body := io.TeeReader(response.Body, ringBuffer)
3730 rootDecoder := xml.NewDecoder(body)
3731 t, err := smithyxml.FetchRootElement(rootDecoder)
3732 if err == io.EOF {
3733 return out, metadata, nil
3734 }
3735 if err != nil {
3736 var snapshot bytes.Buffer
3737 io.Copy(&snapshot, ringBuffer)
3738 return out, metadata, &smithy.DeserializationError{
3739 Err: fmt.Errorf("failed to decode response body, %w", err),
3740 Snapshot: snapshot.Bytes(),
3741 }
3742 }
3743
3744 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3745 err = awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(&output, decoder)
3746 if err != nil {
3747 var snapshot bytes.Buffer
3748 io.Copy(&snapshot, ringBuffer)
3749 return out, metadata, &smithy.DeserializationError{
3750 Err: fmt.Errorf("failed to decode response body, %w", err),
3751 Snapshot: snapshot.Bytes(),
3752 }
3753 }
3754
3755 span.End()
3756 return out, metadata, err
3757 }
3758
3759 func awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3760 var errorBuffer bytes.Buffer
3761 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3762 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3763 }
3764 errorBody := bytes.NewReader(errorBuffer.Bytes())
3765
3766 errorCode := "UnknownError"
3767 errorMessage := errorCode
3768
3769 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3770 if err != nil {
3771 return err
3772 }
3773 if reqID := errorComponents.RequestID; len(reqID) != 0 {
3774 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3775 }
3776 if len(errorComponents.Code) != 0 {
3777 errorCode = errorComponents.Code
3778 }
3779 if len(errorComponents.Message) != 0 {
3780 errorMessage = errorComponents.Message
3781 }
3782 errorBody.Seek(0, io.SeekStart)
3783 switch {
3784 case strings.EqualFold("InvalidInput", errorCode):
3785 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
3786
3787 case strings.EqualFold("InvalidVPCId", errorCode):
3788 return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
3789
3790 case strings.EqualFold("LastVPCAssociation", errorCode):
3791 return awsRestxml_deserializeErrorLastVPCAssociation(response, errorBody)
3792
3793 case strings.EqualFold("NoSuchHostedZone", errorCode):
3794 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
3795
3796 case strings.EqualFold("VPCAssociationNotFound", errorCode):
3797 return awsRestxml_deserializeErrorVPCAssociationNotFound(response, errorBody)
3798
3799 default:
3800 genericError := &smithy.GenericAPIError{
3801 Code: errorCode,
3802 Message: errorMessage,
3803 }
3804 return genericError
3805
3806 }
3807 }
3808
3809 func awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(v **DisassociateVPCFromHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
3810 if v == nil {
3811 return fmt.Errorf("unexpected nil of type %T", v)
3812 }
3813 var sv *DisassociateVPCFromHostedZoneOutput
3814 if *v == nil {
3815 sv = &DisassociateVPCFromHostedZoneOutput{}
3816 } else {
3817 sv = *v
3818 }
3819
3820 for {
3821 t, done, err := decoder.Token()
3822 if err != nil {
3823 return err
3824 }
3825 if done {
3826 break
3827 }
3828 originalDecoder := decoder
3829 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3830 switch {
3831 case strings.EqualFold("ChangeInfo", t.Name.Local):
3832 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3833 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
3834 return err
3835 }
3836
3837 default:
3838 // Do nothing and ignore the unexpected tag element
3839 err = decoder.Decoder.Skip()
3840 if err != nil {
3841 return err
3842 }
3843
3844 }
3845 decoder = originalDecoder
3846 }
3847 *v = sv
3848 return nil
3849 }
3850
3851 type awsRestxml_deserializeOpEnableHostedZoneDNSSEC struct {
3852 }
3853
3854 func (*awsRestxml_deserializeOpEnableHostedZoneDNSSEC) ID() string {
3855 return "OperationDeserializer"
3856 }
3857
3858 func (m *awsRestxml_deserializeOpEnableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3859 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3860 ) {
3861 out, metadata, err = next.HandleDeserialize(ctx, in)
3862 if err != nil {
3863 return out, metadata, err
3864 }
3865
3866 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3867 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3868 defer endTimer()
3869 defer span.End()
3870 response, ok := out.RawResponse.(*smithyhttp.Response)
3871 if !ok {
3872 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3873 }
3874
3875 if response.StatusCode < 200 || response.StatusCode >= 300 {
3876 return out, metadata, awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response, &metadata)
3877 }
3878 output := &EnableHostedZoneDNSSECOutput{}
3879 out.Result = output
3880
3881 var buff [1024]byte
3882 ringBuffer := smithyio.NewRingBuffer(buff[:])
3883 body := io.TeeReader(response.Body, ringBuffer)
3884 rootDecoder := xml.NewDecoder(body)
3885 t, err := smithyxml.FetchRootElement(rootDecoder)
3886 if err == io.EOF {
3887 return out, metadata, nil
3888 }
3889 if err != nil {
3890 var snapshot bytes.Buffer
3891 io.Copy(&snapshot, ringBuffer)
3892 return out, metadata, &smithy.DeserializationError{
3893 Err: fmt.Errorf("failed to decode response body, %w", err),
3894 Snapshot: snapshot.Bytes(),
3895 }
3896 }
3897
3898 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3899 err = awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(&output, decoder)
3900 if err != nil {
3901 var snapshot bytes.Buffer
3902 io.Copy(&snapshot, ringBuffer)
3903 return out, metadata, &smithy.DeserializationError{
3904 Err: fmt.Errorf("failed to decode response body, %w", err),
3905 Snapshot: snapshot.Bytes(),
3906 }
3907 }
3908
3909 span.End()
3910 return out, metadata, err
3911 }
3912
3913 func awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3914 var errorBuffer bytes.Buffer
3915 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3916 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3917 }
3918 errorBody := bytes.NewReader(errorBuffer.Bytes())
3919
3920 errorCode := "UnknownError"
3921 errorMessage := errorCode
3922
3923 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3924 if err != nil {
3925 return err
3926 }
3927 if reqID := errorComponents.RequestID; len(reqID) != 0 {
3928 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3929 }
3930 if len(errorComponents.Code) != 0 {
3931 errorCode = errorComponents.Code
3932 }
3933 if len(errorComponents.Message) != 0 {
3934 errorMessage = errorComponents.Message
3935 }
3936 errorBody.Seek(0, io.SeekStart)
3937 switch {
3938 case strings.EqualFold("ConcurrentModification", errorCode):
3939 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
3940
3941 case strings.EqualFold("DNSSECNotFound", errorCode):
3942 return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody)
3943
3944 case strings.EqualFold("HostedZonePartiallyDelegated", errorCode):
3945 return awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response, errorBody)
3946
3947 case strings.EqualFold("InvalidArgument", errorCode):
3948 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
3949
3950 case strings.EqualFold("InvalidInput", errorCode):
3951 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
3952
3953 case strings.EqualFold("InvalidKMSArn", errorCode):
3954 return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
3955
3956 case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
3957 return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
3958
3959 case strings.EqualFold("KeySigningKeyWithActiveStatusNotFound", errorCode):
3960 return awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response, errorBody)
3961
3962 case strings.EqualFold("NoSuchHostedZone", errorCode):
3963 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
3964
3965 default:
3966 genericError := &smithy.GenericAPIError{
3967 Code: errorCode,
3968 Message: errorMessage,
3969 }
3970 return genericError
3971
3972 }
3973 }
3974
3975 func awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(v **EnableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error {
3976 if v == nil {
3977 return fmt.Errorf("unexpected nil of type %T", v)
3978 }
3979 var sv *EnableHostedZoneDNSSECOutput
3980 if *v == nil {
3981 sv = &EnableHostedZoneDNSSECOutput{}
3982 } else {
3983 sv = *v
3984 }
3985
3986 for {
3987 t, done, err := decoder.Token()
3988 if err != nil {
3989 return err
3990 }
3991 if done {
3992 break
3993 }
3994 originalDecoder := decoder
3995 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3996 switch {
3997 case strings.EqualFold("ChangeInfo", t.Name.Local):
3998 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3999 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
4000 return err
4001 }
4002
4003 default:
4004 // Do nothing and ignore the unexpected tag element
4005 err = decoder.Decoder.Skip()
4006 if err != nil {
4007 return err
4008 }
4009
4010 }
4011 decoder = originalDecoder
4012 }
4013 *v = sv
4014 return nil
4015 }
4016
4017 type awsRestxml_deserializeOpGetAccountLimit struct {
4018 }
4019
4020 func (*awsRestxml_deserializeOpGetAccountLimit) ID() string {
4021 return "OperationDeserializer"
4022 }
4023
4024 func (m *awsRestxml_deserializeOpGetAccountLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4025 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4026 ) {
4027 out, metadata, err = next.HandleDeserialize(ctx, in)
4028 if err != nil {
4029 return out, metadata, err
4030 }
4031
4032 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4033 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4034 defer endTimer()
4035 defer span.End()
4036 response, ok := out.RawResponse.(*smithyhttp.Response)
4037 if !ok {
4038 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4039 }
4040
4041 if response.StatusCode < 200 || response.StatusCode >= 300 {
4042 return out, metadata, awsRestxml_deserializeOpErrorGetAccountLimit(response, &metadata)
4043 }
4044 output := &GetAccountLimitOutput{}
4045 out.Result = output
4046
4047 var buff [1024]byte
4048 ringBuffer := smithyio.NewRingBuffer(buff[:])
4049 body := io.TeeReader(response.Body, ringBuffer)
4050 rootDecoder := xml.NewDecoder(body)
4051 t, err := smithyxml.FetchRootElement(rootDecoder)
4052 if err == io.EOF {
4053 return out, metadata, nil
4054 }
4055 if err != nil {
4056 var snapshot bytes.Buffer
4057 io.Copy(&snapshot, ringBuffer)
4058 return out, metadata, &smithy.DeserializationError{
4059 Err: fmt.Errorf("failed to decode response body, %w", err),
4060 Snapshot: snapshot.Bytes(),
4061 }
4062 }
4063
4064 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4065 err = awsRestxml_deserializeOpDocumentGetAccountLimitOutput(&output, decoder)
4066 if err != nil {
4067 var snapshot bytes.Buffer
4068 io.Copy(&snapshot, ringBuffer)
4069 return out, metadata, &smithy.DeserializationError{
4070 Err: fmt.Errorf("failed to decode response body, %w", err),
4071 Snapshot: snapshot.Bytes(),
4072 }
4073 }
4074
4075 span.End()
4076 return out, metadata, err
4077 }
4078
4079 func awsRestxml_deserializeOpErrorGetAccountLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4080 var errorBuffer bytes.Buffer
4081 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4082 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4083 }
4084 errorBody := bytes.NewReader(errorBuffer.Bytes())
4085
4086 errorCode := "UnknownError"
4087 errorMessage := errorCode
4088
4089 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4090 if err != nil {
4091 return err
4092 }
4093 if reqID := errorComponents.RequestID; len(reqID) != 0 {
4094 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4095 }
4096 if len(errorComponents.Code) != 0 {
4097 errorCode = errorComponents.Code
4098 }
4099 if len(errorComponents.Message) != 0 {
4100 errorMessage = errorComponents.Message
4101 }
4102 errorBody.Seek(0, io.SeekStart)
4103 switch {
4104 case strings.EqualFold("InvalidInput", errorCode):
4105 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
4106
4107 default:
4108 genericError := &smithy.GenericAPIError{
4109 Code: errorCode,
4110 Message: errorMessage,
4111 }
4112 return genericError
4113
4114 }
4115 }
4116
4117 func awsRestxml_deserializeOpDocumentGetAccountLimitOutput(v **GetAccountLimitOutput, decoder smithyxml.NodeDecoder) error {
4118 if v == nil {
4119 return fmt.Errorf("unexpected nil of type %T", v)
4120 }
4121 var sv *GetAccountLimitOutput
4122 if *v == nil {
4123 sv = &GetAccountLimitOutput{}
4124 } else {
4125 sv = *v
4126 }
4127
4128 for {
4129 t, done, err := decoder.Token()
4130 if err != nil {
4131 return err
4132 }
4133 if done {
4134 break
4135 }
4136 originalDecoder := decoder
4137 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
4138 switch {
4139 case strings.EqualFold("Count", t.Name.Local):
4140 val, err := decoder.Value()
4141 if err != nil {
4142 return err
4143 }
4144 if val == nil {
4145 break
4146 }
4147 {
4148 xtv := string(val)
4149 i64, err := strconv.ParseInt(xtv, 10, 64)
4150 if err != nil {
4151 return err
4152 }
4153 sv.Count = i64
4154 }
4155
4156 case strings.EqualFold("Limit", t.Name.Local):
4157 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4158 if err := awsRestxml_deserializeDocumentAccountLimit(&sv.Limit, nodeDecoder); err != nil {
4159 return err
4160 }
4161
4162 default:
4163 // Do nothing and ignore the unexpected tag element
4164 err = decoder.Decoder.Skip()
4165 if err != nil {
4166 return err
4167 }
4168
4169 }
4170 decoder = originalDecoder
4171 }
4172 *v = sv
4173 return nil
4174 }
4175
4176 type awsRestxml_deserializeOpGetChange struct {
4177 }
4178
4179 func (*awsRestxml_deserializeOpGetChange) ID() string {
4180 return "OperationDeserializer"
4181 }
4182
4183 func (m *awsRestxml_deserializeOpGetChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4184 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4185 ) {
4186 out, metadata, err = next.HandleDeserialize(ctx, in)
4187 if err != nil {
4188 return out, metadata, err
4189 }
4190
4191 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4192 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4193 defer endTimer()
4194 defer span.End()
4195 response, ok := out.RawResponse.(*smithyhttp.Response)
4196 if !ok {
4197 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4198 }
4199
4200 if response.StatusCode < 200 || response.StatusCode >= 300 {
4201 return out, metadata, awsRestxml_deserializeOpErrorGetChange(response, &metadata)
4202 }
4203 output := &GetChangeOutput{}
4204 out.Result = output
4205
4206 var buff [1024]byte
4207 ringBuffer := smithyio.NewRingBuffer(buff[:])
4208 body := io.TeeReader(response.Body, ringBuffer)
4209 rootDecoder := xml.NewDecoder(body)
4210 t, err := smithyxml.FetchRootElement(rootDecoder)
4211 if err == io.EOF {
4212 return out, metadata, nil
4213 }
4214 if err != nil {
4215 var snapshot bytes.Buffer
4216 io.Copy(&snapshot, ringBuffer)
4217 return out, metadata, &smithy.DeserializationError{
4218 Err: fmt.Errorf("failed to decode response body, %w", err),
4219 Snapshot: snapshot.Bytes(),
4220 }
4221 }
4222
4223 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4224 err = awsRestxml_deserializeOpDocumentGetChangeOutput(&output, decoder)
4225 if err != nil {
4226 var snapshot bytes.Buffer
4227 io.Copy(&snapshot, ringBuffer)
4228 return out, metadata, &smithy.DeserializationError{
4229 Err: fmt.Errorf("failed to decode response body, %w", err),
4230 Snapshot: snapshot.Bytes(),
4231 }
4232 }
4233
4234 span.End()
4235 return out, metadata, err
4236 }
4237
4238 func awsRestxml_deserializeOpErrorGetChange(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4239 var errorBuffer bytes.Buffer
4240 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4241 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4242 }
4243 errorBody := bytes.NewReader(errorBuffer.Bytes())
4244
4245 errorCode := "UnknownError"
4246 errorMessage := errorCode
4247
4248 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4249 if err != nil {
4250 return err
4251 }
4252 if reqID := errorComponents.RequestID; len(reqID) != 0 {
4253 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4254 }
4255 if len(errorComponents.Code) != 0 {
4256 errorCode = errorComponents.Code
4257 }
4258 if len(errorComponents.Message) != 0 {
4259 errorMessage = errorComponents.Message
4260 }
4261 errorBody.Seek(0, io.SeekStart)
4262 switch {
4263 case strings.EqualFold("InvalidInput", errorCode):
4264 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
4265
4266 case strings.EqualFold("NoSuchChange", errorCode):
4267 return awsRestxml_deserializeErrorNoSuchChange(response, errorBody)
4268
4269 default:
4270 genericError := &smithy.GenericAPIError{
4271 Code: errorCode,
4272 Message: errorMessage,
4273 }
4274 return genericError
4275
4276 }
4277 }
4278
4279 func awsRestxml_deserializeOpDocumentGetChangeOutput(v **GetChangeOutput, decoder smithyxml.NodeDecoder) error {
4280 if v == nil {
4281 return fmt.Errorf("unexpected nil of type %T", v)
4282 }
4283 var sv *GetChangeOutput
4284 if *v == nil {
4285 sv = &GetChangeOutput{}
4286 } else {
4287 sv = *v
4288 }
4289
4290 for {
4291 t, done, err := decoder.Token()
4292 if err != nil {
4293 return err
4294 }
4295 if done {
4296 break
4297 }
4298 originalDecoder := decoder
4299 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
4300 switch {
4301 case strings.EqualFold("ChangeInfo", t.Name.Local):
4302 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4303 if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
4304 return err
4305 }
4306
4307 default:
4308 // Do nothing and ignore the unexpected tag element
4309 err = decoder.Decoder.Skip()
4310 if err != nil {
4311 return err
4312 }
4313
4314 }
4315 decoder = originalDecoder
4316 }
4317 *v = sv
4318 return nil
4319 }
4320
4321 type awsRestxml_deserializeOpGetCheckerIpRanges struct {
4322 }
4323
4324 func (*awsRestxml_deserializeOpGetCheckerIpRanges) ID() string {
4325 return "OperationDeserializer"
4326 }
4327
4328 func (m *awsRestxml_deserializeOpGetCheckerIpRanges) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4329 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4330 ) {
4331 out, metadata, err = next.HandleDeserialize(ctx, in)
4332 if err != nil {
4333 return out, metadata, err
4334 }
4335
4336 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4337 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4338 defer endTimer()
4339 defer span.End()
4340 response, ok := out.RawResponse.(*smithyhttp.Response)
4341 if !ok {
4342 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4343 }
4344
4345 if response.StatusCode < 200 || response.StatusCode >= 300 {
4346 return out, metadata, awsRestxml_deserializeOpErrorGetCheckerIpRanges(response, &metadata)
4347 }
4348 output := &GetCheckerIpRangesOutput{}
4349 out.Result = output
4350
4351 var buff [1024]byte
4352 ringBuffer := smithyio.NewRingBuffer(buff[:])
4353 body := io.TeeReader(response.Body, ringBuffer)
4354 rootDecoder := xml.NewDecoder(body)
4355 t, err := smithyxml.FetchRootElement(rootDecoder)
4356 if err == io.EOF {
4357 return out, metadata, nil
4358 }
4359 if err != nil {
4360 var snapshot bytes.Buffer
4361 io.Copy(&snapshot, ringBuffer)
4362 return out, metadata, &smithy.DeserializationError{
4363 Err: fmt.Errorf("failed to decode response body, %w", err),
4364 Snapshot: snapshot.Bytes(),
4365 }
4366 }
4367
4368 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4369 err = awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(&output, decoder)
4370 if err != nil {
4371 var snapshot bytes.Buffer
4372 io.Copy(&snapshot, ringBuffer)
4373 return out, metadata, &smithy.DeserializationError{
4374 Err: fmt.Errorf("failed to decode response body, %w", err),
4375 Snapshot: snapshot.Bytes(),
4376 }
4377 }
4378
4379 span.End()
4380 return out, metadata, err
4381 }
4382
4383 func awsRestxml_deserializeOpErrorGetCheckerIpRanges(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4384 var errorBuffer bytes.Buffer
4385 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4386 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4387 }
4388 errorBody := bytes.NewReader(errorBuffer.Bytes())
4389
4390 errorCode := "UnknownError"
4391 errorMessage := errorCode
4392
4393 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4394 if err != nil {
4395 return err
4396 }
4397 if reqID := errorComponents.RequestID; len(reqID) != 0 {
4398 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4399 }
4400 if len(errorComponents.Code) != 0 {
4401 errorCode = errorComponents.Code
4402 }
4403 if len(errorComponents.Message) != 0 {
4404 errorMessage = errorComponents.Message
4405 }
4406 errorBody.Seek(0, io.SeekStart)
4407 switch {
4408 default:
4409 genericError := &smithy.GenericAPIError{
4410 Code: errorCode,
4411 Message: errorMessage,
4412 }
4413 return genericError
4414
4415 }
4416 }
4417
4418 func awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(v **GetCheckerIpRangesOutput, decoder smithyxml.NodeDecoder) error {
4419 if v == nil {
4420 return fmt.Errorf("unexpected nil of type %T", v)
4421 }
4422 var sv *GetCheckerIpRangesOutput
4423 if *v == nil {
4424 sv = &GetCheckerIpRangesOutput{}
4425 } else {
4426 sv = *v
4427 }
4428
4429 for {
4430 t, done, err := decoder.Token()
4431 if err != nil {
4432 return err
4433 }
4434 if done {
4435 break
4436 }
4437 originalDecoder := decoder
4438 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
4439 switch {
4440 case strings.EqualFold("CheckerIpRanges", t.Name.Local):
4441 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4442 if err := awsRestxml_deserializeDocumentCheckerIpRanges(&sv.CheckerIpRanges, nodeDecoder); err != nil {
4443 return err
4444 }
4445
4446 default:
4447 // Do nothing and ignore the unexpected tag element
4448 err = decoder.Decoder.Skip()
4449 if err != nil {
4450 return err
4451 }
4452
4453 }
4454 decoder = originalDecoder
4455 }
4456 *v = sv
4457 return nil
4458 }
4459
4460 type awsRestxml_deserializeOpGetDNSSEC struct {
4461 }
4462
4463 func (*awsRestxml_deserializeOpGetDNSSEC) ID() string {
4464 return "OperationDeserializer"
4465 }
4466
4467 func (m *awsRestxml_deserializeOpGetDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4468 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4469 ) {
4470 out, metadata, err = next.HandleDeserialize(ctx, in)
4471 if err != nil {
4472 return out, metadata, err
4473 }
4474
4475 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4476 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4477 defer endTimer()
4478 defer span.End()
4479 response, ok := out.RawResponse.(*smithyhttp.Response)
4480 if !ok {
4481 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4482 }
4483
4484 if response.StatusCode < 200 || response.StatusCode >= 300 {
4485 return out, metadata, awsRestxml_deserializeOpErrorGetDNSSEC(response, &metadata)
4486 }
4487 output := &GetDNSSECOutput{}
4488 out.Result = output
4489
4490 var buff [1024]byte
4491 ringBuffer := smithyio.NewRingBuffer(buff[:])
4492 body := io.TeeReader(response.Body, ringBuffer)
4493 rootDecoder := xml.NewDecoder(body)
4494 t, err := smithyxml.FetchRootElement(rootDecoder)
4495 if err == io.EOF {
4496 return out, metadata, nil
4497 }
4498 if err != nil {
4499 var snapshot bytes.Buffer
4500 io.Copy(&snapshot, ringBuffer)
4501 return out, metadata, &smithy.DeserializationError{
4502 Err: fmt.Errorf("failed to decode response body, %w", err),
4503 Snapshot: snapshot.Bytes(),
4504 }
4505 }
4506
4507 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4508 err = awsRestxml_deserializeOpDocumentGetDNSSECOutput(&output, decoder)
4509 if err != nil {
4510 var snapshot bytes.Buffer
4511 io.Copy(&snapshot, ringBuffer)
4512 return out, metadata, &smithy.DeserializationError{
4513 Err: fmt.Errorf("failed to decode response body, %w", err),
4514 Snapshot: snapshot.Bytes(),
4515 }
4516 }
4517
4518 span.End()
4519 return out, metadata, err
4520 }
4521
4522 func awsRestxml_deserializeOpErrorGetDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4523 var errorBuffer bytes.Buffer
4524 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4525 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4526 }
4527 errorBody := bytes.NewReader(errorBuffer.Bytes())
4528
4529 errorCode := "UnknownError"
4530 errorMessage := errorCode
4531
4532 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4533 if err != nil {
4534 return err
4535 }
4536 if reqID := errorComponents.RequestID; len(reqID) != 0 {
4537 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4538 }
4539 if len(errorComponents.Code) != 0 {
4540 errorCode = errorComponents.Code
4541 }
4542 if len(errorComponents.Message) != 0 {
4543 errorMessage = errorComponents.Message
4544 }
4545 errorBody.Seek(0, io.SeekStart)
4546 switch {
4547 case strings.EqualFold("InvalidArgument", errorCode):
4548 return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
4549
4550 case strings.EqualFold("InvalidInput", errorCode):
4551 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
4552
4553 case strings.EqualFold("NoSuchHostedZone", errorCode):
4554 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
4555
4556 default:
4557 genericError := &smithy.GenericAPIError{
4558 Code: errorCode,
4559 Message: errorMessage,
4560 }
4561 return genericError
4562
4563 }
4564 }
4565
4566 func awsRestxml_deserializeOpDocumentGetDNSSECOutput(v **GetDNSSECOutput, decoder smithyxml.NodeDecoder) error {
4567 if v == nil {
4568 return fmt.Errorf("unexpected nil of type %T", v)
4569 }
4570 var sv *GetDNSSECOutput
4571 if *v == nil {
4572 sv = &GetDNSSECOutput{}
4573 } else {
4574 sv = *v
4575 }
4576
4577 for {
4578 t, done, err := decoder.Token()
4579 if err != nil {
4580 return err
4581 }
4582 if done {
4583 break
4584 }
4585 originalDecoder := decoder
4586 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
4587 switch {
4588 case strings.EqualFold("KeySigningKeys", t.Name.Local):
4589 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4590 if err := awsRestxml_deserializeDocumentKeySigningKeys(&sv.KeySigningKeys, nodeDecoder); err != nil {
4591 return err
4592 }
4593
4594 case strings.EqualFold("Status", t.Name.Local):
4595 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4596 if err := awsRestxml_deserializeDocumentDNSSECStatus(&sv.Status, nodeDecoder); err != nil {
4597 return err
4598 }
4599
4600 default:
4601 // Do nothing and ignore the unexpected tag element
4602 err = decoder.Decoder.Skip()
4603 if err != nil {
4604 return err
4605 }
4606
4607 }
4608 decoder = originalDecoder
4609 }
4610 *v = sv
4611 return nil
4612 }
4613
4614 type awsRestxml_deserializeOpGetGeoLocation struct {
4615 }
4616
4617 func (*awsRestxml_deserializeOpGetGeoLocation) ID() string {
4618 return "OperationDeserializer"
4619 }
4620
4621 func (m *awsRestxml_deserializeOpGetGeoLocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4622 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4623 ) {
4624 out, metadata, err = next.HandleDeserialize(ctx, in)
4625 if err != nil {
4626 return out, metadata, err
4627 }
4628
4629 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4630 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4631 defer endTimer()
4632 defer span.End()
4633 response, ok := out.RawResponse.(*smithyhttp.Response)
4634 if !ok {
4635 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4636 }
4637
4638 if response.StatusCode < 200 || response.StatusCode >= 300 {
4639 return out, metadata, awsRestxml_deserializeOpErrorGetGeoLocation(response, &metadata)
4640 }
4641 output := &GetGeoLocationOutput{}
4642 out.Result = output
4643
4644 var buff [1024]byte
4645 ringBuffer := smithyio.NewRingBuffer(buff[:])
4646 body := io.TeeReader(response.Body, ringBuffer)
4647 rootDecoder := xml.NewDecoder(body)
4648 t, err := smithyxml.FetchRootElement(rootDecoder)
4649 if err == io.EOF {
4650 return out, metadata, nil
4651 }
4652 if err != nil {
4653 var snapshot bytes.Buffer
4654 io.Copy(&snapshot, ringBuffer)
4655 return out, metadata, &smithy.DeserializationError{
4656 Err: fmt.Errorf("failed to decode response body, %w", err),
4657 Snapshot: snapshot.Bytes(),
4658 }
4659 }
4660
4661 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4662 err = awsRestxml_deserializeOpDocumentGetGeoLocationOutput(&output, decoder)
4663 if err != nil {
4664 var snapshot bytes.Buffer
4665 io.Copy(&snapshot, ringBuffer)
4666 return out, metadata, &smithy.DeserializationError{
4667 Err: fmt.Errorf("failed to decode response body, %w", err),
4668 Snapshot: snapshot.Bytes(),
4669 }
4670 }
4671
4672 span.End()
4673 return out, metadata, err
4674 }
4675
4676 func awsRestxml_deserializeOpErrorGetGeoLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4677 var errorBuffer bytes.Buffer
4678 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4679 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4680 }
4681 errorBody := bytes.NewReader(errorBuffer.Bytes())
4682
4683 errorCode := "UnknownError"
4684 errorMessage := errorCode
4685
4686 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4687 if err != nil {
4688 return err
4689 }
4690 if reqID := errorComponents.RequestID; len(reqID) != 0 {
4691 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4692 }
4693 if len(errorComponents.Code) != 0 {
4694 errorCode = errorComponents.Code
4695 }
4696 if len(errorComponents.Message) != 0 {
4697 errorMessage = errorComponents.Message
4698 }
4699 errorBody.Seek(0, io.SeekStart)
4700 switch {
4701 case strings.EqualFold("InvalidInput", errorCode):
4702 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
4703
4704 case strings.EqualFold("NoSuchGeoLocation", errorCode):
4705 return awsRestxml_deserializeErrorNoSuchGeoLocation(response, errorBody)
4706
4707 default:
4708 genericError := &smithy.GenericAPIError{
4709 Code: errorCode,
4710 Message: errorMessage,
4711 }
4712 return genericError
4713
4714 }
4715 }
4716
4717 func awsRestxml_deserializeOpDocumentGetGeoLocationOutput(v **GetGeoLocationOutput, decoder smithyxml.NodeDecoder) error {
4718 if v == nil {
4719 return fmt.Errorf("unexpected nil of type %T", v)
4720 }
4721 var sv *GetGeoLocationOutput
4722 if *v == nil {
4723 sv = &GetGeoLocationOutput{}
4724 } else {
4725 sv = *v
4726 }
4727
4728 for {
4729 t, done, err := decoder.Token()
4730 if err != nil {
4731 return err
4732 }
4733 if done {
4734 break
4735 }
4736 originalDecoder := decoder
4737 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
4738 switch {
4739 case strings.EqualFold("GeoLocationDetails", t.Name.Local):
4740 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4741 if err := awsRestxml_deserializeDocumentGeoLocationDetails(&sv.GeoLocationDetails, nodeDecoder); err != nil {
4742 return err
4743 }
4744
4745 default:
4746 // Do nothing and ignore the unexpected tag element
4747 err = decoder.Decoder.Skip()
4748 if err != nil {
4749 return err
4750 }
4751
4752 }
4753 decoder = originalDecoder
4754 }
4755 *v = sv
4756 return nil
4757 }
4758
4759 type awsRestxml_deserializeOpGetHealthCheck struct {
4760 }
4761
4762 func (*awsRestxml_deserializeOpGetHealthCheck) ID() string {
4763 return "OperationDeserializer"
4764 }
4765
4766 func (m *awsRestxml_deserializeOpGetHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4767 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4768 ) {
4769 out, metadata, err = next.HandleDeserialize(ctx, in)
4770 if err != nil {
4771 return out, metadata, err
4772 }
4773
4774 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4775 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4776 defer endTimer()
4777 defer span.End()
4778 response, ok := out.RawResponse.(*smithyhttp.Response)
4779 if !ok {
4780 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4781 }
4782
4783 if response.StatusCode < 200 || response.StatusCode >= 300 {
4784 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheck(response, &metadata)
4785 }
4786 output := &GetHealthCheckOutput{}
4787 out.Result = output
4788
4789 var buff [1024]byte
4790 ringBuffer := smithyio.NewRingBuffer(buff[:])
4791 body := io.TeeReader(response.Body, ringBuffer)
4792 rootDecoder := xml.NewDecoder(body)
4793 t, err := smithyxml.FetchRootElement(rootDecoder)
4794 if err == io.EOF {
4795 return out, metadata, nil
4796 }
4797 if err != nil {
4798 var snapshot bytes.Buffer
4799 io.Copy(&snapshot, ringBuffer)
4800 return out, metadata, &smithy.DeserializationError{
4801 Err: fmt.Errorf("failed to decode response body, %w", err),
4802 Snapshot: snapshot.Bytes(),
4803 }
4804 }
4805
4806 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4807 err = awsRestxml_deserializeOpDocumentGetHealthCheckOutput(&output, decoder)
4808 if err != nil {
4809 var snapshot bytes.Buffer
4810 io.Copy(&snapshot, ringBuffer)
4811 return out, metadata, &smithy.DeserializationError{
4812 Err: fmt.Errorf("failed to decode response body, %w", err),
4813 Snapshot: snapshot.Bytes(),
4814 }
4815 }
4816
4817 span.End()
4818 return out, metadata, err
4819 }
4820
4821 func awsRestxml_deserializeOpErrorGetHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4822 var errorBuffer bytes.Buffer
4823 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4824 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4825 }
4826 errorBody := bytes.NewReader(errorBuffer.Bytes())
4827
4828 errorCode := "UnknownError"
4829 errorMessage := errorCode
4830
4831 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4832 if err != nil {
4833 return err
4834 }
4835 if reqID := errorComponents.RequestID; len(reqID) != 0 {
4836 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4837 }
4838 if len(errorComponents.Code) != 0 {
4839 errorCode = errorComponents.Code
4840 }
4841 if len(errorComponents.Message) != 0 {
4842 errorMessage = errorComponents.Message
4843 }
4844 errorBody.Seek(0, io.SeekStart)
4845 switch {
4846 case strings.EqualFold("IncompatibleVersion", errorCode):
4847 return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody)
4848
4849 case strings.EqualFold("InvalidInput", errorCode):
4850 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
4851
4852 case strings.EqualFold("NoSuchHealthCheck", errorCode):
4853 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
4854
4855 default:
4856 genericError := &smithy.GenericAPIError{
4857 Code: errorCode,
4858 Message: errorMessage,
4859 }
4860 return genericError
4861
4862 }
4863 }
4864
4865 func awsRestxml_deserializeOpDocumentGetHealthCheckOutput(v **GetHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
4866 if v == nil {
4867 return fmt.Errorf("unexpected nil of type %T", v)
4868 }
4869 var sv *GetHealthCheckOutput
4870 if *v == nil {
4871 sv = &GetHealthCheckOutput{}
4872 } else {
4873 sv = *v
4874 }
4875
4876 for {
4877 t, done, err := decoder.Token()
4878 if err != nil {
4879 return err
4880 }
4881 if done {
4882 break
4883 }
4884 originalDecoder := decoder
4885 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
4886 switch {
4887 case strings.EqualFold("HealthCheck", t.Name.Local):
4888 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4889 if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
4890 return err
4891 }
4892
4893 default:
4894 // Do nothing and ignore the unexpected tag element
4895 err = decoder.Decoder.Skip()
4896 if err != nil {
4897 return err
4898 }
4899
4900 }
4901 decoder = originalDecoder
4902 }
4903 *v = sv
4904 return nil
4905 }
4906
4907 type awsRestxml_deserializeOpGetHealthCheckCount struct {
4908 }
4909
4910 func (*awsRestxml_deserializeOpGetHealthCheckCount) ID() string {
4911 return "OperationDeserializer"
4912 }
4913
4914 func (m *awsRestxml_deserializeOpGetHealthCheckCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4915 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4916 ) {
4917 out, metadata, err = next.HandleDeserialize(ctx, in)
4918 if err != nil {
4919 return out, metadata, err
4920 }
4921
4922 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4923 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4924 defer endTimer()
4925 defer span.End()
4926 response, ok := out.RawResponse.(*smithyhttp.Response)
4927 if !ok {
4928 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4929 }
4930
4931 if response.StatusCode < 200 || response.StatusCode >= 300 {
4932 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckCount(response, &metadata)
4933 }
4934 output := &GetHealthCheckCountOutput{}
4935 out.Result = output
4936
4937 var buff [1024]byte
4938 ringBuffer := smithyio.NewRingBuffer(buff[:])
4939 body := io.TeeReader(response.Body, ringBuffer)
4940 rootDecoder := xml.NewDecoder(body)
4941 t, err := smithyxml.FetchRootElement(rootDecoder)
4942 if err == io.EOF {
4943 return out, metadata, nil
4944 }
4945 if err != nil {
4946 var snapshot bytes.Buffer
4947 io.Copy(&snapshot, ringBuffer)
4948 return out, metadata, &smithy.DeserializationError{
4949 Err: fmt.Errorf("failed to decode response body, %w", err),
4950 Snapshot: snapshot.Bytes(),
4951 }
4952 }
4953
4954 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4955 err = awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(&output, decoder)
4956 if err != nil {
4957 var snapshot bytes.Buffer
4958 io.Copy(&snapshot, ringBuffer)
4959 return out, metadata, &smithy.DeserializationError{
4960 Err: fmt.Errorf("failed to decode response body, %w", err),
4961 Snapshot: snapshot.Bytes(),
4962 }
4963 }
4964
4965 span.End()
4966 return out, metadata, err
4967 }
4968
4969 func awsRestxml_deserializeOpErrorGetHealthCheckCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4970 var errorBuffer bytes.Buffer
4971 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4972 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4973 }
4974 errorBody := bytes.NewReader(errorBuffer.Bytes())
4975
4976 errorCode := "UnknownError"
4977 errorMessage := errorCode
4978
4979 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4980 if err != nil {
4981 return err
4982 }
4983 if reqID := errorComponents.RequestID; len(reqID) != 0 {
4984 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4985 }
4986 if len(errorComponents.Code) != 0 {
4987 errorCode = errorComponents.Code
4988 }
4989 if len(errorComponents.Message) != 0 {
4990 errorMessage = errorComponents.Message
4991 }
4992 errorBody.Seek(0, io.SeekStart)
4993 switch {
4994 default:
4995 genericError := &smithy.GenericAPIError{
4996 Code: errorCode,
4997 Message: errorMessage,
4998 }
4999 return genericError
5000
5001 }
5002 }
5003
5004 func awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(v **GetHealthCheckCountOutput, decoder smithyxml.NodeDecoder) error {
5005 if v == nil {
5006 return fmt.Errorf("unexpected nil of type %T", v)
5007 }
5008 var sv *GetHealthCheckCountOutput
5009 if *v == nil {
5010 sv = &GetHealthCheckCountOutput{}
5011 } else {
5012 sv = *v
5013 }
5014
5015 for {
5016 t, done, err := decoder.Token()
5017 if err != nil {
5018 return err
5019 }
5020 if done {
5021 break
5022 }
5023 originalDecoder := decoder
5024 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
5025 switch {
5026 case strings.EqualFold("HealthCheckCount", t.Name.Local):
5027 val, err := decoder.Value()
5028 if err != nil {
5029 return err
5030 }
5031 if val == nil {
5032 break
5033 }
5034 {
5035 xtv := string(val)
5036 i64, err := strconv.ParseInt(xtv, 10, 64)
5037 if err != nil {
5038 return err
5039 }
5040 sv.HealthCheckCount = ptr.Int64(i64)
5041 }
5042
5043 default:
5044 // Do nothing and ignore the unexpected tag element
5045 err = decoder.Decoder.Skip()
5046 if err != nil {
5047 return err
5048 }
5049
5050 }
5051 decoder = originalDecoder
5052 }
5053 *v = sv
5054 return nil
5055 }
5056
5057 type awsRestxml_deserializeOpGetHealthCheckLastFailureReason struct {
5058 }
5059
5060 func (*awsRestxml_deserializeOpGetHealthCheckLastFailureReason) ID() string {
5061 return "OperationDeserializer"
5062 }
5063
5064 func (m *awsRestxml_deserializeOpGetHealthCheckLastFailureReason) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5065 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5066 ) {
5067 out, metadata, err = next.HandleDeserialize(ctx, in)
5068 if err != nil {
5069 return out, metadata, err
5070 }
5071
5072 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5073 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5074 defer endTimer()
5075 defer span.End()
5076 response, ok := out.RawResponse.(*smithyhttp.Response)
5077 if !ok {
5078 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5079 }
5080
5081 if response.StatusCode < 200 || response.StatusCode >= 300 {
5082 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response, &metadata)
5083 }
5084 output := &GetHealthCheckLastFailureReasonOutput{}
5085 out.Result = output
5086
5087 var buff [1024]byte
5088 ringBuffer := smithyio.NewRingBuffer(buff[:])
5089 body := io.TeeReader(response.Body, ringBuffer)
5090 rootDecoder := xml.NewDecoder(body)
5091 t, err := smithyxml.FetchRootElement(rootDecoder)
5092 if err == io.EOF {
5093 return out, metadata, nil
5094 }
5095 if err != nil {
5096 var snapshot bytes.Buffer
5097 io.Copy(&snapshot, ringBuffer)
5098 return out, metadata, &smithy.DeserializationError{
5099 Err: fmt.Errorf("failed to decode response body, %w", err),
5100 Snapshot: snapshot.Bytes(),
5101 }
5102 }
5103
5104 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5105 err = awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(&output, decoder)
5106 if err != nil {
5107 var snapshot bytes.Buffer
5108 io.Copy(&snapshot, ringBuffer)
5109 return out, metadata, &smithy.DeserializationError{
5110 Err: fmt.Errorf("failed to decode response body, %w", err),
5111 Snapshot: snapshot.Bytes(),
5112 }
5113 }
5114
5115 span.End()
5116 return out, metadata, err
5117 }
5118
5119 func awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5120 var errorBuffer bytes.Buffer
5121 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5122 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5123 }
5124 errorBody := bytes.NewReader(errorBuffer.Bytes())
5125
5126 errorCode := "UnknownError"
5127 errorMessage := errorCode
5128
5129 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5130 if err != nil {
5131 return err
5132 }
5133 if reqID := errorComponents.RequestID; len(reqID) != 0 {
5134 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5135 }
5136 if len(errorComponents.Code) != 0 {
5137 errorCode = errorComponents.Code
5138 }
5139 if len(errorComponents.Message) != 0 {
5140 errorMessage = errorComponents.Message
5141 }
5142 errorBody.Seek(0, io.SeekStart)
5143 switch {
5144 case strings.EqualFold("InvalidInput", errorCode):
5145 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
5146
5147 case strings.EqualFold("NoSuchHealthCheck", errorCode):
5148 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
5149
5150 default:
5151 genericError := &smithy.GenericAPIError{
5152 Code: errorCode,
5153 Message: errorMessage,
5154 }
5155 return genericError
5156
5157 }
5158 }
5159
5160 func awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(v **GetHealthCheckLastFailureReasonOutput, decoder smithyxml.NodeDecoder) error {
5161 if v == nil {
5162 return fmt.Errorf("unexpected nil of type %T", v)
5163 }
5164 var sv *GetHealthCheckLastFailureReasonOutput
5165 if *v == nil {
5166 sv = &GetHealthCheckLastFailureReasonOutput{}
5167 } else {
5168 sv = *v
5169 }
5170
5171 for {
5172 t, done, err := decoder.Token()
5173 if err != nil {
5174 return err
5175 }
5176 if done {
5177 break
5178 }
5179 originalDecoder := decoder
5180 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
5181 switch {
5182 case strings.EqualFold("HealthCheckObservations", t.Name.Local):
5183 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5184 if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil {
5185 return err
5186 }
5187
5188 default:
5189 // Do nothing and ignore the unexpected tag element
5190 err = decoder.Decoder.Skip()
5191 if err != nil {
5192 return err
5193 }
5194
5195 }
5196 decoder = originalDecoder
5197 }
5198 *v = sv
5199 return nil
5200 }
5201
5202 type awsRestxml_deserializeOpGetHealthCheckStatus struct {
5203 }
5204
5205 func (*awsRestxml_deserializeOpGetHealthCheckStatus) ID() string {
5206 return "OperationDeserializer"
5207 }
5208
5209 func (m *awsRestxml_deserializeOpGetHealthCheckStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5210 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5211 ) {
5212 out, metadata, err = next.HandleDeserialize(ctx, in)
5213 if err != nil {
5214 return out, metadata, err
5215 }
5216
5217 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5218 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5219 defer endTimer()
5220 defer span.End()
5221 response, ok := out.RawResponse.(*smithyhttp.Response)
5222 if !ok {
5223 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5224 }
5225
5226 if response.StatusCode < 200 || response.StatusCode >= 300 {
5227 return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckStatus(response, &metadata)
5228 }
5229 output := &GetHealthCheckStatusOutput{}
5230 out.Result = output
5231
5232 var buff [1024]byte
5233 ringBuffer := smithyio.NewRingBuffer(buff[:])
5234 body := io.TeeReader(response.Body, ringBuffer)
5235 rootDecoder := xml.NewDecoder(body)
5236 t, err := smithyxml.FetchRootElement(rootDecoder)
5237 if err == io.EOF {
5238 return out, metadata, nil
5239 }
5240 if err != nil {
5241 var snapshot bytes.Buffer
5242 io.Copy(&snapshot, ringBuffer)
5243 return out, metadata, &smithy.DeserializationError{
5244 Err: fmt.Errorf("failed to decode response body, %w", err),
5245 Snapshot: snapshot.Bytes(),
5246 }
5247 }
5248
5249 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5250 err = awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(&output, decoder)
5251 if err != nil {
5252 var snapshot bytes.Buffer
5253 io.Copy(&snapshot, ringBuffer)
5254 return out, metadata, &smithy.DeserializationError{
5255 Err: fmt.Errorf("failed to decode response body, %w", err),
5256 Snapshot: snapshot.Bytes(),
5257 }
5258 }
5259
5260 span.End()
5261 return out, metadata, err
5262 }
5263
5264 func awsRestxml_deserializeOpErrorGetHealthCheckStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5265 var errorBuffer bytes.Buffer
5266 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5267 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5268 }
5269 errorBody := bytes.NewReader(errorBuffer.Bytes())
5270
5271 errorCode := "UnknownError"
5272 errorMessage := errorCode
5273
5274 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5275 if err != nil {
5276 return err
5277 }
5278 if reqID := errorComponents.RequestID; len(reqID) != 0 {
5279 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5280 }
5281 if len(errorComponents.Code) != 0 {
5282 errorCode = errorComponents.Code
5283 }
5284 if len(errorComponents.Message) != 0 {
5285 errorMessage = errorComponents.Message
5286 }
5287 errorBody.Seek(0, io.SeekStart)
5288 switch {
5289 case strings.EqualFold("InvalidInput", errorCode):
5290 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
5291
5292 case strings.EqualFold("NoSuchHealthCheck", errorCode):
5293 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
5294
5295 default:
5296 genericError := &smithy.GenericAPIError{
5297 Code: errorCode,
5298 Message: errorMessage,
5299 }
5300 return genericError
5301
5302 }
5303 }
5304
5305 func awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(v **GetHealthCheckStatusOutput, decoder smithyxml.NodeDecoder) error {
5306 if v == nil {
5307 return fmt.Errorf("unexpected nil of type %T", v)
5308 }
5309 var sv *GetHealthCheckStatusOutput
5310 if *v == nil {
5311 sv = &GetHealthCheckStatusOutput{}
5312 } else {
5313 sv = *v
5314 }
5315
5316 for {
5317 t, done, err := decoder.Token()
5318 if err != nil {
5319 return err
5320 }
5321 if done {
5322 break
5323 }
5324 originalDecoder := decoder
5325 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
5326 switch {
5327 case strings.EqualFold("HealthCheckObservations", t.Name.Local):
5328 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5329 if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil {
5330 return err
5331 }
5332
5333 default:
5334 // Do nothing and ignore the unexpected tag element
5335 err = decoder.Decoder.Skip()
5336 if err != nil {
5337 return err
5338 }
5339
5340 }
5341 decoder = originalDecoder
5342 }
5343 *v = sv
5344 return nil
5345 }
5346
5347 type awsRestxml_deserializeOpGetHostedZone struct {
5348 }
5349
5350 func (*awsRestxml_deserializeOpGetHostedZone) ID() string {
5351 return "OperationDeserializer"
5352 }
5353
5354 func (m *awsRestxml_deserializeOpGetHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5355 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5356 ) {
5357 out, metadata, err = next.HandleDeserialize(ctx, in)
5358 if err != nil {
5359 return out, metadata, err
5360 }
5361
5362 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5363 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5364 defer endTimer()
5365 defer span.End()
5366 response, ok := out.RawResponse.(*smithyhttp.Response)
5367 if !ok {
5368 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5369 }
5370
5371 if response.StatusCode < 200 || response.StatusCode >= 300 {
5372 return out, metadata, awsRestxml_deserializeOpErrorGetHostedZone(response, &metadata)
5373 }
5374 output := &GetHostedZoneOutput{}
5375 out.Result = output
5376
5377 var buff [1024]byte
5378 ringBuffer := smithyio.NewRingBuffer(buff[:])
5379 body := io.TeeReader(response.Body, ringBuffer)
5380 rootDecoder := xml.NewDecoder(body)
5381 t, err := smithyxml.FetchRootElement(rootDecoder)
5382 if err == io.EOF {
5383 return out, metadata, nil
5384 }
5385 if err != nil {
5386 var snapshot bytes.Buffer
5387 io.Copy(&snapshot, ringBuffer)
5388 return out, metadata, &smithy.DeserializationError{
5389 Err: fmt.Errorf("failed to decode response body, %w", err),
5390 Snapshot: snapshot.Bytes(),
5391 }
5392 }
5393
5394 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5395 err = awsRestxml_deserializeOpDocumentGetHostedZoneOutput(&output, decoder)
5396 if err != nil {
5397 var snapshot bytes.Buffer
5398 io.Copy(&snapshot, ringBuffer)
5399 return out, metadata, &smithy.DeserializationError{
5400 Err: fmt.Errorf("failed to decode response body, %w", err),
5401 Snapshot: snapshot.Bytes(),
5402 }
5403 }
5404
5405 span.End()
5406 return out, metadata, err
5407 }
5408
5409 func awsRestxml_deserializeOpErrorGetHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5410 var errorBuffer bytes.Buffer
5411 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5412 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5413 }
5414 errorBody := bytes.NewReader(errorBuffer.Bytes())
5415
5416 errorCode := "UnknownError"
5417 errorMessage := errorCode
5418
5419 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5420 if err != nil {
5421 return err
5422 }
5423 if reqID := errorComponents.RequestID; len(reqID) != 0 {
5424 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5425 }
5426 if len(errorComponents.Code) != 0 {
5427 errorCode = errorComponents.Code
5428 }
5429 if len(errorComponents.Message) != 0 {
5430 errorMessage = errorComponents.Message
5431 }
5432 errorBody.Seek(0, io.SeekStart)
5433 switch {
5434 case strings.EqualFold("InvalidInput", errorCode):
5435 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
5436
5437 case strings.EqualFold("NoSuchHostedZone", errorCode):
5438 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
5439
5440 default:
5441 genericError := &smithy.GenericAPIError{
5442 Code: errorCode,
5443 Message: errorMessage,
5444 }
5445 return genericError
5446
5447 }
5448 }
5449
5450 func awsRestxml_deserializeOpDocumentGetHostedZoneOutput(v **GetHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
5451 if v == nil {
5452 return fmt.Errorf("unexpected nil of type %T", v)
5453 }
5454 var sv *GetHostedZoneOutput
5455 if *v == nil {
5456 sv = &GetHostedZoneOutput{}
5457 } else {
5458 sv = *v
5459 }
5460
5461 for {
5462 t, done, err := decoder.Token()
5463 if err != nil {
5464 return err
5465 }
5466 if done {
5467 break
5468 }
5469 originalDecoder := decoder
5470 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
5471 switch {
5472 case strings.EqualFold("DelegationSet", t.Name.Local):
5473 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5474 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
5475 return err
5476 }
5477
5478 case strings.EqualFold("HostedZone", t.Name.Local):
5479 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5480 if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
5481 return err
5482 }
5483
5484 case strings.EqualFold("VPCs", t.Name.Local):
5485 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5486 if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil {
5487 return err
5488 }
5489
5490 default:
5491 // Do nothing and ignore the unexpected tag element
5492 err = decoder.Decoder.Skip()
5493 if err != nil {
5494 return err
5495 }
5496
5497 }
5498 decoder = originalDecoder
5499 }
5500 *v = sv
5501 return nil
5502 }
5503
5504 type awsRestxml_deserializeOpGetHostedZoneCount struct {
5505 }
5506
5507 func (*awsRestxml_deserializeOpGetHostedZoneCount) ID() string {
5508 return "OperationDeserializer"
5509 }
5510
5511 func (m *awsRestxml_deserializeOpGetHostedZoneCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5512 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5513 ) {
5514 out, metadata, err = next.HandleDeserialize(ctx, in)
5515 if err != nil {
5516 return out, metadata, err
5517 }
5518
5519 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5520 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5521 defer endTimer()
5522 defer span.End()
5523 response, ok := out.RawResponse.(*smithyhttp.Response)
5524 if !ok {
5525 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5526 }
5527
5528 if response.StatusCode < 200 || response.StatusCode >= 300 {
5529 return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneCount(response, &metadata)
5530 }
5531 output := &GetHostedZoneCountOutput{}
5532 out.Result = output
5533
5534 var buff [1024]byte
5535 ringBuffer := smithyio.NewRingBuffer(buff[:])
5536 body := io.TeeReader(response.Body, ringBuffer)
5537 rootDecoder := xml.NewDecoder(body)
5538 t, err := smithyxml.FetchRootElement(rootDecoder)
5539 if err == io.EOF {
5540 return out, metadata, nil
5541 }
5542 if err != nil {
5543 var snapshot bytes.Buffer
5544 io.Copy(&snapshot, ringBuffer)
5545 return out, metadata, &smithy.DeserializationError{
5546 Err: fmt.Errorf("failed to decode response body, %w", err),
5547 Snapshot: snapshot.Bytes(),
5548 }
5549 }
5550
5551 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5552 err = awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(&output, decoder)
5553 if err != nil {
5554 var snapshot bytes.Buffer
5555 io.Copy(&snapshot, ringBuffer)
5556 return out, metadata, &smithy.DeserializationError{
5557 Err: fmt.Errorf("failed to decode response body, %w", err),
5558 Snapshot: snapshot.Bytes(),
5559 }
5560 }
5561
5562 span.End()
5563 return out, metadata, err
5564 }
5565
5566 func awsRestxml_deserializeOpErrorGetHostedZoneCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5567 var errorBuffer bytes.Buffer
5568 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5569 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5570 }
5571 errorBody := bytes.NewReader(errorBuffer.Bytes())
5572
5573 errorCode := "UnknownError"
5574 errorMessage := errorCode
5575
5576 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5577 if err != nil {
5578 return err
5579 }
5580 if reqID := errorComponents.RequestID; len(reqID) != 0 {
5581 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5582 }
5583 if len(errorComponents.Code) != 0 {
5584 errorCode = errorComponents.Code
5585 }
5586 if len(errorComponents.Message) != 0 {
5587 errorMessage = errorComponents.Message
5588 }
5589 errorBody.Seek(0, io.SeekStart)
5590 switch {
5591 case strings.EqualFold("InvalidInput", errorCode):
5592 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
5593
5594 default:
5595 genericError := &smithy.GenericAPIError{
5596 Code: errorCode,
5597 Message: errorMessage,
5598 }
5599 return genericError
5600
5601 }
5602 }
5603
5604 func awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(v **GetHostedZoneCountOutput, decoder smithyxml.NodeDecoder) error {
5605 if v == nil {
5606 return fmt.Errorf("unexpected nil of type %T", v)
5607 }
5608 var sv *GetHostedZoneCountOutput
5609 if *v == nil {
5610 sv = &GetHostedZoneCountOutput{}
5611 } else {
5612 sv = *v
5613 }
5614
5615 for {
5616 t, done, err := decoder.Token()
5617 if err != nil {
5618 return err
5619 }
5620 if done {
5621 break
5622 }
5623 originalDecoder := decoder
5624 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
5625 switch {
5626 case strings.EqualFold("HostedZoneCount", t.Name.Local):
5627 val, err := decoder.Value()
5628 if err != nil {
5629 return err
5630 }
5631 if val == nil {
5632 break
5633 }
5634 {
5635 xtv := string(val)
5636 i64, err := strconv.ParseInt(xtv, 10, 64)
5637 if err != nil {
5638 return err
5639 }
5640 sv.HostedZoneCount = ptr.Int64(i64)
5641 }
5642
5643 default:
5644 // Do nothing and ignore the unexpected tag element
5645 err = decoder.Decoder.Skip()
5646 if err != nil {
5647 return err
5648 }
5649
5650 }
5651 decoder = originalDecoder
5652 }
5653 *v = sv
5654 return nil
5655 }
5656
5657 type awsRestxml_deserializeOpGetHostedZoneLimit struct {
5658 }
5659
5660 func (*awsRestxml_deserializeOpGetHostedZoneLimit) ID() string {
5661 return "OperationDeserializer"
5662 }
5663
5664 func (m *awsRestxml_deserializeOpGetHostedZoneLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5665 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5666 ) {
5667 out, metadata, err = next.HandleDeserialize(ctx, in)
5668 if err != nil {
5669 return out, metadata, err
5670 }
5671
5672 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5673 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5674 defer endTimer()
5675 defer span.End()
5676 response, ok := out.RawResponse.(*smithyhttp.Response)
5677 if !ok {
5678 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5679 }
5680
5681 if response.StatusCode < 200 || response.StatusCode >= 300 {
5682 return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneLimit(response, &metadata)
5683 }
5684 output := &GetHostedZoneLimitOutput{}
5685 out.Result = output
5686
5687 var buff [1024]byte
5688 ringBuffer := smithyio.NewRingBuffer(buff[:])
5689 body := io.TeeReader(response.Body, ringBuffer)
5690 rootDecoder := xml.NewDecoder(body)
5691 t, err := smithyxml.FetchRootElement(rootDecoder)
5692 if err == io.EOF {
5693 return out, metadata, nil
5694 }
5695 if err != nil {
5696 var snapshot bytes.Buffer
5697 io.Copy(&snapshot, ringBuffer)
5698 return out, metadata, &smithy.DeserializationError{
5699 Err: fmt.Errorf("failed to decode response body, %w", err),
5700 Snapshot: snapshot.Bytes(),
5701 }
5702 }
5703
5704 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5705 err = awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(&output, decoder)
5706 if err != nil {
5707 var snapshot bytes.Buffer
5708 io.Copy(&snapshot, ringBuffer)
5709 return out, metadata, &smithy.DeserializationError{
5710 Err: fmt.Errorf("failed to decode response body, %w", err),
5711 Snapshot: snapshot.Bytes(),
5712 }
5713 }
5714
5715 span.End()
5716 return out, metadata, err
5717 }
5718
5719 func awsRestxml_deserializeOpErrorGetHostedZoneLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5720 var errorBuffer bytes.Buffer
5721 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5722 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5723 }
5724 errorBody := bytes.NewReader(errorBuffer.Bytes())
5725
5726 errorCode := "UnknownError"
5727 errorMessage := errorCode
5728
5729 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5730 if err != nil {
5731 return err
5732 }
5733 if reqID := errorComponents.RequestID; len(reqID) != 0 {
5734 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5735 }
5736 if len(errorComponents.Code) != 0 {
5737 errorCode = errorComponents.Code
5738 }
5739 if len(errorComponents.Message) != 0 {
5740 errorMessage = errorComponents.Message
5741 }
5742 errorBody.Seek(0, io.SeekStart)
5743 switch {
5744 case strings.EqualFold("HostedZoneNotPrivate", errorCode):
5745 return awsRestxml_deserializeErrorHostedZoneNotPrivate(response, errorBody)
5746
5747 case strings.EqualFold("InvalidInput", errorCode):
5748 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
5749
5750 case strings.EqualFold("NoSuchHostedZone", errorCode):
5751 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
5752
5753 default:
5754 genericError := &smithy.GenericAPIError{
5755 Code: errorCode,
5756 Message: errorMessage,
5757 }
5758 return genericError
5759
5760 }
5761 }
5762
5763 func awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(v **GetHostedZoneLimitOutput, decoder smithyxml.NodeDecoder) error {
5764 if v == nil {
5765 return fmt.Errorf("unexpected nil of type %T", v)
5766 }
5767 var sv *GetHostedZoneLimitOutput
5768 if *v == nil {
5769 sv = &GetHostedZoneLimitOutput{}
5770 } else {
5771 sv = *v
5772 }
5773
5774 for {
5775 t, done, err := decoder.Token()
5776 if err != nil {
5777 return err
5778 }
5779 if done {
5780 break
5781 }
5782 originalDecoder := decoder
5783 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
5784 switch {
5785 case strings.EqualFold("Count", t.Name.Local):
5786 val, err := decoder.Value()
5787 if err != nil {
5788 return err
5789 }
5790 if val == nil {
5791 break
5792 }
5793 {
5794 xtv := string(val)
5795 i64, err := strconv.ParseInt(xtv, 10, 64)
5796 if err != nil {
5797 return err
5798 }
5799 sv.Count = i64
5800 }
5801
5802 case strings.EqualFold("Limit", t.Name.Local):
5803 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5804 if err := awsRestxml_deserializeDocumentHostedZoneLimit(&sv.Limit, nodeDecoder); err != nil {
5805 return err
5806 }
5807
5808 default:
5809 // Do nothing and ignore the unexpected tag element
5810 err = decoder.Decoder.Skip()
5811 if err != nil {
5812 return err
5813 }
5814
5815 }
5816 decoder = originalDecoder
5817 }
5818 *v = sv
5819 return nil
5820 }
5821
5822 type awsRestxml_deserializeOpGetQueryLoggingConfig struct {
5823 }
5824
5825 func (*awsRestxml_deserializeOpGetQueryLoggingConfig) ID() string {
5826 return "OperationDeserializer"
5827 }
5828
5829 func (m *awsRestxml_deserializeOpGetQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5830 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5831 ) {
5832 out, metadata, err = next.HandleDeserialize(ctx, in)
5833 if err != nil {
5834 return out, metadata, err
5835 }
5836
5837 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5838 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5839 defer endTimer()
5840 defer span.End()
5841 response, ok := out.RawResponse.(*smithyhttp.Response)
5842 if !ok {
5843 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5844 }
5845
5846 if response.StatusCode < 200 || response.StatusCode >= 300 {
5847 return out, metadata, awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response, &metadata)
5848 }
5849 output := &GetQueryLoggingConfigOutput{}
5850 out.Result = output
5851
5852 var buff [1024]byte
5853 ringBuffer := smithyio.NewRingBuffer(buff[:])
5854 body := io.TeeReader(response.Body, ringBuffer)
5855 rootDecoder := xml.NewDecoder(body)
5856 t, err := smithyxml.FetchRootElement(rootDecoder)
5857 if err == io.EOF {
5858 return out, metadata, nil
5859 }
5860 if err != nil {
5861 var snapshot bytes.Buffer
5862 io.Copy(&snapshot, ringBuffer)
5863 return out, metadata, &smithy.DeserializationError{
5864 Err: fmt.Errorf("failed to decode response body, %w", err),
5865 Snapshot: snapshot.Bytes(),
5866 }
5867 }
5868
5869 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5870 err = awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(&output, decoder)
5871 if err != nil {
5872 var snapshot bytes.Buffer
5873 io.Copy(&snapshot, ringBuffer)
5874 return out, metadata, &smithy.DeserializationError{
5875 Err: fmt.Errorf("failed to decode response body, %w", err),
5876 Snapshot: snapshot.Bytes(),
5877 }
5878 }
5879
5880 span.End()
5881 return out, metadata, err
5882 }
5883
5884 func awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5885 var errorBuffer bytes.Buffer
5886 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5887 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5888 }
5889 errorBody := bytes.NewReader(errorBuffer.Bytes())
5890
5891 errorCode := "UnknownError"
5892 errorMessage := errorCode
5893
5894 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5895 if err != nil {
5896 return err
5897 }
5898 if reqID := errorComponents.RequestID; len(reqID) != 0 {
5899 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5900 }
5901 if len(errorComponents.Code) != 0 {
5902 errorCode = errorComponents.Code
5903 }
5904 if len(errorComponents.Message) != 0 {
5905 errorMessage = errorComponents.Message
5906 }
5907 errorBody.Seek(0, io.SeekStart)
5908 switch {
5909 case strings.EqualFold("InvalidInput", errorCode):
5910 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
5911
5912 case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode):
5913 return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody)
5914
5915 default:
5916 genericError := &smithy.GenericAPIError{
5917 Code: errorCode,
5918 Message: errorMessage,
5919 }
5920 return genericError
5921
5922 }
5923 }
5924
5925 func awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(v **GetQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error {
5926 if v == nil {
5927 return fmt.Errorf("unexpected nil of type %T", v)
5928 }
5929 var sv *GetQueryLoggingConfigOutput
5930 if *v == nil {
5931 sv = &GetQueryLoggingConfigOutput{}
5932 } else {
5933 sv = *v
5934 }
5935
5936 for {
5937 t, done, err := decoder.Token()
5938 if err != nil {
5939 return err
5940 }
5941 if done {
5942 break
5943 }
5944 originalDecoder := decoder
5945 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
5946 switch {
5947 case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
5948 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5949 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil {
5950 return err
5951 }
5952
5953 default:
5954 // Do nothing and ignore the unexpected tag element
5955 err = decoder.Decoder.Skip()
5956 if err != nil {
5957 return err
5958 }
5959
5960 }
5961 decoder = originalDecoder
5962 }
5963 *v = sv
5964 return nil
5965 }
5966
5967 type awsRestxml_deserializeOpGetReusableDelegationSet struct {
5968 }
5969
5970 func (*awsRestxml_deserializeOpGetReusableDelegationSet) ID() string {
5971 return "OperationDeserializer"
5972 }
5973
5974 func (m *awsRestxml_deserializeOpGetReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5975 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5976 ) {
5977 out, metadata, err = next.HandleDeserialize(ctx, in)
5978 if err != nil {
5979 return out, metadata, err
5980 }
5981
5982 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5983 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5984 defer endTimer()
5985 defer span.End()
5986 response, ok := out.RawResponse.(*smithyhttp.Response)
5987 if !ok {
5988 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5989 }
5990
5991 if response.StatusCode < 200 || response.StatusCode >= 300 {
5992 return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSet(response, &metadata)
5993 }
5994 output := &GetReusableDelegationSetOutput{}
5995 out.Result = output
5996
5997 var buff [1024]byte
5998 ringBuffer := smithyio.NewRingBuffer(buff[:])
5999 body := io.TeeReader(response.Body, ringBuffer)
6000 rootDecoder := xml.NewDecoder(body)
6001 t, err := smithyxml.FetchRootElement(rootDecoder)
6002 if err == io.EOF {
6003 return out, metadata, nil
6004 }
6005 if err != nil {
6006 var snapshot bytes.Buffer
6007 io.Copy(&snapshot, ringBuffer)
6008 return out, metadata, &smithy.DeserializationError{
6009 Err: fmt.Errorf("failed to decode response body, %w", err),
6010 Snapshot: snapshot.Bytes(),
6011 }
6012 }
6013
6014 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6015 err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(&output, decoder)
6016 if err != nil {
6017 var snapshot bytes.Buffer
6018 io.Copy(&snapshot, ringBuffer)
6019 return out, metadata, &smithy.DeserializationError{
6020 Err: fmt.Errorf("failed to decode response body, %w", err),
6021 Snapshot: snapshot.Bytes(),
6022 }
6023 }
6024
6025 span.End()
6026 return out, metadata, err
6027 }
6028
6029 func awsRestxml_deserializeOpErrorGetReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6030 var errorBuffer bytes.Buffer
6031 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6032 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6033 }
6034 errorBody := bytes.NewReader(errorBuffer.Bytes())
6035
6036 errorCode := "UnknownError"
6037 errorMessage := errorCode
6038
6039 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6040 if err != nil {
6041 return err
6042 }
6043 if reqID := errorComponents.RequestID; len(reqID) != 0 {
6044 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6045 }
6046 if len(errorComponents.Code) != 0 {
6047 errorCode = errorComponents.Code
6048 }
6049 if len(errorComponents.Message) != 0 {
6050 errorMessage = errorComponents.Message
6051 }
6052 errorBody.Seek(0, io.SeekStart)
6053 switch {
6054 case strings.EqualFold("DelegationSetNotReusable", errorCode):
6055 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
6056
6057 case strings.EqualFold("InvalidInput", errorCode):
6058 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
6059
6060 case strings.EqualFold("NoSuchDelegationSet", errorCode):
6061 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
6062
6063 default:
6064 genericError := &smithy.GenericAPIError{
6065 Code: errorCode,
6066 Message: errorMessage,
6067 }
6068 return genericError
6069
6070 }
6071 }
6072
6073 func awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(v **GetReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error {
6074 if v == nil {
6075 return fmt.Errorf("unexpected nil of type %T", v)
6076 }
6077 var sv *GetReusableDelegationSetOutput
6078 if *v == nil {
6079 sv = &GetReusableDelegationSetOutput{}
6080 } else {
6081 sv = *v
6082 }
6083
6084 for {
6085 t, done, err := decoder.Token()
6086 if err != nil {
6087 return err
6088 }
6089 if done {
6090 break
6091 }
6092 originalDecoder := decoder
6093 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
6094 switch {
6095 case strings.EqualFold("DelegationSet", t.Name.Local):
6096 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6097 if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
6098 return err
6099 }
6100
6101 default:
6102 // Do nothing and ignore the unexpected tag element
6103 err = decoder.Decoder.Skip()
6104 if err != nil {
6105 return err
6106 }
6107
6108 }
6109 decoder = originalDecoder
6110 }
6111 *v = sv
6112 return nil
6113 }
6114
6115 type awsRestxml_deserializeOpGetReusableDelegationSetLimit struct {
6116 }
6117
6118 func (*awsRestxml_deserializeOpGetReusableDelegationSetLimit) ID() string {
6119 return "OperationDeserializer"
6120 }
6121
6122 func (m *awsRestxml_deserializeOpGetReusableDelegationSetLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6123 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6124 ) {
6125 out, metadata, err = next.HandleDeserialize(ctx, in)
6126 if err != nil {
6127 return out, metadata, err
6128 }
6129
6130 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6131 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6132 defer endTimer()
6133 defer span.End()
6134 response, ok := out.RawResponse.(*smithyhttp.Response)
6135 if !ok {
6136 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6137 }
6138
6139 if response.StatusCode < 200 || response.StatusCode >= 300 {
6140 return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response, &metadata)
6141 }
6142 output := &GetReusableDelegationSetLimitOutput{}
6143 out.Result = output
6144
6145 var buff [1024]byte
6146 ringBuffer := smithyio.NewRingBuffer(buff[:])
6147 body := io.TeeReader(response.Body, ringBuffer)
6148 rootDecoder := xml.NewDecoder(body)
6149 t, err := smithyxml.FetchRootElement(rootDecoder)
6150 if err == io.EOF {
6151 return out, metadata, nil
6152 }
6153 if err != nil {
6154 var snapshot bytes.Buffer
6155 io.Copy(&snapshot, ringBuffer)
6156 return out, metadata, &smithy.DeserializationError{
6157 Err: fmt.Errorf("failed to decode response body, %w", err),
6158 Snapshot: snapshot.Bytes(),
6159 }
6160 }
6161
6162 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6163 err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(&output, decoder)
6164 if err != nil {
6165 var snapshot bytes.Buffer
6166 io.Copy(&snapshot, ringBuffer)
6167 return out, metadata, &smithy.DeserializationError{
6168 Err: fmt.Errorf("failed to decode response body, %w", err),
6169 Snapshot: snapshot.Bytes(),
6170 }
6171 }
6172
6173 span.End()
6174 return out, metadata, err
6175 }
6176
6177 func awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6178 var errorBuffer bytes.Buffer
6179 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6180 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6181 }
6182 errorBody := bytes.NewReader(errorBuffer.Bytes())
6183
6184 errorCode := "UnknownError"
6185 errorMessage := errorCode
6186
6187 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6188 if err != nil {
6189 return err
6190 }
6191 if reqID := errorComponents.RequestID; len(reqID) != 0 {
6192 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6193 }
6194 if len(errorComponents.Code) != 0 {
6195 errorCode = errorComponents.Code
6196 }
6197 if len(errorComponents.Message) != 0 {
6198 errorMessage = errorComponents.Message
6199 }
6200 errorBody.Seek(0, io.SeekStart)
6201 switch {
6202 case strings.EqualFold("InvalidInput", errorCode):
6203 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
6204
6205 case strings.EqualFold("NoSuchDelegationSet", errorCode):
6206 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
6207
6208 default:
6209 genericError := &smithy.GenericAPIError{
6210 Code: errorCode,
6211 Message: errorMessage,
6212 }
6213 return genericError
6214
6215 }
6216 }
6217
6218 func awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(v **GetReusableDelegationSetLimitOutput, decoder smithyxml.NodeDecoder) error {
6219 if v == nil {
6220 return fmt.Errorf("unexpected nil of type %T", v)
6221 }
6222 var sv *GetReusableDelegationSetLimitOutput
6223 if *v == nil {
6224 sv = &GetReusableDelegationSetLimitOutput{}
6225 } else {
6226 sv = *v
6227 }
6228
6229 for {
6230 t, done, err := decoder.Token()
6231 if err != nil {
6232 return err
6233 }
6234 if done {
6235 break
6236 }
6237 originalDecoder := decoder
6238 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
6239 switch {
6240 case strings.EqualFold("Count", t.Name.Local):
6241 val, err := decoder.Value()
6242 if err != nil {
6243 return err
6244 }
6245 if val == nil {
6246 break
6247 }
6248 {
6249 xtv := string(val)
6250 i64, err := strconv.ParseInt(xtv, 10, 64)
6251 if err != nil {
6252 return err
6253 }
6254 sv.Count = i64
6255 }
6256
6257 case strings.EqualFold("Limit", t.Name.Local):
6258 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6259 if err := awsRestxml_deserializeDocumentReusableDelegationSetLimit(&sv.Limit, nodeDecoder); err != nil {
6260 return err
6261 }
6262
6263 default:
6264 // Do nothing and ignore the unexpected tag element
6265 err = decoder.Decoder.Skip()
6266 if err != nil {
6267 return err
6268 }
6269
6270 }
6271 decoder = originalDecoder
6272 }
6273 *v = sv
6274 return nil
6275 }
6276
6277 type awsRestxml_deserializeOpGetTrafficPolicy struct {
6278 }
6279
6280 func (*awsRestxml_deserializeOpGetTrafficPolicy) ID() string {
6281 return "OperationDeserializer"
6282 }
6283
6284 func (m *awsRestxml_deserializeOpGetTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6285 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6286 ) {
6287 out, metadata, err = next.HandleDeserialize(ctx, in)
6288 if err != nil {
6289 return out, metadata, err
6290 }
6291
6292 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6293 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6294 defer endTimer()
6295 defer span.End()
6296 response, ok := out.RawResponse.(*smithyhttp.Response)
6297 if !ok {
6298 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6299 }
6300
6301 if response.StatusCode < 200 || response.StatusCode >= 300 {
6302 return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicy(response, &metadata)
6303 }
6304 output := &GetTrafficPolicyOutput{}
6305 out.Result = output
6306
6307 var buff [1024]byte
6308 ringBuffer := smithyio.NewRingBuffer(buff[:])
6309 body := io.TeeReader(response.Body, ringBuffer)
6310 rootDecoder := xml.NewDecoder(body)
6311 t, err := smithyxml.FetchRootElement(rootDecoder)
6312 if err == io.EOF {
6313 return out, metadata, nil
6314 }
6315 if err != nil {
6316 var snapshot bytes.Buffer
6317 io.Copy(&snapshot, ringBuffer)
6318 return out, metadata, &smithy.DeserializationError{
6319 Err: fmt.Errorf("failed to decode response body, %w", err),
6320 Snapshot: snapshot.Bytes(),
6321 }
6322 }
6323
6324 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6325 err = awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(&output, decoder)
6326 if err != nil {
6327 var snapshot bytes.Buffer
6328 io.Copy(&snapshot, ringBuffer)
6329 return out, metadata, &smithy.DeserializationError{
6330 Err: fmt.Errorf("failed to decode response body, %w", err),
6331 Snapshot: snapshot.Bytes(),
6332 }
6333 }
6334
6335 span.End()
6336 return out, metadata, err
6337 }
6338
6339 func awsRestxml_deserializeOpErrorGetTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6340 var errorBuffer bytes.Buffer
6341 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6342 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6343 }
6344 errorBody := bytes.NewReader(errorBuffer.Bytes())
6345
6346 errorCode := "UnknownError"
6347 errorMessage := errorCode
6348
6349 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6350 if err != nil {
6351 return err
6352 }
6353 if reqID := errorComponents.RequestID; len(reqID) != 0 {
6354 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6355 }
6356 if len(errorComponents.Code) != 0 {
6357 errorCode = errorComponents.Code
6358 }
6359 if len(errorComponents.Message) != 0 {
6360 errorMessage = errorComponents.Message
6361 }
6362 errorBody.Seek(0, io.SeekStart)
6363 switch {
6364 case strings.EqualFold("InvalidInput", errorCode):
6365 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
6366
6367 case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
6368 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
6369
6370 default:
6371 genericError := &smithy.GenericAPIError{
6372 Code: errorCode,
6373 Message: errorMessage,
6374 }
6375 return genericError
6376
6377 }
6378 }
6379
6380 func awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(v **GetTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error {
6381 if v == nil {
6382 return fmt.Errorf("unexpected nil of type %T", v)
6383 }
6384 var sv *GetTrafficPolicyOutput
6385 if *v == nil {
6386 sv = &GetTrafficPolicyOutput{}
6387 } else {
6388 sv = *v
6389 }
6390
6391 for {
6392 t, done, err := decoder.Token()
6393 if err != nil {
6394 return err
6395 }
6396 if done {
6397 break
6398 }
6399 originalDecoder := decoder
6400 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
6401 switch {
6402 case strings.EqualFold("TrafficPolicy", t.Name.Local):
6403 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6404 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
6405 return err
6406 }
6407
6408 default:
6409 // Do nothing and ignore the unexpected tag element
6410 err = decoder.Decoder.Skip()
6411 if err != nil {
6412 return err
6413 }
6414
6415 }
6416 decoder = originalDecoder
6417 }
6418 *v = sv
6419 return nil
6420 }
6421
6422 type awsRestxml_deserializeOpGetTrafficPolicyInstance struct {
6423 }
6424
6425 func (*awsRestxml_deserializeOpGetTrafficPolicyInstance) ID() string {
6426 return "OperationDeserializer"
6427 }
6428
6429 func (m *awsRestxml_deserializeOpGetTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6430 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6431 ) {
6432 out, metadata, err = next.HandleDeserialize(ctx, in)
6433 if err != nil {
6434 return out, metadata, err
6435 }
6436
6437 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6438 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6439 defer endTimer()
6440 defer span.End()
6441 response, ok := out.RawResponse.(*smithyhttp.Response)
6442 if !ok {
6443 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6444 }
6445
6446 if response.StatusCode < 200 || response.StatusCode >= 300 {
6447 return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response, &metadata)
6448 }
6449 output := &GetTrafficPolicyInstanceOutput{}
6450 out.Result = output
6451
6452 var buff [1024]byte
6453 ringBuffer := smithyio.NewRingBuffer(buff[:])
6454 body := io.TeeReader(response.Body, ringBuffer)
6455 rootDecoder := xml.NewDecoder(body)
6456 t, err := smithyxml.FetchRootElement(rootDecoder)
6457 if err == io.EOF {
6458 return out, metadata, nil
6459 }
6460 if err != nil {
6461 var snapshot bytes.Buffer
6462 io.Copy(&snapshot, ringBuffer)
6463 return out, metadata, &smithy.DeserializationError{
6464 Err: fmt.Errorf("failed to decode response body, %w", err),
6465 Snapshot: snapshot.Bytes(),
6466 }
6467 }
6468
6469 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6470 err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(&output, decoder)
6471 if err != nil {
6472 var snapshot bytes.Buffer
6473 io.Copy(&snapshot, ringBuffer)
6474 return out, metadata, &smithy.DeserializationError{
6475 Err: fmt.Errorf("failed to decode response body, %w", err),
6476 Snapshot: snapshot.Bytes(),
6477 }
6478 }
6479
6480 span.End()
6481 return out, metadata, err
6482 }
6483
6484 func awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6485 var errorBuffer bytes.Buffer
6486 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6487 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6488 }
6489 errorBody := bytes.NewReader(errorBuffer.Bytes())
6490
6491 errorCode := "UnknownError"
6492 errorMessage := errorCode
6493
6494 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6495 if err != nil {
6496 return err
6497 }
6498 if reqID := errorComponents.RequestID; len(reqID) != 0 {
6499 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6500 }
6501 if len(errorComponents.Code) != 0 {
6502 errorCode = errorComponents.Code
6503 }
6504 if len(errorComponents.Message) != 0 {
6505 errorMessage = errorComponents.Message
6506 }
6507 errorBody.Seek(0, io.SeekStart)
6508 switch {
6509 case strings.EqualFold("InvalidInput", errorCode):
6510 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
6511
6512 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
6513 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
6514
6515 default:
6516 genericError := &smithy.GenericAPIError{
6517 Code: errorCode,
6518 Message: errorMessage,
6519 }
6520 return genericError
6521
6522 }
6523 }
6524
6525 func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(v **GetTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
6526 if v == nil {
6527 return fmt.Errorf("unexpected nil of type %T", v)
6528 }
6529 var sv *GetTrafficPolicyInstanceOutput
6530 if *v == nil {
6531 sv = &GetTrafficPolicyInstanceOutput{}
6532 } else {
6533 sv = *v
6534 }
6535
6536 for {
6537 t, done, err := decoder.Token()
6538 if err != nil {
6539 return err
6540 }
6541 if done {
6542 break
6543 }
6544 originalDecoder := decoder
6545 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
6546 switch {
6547 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
6548 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6549 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
6550 return err
6551 }
6552
6553 default:
6554 // Do nothing and ignore the unexpected tag element
6555 err = decoder.Decoder.Skip()
6556 if err != nil {
6557 return err
6558 }
6559
6560 }
6561 decoder = originalDecoder
6562 }
6563 *v = sv
6564 return nil
6565 }
6566
6567 type awsRestxml_deserializeOpGetTrafficPolicyInstanceCount struct {
6568 }
6569
6570 func (*awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) ID() string {
6571 return "OperationDeserializer"
6572 }
6573
6574 func (m *awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6575 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6576 ) {
6577 out, metadata, err = next.HandleDeserialize(ctx, in)
6578 if err != nil {
6579 return out, metadata, err
6580 }
6581
6582 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6583 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6584 defer endTimer()
6585 defer span.End()
6586 response, ok := out.RawResponse.(*smithyhttp.Response)
6587 if !ok {
6588 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6589 }
6590
6591 if response.StatusCode < 200 || response.StatusCode >= 300 {
6592 return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response, &metadata)
6593 }
6594 output := &GetTrafficPolicyInstanceCountOutput{}
6595 out.Result = output
6596
6597 var buff [1024]byte
6598 ringBuffer := smithyio.NewRingBuffer(buff[:])
6599 body := io.TeeReader(response.Body, ringBuffer)
6600 rootDecoder := xml.NewDecoder(body)
6601 t, err := smithyxml.FetchRootElement(rootDecoder)
6602 if err == io.EOF {
6603 return out, metadata, nil
6604 }
6605 if err != nil {
6606 var snapshot bytes.Buffer
6607 io.Copy(&snapshot, ringBuffer)
6608 return out, metadata, &smithy.DeserializationError{
6609 Err: fmt.Errorf("failed to decode response body, %w", err),
6610 Snapshot: snapshot.Bytes(),
6611 }
6612 }
6613
6614 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6615 err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(&output, decoder)
6616 if err != nil {
6617 var snapshot bytes.Buffer
6618 io.Copy(&snapshot, ringBuffer)
6619 return out, metadata, &smithy.DeserializationError{
6620 Err: fmt.Errorf("failed to decode response body, %w", err),
6621 Snapshot: snapshot.Bytes(),
6622 }
6623 }
6624
6625 span.End()
6626 return out, metadata, err
6627 }
6628
6629 func awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6630 var errorBuffer bytes.Buffer
6631 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6632 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6633 }
6634 errorBody := bytes.NewReader(errorBuffer.Bytes())
6635
6636 errorCode := "UnknownError"
6637 errorMessage := errorCode
6638
6639 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6640 if err != nil {
6641 return err
6642 }
6643 if reqID := errorComponents.RequestID; len(reqID) != 0 {
6644 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6645 }
6646 if len(errorComponents.Code) != 0 {
6647 errorCode = errorComponents.Code
6648 }
6649 if len(errorComponents.Message) != 0 {
6650 errorMessage = errorComponents.Message
6651 }
6652 errorBody.Seek(0, io.SeekStart)
6653 switch {
6654 default:
6655 genericError := &smithy.GenericAPIError{
6656 Code: errorCode,
6657 Message: errorMessage,
6658 }
6659 return genericError
6660
6661 }
6662 }
6663
6664 func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(v **GetTrafficPolicyInstanceCountOutput, decoder smithyxml.NodeDecoder) error {
6665 if v == nil {
6666 return fmt.Errorf("unexpected nil of type %T", v)
6667 }
6668 var sv *GetTrafficPolicyInstanceCountOutput
6669 if *v == nil {
6670 sv = &GetTrafficPolicyInstanceCountOutput{}
6671 } else {
6672 sv = *v
6673 }
6674
6675 for {
6676 t, done, err := decoder.Token()
6677 if err != nil {
6678 return err
6679 }
6680 if done {
6681 break
6682 }
6683 originalDecoder := decoder
6684 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
6685 switch {
6686 case strings.EqualFold("TrafficPolicyInstanceCount", t.Name.Local):
6687 val, err := decoder.Value()
6688 if err != nil {
6689 return err
6690 }
6691 if val == nil {
6692 break
6693 }
6694 {
6695 xtv := string(val)
6696 i64, err := strconv.ParseInt(xtv, 10, 64)
6697 if err != nil {
6698 return err
6699 }
6700 sv.TrafficPolicyInstanceCount = ptr.Int32(int32(i64))
6701 }
6702
6703 default:
6704 // Do nothing and ignore the unexpected tag element
6705 err = decoder.Decoder.Skip()
6706 if err != nil {
6707 return err
6708 }
6709
6710 }
6711 decoder = originalDecoder
6712 }
6713 *v = sv
6714 return nil
6715 }
6716
6717 type awsRestxml_deserializeOpListCidrBlocks struct {
6718 }
6719
6720 func (*awsRestxml_deserializeOpListCidrBlocks) ID() string {
6721 return "OperationDeserializer"
6722 }
6723
6724 func (m *awsRestxml_deserializeOpListCidrBlocks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6725 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6726 ) {
6727 out, metadata, err = next.HandleDeserialize(ctx, in)
6728 if err != nil {
6729 return out, metadata, err
6730 }
6731
6732 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6733 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6734 defer endTimer()
6735 defer span.End()
6736 response, ok := out.RawResponse.(*smithyhttp.Response)
6737 if !ok {
6738 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6739 }
6740
6741 if response.StatusCode < 200 || response.StatusCode >= 300 {
6742 return out, metadata, awsRestxml_deserializeOpErrorListCidrBlocks(response, &metadata)
6743 }
6744 output := &ListCidrBlocksOutput{}
6745 out.Result = output
6746
6747 var buff [1024]byte
6748 ringBuffer := smithyio.NewRingBuffer(buff[:])
6749 body := io.TeeReader(response.Body, ringBuffer)
6750 rootDecoder := xml.NewDecoder(body)
6751 t, err := smithyxml.FetchRootElement(rootDecoder)
6752 if err == io.EOF {
6753 return out, metadata, nil
6754 }
6755 if err != nil {
6756 var snapshot bytes.Buffer
6757 io.Copy(&snapshot, ringBuffer)
6758 return out, metadata, &smithy.DeserializationError{
6759 Err: fmt.Errorf("failed to decode response body, %w", err),
6760 Snapshot: snapshot.Bytes(),
6761 }
6762 }
6763
6764 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6765 err = awsRestxml_deserializeOpDocumentListCidrBlocksOutput(&output, decoder)
6766 if err != nil {
6767 var snapshot bytes.Buffer
6768 io.Copy(&snapshot, ringBuffer)
6769 return out, metadata, &smithy.DeserializationError{
6770 Err: fmt.Errorf("failed to decode response body, %w", err),
6771 Snapshot: snapshot.Bytes(),
6772 }
6773 }
6774
6775 span.End()
6776 return out, metadata, err
6777 }
6778
6779 func awsRestxml_deserializeOpErrorListCidrBlocks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6780 var errorBuffer bytes.Buffer
6781 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6782 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6783 }
6784 errorBody := bytes.NewReader(errorBuffer.Bytes())
6785
6786 errorCode := "UnknownError"
6787 errorMessage := errorCode
6788
6789 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6790 if err != nil {
6791 return err
6792 }
6793 if reqID := errorComponents.RequestID; len(reqID) != 0 {
6794 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6795 }
6796 if len(errorComponents.Code) != 0 {
6797 errorCode = errorComponents.Code
6798 }
6799 if len(errorComponents.Message) != 0 {
6800 errorMessage = errorComponents.Message
6801 }
6802 errorBody.Seek(0, io.SeekStart)
6803 switch {
6804 case strings.EqualFold("InvalidInput", errorCode):
6805 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
6806
6807 case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
6808 return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
6809
6810 case strings.EqualFold("NoSuchCidrLocationException", errorCode):
6811 return awsRestxml_deserializeErrorNoSuchCidrLocationException(response, errorBody)
6812
6813 default:
6814 genericError := &smithy.GenericAPIError{
6815 Code: errorCode,
6816 Message: errorMessage,
6817 }
6818 return genericError
6819
6820 }
6821 }
6822
6823 func awsRestxml_deserializeOpDocumentListCidrBlocksOutput(v **ListCidrBlocksOutput, decoder smithyxml.NodeDecoder) error {
6824 if v == nil {
6825 return fmt.Errorf("unexpected nil of type %T", v)
6826 }
6827 var sv *ListCidrBlocksOutput
6828 if *v == nil {
6829 sv = &ListCidrBlocksOutput{}
6830 } else {
6831 sv = *v
6832 }
6833
6834 for {
6835 t, done, err := decoder.Token()
6836 if err != nil {
6837 return err
6838 }
6839 if done {
6840 break
6841 }
6842 originalDecoder := decoder
6843 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
6844 switch {
6845 case strings.EqualFold("CidrBlocks", t.Name.Local):
6846 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6847 if err := awsRestxml_deserializeDocumentCidrBlockSummaries(&sv.CidrBlocks, nodeDecoder); err != nil {
6848 return err
6849 }
6850
6851 case strings.EqualFold("NextToken", t.Name.Local):
6852 val, err := decoder.Value()
6853 if err != nil {
6854 return err
6855 }
6856 if val == nil {
6857 break
6858 }
6859 {
6860 xtv := string(val)
6861 sv.NextToken = ptr.String(xtv)
6862 }
6863
6864 default:
6865 // Do nothing and ignore the unexpected tag element
6866 err = decoder.Decoder.Skip()
6867 if err != nil {
6868 return err
6869 }
6870
6871 }
6872 decoder = originalDecoder
6873 }
6874 *v = sv
6875 return nil
6876 }
6877
6878 type awsRestxml_deserializeOpListCidrCollections struct {
6879 }
6880
6881 func (*awsRestxml_deserializeOpListCidrCollections) ID() string {
6882 return "OperationDeserializer"
6883 }
6884
6885 func (m *awsRestxml_deserializeOpListCidrCollections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6886 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6887 ) {
6888 out, metadata, err = next.HandleDeserialize(ctx, in)
6889 if err != nil {
6890 return out, metadata, err
6891 }
6892
6893 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6894 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6895 defer endTimer()
6896 defer span.End()
6897 response, ok := out.RawResponse.(*smithyhttp.Response)
6898 if !ok {
6899 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6900 }
6901
6902 if response.StatusCode < 200 || response.StatusCode >= 300 {
6903 return out, metadata, awsRestxml_deserializeOpErrorListCidrCollections(response, &metadata)
6904 }
6905 output := &ListCidrCollectionsOutput{}
6906 out.Result = output
6907
6908 var buff [1024]byte
6909 ringBuffer := smithyio.NewRingBuffer(buff[:])
6910 body := io.TeeReader(response.Body, ringBuffer)
6911 rootDecoder := xml.NewDecoder(body)
6912 t, err := smithyxml.FetchRootElement(rootDecoder)
6913 if err == io.EOF {
6914 return out, metadata, nil
6915 }
6916 if err != nil {
6917 var snapshot bytes.Buffer
6918 io.Copy(&snapshot, ringBuffer)
6919 return out, metadata, &smithy.DeserializationError{
6920 Err: fmt.Errorf("failed to decode response body, %w", err),
6921 Snapshot: snapshot.Bytes(),
6922 }
6923 }
6924
6925 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6926 err = awsRestxml_deserializeOpDocumentListCidrCollectionsOutput(&output, decoder)
6927 if err != nil {
6928 var snapshot bytes.Buffer
6929 io.Copy(&snapshot, ringBuffer)
6930 return out, metadata, &smithy.DeserializationError{
6931 Err: fmt.Errorf("failed to decode response body, %w", err),
6932 Snapshot: snapshot.Bytes(),
6933 }
6934 }
6935
6936 span.End()
6937 return out, metadata, err
6938 }
6939
6940 func awsRestxml_deserializeOpErrorListCidrCollections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6941 var errorBuffer bytes.Buffer
6942 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6943 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6944 }
6945 errorBody := bytes.NewReader(errorBuffer.Bytes())
6946
6947 errorCode := "UnknownError"
6948 errorMessage := errorCode
6949
6950 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6951 if err != nil {
6952 return err
6953 }
6954 if reqID := errorComponents.RequestID; len(reqID) != 0 {
6955 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6956 }
6957 if len(errorComponents.Code) != 0 {
6958 errorCode = errorComponents.Code
6959 }
6960 if len(errorComponents.Message) != 0 {
6961 errorMessage = errorComponents.Message
6962 }
6963 errorBody.Seek(0, io.SeekStart)
6964 switch {
6965 case strings.EqualFold("InvalidInput", errorCode):
6966 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
6967
6968 default:
6969 genericError := &smithy.GenericAPIError{
6970 Code: errorCode,
6971 Message: errorMessage,
6972 }
6973 return genericError
6974
6975 }
6976 }
6977
6978 func awsRestxml_deserializeOpDocumentListCidrCollectionsOutput(v **ListCidrCollectionsOutput, decoder smithyxml.NodeDecoder) error {
6979 if v == nil {
6980 return fmt.Errorf("unexpected nil of type %T", v)
6981 }
6982 var sv *ListCidrCollectionsOutput
6983 if *v == nil {
6984 sv = &ListCidrCollectionsOutput{}
6985 } else {
6986 sv = *v
6987 }
6988
6989 for {
6990 t, done, err := decoder.Token()
6991 if err != nil {
6992 return err
6993 }
6994 if done {
6995 break
6996 }
6997 originalDecoder := decoder
6998 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
6999 switch {
7000 case strings.EqualFold("CidrCollections", t.Name.Local):
7001 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7002 if err := awsRestxml_deserializeDocumentCollectionSummaries(&sv.CidrCollections, nodeDecoder); err != nil {
7003 return err
7004 }
7005
7006 case strings.EqualFold("NextToken", t.Name.Local):
7007 val, err := decoder.Value()
7008 if err != nil {
7009 return err
7010 }
7011 if val == nil {
7012 break
7013 }
7014 {
7015 xtv := string(val)
7016 sv.NextToken = ptr.String(xtv)
7017 }
7018
7019 default:
7020 // Do nothing and ignore the unexpected tag element
7021 err = decoder.Decoder.Skip()
7022 if err != nil {
7023 return err
7024 }
7025
7026 }
7027 decoder = originalDecoder
7028 }
7029 *v = sv
7030 return nil
7031 }
7032
7033 type awsRestxml_deserializeOpListCidrLocations struct {
7034 }
7035
7036 func (*awsRestxml_deserializeOpListCidrLocations) ID() string {
7037 return "OperationDeserializer"
7038 }
7039
7040 func (m *awsRestxml_deserializeOpListCidrLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7041 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7042 ) {
7043 out, metadata, err = next.HandleDeserialize(ctx, in)
7044 if err != nil {
7045 return out, metadata, err
7046 }
7047
7048 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7049 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7050 defer endTimer()
7051 defer span.End()
7052 response, ok := out.RawResponse.(*smithyhttp.Response)
7053 if !ok {
7054 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7055 }
7056
7057 if response.StatusCode < 200 || response.StatusCode >= 300 {
7058 return out, metadata, awsRestxml_deserializeOpErrorListCidrLocations(response, &metadata)
7059 }
7060 output := &ListCidrLocationsOutput{}
7061 out.Result = output
7062
7063 var buff [1024]byte
7064 ringBuffer := smithyio.NewRingBuffer(buff[:])
7065 body := io.TeeReader(response.Body, ringBuffer)
7066 rootDecoder := xml.NewDecoder(body)
7067 t, err := smithyxml.FetchRootElement(rootDecoder)
7068 if err == io.EOF {
7069 return out, metadata, nil
7070 }
7071 if err != nil {
7072 var snapshot bytes.Buffer
7073 io.Copy(&snapshot, ringBuffer)
7074 return out, metadata, &smithy.DeserializationError{
7075 Err: fmt.Errorf("failed to decode response body, %w", err),
7076 Snapshot: snapshot.Bytes(),
7077 }
7078 }
7079
7080 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7081 err = awsRestxml_deserializeOpDocumentListCidrLocationsOutput(&output, decoder)
7082 if err != nil {
7083 var snapshot bytes.Buffer
7084 io.Copy(&snapshot, ringBuffer)
7085 return out, metadata, &smithy.DeserializationError{
7086 Err: fmt.Errorf("failed to decode response body, %w", err),
7087 Snapshot: snapshot.Bytes(),
7088 }
7089 }
7090
7091 span.End()
7092 return out, metadata, err
7093 }
7094
7095 func awsRestxml_deserializeOpErrorListCidrLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7096 var errorBuffer bytes.Buffer
7097 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7098 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7099 }
7100 errorBody := bytes.NewReader(errorBuffer.Bytes())
7101
7102 errorCode := "UnknownError"
7103 errorMessage := errorCode
7104
7105 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7106 if err != nil {
7107 return err
7108 }
7109 if reqID := errorComponents.RequestID; len(reqID) != 0 {
7110 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7111 }
7112 if len(errorComponents.Code) != 0 {
7113 errorCode = errorComponents.Code
7114 }
7115 if len(errorComponents.Message) != 0 {
7116 errorMessage = errorComponents.Message
7117 }
7118 errorBody.Seek(0, io.SeekStart)
7119 switch {
7120 case strings.EqualFold("InvalidInput", errorCode):
7121 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
7122
7123 case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
7124 return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
7125
7126 default:
7127 genericError := &smithy.GenericAPIError{
7128 Code: errorCode,
7129 Message: errorMessage,
7130 }
7131 return genericError
7132
7133 }
7134 }
7135
7136 func awsRestxml_deserializeOpDocumentListCidrLocationsOutput(v **ListCidrLocationsOutput, decoder smithyxml.NodeDecoder) error {
7137 if v == nil {
7138 return fmt.Errorf("unexpected nil of type %T", v)
7139 }
7140 var sv *ListCidrLocationsOutput
7141 if *v == nil {
7142 sv = &ListCidrLocationsOutput{}
7143 } else {
7144 sv = *v
7145 }
7146
7147 for {
7148 t, done, err := decoder.Token()
7149 if err != nil {
7150 return err
7151 }
7152 if done {
7153 break
7154 }
7155 originalDecoder := decoder
7156 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
7157 switch {
7158 case strings.EqualFold("CidrLocations", t.Name.Local):
7159 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7160 if err := awsRestxml_deserializeDocumentLocationSummaries(&sv.CidrLocations, nodeDecoder); err != nil {
7161 return err
7162 }
7163
7164 case strings.EqualFold("NextToken", t.Name.Local):
7165 val, err := decoder.Value()
7166 if err != nil {
7167 return err
7168 }
7169 if val == nil {
7170 break
7171 }
7172 {
7173 xtv := string(val)
7174 sv.NextToken = ptr.String(xtv)
7175 }
7176
7177 default:
7178 // Do nothing and ignore the unexpected tag element
7179 err = decoder.Decoder.Skip()
7180 if err != nil {
7181 return err
7182 }
7183
7184 }
7185 decoder = originalDecoder
7186 }
7187 *v = sv
7188 return nil
7189 }
7190
7191 type awsRestxml_deserializeOpListGeoLocations struct {
7192 }
7193
7194 func (*awsRestxml_deserializeOpListGeoLocations) ID() string {
7195 return "OperationDeserializer"
7196 }
7197
7198 func (m *awsRestxml_deserializeOpListGeoLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7199 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7200 ) {
7201 out, metadata, err = next.HandleDeserialize(ctx, in)
7202 if err != nil {
7203 return out, metadata, err
7204 }
7205
7206 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7207 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7208 defer endTimer()
7209 defer span.End()
7210 response, ok := out.RawResponse.(*smithyhttp.Response)
7211 if !ok {
7212 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7213 }
7214
7215 if response.StatusCode < 200 || response.StatusCode >= 300 {
7216 return out, metadata, awsRestxml_deserializeOpErrorListGeoLocations(response, &metadata)
7217 }
7218 output := &ListGeoLocationsOutput{}
7219 out.Result = output
7220
7221 var buff [1024]byte
7222 ringBuffer := smithyio.NewRingBuffer(buff[:])
7223 body := io.TeeReader(response.Body, ringBuffer)
7224 rootDecoder := xml.NewDecoder(body)
7225 t, err := smithyxml.FetchRootElement(rootDecoder)
7226 if err == io.EOF {
7227 return out, metadata, nil
7228 }
7229 if err != nil {
7230 var snapshot bytes.Buffer
7231 io.Copy(&snapshot, ringBuffer)
7232 return out, metadata, &smithy.DeserializationError{
7233 Err: fmt.Errorf("failed to decode response body, %w", err),
7234 Snapshot: snapshot.Bytes(),
7235 }
7236 }
7237
7238 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7239 err = awsRestxml_deserializeOpDocumentListGeoLocationsOutput(&output, decoder)
7240 if err != nil {
7241 var snapshot bytes.Buffer
7242 io.Copy(&snapshot, ringBuffer)
7243 return out, metadata, &smithy.DeserializationError{
7244 Err: fmt.Errorf("failed to decode response body, %w", err),
7245 Snapshot: snapshot.Bytes(),
7246 }
7247 }
7248
7249 span.End()
7250 return out, metadata, err
7251 }
7252
7253 func awsRestxml_deserializeOpErrorListGeoLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7254 var errorBuffer bytes.Buffer
7255 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7256 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7257 }
7258 errorBody := bytes.NewReader(errorBuffer.Bytes())
7259
7260 errorCode := "UnknownError"
7261 errorMessage := errorCode
7262
7263 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7264 if err != nil {
7265 return err
7266 }
7267 if reqID := errorComponents.RequestID; len(reqID) != 0 {
7268 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7269 }
7270 if len(errorComponents.Code) != 0 {
7271 errorCode = errorComponents.Code
7272 }
7273 if len(errorComponents.Message) != 0 {
7274 errorMessage = errorComponents.Message
7275 }
7276 errorBody.Seek(0, io.SeekStart)
7277 switch {
7278 case strings.EqualFold("InvalidInput", errorCode):
7279 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
7280
7281 default:
7282 genericError := &smithy.GenericAPIError{
7283 Code: errorCode,
7284 Message: errorMessage,
7285 }
7286 return genericError
7287
7288 }
7289 }
7290
7291 func awsRestxml_deserializeOpDocumentListGeoLocationsOutput(v **ListGeoLocationsOutput, decoder smithyxml.NodeDecoder) error {
7292 if v == nil {
7293 return fmt.Errorf("unexpected nil of type %T", v)
7294 }
7295 var sv *ListGeoLocationsOutput
7296 if *v == nil {
7297 sv = &ListGeoLocationsOutput{}
7298 } else {
7299 sv = *v
7300 }
7301
7302 for {
7303 t, done, err := decoder.Token()
7304 if err != nil {
7305 return err
7306 }
7307 if done {
7308 break
7309 }
7310 originalDecoder := decoder
7311 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
7312 switch {
7313 case strings.EqualFold("GeoLocationDetailsList", t.Name.Local):
7314 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7315 if err := awsRestxml_deserializeDocumentGeoLocationDetailsList(&sv.GeoLocationDetailsList, nodeDecoder); err != nil {
7316 return err
7317 }
7318
7319 case strings.EqualFold("IsTruncated", t.Name.Local):
7320 val, err := decoder.Value()
7321 if err != nil {
7322 return err
7323 }
7324 if val == nil {
7325 break
7326 }
7327 {
7328 xtv, err := strconv.ParseBool(string(val))
7329 if err != nil {
7330 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
7331 }
7332 sv.IsTruncated = xtv
7333 }
7334
7335 case strings.EqualFold("MaxItems", t.Name.Local):
7336 val, err := decoder.Value()
7337 if err != nil {
7338 return err
7339 }
7340 if val == nil {
7341 break
7342 }
7343 {
7344 xtv := string(val)
7345 i64, err := strconv.ParseInt(xtv, 10, 64)
7346 if err != nil {
7347 return err
7348 }
7349 sv.MaxItems = ptr.Int32(int32(i64))
7350 }
7351
7352 case strings.EqualFold("NextContinentCode", t.Name.Local):
7353 val, err := decoder.Value()
7354 if err != nil {
7355 return err
7356 }
7357 if val == nil {
7358 break
7359 }
7360 {
7361 xtv := string(val)
7362 sv.NextContinentCode = ptr.String(xtv)
7363 }
7364
7365 case strings.EqualFold("NextCountryCode", t.Name.Local):
7366 val, err := decoder.Value()
7367 if err != nil {
7368 return err
7369 }
7370 if val == nil {
7371 break
7372 }
7373 {
7374 xtv := string(val)
7375 sv.NextCountryCode = ptr.String(xtv)
7376 }
7377
7378 case strings.EqualFold("NextSubdivisionCode", t.Name.Local):
7379 val, err := decoder.Value()
7380 if err != nil {
7381 return err
7382 }
7383 if val == nil {
7384 break
7385 }
7386 {
7387 xtv := string(val)
7388 sv.NextSubdivisionCode = ptr.String(xtv)
7389 }
7390
7391 default:
7392 // Do nothing and ignore the unexpected tag element
7393 err = decoder.Decoder.Skip()
7394 if err != nil {
7395 return err
7396 }
7397
7398 }
7399 decoder = originalDecoder
7400 }
7401 *v = sv
7402 return nil
7403 }
7404
7405 type awsRestxml_deserializeOpListHealthChecks struct {
7406 }
7407
7408 func (*awsRestxml_deserializeOpListHealthChecks) ID() string {
7409 return "OperationDeserializer"
7410 }
7411
7412 func (m *awsRestxml_deserializeOpListHealthChecks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7413 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7414 ) {
7415 out, metadata, err = next.HandleDeserialize(ctx, in)
7416 if err != nil {
7417 return out, metadata, err
7418 }
7419
7420 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7421 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7422 defer endTimer()
7423 defer span.End()
7424 response, ok := out.RawResponse.(*smithyhttp.Response)
7425 if !ok {
7426 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7427 }
7428
7429 if response.StatusCode < 200 || response.StatusCode >= 300 {
7430 return out, metadata, awsRestxml_deserializeOpErrorListHealthChecks(response, &metadata)
7431 }
7432 output := &ListHealthChecksOutput{}
7433 out.Result = output
7434
7435 var buff [1024]byte
7436 ringBuffer := smithyio.NewRingBuffer(buff[:])
7437 body := io.TeeReader(response.Body, ringBuffer)
7438 rootDecoder := xml.NewDecoder(body)
7439 t, err := smithyxml.FetchRootElement(rootDecoder)
7440 if err == io.EOF {
7441 return out, metadata, nil
7442 }
7443 if err != nil {
7444 var snapshot bytes.Buffer
7445 io.Copy(&snapshot, ringBuffer)
7446 return out, metadata, &smithy.DeserializationError{
7447 Err: fmt.Errorf("failed to decode response body, %w", err),
7448 Snapshot: snapshot.Bytes(),
7449 }
7450 }
7451
7452 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7453 err = awsRestxml_deserializeOpDocumentListHealthChecksOutput(&output, decoder)
7454 if err != nil {
7455 var snapshot bytes.Buffer
7456 io.Copy(&snapshot, ringBuffer)
7457 return out, metadata, &smithy.DeserializationError{
7458 Err: fmt.Errorf("failed to decode response body, %w", err),
7459 Snapshot: snapshot.Bytes(),
7460 }
7461 }
7462
7463 span.End()
7464 return out, metadata, err
7465 }
7466
7467 func awsRestxml_deserializeOpErrorListHealthChecks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7468 var errorBuffer bytes.Buffer
7469 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7470 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7471 }
7472 errorBody := bytes.NewReader(errorBuffer.Bytes())
7473
7474 errorCode := "UnknownError"
7475 errorMessage := errorCode
7476
7477 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7478 if err != nil {
7479 return err
7480 }
7481 if reqID := errorComponents.RequestID; len(reqID) != 0 {
7482 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7483 }
7484 if len(errorComponents.Code) != 0 {
7485 errorCode = errorComponents.Code
7486 }
7487 if len(errorComponents.Message) != 0 {
7488 errorMessage = errorComponents.Message
7489 }
7490 errorBody.Seek(0, io.SeekStart)
7491 switch {
7492 case strings.EqualFold("IncompatibleVersion", errorCode):
7493 return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody)
7494
7495 case strings.EqualFold("InvalidInput", errorCode):
7496 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
7497
7498 default:
7499 genericError := &smithy.GenericAPIError{
7500 Code: errorCode,
7501 Message: errorMessage,
7502 }
7503 return genericError
7504
7505 }
7506 }
7507
7508 func awsRestxml_deserializeOpDocumentListHealthChecksOutput(v **ListHealthChecksOutput, decoder smithyxml.NodeDecoder) error {
7509 if v == nil {
7510 return fmt.Errorf("unexpected nil of type %T", v)
7511 }
7512 var sv *ListHealthChecksOutput
7513 if *v == nil {
7514 sv = &ListHealthChecksOutput{}
7515 } else {
7516 sv = *v
7517 }
7518
7519 for {
7520 t, done, err := decoder.Token()
7521 if err != nil {
7522 return err
7523 }
7524 if done {
7525 break
7526 }
7527 originalDecoder := decoder
7528 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
7529 switch {
7530 case strings.EqualFold("HealthChecks", t.Name.Local):
7531 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7532 if err := awsRestxml_deserializeDocumentHealthChecks(&sv.HealthChecks, nodeDecoder); err != nil {
7533 return err
7534 }
7535
7536 case strings.EqualFold("IsTruncated", t.Name.Local):
7537 val, err := decoder.Value()
7538 if err != nil {
7539 return err
7540 }
7541 if val == nil {
7542 break
7543 }
7544 {
7545 xtv, err := strconv.ParseBool(string(val))
7546 if err != nil {
7547 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
7548 }
7549 sv.IsTruncated = xtv
7550 }
7551
7552 case strings.EqualFold("Marker", t.Name.Local):
7553 val, err := decoder.Value()
7554 if err != nil {
7555 return err
7556 }
7557 if val == nil {
7558 break
7559 }
7560 {
7561 xtv := string(val)
7562 sv.Marker = ptr.String(xtv)
7563 }
7564
7565 case strings.EqualFold("MaxItems", t.Name.Local):
7566 val, err := decoder.Value()
7567 if err != nil {
7568 return err
7569 }
7570 if val == nil {
7571 break
7572 }
7573 {
7574 xtv := string(val)
7575 i64, err := strconv.ParseInt(xtv, 10, 64)
7576 if err != nil {
7577 return err
7578 }
7579 sv.MaxItems = ptr.Int32(int32(i64))
7580 }
7581
7582 case strings.EqualFold("NextMarker", t.Name.Local):
7583 val, err := decoder.Value()
7584 if err != nil {
7585 return err
7586 }
7587 if val == nil {
7588 break
7589 }
7590 {
7591 xtv := string(val)
7592 sv.NextMarker = ptr.String(xtv)
7593 }
7594
7595 default:
7596 // Do nothing and ignore the unexpected tag element
7597 err = decoder.Decoder.Skip()
7598 if err != nil {
7599 return err
7600 }
7601
7602 }
7603 decoder = originalDecoder
7604 }
7605 *v = sv
7606 return nil
7607 }
7608
7609 type awsRestxml_deserializeOpListHostedZones struct {
7610 }
7611
7612 func (*awsRestxml_deserializeOpListHostedZones) ID() string {
7613 return "OperationDeserializer"
7614 }
7615
7616 func (m *awsRestxml_deserializeOpListHostedZones) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7617 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7618 ) {
7619 out, metadata, err = next.HandleDeserialize(ctx, in)
7620 if err != nil {
7621 return out, metadata, err
7622 }
7623
7624 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7625 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7626 defer endTimer()
7627 defer span.End()
7628 response, ok := out.RawResponse.(*smithyhttp.Response)
7629 if !ok {
7630 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7631 }
7632
7633 if response.StatusCode < 200 || response.StatusCode >= 300 {
7634 return out, metadata, awsRestxml_deserializeOpErrorListHostedZones(response, &metadata)
7635 }
7636 output := &ListHostedZonesOutput{}
7637 out.Result = output
7638
7639 var buff [1024]byte
7640 ringBuffer := smithyio.NewRingBuffer(buff[:])
7641 body := io.TeeReader(response.Body, ringBuffer)
7642 rootDecoder := xml.NewDecoder(body)
7643 t, err := smithyxml.FetchRootElement(rootDecoder)
7644 if err == io.EOF {
7645 return out, metadata, nil
7646 }
7647 if err != nil {
7648 var snapshot bytes.Buffer
7649 io.Copy(&snapshot, ringBuffer)
7650 return out, metadata, &smithy.DeserializationError{
7651 Err: fmt.Errorf("failed to decode response body, %w", err),
7652 Snapshot: snapshot.Bytes(),
7653 }
7654 }
7655
7656 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7657 err = awsRestxml_deserializeOpDocumentListHostedZonesOutput(&output, decoder)
7658 if err != nil {
7659 var snapshot bytes.Buffer
7660 io.Copy(&snapshot, ringBuffer)
7661 return out, metadata, &smithy.DeserializationError{
7662 Err: fmt.Errorf("failed to decode response body, %w", err),
7663 Snapshot: snapshot.Bytes(),
7664 }
7665 }
7666
7667 span.End()
7668 return out, metadata, err
7669 }
7670
7671 func awsRestxml_deserializeOpErrorListHostedZones(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7672 var errorBuffer bytes.Buffer
7673 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7674 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7675 }
7676 errorBody := bytes.NewReader(errorBuffer.Bytes())
7677
7678 errorCode := "UnknownError"
7679 errorMessage := errorCode
7680
7681 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7682 if err != nil {
7683 return err
7684 }
7685 if reqID := errorComponents.RequestID; len(reqID) != 0 {
7686 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7687 }
7688 if len(errorComponents.Code) != 0 {
7689 errorCode = errorComponents.Code
7690 }
7691 if len(errorComponents.Message) != 0 {
7692 errorMessage = errorComponents.Message
7693 }
7694 errorBody.Seek(0, io.SeekStart)
7695 switch {
7696 case strings.EqualFold("DelegationSetNotReusable", errorCode):
7697 return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
7698
7699 case strings.EqualFold("InvalidInput", errorCode):
7700 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
7701
7702 case strings.EqualFold("NoSuchDelegationSet", errorCode):
7703 return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
7704
7705 default:
7706 genericError := &smithy.GenericAPIError{
7707 Code: errorCode,
7708 Message: errorMessage,
7709 }
7710 return genericError
7711
7712 }
7713 }
7714
7715 func awsRestxml_deserializeOpDocumentListHostedZonesOutput(v **ListHostedZonesOutput, decoder smithyxml.NodeDecoder) error {
7716 if v == nil {
7717 return fmt.Errorf("unexpected nil of type %T", v)
7718 }
7719 var sv *ListHostedZonesOutput
7720 if *v == nil {
7721 sv = &ListHostedZonesOutput{}
7722 } else {
7723 sv = *v
7724 }
7725
7726 for {
7727 t, done, err := decoder.Token()
7728 if err != nil {
7729 return err
7730 }
7731 if done {
7732 break
7733 }
7734 originalDecoder := decoder
7735 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
7736 switch {
7737 case strings.EqualFold("HostedZones", t.Name.Local):
7738 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7739 if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil {
7740 return err
7741 }
7742
7743 case strings.EqualFold("IsTruncated", t.Name.Local):
7744 val, err := decoder.Value()
7745 if err != nil {
7746 return err
7747 }
7748 if val == nil {
7749 break
7750 }
7751 {
7752 xtv, err := strconv.ParseBool(string(val))
7753 if err != nil {
7754 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
7755 }
7756 sv.IsTruncated = xtv
7757 }
7758
7759 case strings.EqualFold("Marker", t.Name.Local):
7760 val, err := decoder.Value()
7761 if err != nil {
7762 return err
7763 }
7764 if val == nil {
7765 break
7766 }
7767 {
7768 xtv := string(val)
7769 sv.Marker = ptr.String(xtv)
7770 }
7771
7772 case strings.EqualFold("MaxItems", t.Name.Local):
7773 val, err := decoder.Value()
7774 if err != nil {
7775 return err
7776 }
7777 if val == nil {
7778 break
7779 }
7780 {
7781 xtv := string(val)
7782 i64, err := strconv.ParseInt(xtv, 10, 64)
7783 if err != nil {
7784 return err
7785 }
7786 sv.MaxItems = ptr.Int32(int32(i64))
7787 }
7788
7789 case strings.EqualFold("NextMarker", t.Name.Local):
7790 val, err := decoder.Value()
7791 if err != nil {
7792 return err
7793 }
7794 if val == nil {
7795 break
7796 }
7797 {
7798 xtv := string(val)
7799 sv.NextMarker = ptr.String(xtv)
7800 }
7801
7802 default:
7803 // Do nothing and ignore the unexpected tag element
7804 err = decoder.Decoder.Skip()
7805 if err != nil {
7806 return err
7807 }
7808
7809 }
7810 decoder = originalDecoder
7811 }
7812 *v = sv
7813 return nil
7814 }
7815
7816 type awsRestxml_deserializeOpListHostedZonesByName struct {
7817 }
7818
7819 func (*awsRestxml_deserializeOpListHostedZonesByName) ID() string {
7820 return "OperationDeserializer"
7821 }
7822
7823 func (m *awsRestxml_deserializeOpListHostedZonesByName) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7824 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7825 ) {
7826 out, metadata, err = next.HandleDeserialize(ctx, in)
7827 if err != nil {
7828 return out, metadata, err
7829 }
7830
7831 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7832 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7833 defer endTimer()
7834 defer span.End()
7835 response, ok := out.RawResponse.(*smithyhttp.Response)
7836 if !ok {
7837 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7838 }
7839
7840 if response.StatusCode < 200 || response.StatusCode >= 300 {
7841 return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByName(response, &metadata)
7842 }
7843 output := &ListHostedZonesByNameOutput{}
7844 out.Result = output
7845
7846 var buff [1024]byte
7847 ringBuffer := smithyio.NewRingBuffer(buff[:])
7848 body := io.TeeReader(response.Body, ringBuffer)
7849 rootDecoder := xml.NewDecoder(body)
7850 t, err := smithyxml.FetchRootElement(rootDecoder)
7851 if err == io.EOF {
7852 return out, metadata, nil
7853 }
7854 if err != nil {
7855 var snapshot bytes.Buffer
7856 io.Copy(&snapshot, ringBuffer)
7857 return out, metadata, &smithy.DeserializationError{
7858 Err: fmt.Errorf("failed to decode response body, %w", err),
7859 Snapshot: snapshot.Bytes(),
7860 }
7861 }
7862
7863 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7864 err = awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(&output, decoder)
7865 if err != nil {
7866 var snapshot bytes.Buffer
7867 io.Copy(&snapshot, ringBuffer)
7868 return out, metadata, &smithy.DeserializationError{
7869 Err: fmt.Errorf("failed to decode response body, %w", err),
7870 Snapshot: snapshot.Bytes(),
7871 }
7872 }
7873
7874 span.End()
7875 return out, metadata, err
7876 }
7877
7878 func awsRestxml_deserializeOpErrorListHostedZonesByName(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7879 var errorBuffer bytes.Buffer
7880 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7881 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7882 }
7883 errorBody := bytes.NewReader(errorBuffer.Bytes())
7884
7885 errorCode := "UnknownError"
7886 errorMessage := errorCode
7887
7888 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7889 if err != nil {
7890 return err
7891 }
7892 if reqID := errorComponents.RequestID; len(reqID) != 0 {
7893 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7894 }
7895 if len(errorComponents.Code) != 0 {
7896 errorCode = errorComponents.Code
7897 }
7898 if len(errorComponents.Message) != 0 {
7899 errorMessage = errorComponents.Message
7900 }
7901 errorBody.Seek(0, io.SeekStart)
7902 switch {
7903 case strings.EqualFold("InvalidDomainName", errorCode):
7904 return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
7905
7906 case strings.EqualFold("InvalidInput", errorCode):
7907 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
7908
7909 default:
7910 genericError := &smithy.GenericAPIError{
7911 Code: errorCode,
7912 Message: errorMessage,
7913 }
7914 return genericError
7915
7916 }
7917 }
7918
7919 func awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(v **ListHostedZonesByNameOutput, decoder smithyxml.NodeDecoder) error {
7920 if v == nil {
7921 return fmt.Errorf("unexpected nil of type %T", v)
7922 }
7923 var sv *ListHostedZonesByNameOutput
7924 if *v == nil {
7925 sv = &ListHostedZonesByNameOutput{}
7926 } else {
7927 sv = *v
7928 }
7929
7930 for {
7931 t, done, err := decoder.Token()
7932 if err != nil {
7933 return err
7934 }
7935 if done {
7936 break
7937 }
7938 originalDecoder := decoder
7939 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
7940 switch {
7941 case strings.EqualFold("DNSName", t.Name.Local):
7942 val, err := decoder.Value()
7943 if err != nil {
7944 return err
7945 }
7946 if val == nil {
7947 break
7948 }
7949 {
7950 xtv := string(val)
7951 sv.DNSName = ptr.String(xtv)
7952 }
7953
7954 case strings.EqualFold("HostedZoneId", t.Name.Local):
7955 val, err := decoder.Value()
7956 if err != nil {
7957 return err
7958 }
7959 if val == nil {
7960 break
7961 }
7962 {
7963 xtv := string(val)
7964 sv.HostedZoneId = ptr.String(xtv)
7965 }
7966
7967 case strings.EqualFold("HostedZones", t.Name.Local):
7968 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7969 if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil {
7970 return err
7971 }
7972
7973 case strings.EqualFold("IsTruncated", t.Name.Local):
7974 val, err := decoder.Value()
7975 if err != nil {
7976 return err
7977 }
7978 if val == nil {
7979 break
7980 }
7981 {
7982 xtv, err := strconv.ParseBool(string(val))
7983 if err != nil {
7984 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
7985 }
7986 sv.IsTruncated = xtv
7987 }
7988
7989 case strings.EqualFold("MaxItems", t.Name.Local):
7990 val, err := decoder.Value()
7991 if err != nil {
7992 return err
7993 }
7994 if val == nil {
7995 break
7996 }
7997 {
7998 xtv := string(val)
7999 i64, err := strconv.ParseInt(xtv, 10, 64)
8000 if err != nil {
8001 return err
8002 }
8003 sv.MaxItems = ptr.Int32(int32(i64))
8004 }
8005
8006 case strings.EqualFold("NextDNSName", t.Name.Local):
8007 val, err := decoder.Value()
8008 if err != nil {
8009 return err
8010 }
8011 if val == nil {
8012 break
8013 }
8014 {
8015 xtv := string(val)
8016 sv.NextDNSName = ptr.String(xtv)
8017 }
8018
8019 case strings.EqualFold("NextHostedZoneId", t.Name.Local):
8020 val, err := decoder.Value()
8021 if err != nil {
8022 return err
8023 }
8024 if val == nil {
8025 break
8026 }
8027 {
8028 xtv := string(val)
8029 sv.NextHostedZoneId = ptr.String(xtv)
8030 }
8031
8032 default:
8033 // Do nothing and ignore the unexpected tag element
8034 err = decoder.Decoder.Skip()
8035 if err != nil {
8036 return err
8037 }
8038
8039 }
8040 decoder = originalDecoder
8041 }
8042 *v = sv
8043 return nil
8044 }
8045
8046 type awsRestxml_deserializeOpListHostedZonesByVPC struct {
8047 }
8048
8049 func (*awsRestxml_deserializeOpListHostedZonesByVPC) ID() string {
8050 return "OperationDeserializer"
8051 }
8052
8053 func (m *awsRestxml_deserializeOpListHostedZonesByVPC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8054 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8055 ) {
8056 out, metadata, err = next.HandleDeserialize(ctx, in)
8057 if err != nil {
8058 return out, metadata, err
8059 }
8060
8061 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8062 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8063 defer endTimer()
8064 defer span.End()
8065 response, ok := out.RawResponse.(*smithyhttp.Response)
8066 if !ok {
8067 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8068 }
8069
8070 if response.StatusCode < 200 || response.StatusCode >= 300 {
8071 return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByVPC(response, &metadata)
8072 }
8073 output := &ListHostedZonesByVPCOutput{}
8074 out.Result = output
8075
8076 var buff [1024]byte
8077 ringBuffer := smithyio.NewRingBuffer(buff[:])
8078 body := io.TeeReader(response.Body, ringBuffer)
8079 rootDecoder := xml.NewDecoder(body)
8080 t, err := smithyxml.FetchRootElement(rootDecoder)
8081 if err == io.EOF {
8082 return out, metadata, nil
8083 }
8084 if err != nil {
8085 var snapshot bytes.Buffer
8086 io.Copy(&snapshot, ringBuffer)
8087 return out, metadata, &smithy.DeserializationError{
8088 Err: fmt.Errorf("failed to decode response body, %w", err),
8089 Snapshot: snapshot.Bytes(),
8090 }
8091 }
8092
8093 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8094 err = awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(&output, decoder)
8095 if err != nil {
8096 var snapshot bytes.Buffer
8097 io.Copy(&snapshot, ringBuffer)
8098 return out, metadata, &smithy.DeserializationError{
8099 Err: fmt.Errorf("failed to decode response body, %w", err),
8100 Snapshot: snapshot.Bytes(),
8101 }
8102 }
8103
8104 span.End()
8105 return out, metadata, err
8106 }
8107
8108 func awsRestxml_deserializeOpErrorListHostedZonesByVPC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8109 var errorBuffer bytes.Buffer
8110 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8111 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8112 }
8113 errorBody := bytes.NewReader(errorBuffer.Bytes())
8114
8115 errorCode := "UnknownError"
8116 errorMessage := errorCode
8117
8118 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
8119 if err != nil {
8120 return err
8121 }
8122 if reqID := errorComponents.RequestID; len(reqID) != 0 {
8123 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
8124 }
8125 if len(errorComponents.Code) != 0 {
8126 errorCode = errorComponents.Code
8127 }
8128 if len(errorComponents.Message) != 0 {
8129 errorMessage = errorComponents.Message
8130 }
8131 errorBody.Seek(0, io.SeekStart)
8132 switch {
8133 case strings.EqualFold("InvalidInput", errorCode):
8134 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
8135
8136 case strings.EqualFold("InvalidPaginationToken", errorCode):
8137 return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
8138
8139 default:
8140 genericError := &smithy.GenericAPIError{
8141 Code: errorCode,
8142 Message: errorMessage,
8143 }
8144 return genericError
8145
8146 }
8147 }
8148
8149 func awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(v **ListHostedZonesByVPCOutput, decoder smithyxml.NodeDecoder) error {
8150 if v == nil {
8151 return fmt.Errorf("unexpected nil of type %T", v)
8152 }
8153 var sv *ListHostedZonesByVPCOutput
8154 if *v == nil {
8155 sv = &ListHostedZonesByVPCOutput{}
8156 } else {
8157 sv = *v
8158 }
8159
8160 for {
8161 t, done, err := decoder.Token()
8162 if err != nil {
8163 return err
8164 }
8165 if done {
8166 break
8167 }
8168 originalDecoder := decoder
8169 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
8170 switch {
8171 case strings.EqualFold("HostedZoneSummaries", t.Name.Local):
8172 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8173 if err := awsRestxml_deserializeDocumentHostedZoneSummaries(&sv.HostedZoneSummaries, nodeDecoder); err != nil {
8174 return err
8175 }
8176
8177 case strings.EqualFold("MaxItems", t.Name.Local):
8178 val, err := decoder.Value()
8179 if err != nil {
8180 return err
8181 }
8182 if val == nil {
8183 break
8184 }
8185 {
8186 xtv := string(val)
8187 i64, err := strconv.ParseInt(xtv, 10, 64)
8188 if err != nil {
8189 return err
8190 }
8191 sv.MaxItems = ptr.Int32(int32(i64))
8192 }
8193
8194 case strings.EqualFold("NextToken", t.Name.Local):
8195 val, err := decoder.Value()
8196 if err != nil {
8197 return err
8198 }
8199 if val == nil {
8200 break
8201 }
8202 {
8203 xtv := string(val)
8204 sv.NextToken = ptr.String(xtv)
8205 }
8206
8207 default:
8208 // Do nothing and ignore the unexpected tag element
8209 err = decoder.Decoder.Skip()
8210 if err != nil {
8211 return err
8212 }
8213
8214 }
8215 decoder = originalDecoder
8216 }
8217 *v = sv
8218 return nil
8219 }
8220
8221 type awsRestxml_deserializeOpListQueryLoggingConfigs struct {
8222 }
8223
8224 func (*awsRestxml_deserializeOpListQueryLoggingConfigs) ID() string {
8225 return "OperationDeserializer"
8226 }
8227
8228 func (m *awsRestxml_deserializeOpListQueryLoggingConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8229 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8230 ) {
8231 out, metadata, err = next.HandleDeserialize(ctx, in)
8232 if err != nil {
8233 return out, metadata, err
8234 }
8235
8236 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8237 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8238 defer endTimer()
8239 defer span.End()
8240 response, ok := out.RawResponse.(*smithyhttp.Response)
8241 if !ok {
8242 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8243 }
8244
8245 if response.StatusCode < 200 || response.StatusCode >= 300 {
8246 return out, metadata, awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response, &metadata)
8247 }
8248 output := &ListQueryLoggingConfigsOutput{}
8249 out.Result = output
8250
8251 var buff [1024]byte
8252 ringBuffer := smithyio.NewRingBuffer(buff[:])
8253 body := io.TeeReader(response.Body, ringBuffer)
8254 rootDecoder := xml.NewDecoder(body)
8255 t, err := smithyxml.FetchRootElement(rootDecoder)
8256 if err == io.EOF {
8257 return out, metadata, nil
8258 }
8259 if err != nil {
8260 var snapshot bytes.Buffer
8261 io.Copy(&snapshot, ringBuffer)
8262 return out, metadata, &smithy.DeserializationError{
8263 Err: fmt.Errorf("failed to decode response body, %w", err),
8264 Snapshot: snapshot.Bytes(),
8265 }
8266 }
8267
8268 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8269 err = awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(&output, decoder)
8270 if err != nil {
8271 var snapshot bytes.Buffer
8272 io.Copy(&snapshot, ringBuffer)
8273 return out, metadata, &smithy.DeserializationError{
8274 Err: fmt.Errorf("failed to decode response body, %w", err),
8275 Snapshot: snapshot.Bytes(),
8276 }
8277 }
8278
8279 span.End()
8280 return out, metadata, err
8281 }
8282
8283 func awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8284 var errorBuffer bytes.Buffer
8285 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8286 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8287 }
8288 errorBody := bytes.NewReader(errorBuffer.Bytes())
8289
8290 errorCode := "UnknownError"
8291 errorMessage := errorCode
8292
8293 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
8294 if err != nil {
8295 return err
8296 }
8297 if reqID := errorComponents.RequestID; len(reqID) != 0 {
8298 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
8299 }
8300 if len(errorComponents.Code) != 0 {
8301 errorCode = errorComponents.Code
8302 }
8303 if len(errorComponents.Message) != 0 {
8304 errorMessage = errorComponents.Message
8305 }
8306 errorBody.Seek(0, io.SeekStart)
8307 switch {
8308 case strings.EqualFold("InvalidInput", errorCode):
8309 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
8310
8311 case strings.EqualFold("InvalidPaginationToken", errorCode):
8312 return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
8313
8314 case strings.EqualFold("NoSuchHostedZone", errorCode):
8315 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
8316
8317 default:
8318 genericError := &smithy.GenericAPIError{
8319 Code: errorCode,
8320 Message: errorMessage,
8321 }
8322 return genericError
8323
8324 }
8325 }
8326
8327 func awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(v **ListQueryLoggingConfigsOutput, decoder smithyxml.NodeDecoder) error {
8328 if v == nil {
8329 return fmt.Errorf("unexpected nil of type %T", v)
8330 }
8331 var sv *ListQueryLoggingConfigsOutput
8332 if *v == nil {
8333 sv = &ListQueryLoggingConfigsOutput{}
8334 } else {
8335 sv = *v
8336 }
8337
8338 for {
8339 t, done, err := decoder.Token()
8340 if err != nil {
8341 return err
8342 }
8343 if done {
8344 break
8345 }
8346 originalDecoder := decoder
8347 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
8348 switch {
8349 case strings.EqualFold("NextToken", t.Name.Local):
8350 val, err := decoder.Value()
8351 if err != nil {
8352 return err
8353 }
8354 if val == nil {
8355 break
8356 }
8357 {
8358 xtv := string(val)
8359 sv.NextToken = ptr.String(xtv)
8360 }
8361
8362 case strings.EqualFold("QueryLoggingConfigs", t.Name.Local):
8363 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8364 if err := awsRestxml_deserializeDocumentQueryLoggingConfigs(&sv.QueryLoggingConfigs, nodeDecoder); err != nil {
8365 return err
8366 }
8367
8368 default:
8369 // Do nothing and ignore the unexpected tag element
8370 err = decoder.Decoder.Skip()
8371 if err != nil {
8372 return err
8373 }
8374
8375 }
8376 decoder = originalDecoder
8377 }
8378 *v = sv
8379 return nil
8380 }
8381
8382 type awsRestxml_deserializeOpListResourceRecordSets struct {
8383 }
8384
8385 func (*awsRestxml_deserializeOpListResourceRecordSets) ID() string {
8386 return "OperationDeserializer"
8387 }
8388
8389 func (m *awsRestxml_deserializeOpListResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8390 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8391 ) {
8392 out, metadata, err = next.HandleDeserialize(ctx, in)
8393 if err != nil {
8394 return out, metadata, err
8395 }
8396
8397 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8398 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8399 defer endTimer()
8400 defer span.End()
8401 response, ok := out.RawResponse.(*smithyhttp.Response)
8402 if !ok {
8403 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8404 }
8405
8406 if response.StatusCode < 200 || response.StatusCode >= 300 {
8407 return out, metadata, awsRestxml_deserializeOpErrorListResourceRecordSets(response, &metadata)
8408 }
8409 output := &ListResourceRecordSetsOutput{}
8410 out.Result = output
8411
8412 var buff [1024]byte
8413 ringBuffer := smithyio.NewRingBuffer(buff[:])
8414 body := io.TeeReader(response.Body, ringBuffer)
8415 rootDecoder := xml.NewDecoder(body)
8416 t, err := smithyxml.FetchRootElement(rootDecoder)
8417 if err == io.EOF {
8418 return out, metadata, nil
8419 }
8420 if err != nil {
8421 var snapshot bytes.Buffer
8422 io.Copy(&snapshot, ringBuffer)
8423 return out, metadata, &smithy.DeserializationError{
8424 Err: fmt.Errorf("failed to decode response body, %w", err),
8425 Snapshot: snapshot.Bytes(),
8426 }
8427 }
8428
8429 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8430 err = awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(&output, decoder)
8431 if err != nil {
8432 var snapshot bytes.Buffer
8433 io.Copy(&snapshot, ringBuffer)
8434 return out, metadata, &smithy.DeserializationError{
8435 Err: fmt.Errorf("failed to decode response body, %w", err),
8436 Snapshot: snapshot.Bytes(),
8437 }
8438 }
8439
8440 span.End()
8441 return out, metadata, err
8442 }
8443
8444 func awsRestxml_deserializeOpErrorListResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8445 var errorBuffer bytes.Buffer
8446 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8447 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8448 }
8449 errorBody := bytes.NewReader(errorBuffer.Bytes())
8450
8451 errorCode := "UnknownError"
8452 errorMessage := errorCode
8453
8454 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
8455 if err != nil {
8456 return err
8457 }
8458 if reqID := errorComponents.RequestID; len(reqID) != 0 {
8459 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
8460 }
8461 if len(errorComponents.Code) != 0 {
8462 errorCode = errorComponents.Code
8463 }
8464 if len(errorComponents.Message) != 0 {
8465 errorMessage = errorComponents.Message
8466 }
8467 errorBody.Seek(0, io.SeekStart)
8468 switch {
8469 case strings.EqualFold("InvalidInput", errorCode):
8470 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
8471
8472 case strings.EqualFold("NoSuchHostedZone", errorCode):
8473 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
8474
8475 default:
8476 genericError := &smithy.GenericAPIError{
8477 Code: errorCode,
8478 Message: errorMessage,
8479 }
8480 return genericError
8481
8482 }
8483 }
8484
8485 func awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(v **ListResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error {
8486 if v == nil {
8487 return fmt.Errorf("unexpected nil of type %T", v)
8488 }
8489 var sv *ListResourceRecordSetsOutput
8490 if *v == nil {
8491 sv = &ListResourceRecordSetsOutput{}
8492 } else {
8493 sv = *v
8494 }
8495
8496 for {
8497 t, done, err := decoder.Token()
8498 if err != nil {
8499 return err
8500 }
8501 if done {
8502 break
8503 }
8504 originalDecoder := decoder
8505 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
8506 switch {
8507 case strings.EqualFold("IsTruncated", t.Name.Local):
8508 val, err := decoder.Value()
8509 if err != nil {
8510 return err
8511 }
8512 if val == nil {
8513 break
8514 }
8515 {
8516 xtv, err := strconv.ParseBool(string(val))
8517 if err != nil {
8518 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
8519 }
8520 sv.IsTruncated = xtv
8521 }
8522
8523 case strings.EqualFold("MaxItems", t.Name.Local):
8524 val, err := decoder.Value()
8525 if err != nil {
8526 return err
8527 }
8528 if val == nil {
8529 break
8530 }
8531 {
8532 xtv := string(val)
8533 i64, err := strconv.ParseInt(xtv, 10, 64)
8534 if err != nil {
8535 return err
8536 }
8537 sv.MaxItems = ptr.Int32(int32(i64))
8538 }
8539
8540 case strings.EqualFold("NextRecordIdentifier", t.Name.Local):
8541 val, err := decoder.Value()
8542 if err != nil {
8543 return err
8544 }
8545 if val == nil {
8546 break
8547 }
8548 {
8549 xtv := string(val)
8550 sv.NextRecordIdentifier = ptr.String(xtv)
8551 }
8552
8553 case strings.EqualFold("NextRecordName", t.Name.Local):
8554 val, err := decoder.Value()
8555 if err != nil {
8556 return err
8557 }
8558 if val == nil {
8559 break
8560 }
8561 {
8562 xtv := string(val)
8563 sv.NextRecordName = ptr.String(xtv)
8564 }
8565
8566 case strings.EqualFold("NextRecordType", t.Name.Local):
8567 val, err := decoder.Value()
8568 if err != nil {
8569 return err
8570 }
8571 if val == nil {
8572 break
8573 }
8574 {
8575 xtv := string(val)
8576 sv.NextRecordType = types.RRType(xtv)
8577 }
8578
8579 case strings.EqualFold("ResourceRecordSets", t.Name.Local):
8580 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8581 if err := awsRestxml_deserializeDocumentResourceRecordSets(&sv.ResourceRecordSets, nodeDecoder); err != nil {
8582 return err
8583 }
8584
8585 default:
8586 // Do nothing and ignore the unexpected tag element
8587 err = decoder.Decoder.Skip()
8588 if err != nil {
8589 return err
8590 }
8591
8592 }
8593 decoder = originalDecoder
8594 }
8595 *v = sv
8596 return nil
8597 }
8598
8599 type awsRestxml_deserializeOpListReusableDelegationSets struct {
8600 }
8601
8602 func (*awsRestxml_deserializeOpListReusableDelegationSets) ID() string {
8603 return "OperationDeserializer"
8604 }
8605
8606 func (m *awsRestxml_deserializeOpListReusableDelegationSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8607 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8608 ) {
8609 out, metadata, err = next.HandleDeserialize(ctx, in)
8610 if err != nil {
8611 return out, metadata, err
8612 }
8613
8614 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8615 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8616 defer endTimer()
8617 defer span.End()
8618 response, ok := out.RawResponse.(*smithyhttp.Response)
8619 if !ok {
8620 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8621 }
8622
8623 if response.StatusCode < 200 || response.StatusCode >= 300 {
8624 return out, metadata, awsRestxml_deserializeOpErrorListReusableDelegationSets(response, &metadata)
8625 }
8626 output := &ListReusableDelegationSetsOutput{}
8627 out.Result = output
8628
8629 var buff [1024]byte
8630 ringBuffer := smithyio.NewRingBuffer(buff[:])
8631 body := io.TeeReader(response.Body, ringBuffer)
8632 rootDecoder := xml.NewDecoder(body)
8633 t, err := smithyxml.FetchRootElement(rootDecoder)
8634 if err == io.EOF {
8635 return out, metadata, nil
8636 }
8637 if err != nil {
8638 var snapshot bytes.Buffer
8639 io.Copy(&snapshot, ringBuffer)
8640 return out, metadata, &smithy.DeserializationError{
8641 Err: fmt.Errorf("failed to decode response body, %w", err),
8642 Snapshot: snapshot.Bytes(),
8643 }
8644 }
8645
8646 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8647 err = awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(&output, decoder)
8648 if err != nil {
8649 var snapshot bytes.Buffer
8650 io.Copy(&snapshot, ringBuffer)
8651 return out, metadata, &smithy.DeserializationError{
8652 Err: fmt.Errorf("failed to decode response body, %w", err),
8653 Snapshot: snapshot.Bytes(),
8654 }
8655 }
8656
8657 span.End()
8658 return out, metadata, err
8659 }
8660
8661 func awsRestxml_deserializeOpErrorListReusableDelegationSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8662 var errorBuffer bytes.Buffer
8663 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8664 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8665 }
8666 errorBody := bytes.NewReader(errorBuffer.Bytes())
8667
8668 errorCode := "UnknownError"
8669 errorMessage := errorCode
8670
8671 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
8672 if err != nil {
8673 return err
8674 }
8675 if reqID := errorComponents.RequestID; len(reqID) != 0 {
8676 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
8677 }
8678 if len(errorComponents.Code) != 0 {
8679 errorCode = errorComponents.Code
8680 }
8681 if len(errorComponents.Message) != 0 {
8682 errorMessage = errorComponents.Message
8683 }
8684 errorBody.Seek(0, io.SeekStart)
8685 switch {
8686 case strings.EqualFold("InvalidInput", errorCode):
8687 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
8688
8689 default:
8690 genericError := &smithy.GenericAPIError{
8691 Code: errorCode,
8692 Message: errorMessage,
8693 }
8694 return genericError
8695
8696 }
8697 }
8698
8699 func awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(v **ListReusableDelegationSetsOutput, decoder smithyxml.NodeDecoder) error {
8700 if v == nil {
8701 return fmt.Errorf("unexpected nil of type %T", v)
8702 }
8703 var sv *ListReusableDelegationSetsOutput
8704 if *v == nil {
8705 sv = &ListReusableDelegationSetsOutput{}
8706 } else {
8707 sv = *v
8708 }
8709
8710 for {
8711 t, done, err := decoder.Token()
8712 if err != nil {
8713 return err
8714 }
8715 if done {
8716 break
8717 }
8718 originalDecoder := decoder
8719 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
8720 switch {
8721 case strings.EqualFold("DelegationSets", t.Name.Local):
8722 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8723 if err := awsRestxml_deserializeDocumentDelegationSets(&sv.DelegationSets, nodeDecoder); err != nil {
8724 return err
8725 }
8726
8727 case strings.EqualFold("IsTruncated", t.Name.Local):
8728 val, err := decoder.Value()
8729 if err != nil {
8730 return err
8731 }
8732 if val == nil {
8733 break
8734 }
8735 {
8736 xtv, err := strconv.ParseBool(string(val))
8737 if err != nil {
8738 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
8739 }
8740 sv.IsTruncated = xtv
8741 }
8742
8743 case strings.EqualFold("Marker", t.Name.Local):
8744 val, err := decoder.Value()
8745 if err != nil {
8746 return err
8747 }
8748 if val == nil {
8749 break
8750 }
8751 {
8752 xtv := string(val)
8753 sv.Marker = ptr.String(xtv)
8754 }
8755
8756 case strings.EqualFold("MaxItems", t.Name.Local):
8757 val, err := decoder.Value()
8758 if err != nil {
8759 return err
8760 }
8761 if val == nil {
8762 break
8763 }
8764 {
8765 xtv := string(val)
8766 i64, err := strconv.ParseInt(xtv, 10, 64)
8767 if err != nil {
8768 return err
8769 }
8770 sv.MaxItems = ptr.Int32(int32(i64))
8771 }
8772
8773 case strings.EqualFold("NextMarker", t.Name.Local):
8774 val, err := decoder.Value()
8775 if err != nil {
8776 return err
8777 }
8778 if val == nil {
8779 break
8780 }
8781 {
8782 xtv := string(val)
8783 sv.NextMarker = ptr.String(xtv)
8784 }
8785
8786 default:
8787 // Do nothing and ignore the unexpected tag element
8788 err = decoder.Decoder.Skip()
8789 if err != nil {
8790 return err
8791 }
8792
8793 }
8794 decoder = originalDecoder
8795 }
8796 *v = sv
8797 return nil
8798 }
8799
8800 type awsRestxml_deserializeOpListTagsForResource struct {
8801 }
8802
8803 func (*awsRestxml_deserializeOpListTagsForResource) ID() string {
8804 return "OperationDeserializer"
8805 }
8806
8807 func (m *awsRestxml_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8808 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8809 ) {
8810 out, metadata, err = next.HandleDeserialize(ctx, in)
8811 if err != nil {
8812 return out, metadata, err
8813 }
8814
8815 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8816 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8817 defer endTimer()
8818 defer span.End()
8819 response, ok := out.RawResponse.(*smithyhttp.Response)
8820 if !ok {
8821 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8822 }
8823
8824 if response.StatusCode < 200 || response.StatusCode >= 300 {
8825 return out, metadata, awsRestxml_deserializeOpErrorListTagsForResource(response, &metadata)
8826 }
8827 output := &ListTagsForResourceOutput{}
8828 out.Result = output
8829
8830 var buff [1024]byte
8831 ringBuffer := smithyio.NewRingBuffer(buff[:])
8832 body := io.TeeReader(response.Body, ringBuffer)
8833 rootDecoder := xml.NewDecoder(body)
8834 t, err := smithyxml.FetchRootElement(rootDecoder)
8835 if err == io.EOF {
8836 return out, metadata, nil
8837 }
8838 if err != nil {
8839 var snapshot bytes.Buffer
8840 io.Copy(&snapshot, ringBuffer)
8841 return out, metadata, &smithy.DeserializationError{
8842 Err: fmt.Errorf("failed to decode response body, %w", err),
8843 Snapshot: snapshot.Bytes(),
8844 }
8845 }
8846
8847 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8848 err = awsRestxml_deserializeOpDocumentListTagsForResourceOutput(&output, decoder)
8849 if err != nil {
8850 var snapshot bytes.Buffer
8851 io.Copy(&snapshot, ringBuffer)
8852 return out, metadata, &smithy.DeserializationError{
8853 Err: fmt.Errorf("failed to decode response body, %w", err),
8854 Snapshot: snapshot.Bytes(),
8855 }
8856 }
8857
8858 span.End()
8859 return out, metadata, err
8860 }
8861
8862 func awsRestxml_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8863 var errorBuffer bytes.Buffer
8864 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8865 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8866 }
8867 errorBody := bytes.NewReader(errorBuffer.Bytes())
8868
8869 errorCode := "UnknownError"
8870 errorMessage := errorCode
8871
8872 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
8873 if err != nil {
8874 return err
8875 }
8876 if reqID := errorComponents.RequestID; len(reqID) != 0 {
8877 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
8878 }
8879 if len(errorComponents.Code) != 0 {
8880 errorCode = errorComponents.Code
8881 }
8882 if len(errorComponents.Message) != 0 {
8883 errorMessage = errorComponents.Message
8884 }
8885 errorBody.Seek(0, io.SeekStart)
8886 switch {
8887 case strings.EqualFold("InvalidInput", errorCode):
8888 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
8889
8890 case strings.EqualFold("NoSuchHealthCheck", errorCode):
8891 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
8892
8893 case strings.EqualFold("NoSuchHostedZone", errorCode):
8894 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
8895
8896 case strings.EqualFold("PriorRequestNotComplete", errorCode):
8897 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
8898
8899 case strings.EqualFold("ThrottlingException", errorCode):
8900 return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
8901
8902 default:
8903 genericError := &smithy.GenericAPIError{
8904 Code: errorCode,
8905 Message: errorMessage,
8906 }
8907 return genericError
8908
8909 }
8910 }
8911
8912 func awsRestxml_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, decoder smithyxml.NodeDecoder) error {
8913 if v == nil {
8914 return fmt.Errorf("unexpected nil of type %T", v)
8915 }
8916 var sv *ListTagsForResourceOutput
8917 if *v == nil {
8918 sv = &ListTagsForResourceOutput{}
8919 } else {
8920 sv = *v
8921 }
8922
8923 for {
8924 t, done, err := decoder.Token()
8925 if err != nil {
8926 return err
8927 }
8928 if done {
8929 break
8930 }
8931 originalDecoder := decoder
8932 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
8933 switch {
8934 case strings.EqualFold("ResourceTagSet", t.Name.Local):
8935 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8936 if err := awsRestxml_deserializeDocumentResourceTagSet(&sv.ResourceTagSet, nodeDecoder); err != nil {
8937 return err
8938 }
8939
8940 default:
8941 // Do nothing and ignore the unexpected tag element
8942 err = decoder.Decoder.Skip()
8943 if err != nil {
8944 return err
8945 }
8946
8947 }
8948 decoder = originalDecoder
8949 }
8950 *v = sv
8951 return nil
8952 }
8953
8954 type awsRestxml_deserializeOpListTagsForResources struct {
8955 }
8956
8957 func (*awsRestxml_deserializeOpListTagsForResources) ID() string {
8958 return "OperationDeserializer"
8959 }
8960
8961 func (m *awsRestxml_deserializeOpListTagsForResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8962 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8963 ) {
8964 out, metadata, err = next.HandleDeserialize(ctx, in)
8965 if err != nil {
8966 return out, metadata, err
8967 }
8968
8969 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8970 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8971 defer endTimer()
8972 defer span.End()
8973 response, ok := out.RawResponse.(*smithyhttp.Response)
8974 if !ok {
8975 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8976 }
8977
8978 if response.StatusCode < 200 || response.StatusCode >= 300 {
8979 return out, metadata, awsRestxml_deserializeOpErrorListTagsForResources(response, &metadata)
8980 }
8981 output := &ListTagsForResourcesOutput{}
8982 out.Result = output
8983
8984 var buff [1024]byte
8985 ringBuffer := smithyio.NewRingBuffer(buff[:])
8986 body := io.TeeReader(response.Body, ringBuffer)
8987 rootDecoder := xml.NewDecoder(body)
8988 t, err := smithyxml.FetchRootElement(rootDecoder)
8989 if err == io.EOF {
8990 return out, metadata, nil
8991 }
8992 if err != nil {
8993 var snapshot bytes.Buffer
8994 io.Copy(&snapshot, ringBuffer)
8995 return out, metadata, &smithy.DeserializationError{
8996 Err: fmt.Errorf("failed to decode response body, %w", err),
8997 Snapshot: snapshot.Bytes(),
8998 }
8999 }
9000
9001 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9002 err = awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(&output, decoder)
9003 if err != nil {
9004 var snapshot bytes.Buffer
9005 io.Copy(&snapshot, ringBuffer)
9006 return out, metadata, &smithy.DeserializationError{
9007 Err: fmt.Errorf("failed to decode response body, %w", err),
9008 Snapshot: snapshot.Bytes(),
9009 }
9010 }
9011
9012 span.End()
9013 return out, metadata, err
9014 }
9015
9016 func awsRestxml_deserializeOpErrorListTagsForResources(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9017 var errorBuffer bytes.Buffer
9018 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9019 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9020 }
9021 errorBody := bytes.NewReader(errorBuffer.Bytes())
9022
9023 errorCode := "UnknownError"
9024 errorMessage := errorCode
9025
9026 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
9027 if err != nil {
9028 return err
9029 }
9030 if reqID := errorComponents.RequestID; len(reqID) != 0 {
9031 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
9032 }
9033 if len(errorComponents.Code) != 0 {
9034 errorCode = errorComponents.Code
9035 }
9036 if len(errorComponents.Message) != 0 {
9037 errorMessage = errorComponents.Message
9038 }
9039 errorBody.Seek(0, io.SeekStart)
9040 switch {
9041 case strings.EqualFold("InvalidInput", errorCode):
9042 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
9043
9044 case strings.EqualFold("NoSuchHealthCheck", errorCode):
9045 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
9046
9047 case strings.EqualFold("NoSuchHostedZone", errorCode):
9048 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
9049
9050 case strings.EqualFold("PriorRequestNotComplete", errorCode):
9051 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
9052
9053 case strings.EqualFold("ThrottlingException", errorCode):
9054 return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
9055
9056 default:
9057 genericError := &smithy.GenericAPIError{
9058 Code: errorCode,
9059 Message: errorMessage,
9060 }
9061 return genericError
9062
9063 }
9064 }
9065
9066 func awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(v **ListTagsForResourcesOutput, decoder smithyxml.NodeDecoder) error {
9067 if v == nil {
9068 return fmt.Errorf("unexpected nil of type %T", v)
9069 }
9070 var sv *ListTagsForResourcesOutput
9071 if *v == nil {
9072 sv = &ListTagsForResourcesOutput{}
9073 } else {
9074 sv = *v
9075 }
9076
9077 for {
9078 t, done, err := decoder.Token()
9079 if err != nil {
9080 return err
9081 }
9082 if done {
9083 break
9084 }
9085 originalDecoder := decoder
9086 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
9087 switch {
9088 case strings.EqualFold("ResourceTagSets", t.Name.Local):
9089 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9090 if err := awsRestxml_deserializeDocumentResourceTagSetList(&sv.ResourceTagSets, nodeDecoder); err != nil {
9091 return err
9092 }
9093
9094 default:
9095 // Do nothing and ignore the unexpected tag element
9096 err = decoder.Decoder.Skip()
9097 if err != nil {
9098 return err
9099 }
9100
9101 }
9102 decoder = originalDecoder
9103 }
9104 *v = sv
9105 return nil
9106 }
9107
9108 type awsRestxml_deserializeOpListTrafficPolicies struct {
9109 }
9110
9111 func (*awsRestxml_deserializeOpListTrafficPolicies) ID() string {
9112 return "OperationDeserializer"
9113 }
9114
9115 func (m *awsRestxml_deserializeOpListTrafficPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9116 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9117 ) {
9118 out, metadata, err = next.HandleDeserialize(ctx, in)
9119 if err != nil {
9120 return out, metadata, err
9121 }
9122
9123 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9124 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9125 defer endTimer()
9126 defer span.End()
9127 response, ok := out.RawResponse.(*smithyhttp.Response)
9128 if !ok {
9129 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9130 }
9131
9132 if response.StatusCode < 200 || response.StatusCode >= 300 {
9133 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicies(response, &metadata)
9134 }
9135 output := &ListTrafficPoliciesOutput{}
9136 out.Result = output
9137
9138 var buff [1024]byte
9139 ringBuffer := smithyio.NewRingBuffer(buff[:])
9140 body := io.TeeReader(response.Body, ringBuffer)
9141 rootDecoder := xml.NewDecoder(body)
9142 t, err := smithyxml.FetchRootElement(rootDecoder)
9143 if err == io.EOF {
9144 return out, metadata, nil
9145 }
9146 if err != nil {
9147 var snapshot bytes.Buffer
9148 io.Copy(&snapshot, ringBuffer)
9149 return out, metadata, &smithy.DeserializationError{
9150 Err: fmt.Errorf("failed to decode response body, %w", err),
9151 Snapshot: snapshot.Bytes(),
9152 }
9153 }
9154
9155 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9156 err = awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(&output, decoder)
9157 if err != nil {
9158 var snapshot bytes.Buffer
9159 io.Copy(&snapshot, ringBuffer)
9160 return out, metadata, &smithy.DeserializationError{
9161 Err: fmt.Errorf("failed to decode response body, %w", err),
9162 Snapshot: snapshot.Bytes(),
9163 }
9164 }
9165
9166 span.End()
9167 return out, metadata, err
9168 }
9169
9170 func awsRestxml_deserializeOpErrorListTrafficPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9171 var errorBuffer bytes.Buffer
9172 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9173 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9174 }
9175 errorBody := bytes.NewReader(errorBuffer.Bytes())
9176
9177 errorCode := "UnknownError"
9178 errorMessage := errorCode
9179
9180 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
9181 if err != nil {
9182 return err
9183 }
9184 if reqID := errorComponents.RequestID; len(reqID) != 0 {
9185 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
9186 }
9187 if len(errorComponents.Code) != 0 {
9188 errorCode = errorComponents.Code
9189 }
9190 if len(errorComponents.Message) != 0 {
9191 errorMessage = errorComponents.Message
9192 }
9193 errorBody.Seek(0, io.SeekStart)
9194 switch {
9195 case strings.EqualFold("InvalidInput", errorCode):
9196 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
9197
9198 default:
9199 genericError := &smithy.GenericAPIError{
9200 Code: errorCode,
9201 Message: errorMessage,
9202 }
9203 return genericError
9204
9205 }
9206 }
9207
9208 func awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(v **ListTrafficPoliciesOutput, decoder smithyxml.NodeDecoder) error {
9209 if v == nil {
9210 return fmt.Errorf("unexpected nil of type %T", v)
9211 }
9212 var sv *ListTrafficPoliciesOutput
9213 if *v == nil {
9214 sv = &ListTrafficPoliciesOutput{}
9215 } else {
9216 sv = *v
9217 }
9218
9219 for {
9220 t, done, err := decoder.Token()
9221 if err != nil {
9222 return err
9223 }
9224 if done {
9225 break
9226 }
9227 originalDecoder := decoder
9228 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
9229 switch {
9230 case strings.EqualFold("IsTruncated", t.Name.Local):
9231 val, err := decoder.Value()
9232 if err != nil {
9233 return err
9234 }
9235 if val == nil {
9236 break
9237 }
9238 {
9239 xtv, err := strconv.ParseBool(string(val))
9240 if err != nil {
9241 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
9242 }
9243 sv.IsTruncated = xtv
9244 }
9245
9246 case strings.EqualFold("MaxItems", t.Name.Local):
9247 val, err := decoder.Value()
9248 if err != nil {
9249 return err
9250 }
9251 if val == nil {
9252 break
9253 }
9254 {
9255 xtv := string(val)
9256 i64, err := strconv.ParseInt(xtv, 10, 64)
9257 if err != nil {
9258 return err
9259 }
9260 sv.MaxItems = ptr.Int32(int32(i64))
9261 }
9262
9263 case strings.EqualFold("TrafficPolicyIdMarker", t.Name.Local):
9264 val, err := decoder.Value()
9265 if err != nil {
9266 return err
9267 }
9268 if val == nil {
9269 break
9270 }
9271 {
9272 xtv := string(val)
9273 sv.TrafficPolicyIdMarker = ptr.String(xtv)
9274 }
9275
9276 case strings.EqualFold("TrafficPolicySummaries", t.Name.Local):
9277 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9278 if err := awsRestxml_deserializeDocumentTrafficPolicySummaries(&sv.TrafficPolicySummaries, nodeDecoder); err != nil {
9279 return err
9280 }
9281
9282 default:
9283 // Do nothing and ignore the unexpected tag element
9284 err = decoder.Decoder.Skip()
9285 if err != nil {
9286 return err
9287 }
9288
9289 }
9290 decoder = originalDecoder
9291 }
9292 *v = sv
9293 return nil
9294 }
9295
9296 type awsRestxml_deserializeOpListTrafficPolicyInstances struct {
9297 }
9298
9299 func (*awsRestxml_deserializeOpListTrafficPolicyInstances) ID() string {
9300 return "OperationDeserializer"
9301 }
9302
9303 func (m *awsRestxml_deserializeOpListTrafficPolicyInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9304 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9305 ) {
9306 out, metadata, err = next.HandleDeserialize(ctx, in)
9307 if err != nil {
9308 return out, metadata, err
9309 }
9310
9311 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9312 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9313 defer endTimer()
9314 defer span.End()
9315 response, ok := out.RawResponse.(*smithyhttp.Response)
9316 if !ok {
9317 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9318 }
9319
9320 if response.StatusCode < 200 || response.StatusCode >= 300 {
9321 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response, &metadata)
9322 }
9323 output := &ListTrafficPolicyInstancesOutput{}
9324 out.Result = output
9325
9326 var buff [1024]byte
9327 ringBuffer := smithyio.NewRingBuffer(buff[:])
9328 body := io.TeeReader(response.Body, ringBuffer)
9329 rootDecoder := xml.NewDecoder(body)
9330 t, err := smithyxml.FetchRootElement(rootDecoder)
9331 if err == io.EOF {
9332 return out, metadata, nil
9333 }
9334 if err != nil {
9335 var snapshot bytes.Buffer
9336 io.Copy(&snapshot, ringBuffer)
9337 return out, metadata, &smithy.DeserializationError{
9338 Err: fmt.Errorf("failed to decode response body, %w", err),
9339 Snapshot: snapshot.Bytes(),
9340 }
9341 }
9342
9343 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9344 err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(&output, decoder)
9345 if err != nil {
9346 var snapshot bytes.Buffer
9347 io.Copy(&snapshot, ringBuffer)
9348 return out, metadata, &smithy.DeserializationError{
9349 Err: fmt.Errorf("failed to decode response body, %w", err),
9350 Snapshot: snapshot.Bytes(),
9351 }
9352 }
9353
9354 span.End()
9355 return out, metadata, err
9356 }
9357
9358 func awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9359 var errorBuffer bytes.Buffer
9360 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9361 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9362 }
9363 errorBody := bytes.NewReader(errorBuffer.Bytes())
9364
9365 errorCode := "UnknownError"
9366 errorMessage := errorCode
9367
9368 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
9369 if err != nil {
9370 return err
9371 }
9372 if reqID := errorComponents.RequestID; len(reqID) != 0 {
9373 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
9374 }
9375 if len(errorComponents.Code) != 0 {
9376 errorCode = errorComponents.Code
9377 }
9378 if len(errorComponents.Message) != 0 {
9379 errorMessage = errorComponents.Message
9380 }
9381 errorBody.Seek(0, io.SeekStart)
9382 switch {
9383 case strings.EqualFold("InvalidInput", errorCode):
9384 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
9385
9386 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
9387 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
9388
9389 default:
9390 genericError := &smithy.GenericAPIError{
9391 Code: errorCode,
9392 Message: errorMessage,
9393 }
9394 return genericError
9395
9396 }
9397 }
9398
9399 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(v **ListTrafficPolicyInstancesOutput, decoder smithyxml.NodeDecoder) error {
9400 if v == nil {
9401 return fmt.Errorf("unexpected nil of type %T", v)
9402 }
9403 var sv *ListTrafficPolicyInstancesOutput
9404 if *v == nil {
9405 sv = &ListTrafficPolicyInstancesOutput{}
9406 } else {
9407 sv = *v
9408 }
9409
9410 for {
9411 t, done, err := decoder.Token()
9412 if err != nil {
9413 return err
9414 }
9415 if done {
9416 break
9417 }
9418 originalDecoder := decoder
9419 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
9420 switch {
9421 case strings.EqualFold("HostedZoneIdMarker", t.Name.Local):
9422 val, err := decoder.Value()
9423 if err != nil {
9424 return err
9425 }
9426 if val == nil {
9427 break
9428 }
9429 {
9430 xtv := string(val)
9431 sv.HostedZoneIdMarker = ptr.String(xtv)
9432 }
9433
9434 case strings.EqualFold("IsTruncated", t.Name.Local):
9435 val, err := decoder.Value()
9436 if err != nil {
9437 return err
9438 }
9439 if val == nil {
9440 break
9441 }
9442 {
9443 xtv, err := strconv.ParseBool(string(val))
9444 if err != nil {
9445 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
9446 }
9447 sv.IsTruncated = xtv
9448 }
9449
9450 case strings.EqualFold("MaxItems", t.Name.Local):
9451 val, err := decoder.Value()
9452 if err != nil {
9453 return err
9454 }
9455 if val == nil {
9456 break
9457 }
9458 {
9459 xtv := string(val)
9460 i64, err := strconv.ParseInt(xtv, 10, 64)
9461 if err != nil {
9462 return err
9463 }
9464 sv.MaxItems = ptr.Int32(int32(i64))
9465 }
9466
9467 case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
9468 val, err := decoder.Value()
9469 if err != nil {
9470 return err
9471 }
9472 if val == nil {
9473 break
9474 }
9475 {
9476 xtv := string(val)
9477 sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
9478 }
9479
9480 case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
9481 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9482 if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
9483 return err
9484 }
9485
9486 case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
9487 val, err := decoder.Value()
9488 if err != nil {
9489 return err
9490 }
9491 if val == nil {
9492 break
9493 }
9494 {
9495 xtv := string(val)
9496 sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
9497 }
9498
9499 default:
9500 // Do nothing and ignore the unexpected tag element
9501 err = decoder.Decoder.Skip()
9502 if err != nil {
9503 return err
9504 }
9505
9506 }
9507 decoder = originalDecoder
9508 }
9509 *v = sv
9510 return nil
9511 }
9512
9513 type awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone struct {
9514 }
9515
9516 func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) ID() string {
9517 return "OperationDeserializer"
9518 }
9519
9520 func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9521 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9522 ) {
9523 out, metadata, err = next.HandleDeserialize(ctx, in)
9524 if err != nil {
9525 return out, metadata, err
9526 }
9527
9528 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9529 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9530 defer endTimer()
9531 defer span.End()
9532 response, ok := out.RawResponse.(*smithyhttp.Response)
9533 if !ok {
9534 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9535 }
9536
9537 if response.StatusCode < 200 || response.StatusCode >= 300 {
9538 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response, &metadata)
9539 }
9540 output := &ListTrafficPolicyInstancesByHostedZoneOutput{}
9541 out.Result = output
9542
9543 var buff [1024]byte
9544 ringBuffer := smithyio.NewRingBuffer(buff[:])
9545 body := io.TeeReader(response.Body, ringBuffer)
9546 rootDecoder := xml.NewDecoder(body)
9547 t, err := smithyxml.FetchRootElement(rootDecoder)
9548 if err == io.EOF {
9549 return out, metadata, nil
9550 }
9551 if err != nil {
9552 var snapshot bytes.Buffer
9553 io.Copy(&snapshot, ringBuffer)
9554 return out, metadata, &smithy.DeserializationError{
9555 Err: fmt.Errorf("failed to decode response body, %w", err),
9556 Snapshot: snapshot.Bytes(),
9557 }
9558 }
9559
9560 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9561 err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(&output, decoder)
9562 if err != nil {
9563 var snapshot bytes.Buffer
9564 io.Copy(&snapshot, ringBuffer)
9565 return out, metadata, &smithy.DeserializationError{
9566 Err: fmt.Errorf("failed to decode response body, %w", err),
9567 Snapshot: snapshot.Bytes(),
9568 }
9569 }
9570
9571 span.End()
9572 return out, metadata, err
9573 }
9574
9575 func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9576 var errorBuffer bytes.Buffer
9577 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9578 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9579 }
9580 errorBody := bytes.NewReader(errorBuffer.Bytes())
9581
9582 errorCode := "UnknownError"
9583 errorMessage := errorCode
9584
9585 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
9586 if err != nil {
9587 return err
9588 }
9589 if reqID := errorComponents.RequestID; len(reqID) != 0 {
9590 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
9591 }
9592 if len(errorComponents.Code) != 0 {
9593 errorCode = errorComponents.Code
9594 }
9595 if len(errorComponents.Message) != 0 {
9596 errorMessage = errorComponents.Message
9597 }
9598 errorBody.Seek(0, io.SeekStart)
9599 switch {
9600 case strings.EqualFold("InvalidInput", errorCode):
9601 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
9602
9603 case strings.EqualFold("NoSuchHostedZone", errorCode):
9604 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
9605
9606 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
9607 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
9608
9609 default:
9610 genericError := &smithy.GenericAPIError{
9611 Code: errorCode,
9612 Message: errorMessage,
9613 }
9614 return genericError
9615
9616 }
9617 }
9618
9619 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(v **ListTrafficPolicyInstancesByHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
9620 if v == nil {
9621 return fmt.Errorf("unexpected nil of type %T", v)
9622 }
9623 var sv *ListTrafficPolicyInstancesByHostedZoneOutput
9624 if *v == nil {
9625 sv = &ListTrafficPolicyInstancesByHostedZoneOutput{}
9626 } else {
9627 sv = *v
9628 }
9629
9630 for {
9631 t, done, err := decoder.Token()
9632 if err != nil {
9633 return err
9634 }
9635 if done {
9636 break
9637 }
9638 originalDecoder := decoder
9639 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
9640 switch {
9641 case strings.EqualFold("IsTruncated", t.Name.Local):
9642 val, err := decoder.Value()
9643 if err != nil {
9644 return err
9645 }
9646 if val == nil {
9647 break
9648 }
9649 {
9650 xtv, err := strconv.ParseBool(string(val))
9651 if err != nil {
9652 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
9653 }
9654 sv.IsTruncated = xtv
9655 }
9656
9657 case strings.EqualFold("MaxItems", t.Name.Local):
9658 val, err := decoder.Value()
9659 if err != nil {
9660 return err
9661 }
9662 if val == nil {
9663 break
9664 }
9665 {
9666 xtv := string(val)
9667 i64, err := strconv.ParseInt(xtv, 10, 64)
9668 if err != nil {
9669 return err
9670 }
9671 sv.MaxItems = ptr.Int32(int32(i64))
9672 }
9673
9674 case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
9675 val, err := decoder.Value()
9676 if err != nil {
9677 return err
9678 }
9679 if val == nil {
9680 break
9681 }
9682 {
9683 xtv := string(val)
9684 sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
9685 }
9686
9687 case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
9688 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9689 if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
9690 return err
9691 }
9692
9693 case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
9694 val, err := decoder.Value()
9695 if err != nil {
9696 return err
9697 }
9698 if val == nil {
9699 break
9700 }
9701 {
9702 xtv := string(val)
9703 sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
9704 }
9705
9706 default:
9707 // Do nothing and ignore the unexpected tag element
9708 err = decoder.Decoder.Skip()
9709 if err != nil {
9710 return err
9711 }
9712
9713 }
9714 decoder = originalDecoder
9715 }
9716 *v = sv
9717 return nil
9718 }
9719
9720 type awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy struct {
9721 }
9722
9723 func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) ID() string {
9724 return "OperationDeserializer"
9725 }
9726
9727 func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9728 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9729 ) {
9730 out, metadata, err = next.HandleDeserialize(ctx, in)
9731 if err != nil {
9732 return out, metadata, err
9733 }
9734
9735 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9736 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9737 defer endTimer()
9738 defer span.End()
9739 response, ok := out.RawResponse.(*smithyhttp.Response)
9740 if !ok {
9741 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9742 }
9743
9744 if response.StatusCode < 200 || response.StatusCode >= 300 {
9745 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response, &metadata)
9746 }
9747 output := &ListTrafficPolicyInstancesByPolicyOutput{}
9748 out.Result = output
9749
9750 var buff [1024]byte
9751 ringBuffer := smithyio.NewRingBuffer(buff[:])
9752 body := io.TeeReader(response.Body, ringBuffer)
9753 rootDecoder := xml.NewDecoder(body)
9754 t, err := smithyxml.FetchRootElement(rootDecoder)
9755 if err == io.EOF {
9756 return out, metadata, nil
9757 }
9758 if err != nil {
9759 var snapshot bytes.Buffer
9760 io.Copy(&snapshot, ringBuffer)
9761 return out, metadata, &smithy.DeserializationError{
9762 Err: fmt.Errorf("failed to decode response body, %w", err),
9763 Snapshot: snapshot.Bytes(),
9764 }
9765 }
9766
9767 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9768 err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(&output, decoder)
9769 if err != nil {
9770 var snapshot bytes.Buffer
9771 io.Copy(&snapshot, ringBuffer)
9772 return out, metadata, &smithy.DeserializationError{
9773 Err: fmt.Errorf("failed to decode response body, %w", err),
9774 Snapshot: snapshot.Bytes(),
9775 }
9776 }
9777
9778 span.End()
9779 return out, metadata, err
9780 }
9781
9782 func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9783 var errorBuffer bytes.Buffer
9784 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9785 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9786 }
9787 errorBody := bytes.NewReader(errorBuffer.Bytes())
9788
9789 errorCode := "UnknownError"
9790 errorMessage := errorCode
9791
9792 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
9793 if err != nil {
9794 return err
9795 }
9796 if reqID := errorComponents.RequestID; len(reqID) != 0 {
9797 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
9798 }
9799 if len(errorComponents.Code) != 0 {
9800 errorCode = errorComponents.Code
9801 }
9802 if len(errorComponents.Message) != 0 {
9803 errorMessage = errorComponents.Message
9804 }
9805 errorBody.Seek(0, io.SeekStart)
9806 switch {
9807 case strings.EqualFold("InvalidInput", errorCode):
9808 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
9809
9810 case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
9811 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
9812
9813 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
9814 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
9815
9816 default:
9817 genericError := &smithy.GenericAPIError{
9818 Code: errorCode,
9819 Message: errorMessage,
9820 }
9821 return genericError
9822
9823 }
9824 }
9825
9826 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(v **ListTrafficPolicyInstancesByPolicyOutput, decoder smithyxml.NodeDecoder) error {
9827 if v == nil {
9828 return fmt.Errorf("unexpected nil of type %T", v)
9829 }
9830 var sv *ListTrafficPolicyInstancesByPolicyOutput
9831 if *v == nil {
9832 sv = &ListTrafficPolicyInstancesByPolicyOutput{}
9833 } else {
9834 sv = *v
9835 }
9836
9837 for {
9838 t, done, err := decoder.Token()
9839 if err != nil {
9840 return err
9841 }
9842 if done {
9843 break
9844 }
9845 originalDecoder := decoder
9846 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
9847 switch {
9848 case strings.EqualFold("HostedZoneIdMarker", t.Name.Local):
9849 val, err := decoder.Value()
9850 if err != nil {
9851 return err
9852 }
9853 if val == nil {
9854 break
9855 }
9856 {
9857 xtv := string(val)
9858 sv.HostedZoneIdMarker = ptr.String(xtv)
9859 }
9860
9861 case strings.EqualFold("IsTruncated", t.Name.Local):
9862 val, err := decoder.Value()
9863 if err != nil {
9864 return err
9865 }
9866 if val == nil {
9867 break
9868 }
9869 {
9870 xtv, err := strconv.ParseBool(string(val))
9871 if err != nil {
9872 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
9873 }
9874 sv.IsTruncated = xtv
9875 }
9876
9877 case strings.EqualFold("MaxItems", t.Name.Local):
9878 val, err := decoder.Value()
9879 if err != nil {
9880 return err
9881 }
9882 if val == nil {
9883 break
9884 }
9885 {
9886 xtv := string(val)
9887 i64, err := strconv.ParseInt(xtv, 10, 64)
9888 if err != nil {
9889 return err
9890 }
9891 sv.MaxItems = ptr.Int32(int32(i64))
9892 }
9893
9894 case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
9895 val, err := decoder.Value()
9896 if err != nil {
9897 return err
9898 }
9899 if val == nil {
9900 break
9901 }
9902 {
9903 xtv := string(val)
9904 sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
9905 }
9906
9907 case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
9908 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9909 if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
9910 return err
9911 }
9912
9913 case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
9914 val, err := decoder.Value()
9915 if err != nil {
9916 return err
9917 }
9918 if val == nil {
9919 break
9920 }
9921 {
9922 xtv := string(val)
9923 sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
9924 }
9925
9926 default:
9927 // Do nothing and ignore the unexpected tag element
9928 err = decoder.Decoder.Skip()
9929 if err != nil {
9930 return err
9931 }
9932
9933 }
9934 decoder = originalDecoder
9935 }
9936 *v = sv
9937 return nil
9938 }
9939
9940 type awsRestxml_deserializeOpListTrafficPolicyVersions struct {
9941 }
9942
9943 func (*awsRestxml_deserializeOpListTrafficPolicyVersions) ID() string {
9944 return "OperationDeserializer"
9945 }
9946
9947 func (m *awsRestxml_deserializeOpListTrafficPolicyVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9948 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9949 ) {
9950 out, metadata, err = next.HandleDeserialize(ctx, in)
9951 if err != nil {
9952 return out, metadata, err
9953 }
9954
9955 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9956 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9957 defer endTimer()
9958 defer span.End()
9959 response, ok := out.RawResponse.(*smithyhttp.Response)
9960 if !ok {
9961 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9962 }
9963
9964 if response.StatusCode < 200 || response.StatusCode >= 300 {
9965 return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response, &metadata)
9966 }
9967 output := &ListTrafficPolicyVersionsOutput{}
9968 out.Result = output
9969
9970 var buff [1024]byte
9971 ringBuffer := smithyio.NewRingBuffer(buff[:])
9972 body := io.TeeReader(response.Body, ringBuffer)
9973 rootDecoder := xml.NewDecoder(body)
9974 t, err := smithyxml.FetchRootElement(rootDecoder)
9975 if err == io.EOF {
9976 return out, metadata, nil
9977 }
9978 if err != nil {
9979 var snapshot bytes.Buffer
9980 io.Copy(&snapshot, ringBuffer)
9981 return out, metadata, &smithy.DeserializationError{
9982 Err: fmt.Errorf("failed to decode response body, %w", err),
9983 Snapshot: snapshot.Bytes(),
9984 }
9985 }
9986
9987 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9988 err = awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(&output, decoder)
9989 if err != nil {
9990 var snapshot bytes.Buffer
9991 io.Copy(&snapshot, ringBuffer)
9992 return out, metadata, &smithy.DeserializationError{
9993 Err: fmt.Errorf("failed to decode response body, %w", err),
9994 Snapshot: snapshot.Bytes(),
9995 }
9996 }
9997
9998 span.End()
9999 return out, metadata, err
10000 }
10001
10002 func awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10003 var errorBuffer bytes.Buffer
10004 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10005 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10006 }
10007 errorBody := bytes.NewReader(errorBuffer.Bytes())
10008
10009 errorCode := "UnknownError"
10010 errorMessage := errorCode
10011
10012 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
10013 if err != nil {
10014 return err
10015 }
10016 if reqID := errorComponents.RequestID; len(reqID) != 0 {
10017 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
10018 }
10019 if len(errorComponents.Code) != 0 {
10020 errorCode = errorComponents.Code
10021 }
10022 if len(errorComponents.Message) != 0 {
10023 errorMessage = errorComponents.Message
10024 }
10025 errorBody.Seek(0, io.SeekStart)
10026 switch {
10027 case strings.EqualFold("InvalidInput", errorCode):
10028 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
10029
10030 case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
10031 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
10032
10033 default:
10034 genericError := &smithy.GenericAPIError{
10035 Code: errorCode,
10036 Message: errorMessage,
10037 }
10038 return genericError
10039
10040 }
10041 }
10042
10043 func awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(v **ListTrafficPolicyVersionsOutput, decoder smithyxml.NodeDecoder) error {
10044 if v == nil {
10045 return fmt.Errorf("unexpected nil of type %T", v)
10046 }
10047 var sv *ListTrafficPolicyVersionsOutput
10048 if *v == nil {
10049 sv = &ListTrafficPolicyVersionsOutput{}
10050 } else {
10051 sv = *v
10052 }
10053
10054 for {
10055 t, done, err := decoder.Token()
10056 if err != nil {
10057 return err
10058 }
10059 if done {
10060 break
10061 }
10062 originalDecoder := decoder
10063 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
10064 switch {
10065 case strings.EqualFold("IsTruncated", t.Name.Local):
10066 val, err := decoder.Value()
10067 if err != nil {
10068 return err
10069 }
10070 if val == nil {
10071 break
10072 }
10073 {
10074 xtv, err := strconv.ParseBool(string(val))
10075 if err != nil {
10076 return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
10077 }
10078 sv.IsTruncated = xtv
10079 }
10080
10081 case strings.EqualFold("MaxItems", t.Name.Local):
10082 val, err := decoder.Value()
10083 if err != nil {
10084 return err
10085 }
10086 if val == nil {
10087 break
10088 }
10089 {
10090 xtv := string(val)
10091 i64, err := strconv.ParseInt(xtv, 10, 64)
10092 if err != nil {
10093 return err
10094 }
10095 sv.MaxItems = ptr.Int32(int32(i64))
10096 }
10097
10098 case strings.EqualFold("TrafficPolicies", t.Name.Local):
10099 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10100 if err := awsRestxml_deserializeDocumentTrafficPolicies(&sv.TrafficPolicies, nodeDecoder); err != nil {
10101 return err
10102 }
10103
10104 case strings.EqualFold("TrafficPolicyVersionMarker", t.Name.Local):
10105 val, err := decoder.Value()
10106 if err != nil {
10107 return err
10108 }
10109 if val == nil {
10110 break
10111 }
10112 {
10113 xtv := string(val)
10114 sv.TrafficPolicyVersionMarker = ptr.String(xtv)
10115 }
10116
10117 default:
10118 // Do nothing and ignore the unexpected tag element
10119 err = decoder.Decoder.Skip()
10120 if err != nil {
10121 return err
10122 }
10123
10124 }
10125 decoder = originalDecoder
10126 }
10127 *v = sv
10128 return nil
10129 }
10130
10131 type awsRestxml_deserializeOpListVPCAssociationAuthorizations struct {
10132 }
10133
10134 func (*awsRestxml_deserializeOpListVPCAssociationAuthorizations) ID() string {
10135 return "OperationDeserializer"
10136 }
10137
10138 func (m *awsRestxml_deserializeOpListVPCAssociationAuthorizations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10139 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10140 ) {
10141 out, metadata, err = next.HandleDeserialize(ctx, in)
10142 if err != nil {
10143 return out, metadata, err
10144 }
10145
10146 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10147 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10148 defer endTimer()
10149 defer span.End()
10150 response, ok := out.RawResponse.(*smithyhttp.Response)
10151 if !ok {
10152 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10153 }
10154
10155 if response.StatusCode < 200 || response.StatusCode >= 300 {
10156 return out, metadata, awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response, &metadata)
10157 }
10158 output := &ListVPCAssociationAuthorizationsOutput{}
10159 out.Result = output
10160
10161 var buff [1024]byte
10162 ringBuffer := smithyio.NewRingBuffer(buff[:])
10163 body := io.TeeReader(response.Body, ringBuffer)
10164 rootDecoder := xml.NewDecoder(body)
10165 t, err := smithyxml.FetchRootElement(rootDecoder)
10166 if err == io.EOF {
10167 return out, metadata, nil
10168 }
10169 if err != nil {
10170 var snapshot bytes.Buffer
10171 io.Copy(&snapshot, ringBuffer)
10172 return out, metadata, &smithy.DeserializationError{
10173 Err: fmt.Errorf("failed to decode response body, %w", err),
10174 Snapshot: snapshot.Bytes(),
10175 }
10176 }
10177
10178 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10179 err = awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(&output, decoder)
10180 if err != nil {
10181 var snapshot bytes.Buffer
10182 io.Copy(&snapshot, ringBuffer)
10183 return out, metadata, &smithy.DeserializationError{
10184 Err: fmt.Errorf("failed to decode response body, %w", err),
10185 Snapshot: snapshot.Bytes(),
10186 }
10187 }
10188
10189 span.End()
10190 return out, metadata, err
10191 }
10192
10193 func awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10194 var errorBuffer bytes.Buffer
10195 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10196 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10197 }
10198 errorBody := bytes.NewReader(errorBuffer.Bytes())
10199
10200 errorCode := "UnknownError"
10201 errorMessage := errorCode
10202
10203 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
10204 if err != nil {
10205 return err
10206 }
10207 if reqID := errorComponents.RequestID; len(reqID) != 0 {
10208 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
10209 }
10210 if len(errorComponents.Code) != 0 {
10211 errorCode = errorComponents.Code
10212 }
10213 if len(errorComponents.Message) != 0 {
10214 errorMessage = errorComponents.Message
10215 }
10216 errorBody.Seek(0, io.SeekStart)
10217 switch {
10218 case strings.EqualFold("InvalidInput", errorCode):
10219 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
10220
10221 case strings.EqualFold("InvalidPaginationToken", errorCode):
10222 return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
10223
10224 case strings.EqualFold("NoSuchHostedZone", errorCode):
10225 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
10226
10227 default:
10228 genericError := &smithy.GenericAPIError{
10229 Code: errorCode,
10230 Message: errorMessage,
10231 }
10232 return genericError
10233
10234 }
10235 }
10236
10237 func awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(v **ListVPCAssociationAuthorizationsOutput, decoder smithyxml.NodeDecoder) error {
10238 if v == nil {
10239 return fmt.Errorf("unexpected nil of type %T", v)
10240 }
10241 var sv *ListVPCAssociationAuthorizationsOutput
10242 if *v == nil {
10243 sv = &ListVPCAssociationAuthorizationsOutput{}
10244 } else {
10245 sv = *v
10246 }
10247
10248 for {
10249 t, done, err := decoder.Token()
10250 if err != nil {
10251 return err
10252 }
10253 if done {
10254 break
10255 }
10256 originalDecoder := decoder
10257 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
10258 switch {
10259 case strings.EqualFold("HostedZoneId", t.Name.Local):
10260 val, err := decoder.Value()
10261 if err != nil {
10262 return err
10263 }
10264 if val == nil {
10265 break
10266 }
10267 {
10268 xtv := string(val)
10269 sv.HostedZoneId = ptr.String(xtv)
10270 }
10271
10272 case strings.EqualFold("NextToken", t.Name.Local):
10273 val, err := decoder.Value()
10274 if err != nil {
10275 return err
10276 }
10277 if val == nil {
10278 break
10279 }
10280 {
10281 xtv := string(val)
10282 sv.NextToken = ptr.String(xtv)
10283 }
10284
10285 case strings.EqualFold("VPCs", t.Name.Local):
10286 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10287 if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil {
10288 return err
10289 }
10290
10291 default:
10292 // Do nothing and ignore the unexpected tag element
10293 err = decoder.Decoder.Skip()
10294 if err != nil {
10295 return err
10296 }
10297
10298 }
10299 decoder = originalDecoder
10300 }
10301 *v = sv
10302 return nil
10303 }
10304
10305 type awsRestxml_deserializeOpTestDNSAnswer struct {
10306 }
10307
10308 func (*awsRestxml_deserializeOpTestDNSAnswer) ID() string {
10309 return "OperationDeserializer"
10310 }
10311
10312 func (m *awsRestxml_deserializeOpTestDNSAnswer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10313 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10314 ) {
10315 out, metadata, err = next.HandleDeserialize(ctx, in)
10316 if err != nil {
10317 return out, metadata, err
10318 }
10319
10320 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10321 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10322 defer endTimer()
10323 defer span.End()
10324 response, ok := out.RawResponse.(*smithyhttp.Response)
10325 if !ok {
10326 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10327 }
10328
10329 if response.StatusCode < 200 || response.StatusCode >= 300 {
10330 return out, metadata, awsRestxml_deserializeOpErrorTestDNSAnswer(response, &metadata)
10331 }
10332 output := &TestDNSAnswerOutput{}
10333 out.Result = output
10334
10335 var buff [1024]byte
10336 ringBuffer := smithyio.NewRingBuffer(buff[:])
10337 body := io.TeeReader(response.Body, ringBuffer)
10338 rootDecoder := xml.NewDecoder(body)
10339 t, err := smithyxml.FetchRootElement(rootDecoder)
10340 if err == io.EOF {
10341 return out, metadata, nil
10342 }
10343 if err != nil {
10344 var snapshot bytes.Buffer
10345 io.Copy(&snapshot, ringBuffer)
10346 return out, metadata, &smithy.DeserializationError{
10347 Err: fmt.Errorf("failed to decode response body, %w", err),
10348 Snapshot: snapshot.Bytes(),
10349 }
10350 }
10351
10352 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10353 err = awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(&output, decoder)
10354 if err != nil {
10355 var snapshot bytes.Buffer
10356 io.Copy(&snapshot, ringBuffer)
10357 return out, metadata, &smithy.DeserializationError{
10358 Err: fmt.Errorf("failed to decode response body, %w", err),
10359 Snapshot: snapshot.Bytes(),
10360 }
10361 }
10362
10363 span.End()
10364 return out, metadata, err
10365 }
10366
10367 func awsRestxml_deserializeOpErrorTestDNSAnswer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10368 var errorBuffer bytes.Buffer
10369 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10370 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10371 }
10372 errorBody := bytes.NewReader(errorBuffer.Bytes())
10373
10374 errorCode := "UnknownError"
10375 errorMessage := errorCode
10376
10377 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
10378 if err != nil {
10379 return err
10380 }
10381 if reqID := errorComponents.RequestID; len(reqID) != 0 {
10382 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
10383 }
10384 if len(errorComponents.Code) != 0 {
10385 errorCode = errorComponents.Code
10386 }
10387 if len(errorComponents.Message) != 0 {
10388 errorMessage = errorComponents.Message
10389 }
10390 errorBody.Seek(0, io.SeekStart)
10391 switch {
10392 case strings.EqualFold("InvalidInput", errorCode):
10393 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
10394
10395 case strings.EqualFold("NoSuchHostedZone", errorCode):
10396 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
10397
10398 default:
10399 genericError := &smithy.GenericAPIError{
10400 Code: errorCode,
10401 Message: errorMessage,
10402 }
10403 return genericError
10404
10405 }
10406 }
10407
10408 func awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(v **TestDNSAnswerOutput, decoder smithyxml.NodeDecoder) error {
10409 if v == nil {
10410 return fmt.Errorf("unexpected nil of type %T", v)
10411 }
10412 var sv *TestDNSAnswerOutput
10413 if *v == nil {
10414 sv = &TestDNSAnswerOutput{}
10415 } else {
10416 sv = *v
10417 }
10418
10419 for {
10420 t, done, err := decoder.Token()
10421 if err != nil {
10422 return err
10423 }
10424 if done {
10425 break
10426 }
10427 originalDecoder := decoder
10428 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
10429 switch {
10430 case strings.EqualFold("Nameserver", t.Name.Local):
10431 val, err := decoder.Value()
10432 if err != nil {
10433 return err
10434 }
10435 if val == nil {
10436 break
10437 }
10438 {
10439 xtv := string(val)
10440 sv.Nameserver = ptr.String(xtv)
10441 }
10442
10443 case strings.EqualFold("Protocol", t.Name.Local):
10444 val, err := decoder.Value()
10445 if err != nil {
10446 return err
10447 }
10448 if val == nil {
10449 break
10450 }
10451 {
10452 xtv := string(val)
10453 sv.Protocol = ptr.String(xtv)
10454 }
10455
10456 case strings.EqualFold("RecordData", t.Name.Local):
10457 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10458 if err := awsRestxml_deserializeDocumentRecordData(&sv.RecordData, nodeDecoder); err != nil {
10459 return err
10460 }
10461
10462 case strings.EqualFold("RecordName", t.Name.Local):
10463 val, err := decoder.Value()
10464 if err != nil {
10465 return err
10466 }
10467 if val == nil {
10468 break
10469 }
10470 {
10471 xtv := string(val)
10472 sv.RecordName = ptr.String(xtv)
10473 }
10474
10475 case strings.EqualFold("RecordType", t.Name.Local):
10476 val, err := decoder.Value()
10477 if err != nil {
10478 return err
10479 }
10480 if val == nil {
10481 break
10482 }
10483 {
10484 xtv := string(val)
10485 sv.RecordType = types.RRType(xtv)
10486 }
10487
10488 case strings.EqualFold("ResponseCode", t.Name.Local):
10489 val, err := decoder.Value()
10490 if err != nil {
10491 return err
10492 }
10493 if val == nil {
10494 break
10495 }
10496 {
10497 xtv := string(val)
10498 sv.ResponseCode = ptr.String(xtv)
10499 }
10500
10501 default:
10502 // Do nothing and ignore the unexpected tag element
10503 err = decoder.Decoder.Skip()
10504 if err != nil {
10505 return err
10506 }
10507
10508 }
10509 decoder = originalDecoder
10510 }
10511 *v = sv
10512 return nil
10513 }
10514
10515 type awsRestxml_deserializeOpUpdateHealthCheck struct {
10516 }
10517
10518 func (*awsRestxml_deserializeOpUpdateHealthCheck) ID() string {
10519 return "OperationDeserializer"
10520 }
10521
10522 func (m *awsRestxml_deserializeOpUpdateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10523 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10524 ) {
10525 out, metadata, err = next.HandleDeserialize(ctx, in)
10526 if err != nil {
10527 return out, metadata, err
10528 }
10529
10530 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10531 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10532 defer endTimer()
10533 defer span.End()
10534 response, ok := out.RawResponse.(*smithyhttp.Response)
10535 if !ok {
10536 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10537 }
10538
10539 if response.StatusCode < 200 || response.StatusCode >= 300 {
10540 return out, metadata, awsRestxml_deserializeOpErrorUpdateHealthCheck(response, &metadata)
10541 }
10542 output := &UpdateHealthCheckOutput{}
10543 out.Result = output
10544
10545 var buff [1024]byte
10546 ringBuffer := smithyio.NewRingBuffer(buff[:])
10547 body := io.TeeReader(response.Body, ringBuffer)
10548 rootDecoder := xml.NewDecoder(body)
10549 t, err := smithyxml.FetchRootElement(rootDecoder)
10550 if err == io.EOF {
10551 return out, metadata, nil
10552 }
10553 if err != nil {
10554 var snapshot bytes.Buffer
10555 io.Copy(&snapshot, ringBuffer)
10556 return out, metadata, &smithy.DeserializationError{
10557 Err: fmt.Errorf("failed to decode response body, %w", err),
10558 Snapshot: snapshot.Bytes(),
10559 }
10560 }
10561
10562 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10563 err = awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(&output, decoder)
10564 if err != nil {
10565 var snapshot bytes.Buffer
10566 io.Copy(&snapshot, ringBuffer)
10567 return out, metadata, &smithy.DeserializationError{
10568 Err: fmt.Errorf("failed to decode response body, %w", err),
10569 Snapshot: snapshot.Bytes(),
10570 }
10571 }
10572
10573 span.End()
10574 return out, metadata, err
10575 }
10576
10577 func awsRestxml_deserializeOpErrorUpdateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10578 var errorBuffer bytes.Buffer
10579 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10580 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10581 }
10582 errorBody := bytes.NewReader(errorBuffer.Bytes())
10583
10584 errorCode := "UnknownError"
10585 errorMessage := errorCode
10586
10587 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
10588 if err != nil {
10589 return err
10590 }
10591 if reqID := errorComponents.RequestID; len(reqID) != 0 {
10592 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
10593 }
10594 if len(errorComponents.Code) != 0 {
10595 errorCode = errorComponents.Code
10596 }
10597 if len(errorComponents.Message) != 0 {
10598 errorMessage = errorComponents.Message
10599 }
10600 errorBody.Seek(0, io.SeekStart)
10601 switch {
10602 case strings.EqualFold("HealthCheckVersionMismatch", errorCode):
10603 return awsRestxml_deserializeErrorHealthCheckVersionMismatch(response, errorBody)
10604
10605 case strings.EqualFold("InvalidInput", errorCode):
10606 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
10607
10608 case strings.EqualFold("NoSuchHealthCheck", errorCode):
10609 return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
10610
10611 default:
10612 genericError := &smithy.GenericAPIError{
10613 Code: errorCode,
10614 Message: errorMessage,
10615 }
10616 return genericError
10617
10618 }
10619 }
10620
10621 func awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(v **UpdateHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
10622 if v == nil {
10623 return fmt.Errorf("unexpected nil of type %T", v)
10624 }
10625 var sv *UpdateHealthCheckOutput
10626 if *v == nil {
10627 sv = &UpdateHealthCheckOutput{}
10628 } else {
10629 sv = *v
10630 }
10631
10632 for {
10633 t, done, err := decoder.Token()
10634 if err != nil {
10635 return err
10636 }
10637 if done {
10638 break
10639 }
10640 originalDecoder := decoder
10641 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
10642 switch {
10643 case strings.EqualFold("HealthCheck", t.Name.Local):
10644 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10645 if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
10646 return err
10647 }
10648
10649 default:
10650 // Do nothing and ignore the unexpected tag element
10651 err = decoder.Decoder.Skip()
10652 if err != nil {
10653 return err
10654 }
10655
10656 }
10657 decoder = originalDecoder
10658 }
10659 *v = sv
10660 return nil
10661 }
10662
10663 type awsRestxml_deserializeOpUpdateHostedZoneComment struct {
10664 }
10665
10666 func (*awsRestxml_deserializeOpUpdateHostedZoneComment) ID() string {
10667 return "OperationDeserializer"
10668 }
10669
10670 func (m *awsRestxml_deserializeOpUpdateHostedZoneComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10671 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10672 ) {
10673 out, metadata, err = next.HandleDeserialize(ctx, in)
10674 if err != nil {
10675 return out, metadata, err
10676 }
10677
10678 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10679 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10680 defer endTimer()
10681 defer span.End()
10682 response, ok := out.RawResponse.(*smithyhttp.Response)
10683 if !ok {
10684 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10685 }
10686
10687 if response.StatusCode < 200 || response.StatusCode >= 300 {
10688 return out, metadata, awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response, &metadata)
10689 }
10690 output := &UpdateHostedZoneCommentOutput{}
10691 out.Result = output
10692
10693 var buff [1024]byte
10694 ringBuffer := smithyio.NewRingBuffer(buff[:])
10695 body := io.TeeReader(response.Body, ringBuffer)
10696 rootDecoder := xml.NewDecoder(body)
10697 t, err := smithyxml.FetchRootElement(rootDecoder)
10698 if err == io.EOF {
10699 return out, metadata, nil
10700 }
10701 if err != nil {
10702 var snapshot bytes.Buffer
10703 io.Copy(&snapshot, ringBuffer)
10704 return out, metadata, &smithy.DeserializationError{
10705 Err: fmt.Errorf("failed to decode response body, %w", err),
10706 Snapshot: snapshot.Bytes(),
10707 }
10708 }
10709
10710 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10711 err = awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(&output, decoder)
10712 if err != nil {
10713 var snapshot bytes.Buffer
10714 io.Copy(&snapshot, ringBuffer)
10715 return out, metadata, &smithy.DeserializationError{
10716 Err: fmt.Errorf("failed to decode response body, %w", err),
10717 Snapshot: snapshot.Bytes(),
10718 }
10719 }
10720
10721 span.End()
10722 return out, metadata, err
10723 }
10724
10725 func awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10726 var errorBuffer bytes.Buffer
10727 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10728 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10729 }
10730 errorBody := bytes.NewReader(errorBuffer.Bytes())
10731
10732 errorCode := "UnknownError"
10733 errorMessage := errorCode
10734
10735 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
10736 if err != nil {
10737 return err
10738 }
10739 if reqID := errorComponents.RequestID; len(reqID) != 0 {
10740 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
10741 }
10742 if len(errorComponents.Code) != 0 {
10743 errorCode = errorComponents.Code
10744 }
10745 if len(errorComponents.Message) != 0 {
10746 errorMessage = errorComponents.Message
10747 }
10748 errorBody.Seek(0, io.SeekStart)
10749 switch {
10750 case strings.EqualFold("InvalidInput", errorCode):
10751 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
10752
10753 case strings.EqualFold("NoSuchHostedZone", errorCode):
10754 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
10755
10756 case strings.EqualFold("PriorRequestNotComplete", errorCode):
10757 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
10758
10759 default:
10760 genericError := &smithy.GenericAPIError{
10761 Code: errorCode,
10762 Message: errorMessage,
10763 }
10764 return genericError
10765
10766 }
10767 }
10768
10769 func awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(v **UpdateHostedZoneCommentOutput, decoder smithyxml.NodeDecoder) error {
10770 if v == nil {
10771 return fmt.Errorf("unexpected nil of type %T", v)
10772 }
10773 var sv *UpdateHostedZoneCommentOutput
10774 if *v == nil {
10775 sv = &UpdateHostedZoneCommentOutput{}
10776 } else {
10777 sv = *v
10778 }
10779
10780 for {
10781 t, done, err := decoder.Token()
10782 if err != nil {
10783 return err
10784 }
10785 if done {
10786 break
10787 }
10788 originalDecoder := decoder
10789 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
10790 switch {
10791 case strings.EqualFold("HostedZone", t.Name.Local):
10792 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10793 if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
10794 return err
10795 }
10796
10797 default:
10798 // Do nothing and ignore the unexpected tag element
10799 err = decoder.Decoder.Skip()
10800 if err != nil {
10801 return err
10802 }
10803
10804 }
10805 decoder = originalDecoder
10806 }
10807 *v = sv
10808 return nil
10809 }
10810
10811 type awsRestxml_deserializeOpUpdateHostedZoneFeatures struct {
10812 }
10813
10814 func (*awsRestxml_deserializeOpUpdateHostedZoneFeatures) ID() string {
10815 return "OperationDeserializer"
10816 }
10817
10818 func (m *awsRestxml_deserializeOpUpdateHostedZoneFeatures) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10819 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10820 ) {
10821 out, metadata, err = next.HandleDeserialize(ctx, in)
10822 if err != nil {
10823 return out, metadata, err
10824 }
10825
10826 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10827 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10828 defer endTimer()
10829 defer span.End()
10830 response, ok := out.RawResponse.(*smithyhttp.Response)
10831 if !ok {
10832 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10833 }
10834
10835 if response.StatusCode < 200 || response.StatusCode >= 300 {
10836 return out, metadata, awsRestxml_deserializeOpErrorUpdateHostedZoneFeatures(response, &metadata)
10837 }
10838 output := &UpdateHostedZoneFeaturesOutput{}
10839 out.Result = output
10840
10841 span.End()
10842 return out, metadata, err
10843 }
10844
10845 func awsRestxml_deserializeOpErrorUpdateHostedZoneFeatures(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10846 var errorBuffer bytes.Buffer
10847 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10848 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10849 }
10850 errorBody := bytes.NewReader(errorBuffer.Bytes())
10851
10852 errorCode := "UnknownError"
10853 errorMessage := errorCode
10854
10855 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
10856 if err != nil {
10857 return err
10858 }
10859 if reqID := errorComponents.RequestID; len(reqID) != 0 {
10860 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
10861 }
10862 if len(errorComponents.Code) != 0 {
10863 errorCode = errorComponents.Code
10864 }
10865 if len(errorComponents.Message) != 0 {
10866 errorMessage = errorComponents.Message
10867 }
10868 errorBody.Seek(0, io.SeekStart)
10869 switch {
10870 case strings.EqualFold("InvalidInput", errorCode):
10871 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
10872
10873 case strings.EqualFold("LimitsExceeded", errorCode):
10874 return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
10875
10876 case strings.EqualFold("NoSuchHostedZone", errorCode):
10877 return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
10878
10879 case strings.EqualFold("PriorRequestNotComplete", errorCode):
10880 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
10881
10882 default:
10883 genericError := &smithy.GenericAPIError{
10884 Code: errorCode,
10885 Message: errorMessage,
10886 }
10887 return genericError
10888
10889 }
10890 }
10891
10892 type awsRestxml_deserializeOpUpdateTrafficPolicyComment struct {
10893 }
10894
10895 func (*awsRestxml_deserializeOpUpdateTrafficPolicyComment) ID() string {
10896 return "OperationDeserializer"
10897 }
10898
10899 func (m *awsRestxml_deserializeOpUpdateTrafficPolicyComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10900 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10901 ) {
10902 out, metadata, err = next.HandleDeserialize(ctx, in)
10903 if err != nil {
10904 return out, metadata, err
10905 }
10906
10907 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10908 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10909 defer endTimer()
10910 defer span.End()
10911 response, ok := out.RawResponse.(*smithyhttp.Response)
10912 if !ok {
10913 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10914 }
10915
10916 if response.StatusCode < 200 || response.StatusCode >= 300 {
10917 return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response, &metadata)
10918 }
10919 output := &UpdateTrafficPolicyCommentOutput{}
10920 out.Result = output
10921
10922 var buff [1024]byte
10923 ringBuffer := smithyio.NewRingBuffer(buff[:])
10924 body := io.TeeReader(response.Body, ringBuffer)
10925 rootDecoder := xml.NewDecoder(body)
10926 t, err := smithyxml.FetchRootElement(rootDecoder)
10927 if err == io.EOF {
10928 return out, metadata, nil
10929 }
10930 if err != nil {
10931 var snapshot bytes.Buffer
10932 io.Copy(&snapshot, ringBuffer)
10933 return out, metadata, &smithy.DeserializationError{
10934 Err: fmt.Errorf("failed to decode response body, %w", err),
10935 Snapshot: snapshot.Bytes(),
10936 }
10937 }
10938
10939 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10940 err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(&output, decoder)
10941 if err != nil {
10942 var snapshot bytes.Buffer
10943 io.Copy(&snapshot, ringBuffer)
10944 return out, metadata, &smithy.DeserializationError{
10945 Err: fmt.Errorf("failed to decode response body, %w", err),
10946 Snapshot: snapshot.Bytes(),
10947 }
10948 }
10949
10950 span.End()
10951 return out, metadata, err
10952 }
10953
10954 func awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10955 var errorBuffer bytes.Buffer
10956 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10957 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10958 }
10959 errorBody := bytes.NewReader(errorBuffer.Bytes())
10960
10961 errorCode := "UnknownError"
10962 errorMessage := errorCode
10963
10964 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
10965 if err != nil {
10966 return err
10967 }
10968 if reqID := errorComponents.RequestID; len(reqID) != 0 {
10969 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
10970 }
10971 if len(errorComponents.Code) != 0 {
10972 errorCode = errorComponents.Code
10973 }
10974 if len(errorComponents.Message) != 0 {
10975 errorMessage = errorComponents.Message
10976 }
10977 errorBody.Seek(0, io.SeekStart)
10978 switch {
10979 case strings.EqualFold("ConcurrentModification", errorCode):
10980 return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
10981
10982 case strings.EqualFold("InvalidInput", errorCode):
10983 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
10984
10985 case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
10986 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
10987
10988 default:
10989 genericError := &smithy.GenericAPIError{
10990 Code: errorCode,
10991 Message: errorMessage,
10992 }
10993 return genericError
10994
10995 }
10996 }
10997
10998 func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(v **UpdateTrafficPolicyCommentOutput, decoder smithyxml.NodeDecoder) error {
10999 if v == nil {
11000 return fmt.Errorf("unexpected nil of type %T", v)
11001 }
11002 var sv *UpdateTrafficPolicyCommentOutput
11003 if *v == nil {
11004 sv = &UpdateTrafficPolicyCommentOutput{}
11005 } else {
11006 sv = *v
11007 }
11008
11009 for {
11010 t, done, err := decoder.Token()
11011 if err != nil {
11012 return err
11013 }
11014 if done {
11015 break
11016 }
11017 originalDecoder := decoder
11018 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
11019 switch {
11020 case strings.EqualFold("TrafficPolicy", t.Name.Local):
11021 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11022 if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
11023 return err
11024 }
11025
11026 default:
11027 // Do nothing and ignore the unexpected tag element
11028 err = decoder.Decoder.Skip()
11029 if err != nil {
11030 return err
11031 }
11032
11033 }
11034 decoder = originalDecoder
11035 }
11036 *v = sv
11037 return nil
11038 }
11039
11040 type awsRestxml_deserializeOpUpdateTrafficPolicyInstance struct {
11041 }
11042
11043 func (*awsRestxml_deserializeOpUpdateTrafficPolicyInstance) ID() string {
11044 return "OperationDeserializer"
11045 }
11046
11047 func (m *awsRestxml_deserializeOpUpdateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11048 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11049 ) {
11050 out, metadata, err = next.HandleDeserialize(ctx, in)
11051 if err != nil {
11052 return out, metadata, err
11053 }
11054
11055 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
11056 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
11057 defer endTimer()
11058 defer span.End()
11059 response, ok := out.RawResponse.(*smithyhttp.Response)
11060 if !ok {
11061 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11062 }
11063
11064 if response.StatusCode < 200 || response.StatusCode >= 300 {
11065 return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response, &metadata)
11066 }
11067 output := &UpdateTrafficPolicyInstanceOutput{}
11068 out.Result = output
11069
11070 var buff [1024]byte
11071 ringBuffer := smithyio.NewRingBuffer(buff[:])
11072 body := io.TeeReader(response.Body, ringBuffer)
11073 rootDecoder := xml.NewDecoder(body)
11074 t, err := smithyxml.FetchRootElement(rootDecoder)
11075 if err == io.EOF {
11076 return out, metadata, nil
11077 }
11078 if err != nil {
11079 var snapshot bytes.Buffer
11080 io.Copy(&snapshot, ringBuffer)
11081 return out, metadata, &smithy.DeserializationError{
11082 Err: fmt.Errorf("failed to decode response body, %w", err),
11083 Snapshot: snapshot.Bytes(),
11084 }
11085 }
11086
11087 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11088 err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(&output, decoder)
11089 if err != nil {
11090 var snapshot bytes.Buffer
11091 io.Copy(&snapshot, ringBuffer)
11092 return out, metadata, &smithy.DeserializationError{
11093 Err: fmt.Errorf("failed to decode response body, %w", err),
11094 Snapshot: snapshot.Bytes(),
11095 }
11096 }
11097
11098 span.End()
11099 return out, metadata, err
11100 }
11101
11102 func awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11103 var errorBuffer bytes.Buffer
11104 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11105 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11106 }
11107 errorBody := bytes.NewReader(errorBuffer.Bytes())
11108
11109 errorCode := "UnknownError"
11110 errorMessage := errorCode
11111
11112 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
11113 if err != nil {
11114 return err
11115 }
11116 if reqID := errorComponents.RequestID; len(reqID) != 0 {
11117 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
11118 }
11119 if len(errorComponents.Code) != 0 {
11120 errorCode = errorComponents.Code
11121 }
11122 if len(errorComponents.Message) != 0 {
11123 errorMessage = errorComponents.Message
11124 }
11125 errorBody.Seek(0, io.SeekStart)
11126 switch {
11127 case strings.EqualFold("ConflictingTypes", errorCode):
11128 return awsRestxml_deserializeErrorConflictingTypes(response, errorBody)
11129
11130 case strings.EqualFold("InvalidInput", errorCode):
11131 return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
11132
11133 case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
11134 return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
11135
11136 case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
11137 return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
11138
11139 case strings.EqualFold("PriorRequestNotComplete", errorCode):
11140 return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
11141
11142 default:
11143 genericError := &smithy.GenericAPIError{
11144 Code: errorCode,
11145 Message: errorMessage,
11146 }
11147 return genericError
11148
11149 }
11150 }
11151
11152 func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(v **UpdateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
11153 if v == nil {
11154 return fmt.Errorf("unexpected nil of type %T", v)
11155 }
11156 var sv *UpdateTrafficPolicyInstanceOutput
11157 if *v == nil {
11158 sv = &UpdateTrafficPolicyInstanceOutput{}
11159 } else {
11160 sv = *v
11161 }
11162
11163 for {
11164 t, done, err := decoder.Token()
11165 if err != nil {
11166 return err
11167 }
11168 if done {
11169 break
11170 }
11171 originalDecoder := decoder
11172 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
11173 switch {
11174 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
11175 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11176 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
11177 return err
11178 }
11179
11180 default:
11181 // Do nothing and ignore the unexpected tag element
11182 err = decoder.Decoder.Skip()
11183 if err != nil {
11184 return err
11185 }
11186
11187 }
11188 decoder = originalDecoder
11189 }
11190 *v = sv
11191 return nil
11192 }
11193
11194 func awsRestxml_deserializeErrorCidrBlockInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11195 output := &types.CidrBlockInUseException{}
11196 var buff [1024]byte
11197 ringBuffer := smithyio.NewRingBuffer(buff[:])
11198 body := io.TeeReader(errorBody, ringBuffer)
11199 rootDecoder := xml.NewDecoder(body)
11200 t, err := smithyxml.FetchRootElement(rootDecoder)
11201 if err == io.EOF {
11202 return output
11203 }
11204 if err != nil {
11205 var snapshot bytes.Buffer
11206 io.Copy(&snapshot, ringBuffer)
11207 return &smithy.DeserializationError{
11208 Err: fmt.Errorf("failed to decode response body, %w", err),
11209 Snapshot: snapshot.Bytes(),
11210 }
11211 }
11212
11213 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11214 t, err = decoder.GetElement("Error")
11215 if err != nil {
11216 var snapshot bytes.Buffer
11217 io.Copy(&snapshot, ringBuffer)
11218 return &smithy.DeserializationError{
11219 Err: fmt.Errorf("failed to decode response body, %w", err),
11220 Snapshot: snapshot.Bytes(),
11221 }
11222 }
11223
11224 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11225 err = awsRestxml_deserializeDocumentCidrBlockInUseException(&output, decoder)
11226 if err != nil {
11227 var snapshot bytes.Buffer
11228 io.Copy(&snapshot, ringBuffer)
11229 return &smithy.DeserializationError{
11230 Err: fmt.Errorf("failed to decode response body, %w", err),
11231 Snapshot: snapshot.Bytes(),
11232 }
11233 }
11234
11235 return output
11236 }
11237
11238 func awsRestxml_deserializeErrorCidrCollectionAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11239 output := &types.CidrCollectionAlreadyExistsException{}
11240 var buff [1024]byte
11241 ringBuffer := smithyio.NewRingBuffer(buff[:])
11242 body := io.TeeReader(errorBody, ringBuffer)
11243 rootDecoder := xml.NewDecoder(body)
11244 t, err := smithyxml.FetchRootElement(rootDecoder)
11245 if err == io.EOF {
11246 return output
11247 }
11248 if err != nil {
11249 var snapshot bytes.Buffer
11250 io.Copy(&snapshot, ringBuffer)
11251 return &smithy.DeserializationError{
11252 Err: fmt.Errorf("failed to decode response body, %w", err),
11253 Snapshot: snapshot.Bytes(),
11254 }
11255 }
11256
11257 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11258 t, err = decoder.GetElement("Error")
11259 if err != nil {
11260 var snapshot bytes.Buffer
11261 io.Copy(&snapshot, ringBuffer)
11262 return &smithy.DeserializationError{
11263 Err: fmt.Errorf("failed to decode response body, %w", err),
11264 Snapshot: snapshot.Bytes(),
11265 }
11266 }
11267
11268 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11269 err = awsRestxml_deserializeDocumentCidrCollectionAlreadyExistsException(&output, decoder)
11270 if err != nil {
11271 var snapshot bytes.Buffer
11272 io.Copy(&snapshot, ringBuffer)
11273 return &smithy.DeserializationError{
11274 Err: fmt.Errorf("failed to decode response body, %w", err),
11275 Snapshot: snapshot.Bytes(),
11276 }
11277 }
11278
11279 return output
11280 }
11281
11282 func awsRestxml_deserializeErrorCidrCollectionInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11283 output := &types.CidrCollectionInUseException{}
11284 var buff [1024]byte
11285 ringBuffer := smithyio.NewRingBuffer(buff[:])
11286 body := io.TeeReader(errorBody, ringBuffer)
11287 rootDecoder := xml.NewDecoder(body)
11288 t, err := smithyxml.FetchRootElement(rootDecoder)
11289 if err == io.EOF {
11290 return output
11291 }
11292 if err != nil {
11293 var snapshot bytes.Buffer
11294 io.Copy(&snapshot, ringBuffer)
11295 return &smithy.DeserializationError{
11296 Err: fmt.Errorf("failed to decode response body, %w", err),
11297 Snapshot: snapshot.Bytes(),
11298 }
11299 }
11300
11301 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11302 t, err = decoder.GetElement("Error")
11303 if err != nil {
11304 var snapshot bytes.Buffer
11305 io.Copy(&snapshot, ringBuffer)
11306 return &smithy.DeserializationError{
11307 Err: fmt.Errorf("failed to decode response body, %w", err),
11308 Snapshot: snapshot.Bytes(),
11309 }
11310 }
11311
11312 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11313 err = awsRestxml_deserializeDocumentCidrCollectionInUseException(&output, decoder)
11314 if err != nil {
11315 var snapshot bytes.Buffer
11316 io.Copy(&snapshot, ringBuffer)
11317 return &smithy.DeserializationError{
11318 Err: fmt.Errorf("failed to decode response body, %w", err),
11319 Snapshot: snapshot.Bytes(),
11320 }
11321 }
11322
11323 return output
11324 }
11325
11326 func awsRestxml_deserializeErrorCidrCollectionVersionMismatchException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11327 output := &types.CidrCollectionVersionMismatchException{}
11328 var buff [1024]byte
11329 ringBuffer := smithyio.NewRingBuffer(buff[:])
11330 body := io.TeeReader(errorBody, ringBuffer)
11331 rootDecoder := xml.NewDecoder(body)
11332 t, err := smithyxml.FetchRootElement(rootDecoder)
11333 if err == io.EOF {
11334 return output
11335 }
11336 if err != nil {
11337 var snapshot bytes.Buffer
11338 io.Copy(&snapshot, ringBuffer)
11339 return &smithy.DeserializationError{
11340 Err: fmt.Errorf("failed to decode response body, %w", err),
11341 Snapshot: snapshot.Bytes(),
11342 }
11343 }
11344
11345 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11346 t, err = decoder.GetElement("Error")
11347 if err != nil {
11348 var snapshot bytes.Buffer
11349 io.Copy(&snapshot, ringBuffer)
11350 return &smithy.DeserializationError{
11351 Err: fmt.Errorf("failed to decode response body, %w", err),
11352 Snapshot: snapshot.Bytes(),
11353 }
11354 }
11355
11356 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11357 err = awsRestxml_deserializeDocumentCidrCollectionVersionMismatchException(&output, decoder)
11358 if err != nil {
11359 var snapshot bytes.Buffer
11360 io.Copy(&snapshot, ringBuffer)
11361 return &smithy.DeserializationError{
11362 Err: fmt.Errorf("failed to decode response body, %w", err),
11363 Snapshot: snapshot.Bytes(),
11364 }
11365 }
11366
11367 return output
11368 }
11369
11370 func awsRestxml_deserializeErrorConcurrentModification(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11371 output := &types.ConcurrentModification{}
11372 var buff [1024]byte
11373 ringBuffer := smithyio.NewRingBuffer(buff[:])
11374 body := io.TeeReader(errorBody, ringBuffer)
11375 rootDecoder := xml.NewDecoder(body)
11376 t, err := smithyxml.FetchRootElement(rootDecoder)
11377 if err == io.EOF {
11378 return output
11379 }
11380 if err != nil {
11381 var snapshot bytes.Buffer
11382 io.Copy(&snapshot, ringBuffer)
11383 return &smithy.DeserializationError{
11384 Err: fmt.Errorf("failed to decode response body, %w", err),
11385 Snapshot: snapshot.Bytes(),
11386 }
11387 }
11388
11389 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11390 t, err = decoder.GetElement("Error")
11391 if err != nil {
11392 var snapshot bytes.Buffer
11393 io.Copy(&snapshot, ringBuffer)
11394 return &smithy.DeserializationError{
11395 Err: fmt.Errorf("failed to decode response body, %w", err),
11396 Snapshot: snapshot.Bytes(),
11397 }
11398 }
11399
11400 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11401 err = awsRestxml_deserializeDocumentConcurrentModification(&output, decoder)
11402 if err != nil {
11403 var snapshot bytes.Buffer
11404 io.Copy(&snapshot, ringBuffer)
11405 return &smithy.DeserializationError{
11406 Err: fmt.Errorf("failed to decode response body, %w", err),
11407 Snapshot: snapshot.Bytes(),
11408 }
11409 }
11410
11411 return output
11412 }
11413
11414 func awsRestxml_deserializeErrorConflictingDomainExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11415 output := &types.ConflictingDomainExists{}
11416 var buff [1024]byte
11417 ringBuffer := smithyio.NewRingBuffer(buff[:])
11418 body := io.TeeReader(errorBody, ringBuffer)
11419 rootDecoder := xml.NewDecoder(body)
11420 t, err := smithyxml.FetchRootElement(rootDecoder)
11421 if err == io.EOF {
11422 return output
11423 }
11424 if err != nil {
11425 var snapshot bytes.Buffer
11426 io.Copy(&snapshot, ringBuffer)
11427 return &smithy.DeserializationError{
11428 Err: fmt.Errorf("failed to decode response body, %w", err),
11429 Snapshot: snapshot.Bytes(),
11430 }
11431 }
11432
11433 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11434 t, err = decoder.GetElement("Error")
11435 if err != nil {
11436 var snapshot bytes.Buffer
11437 io.Copy(&snapshot, ringBuffer)
11438 return &smithy.DeserializationError{
11439 Err: fmt.Errorf("failed to decode response body, %w", err),
11440 Snapshot: snapshot.Bytes(),
11441 }
11442 }
11443
11444 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11445 err = awsRestxml_deserializeDocumentConflictingDomainExists(&output, decoder)
11446 if err != nil {
11447 var snapshot bytes.Buffer
11448 io.Copy(&snapshot, ringBuffer)
11449 return &smithy.DeserializationError{
11450 Err: fmt.Errorf("failed to decode response body, %w", err),
11451 Snapshot: snapshot.Bytes(),
11452 }
11453 }
11454
11455 return output
11456 }
11457
11458 func awsRestxml_deserializeErrorConflictingTypes(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11459 output := &types.ConflictingTypes{}
11460 var buff [1024]byte
11461 ringBuffer := smithyio.NewRingBuffer(buff[:])
11462 body := io.TeeReader(errorBody, ringBuffer)
11463 rootDecoder := xml.NewDecoder(body)
11464 t, err := smithyxml.FetchRootElement(rootDecoder)
11465 if err == io.EOF {
11466 return output
11467 }
11468 if err != nil {
11469 var snapshot bytes.Buffer
11470 io.Copy(&snapshot, ringBuffer)
11471 return &smithy.DeserializationError{
11472 Err: fmt.Errorf("failed to decode response body, %w", err),
11473 Snapshot: snapshot.Bytes(),
11474 }
11475 }
11476
11477 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11478 t, err = decoder.GetElement("Error")
11479 if err != nil {
11480 var snapshot bytes.Buffer
11481 io.Copy(&snapshot, ringBuffer)
11482 return &smithy.DeserializationError{
11483 Err: fmt.Errorf("failed to decode response body, %w", err),
11484 Snapshot: snapshot.Bytes(),
11485 }
11486 }
11487
11488 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11489 err = awsRestxml_deserializeDocumentConflictingTypes(&output, decoder)
11490 if err != nil {
11491 var snapshot bytes.Buffer
11492 io.Copy(&snapshot, ringBuffer)
11493 return &smithy.DeserializationError{
11494 Err: fmt.Errorf("failed to decode response body, %w", err),
11495 Snapshot: snapshot.Bytes(),
11496 }
11497 }
11498
11499 return output
11500 }
11501
11502 func awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11503 output := &types.DelegationSetAlreadyCreated{}
11504 var buff [1024]byte
11505 ringBuffer := smithyio.NewRingBuffer(buff[:])
11506 body := io.TeeReader(errorBody, ringBuffer)
11507 rootDecoder := xml.NewDecoder(body)
11508 t, err := smithyxml.FetchRootElement(rootDecoder)
11509 if err == io.EOF {
11510 return output
11511 }
11512 if err != nil {
11513 var snapshot bytes.Buffer
11514 io.Copy(&snapshot, ringBuffer)
11515 return &smithy.DeserializationError{
11516 Err: fmt.Errorf("failed to decode response body, %w", err),
11517 Snapshot: snapshot.Bytes(),
11518 }
11519 }
11520
11521 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11522 t, err = decoder.GetElement("Error")
11523 if err != nil {
11524 var snapshot bytes.Buffer
11525 io.Copy(&snapshot, ringBuffer)
11526 return &smithy.DeserializationError{
11527 Err: fmt.Errorf("failed to decode response body, %w", err),
11528 Snapshot: snapshot.Bytes(),
11529 }
11530 }
11531
11532 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11533 err = awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(&output, decoder)
11534 if err != nil {
11535 var snapshot bytes.Buffer
11536 io.Copy(&snapshot, ringBuffer)
11537 return &smithy.DeserializationError{
11538 Err: fmt.Errorf("failed to decode response body, %w", err),
11539 Snapshot: snapshot.Bytes(),
11540 }
11541 }
11542
11543 return output
11544 }
11545
11546 func awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11547 output := &types.DelegationSetAlreadyReusable{}
11548 var buff [1024]byte
11549 ringBuffer := smithyio.NewRingBuffer(buff[:])
11550 body := io.TeeReader(errorBody, ringBuffer)
11551 rootDecoder := xml.NewDecoder(body)
11552 t, err := smithyxml.FetchRootElement(rootDecoder)
11553 if err == io.EOF {
11554 return output
11555 }
11556 if err != nil {
11557 var snapshot bytes.Buffer
11558 io.Copy(&snapshot, ringBuffer)
11559 return &smithy.DeserializationError{
11560 Err: fmt.Errorf("failed to decode response body, %w", err),
11561 Snapshot: snapshot.Bytes(),
11562 }
11563 }
11564
11565 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11566 t, err = decoder.GetElement("Error")
11567 if err != nil {
11568 var snapshot bytes.Buffer
11569 io.Copy(&snapshot, ringBuffer)
11570 return &smithy.DeserializationError{
11571 Err: fmt.Errorf("failed to decode response body, %w", err),
11572 Snapshot: snapshot.Bytes(),
11573 }
11574 }
11575
11576 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11577 err = awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(&output, decoder)
11578 if err != nil {
11579 var snapshot bytes.Buffer
11580 io.Copy(&snapshot, ringBuffer)
11581 return &smithy.DeserializationError{
11582 Err: fmt.Errorf("failed to decode response body, %w", err),
11583 Snapshot: snapshot.Bytes(),
11584 }
11585 }
11586
11587 return output
11588 }
11589
11590 func awsRestxml_deserializeErrorDelegationSetInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11591 output := &types.DelegationSetInUse{}
11592 var buff [1024]byte
11593 ringBuffer := smithyio.NewRingBuffer(buff[:])
11594 body := io.TeeReader(errorBody, ringBuffer)
11595 rootDecoder := xml.NewDecoder(body)
11596 t, err := smithyxml.FetchRootElement(rootDecoder)
11597 if err == io.EOF {
11598 return output
11599 }
11600 if err != nil {
11601 var snapshot bytes.Buffer
11602 io.Copy(&snapshot, ringBuffer)
11603 return &smithy.DeserializationError{
11604 Err: fmt.Errorf("failed to decode response body, %w", err),
11605 Snapshot: snapshot.Bytes(),
11606 }
11607 }
11608
11609 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11610 t, err = decoder.GetElement("Error")
11611 if err != nil {
11612 var snapshot bytes.Buffer
11613 io.Copy(&snapshot, ringBuffer)
11614 return &smithy.DeserializationError{
11615 Err: fmt.Errorf("failed to decode response body, %w", err),
11616 Snapshot: snapshot.Bytes(),
11617 }
11618 }
11619
11620 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11621 err = awsRestxml_deserializeDocumentDelegationSetInUse(&output, decoder)
11622 if err != nil {
11623 var snapshot bytes.Buffer
11624 io.Copy(&snapshot, ringBuffer)
11625 return &smithy.DeserializationError{
11626 Err: fmt.Errorf("failed to decode response body, %w", err),
11627 Snapshot: snapshot.Bytes(),
11628 }
11629 }
11630
11631 return output
11632 }
11633
11634 func awsRestxml_deserializeErrorDelegationSetNotAvailable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11635 output := &types.DelegationSetNotAvailable{}
11636 var buff [1024]byte
11637 ringBuffer := smithyio.NewRingBuffer(buff[:])
11638 body := io.TeeReader(errorBody, ringBuffer)
11639 rootDecoder := xml.NewDecoder(body)
11640 t, err := smithyxml.FetchRootElement(rootDecoder)
11641 if err == io.EOF {
11642 return output
11643 }
11644 if err != nil {
11645 var snapshot bytes.Buffer
11646 io.Copy(&snapshot, ringBuffer)
11647 return &smithy.DeserializationError{
11648 Err: fmt.Errorf("failed to decode response body, %w", err),
11649 Snapshot: snapshot.Bytes(),
11650 }
11651 }
11652
11653 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11654 t, err = decoder.GetElement("Error")
11655 if err != nil {
11656 var snapshot bytes.Buffer
11657 io.Copy(&snapshot, ringBuffer)
11658 return &smithy.DeserializationError{
11659 Err: fmt.Errorf("failed to decode response body, %w", err),
11660 Snapshot: snapshot.Bytes(),
11661 }
11662 }
11663
11664 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11665 err = awsRestxml_deserializeDocumentDelegationSetNotAvailable(&output, decoder)
11666 if err != nil {
11667 var snapshot bytes.Buffer
11668 io.Copy(&snapshot, ringBuffer)
11669 return &smithy.DeserializationError{
11670 Err: fmt.Errorf("failed to decode response body, %w", err),
11671 Snapshot: snapshot.Bytes(),
11672 }
11673 }
11674
11675 return output
11676 }
11677
11678 func awsRestxml_deserializeErrorDelegationSetNotReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11679 output := &types.DelegationSetNotReusable{}
11680 var buff [1024]byte
11681 ringBuffer := smithyio.NewRingBuffer(buff[:])
11682 body := io.TeeReader(errorBody, ringBuffer)
11683 rootDecoder := xml.NewDecoder(body)
11684 t, err := smithyxml.FetchRootElement(rootDecoder)
11685 if err == io.EOF {
11686 return output
11687 }
11688 if err != nil {
11689 var snapshot bytes.Buffer
11690 io.Copy(&snapshot, ringBuffer)
11691 return &smithy.DeserializationError{
11692 Err: fmt.Errorf("failed to decode response body, %w", err),
11693 Snapshot: snapshot.Bytes(),
11694 }
11695 }
11696
11697 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11698 t, err = decoder.GetElement("Error")
11699 if err != nil {
11700 var snapshot bytes.Buffer
11701 io.Copy(&snapshot, ringBuffer)
11702 return &smithy.DeserializationError{
11703 Err: fmt.Errorf("failed to decode response body, %w", err),
11704 Snapshot: snapshot.Bytes(),
11705 }
11706 }
11707
11708 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11709 err = awsRestxml_deserializeDocumentDelegationSetNotReusable(&output, decoder)
11710 if err != nil {
11711 var snapshot bytes.Buffer
11712 io.Copy(&snapshot, ringBuffer)
11713 return &smithy.DeserializationError{
11714 Err: fmt.Errorf("failed to decode response body, %w", err),
11715 Snapshot: snapshot.Bytes(),
11716 }
11717 }
11718
11719 return output
11720 }
11721
11722 func awsRestxml_deserializeErrorDNSSECNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11723 output := &types.DNSSECNotFound{}
11724 var buff [1024]byte
11725 ringBuffer := smithyio.NewRingBuffer(buff[:])
11726 body := io.TeeReader(errorBody, ringBuffer)
11727 rootDecoder := xml.NewDecoder(body)
11728 t, err := smithyxml.FetchRootElement(rootDecoder)
11729 if err == io.EOF {
11730 return output
11731 }
11732 if err != nil {
11733 var snapshot bytes.Buffer
11734 io.Copy(&snapshot, ringBuffer)
11735 return &smithy.DeserializationError{
11736 Err: fmt.Errorf("failed to decode response body, %w", err),
11737 Snapshot: snapshot.Bytes(),
11738 }
11739 }
11740
11741 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11742 t, err = decoder.GetElement("Error")
11743 if err != nil {
11744 var snapshot bytes.Buffer
11745 io.Copy(&snapshot, ringBuffer)
11746 return &smithy.DeserializationError{
11747 Err: fmt.Errorf("failed to decode response body, %w", err),
11748 Snapshot: snapshot.Bytes(),
11749 }
11750 }
11751
11752 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11753 err = awsRestxml_deserializeDocumentDNSSECNotFound(&output, decoder)
11754 if err != nil {
11755 var snapshot bytes.Buffer
11756 io.Copy(&snapshot, ringBuffer)
11757 return &smithy.DeserializationError{
11758 Err: fmt.Errorf("failed to decode response body, %w", err),
11759 Snapshot: snapshot.Bytes(),
11760 }
11761 }
11762
11763 return output
11764 }
11765
11766 func awsRestxml_deserializeErrorHealthCheckAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11767 output := &types.HealthCheckAlreadyExists{}
11768 var buff [1024]byte
11769 ringBuffer := smithyio.NewRingBuffer(buff[:])
11770 body := io.TeeReader(errorBody, ringBuffer)
11771 rootDecoder := xml.NewDecoder(body)
11772 t, err := smithyxml.FetchRootElement(rootDecoder)
11773 if err == io.EOF {
11774 return output
11775 }
11776 if err != nil {
11777 var snapshot bytes.Buffer
11778 io.Copy(&snapshot, ringBuffer)
11779 return &smithy.DeserializationError{
11780 Err: fmt.Errorf("failed to decode response body, %w", err),
11781 Snapshot: snapshot.Bytes(),
11782 }
11783 }
11784
11785 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11786 t, err = decoder.GetElement("Error")
11787 if err != nil {
11788 var snapshot bytes.Buffer
11789 io.Copy(&snapshot, ringBuffer)
11790 return &smithy.DeserializationError{
11791 Err: fmt.Errorf("failed to decode response body, %w", err),
11792 Snapshot: snapshot.Bytes(),
11793 }
11794 }
11795
11796 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11797 err = awsRestxml_deserializeDocumentHealthCheckAlreadyExists(&output, decoder)
11798 if err != nil {
11799 var snapshot bytes.Buffer
11800 io.Copy(&snapshot, ringBuffer)
11801 return &smithy.DeserializationError{
11802 Err: fmt.Errorf("failed to decode response body, %w", err),
11803 Snapshot: snapshot.Bytes(),
11804 }
11805 }
11806
11807 return output
11808 }
11809
11810 func awsRestxml_deserializeErrorHealthCheckInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11811 output := &types.HealthCheckInUse{}
11812 var buff [1024]byte
11813 ringBuffer := smithyio.NewRingBuffer(buff[:])
11814 body := io.TeeReader(errorBody, ringBuffer)
11815 rootDecoder := xml.NewDecoder(body)
11816 t, err := smithyxml.FetchRootElement(rootDecoder)
11817 if err == io.EOF {
11818 return output
11819 }
11820 if err != nil {
11821 var snapshot bytes.Buffer
11822 io.Copy(&snapshot, ringBuffer)
11823 return &smithy.DeserializationError{
11824 Err: fmt.Errorf("failed to decode response body, %w", err),
11825 Snapshot: snapshot.Bytes(),
11826 }
11827 }
11828
11829 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11830 t, err = decoder.GetElement("Error")
11831 if err != nil {
11832 var snapshot bytes.Buffer
11833 io.Copy(&snapshot, ringBuffer)
11834 return &smithy.DeserializationError{
11835 Err: fmt.Errorf("failed to decode response body, %w", err),
11836 Snapshot: snapshot.Bytes(),
11837 }
11838 }
11839
11840 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11841 err = awsRestxml_deserializeDocumentHealthCheckInUse(&output, decoder)
11842 if err != nil {
11843 var snapshot bytes.Buffer
11844 io.Copy(&snapshot, ringBuffer)
11845 return &smithy.DeserializationError{
11846 Err: fmt.Errorf("failed to decode response body, %w", err),
11847 Snapshot: snapshot.Bytes(),
11848 }
11849 }
11850
11851 return output
11852 }
11853
11854 func awsRestxml_deserializeErrorHealthCheckVersionMismatch(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11855 output := &types.HealthCheckVersionMismatch{}
11856 var buff [1024]byte
11857 ringBuffer := smithyio.NewRingBuffer(buff[:])
11858 body := io.TeeReader(errorBody, ringBuffer)
11859 rootDecoder := xml.NewDecoder(body)
11860 t, err := smithyxml.FetchRootElement(rootDecoder)
11861 if err == io.EOF {
11862 return output
11863 }
11864 if err != nil {
11865 var snapshot bytes.Buffer
11866 io.Copy(&snapshot, ringBuffer)
11867 return &smithy.DeserializationError{
11868 Err: fmt.Errorf("failed to decode response body, %w", err),
11869 Snapshot: snapshot.Bytes(),
11870 }
11871 }
11872
11873 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11874 t, err = decoder.GetElement("Error")
11875 if err != nil {
11876 var snapshot bytes.Buffer
11877 io.Copy(&snapshot, ringBuffer)
11878 return &smithy.DeserializationError{
11879 Err: fmt.Errorf("failed to decode response body, %w", err),
11880 Snapshot: snapshot.Bytes(),
11881 }
11882 }
11883
11884 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11885 err = awsRestxml_deserializeDocumentHealthCheckVersionMismatch(&output, decoder)
11886 if err != nil {
11887 var snapshot bytes.Buffer
11888 io.Copy(&snapshot, ringBuffer)
11889 return &smithy.DeserializationError{
11890 Err: fmt.Errorf("failed to decode response body, %w", err),
11891 Snapshot: snapshot.Bytes(),
11892 }
11893 }
11894
11895 return output
11896 }
11897
11898 func awsRestxml_deserializeErrorHostedZoneAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11899 output := &types.HostedZoneAlreadyExists{}
11900 var buff [1024]byte
11901 ringBuffer := smithyio.NewRingBuffer(buff[:])
11902 body := io.TeeReader(errorBody, ringBuffer)
11903 rootDecoder := xml.NewDecoder(body)
11904 t, err := smithyxml.FetchRootElement(rootDecoder)
11905 if err == io.EOF {
11906 return output
11907 }
11908 if err != nil {
11909 var snapshot bytes.Buffer
11910 io.Copy(&snapshot, ringBuffer)
11911 return &smithy.DeserializationError{
11912 Err: fmt.Errorf("failed to decode response body, %w", err),
11913 Snapshot: snapshot.Bytes(),
11914 }
11915 }
11916
11917 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11918 t, err = decoder.GetElement("Error")
11919 if err != nil {
11920 var snapshot bytes.Buffer
11921 io.Copy(&snapshot, ringBuffer)
11922 return &smithy.DeserializationError{
11923 Err: fmt.Errorf("failed to decode response body, %w", err),
11924 Snapshot: snapshot.Bytes(),
11925 }
11926 }
11927
11928 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11929 err = awsRestxml_deserializeDocumentHostedZoneAlreadyExists(&output, decoder)
11930 if err != nil {
11931 var snapshot bytes.Buffer
11932 io.Copy(&snapshot, ringBuffer)
11933 return &smithy.DeserializationError{
11934 Err: fmt.Errorf("failed to decode response body, %w", err),
11935 Snapshot: snapshot.Bytes(),
11936 }
11937 }
11938
11939 return output
11940 }
11941
11942 func awsRestxml_deserializeErrorHostedZoneNotEmpty(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11943 output := &types.HostedZoneNotEmpty{}
11944 var buff [1024]byte
11945 ringBuffer := smithyio.NewRingBuffer(buff[:])
11946 body := io.TeeReader(errorBody, ringBuffer)
11947 rootDecoder := xml.NewDecoder(body)
11948 t, err := smithyxml.FetchRootElement(rootDecoder)
11949 if err == io.EOF {
11950 return output
11951 }
11952 if err != nil {
11953 var snapshot bytes.Buffer
11954 io.Copy(&snapshot, ringBuffer)
11955 return &smithy.DeserializationError{
11956 Err: fmt.Errorf("failed to decode response body, %w", err),
11957 Snapshot: snapshot.Bytes(),
11958 }
11959 }
11960
11961 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
11962 t, err = decoder.GetElement("Error")
11963 if err != nil {
11964 var snapshot bytes.Buffer
11965 io.Copy(&snapshot, ringBuffer)
11966 return &smithy.DeserializationError{
11967 Err: fmt.Errorf("failed to decode response body, %w", err),
11968 Snapshot: snapshot.Bytes(),
11969 }
11970 }
11971
11972 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11973 err = awsRestxml_deserializeDocumentHostedZoneNotEmpty(&output, decoder)
11974 if err != nil {
11975 var snapshot bytes.Buffer
11976 io.Copy(&snapshot, ringBuffer)
11977 return &smithy.DeserializationError{
11978 Err: fmt.Errorf("failed to decode response body, %w", err),
11979 Snapshot: snapshot.Bytes(),
11980 }
11981 }
11982
11983 return output
11984 }
11985
11986 func awsRestxml_deserializeErrorHostedZoneNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
11987 output := &types.HostedZoneNotFound{}
11988 var buff [1024]byte
11989 ringBuffer := smithyio.NewRingBuffer(buff[:])
11990 body := io.TeeReader(errorBody, ringBuffer)
11991 rootDecoder := xml.NewDecoder(body)
11992 t, err := smithyxml.FetchRootElement(rootDecoder)
11993 if err == io.EOF {
11994 return output
11995 }
11996 if err != nil {
11997 var snapshot bytes.Buffer
11998 io.Copy(&snapshot, ringBuffer)
11999 return &smithy.DeserializationError{
12000 Err: fmt.Errorf("failed to decode response body, %w", err),
12001 Snapshot: snapshot.Bytes(),
12002 }
12003 }
12004
12005 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12006 t, err = decoder.GetElement("Error")
12007 if err != nil {
12008 var snapshot bytes.Buffer
12009 io.Copy(&snapshot, ringBuffer)
12010 return &smithy.DeserializationError{
12011 Err: fmt.Errorf("failed to decode response body, %w", err),
12012 Snapshot: snapshot.Bytes(),
12013 }
12014 }
12015
12016 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12017 err = awsRestxml_deserializeDocumentHostedZoneNotFound(&output, decoder)
12018 if err != nil {
12019 var snapshot bytes.Buffer
12020 io.Copy(&snapshot, ringBuffer)
12021 return &smithy.DeserializationError{
12022 Err: fmt.Errorf("failed to decode response body, %w", err),
12023 Snapshot: snapshot.Bytes(),
12024 }
12025 }
12026
12027 return output
12028 }
12029
12030 func awsRestxml_deserializeErrorHostedZoneNotPrivate(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12031 output := &types.HostedZoneNotPrivate{}
12032 var buff [1024]byte
12033 ringBuffer := smithyio.NewRingBuffer(buff[:])
12034 body := io.TeeReader(errorBody, ringBuffer)
12035 rootDecoder := xml.NewDecoder(body)
12036 t, err := smithyxml.FetchRootElement(rootDecoder)
12037 if err == io.EOF {
12038 return output
12039 }
12040 if err != nil {
12041 var snapshot bytes.Buffer
12042 io.Copy(&snapshot, ringBuffer)
12043 return &smithy.DeserializationError{
12044 Err: fmt.Errorf("failed to decode response body, %w", err),
12045 Snapshot: snapshot.Bytes(),
12046 }
12047 }
12048
12049 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12050 t, err = decoder.GetElement("Error")
12051 if err != nil {
12052 var snapshot bytes.Buffer
12053 io.Copy(&snapshot, ringBuffer)
12054 return &smithy.DeserializationError{
12055 Err: fmt.Errorf("failed to decode response body, %w", err),
12056 Snapshot: snapshot.Bytes(),
12057 }
12058 }
12059
12060 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12061 err = awsRestxml_deserializeDocumentHostedZoneNotPrivate(&output, decoder)
12062 if err != nil {
12063 var snapshot bytes.Buffer
12064 io.Copy(&snapshot, ringBuffer)
12065 return &smithy.DeserializationError{
12066 Err: fmt.Errorf("failed to decode response body, %w", err),
12067 Snapshot: snapshot.Bytes(),
12068 }
12069 }
12070
12071 return output
12072 }
12073
12074 func awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12075 output := &types.HostedZonePartiallyDelegated{}
12076 var buff [1024]byte
12077 ringBuffer := smithyio.NewRingBuffer(buff[:])
12078 body := io.TeeReader(errorBody, ringBuffer)
12079 rootDecoder := xml.NewDecoder(body)
12080 t, err := smithyxml.FetchRootElement(rootDecoder)
12081 if err == io.EOF {
12082 return output
12083 }
12084 if err != nil {
12085 var snapshot bytes.Buffer
12086 io.Copy(&snapshot, ringBuffer)
12087 return &smithy.DeserializationError{
12088 Err: fmt.Errorf("failed to decode response body, %w", err),
12089 Snapshot: snapshot.Bytes(),
12090 }
12091 }
12092
12093 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12094 t, err = decoder.GetElement("Error")
12095 if err != nil {
12096 var snapshot bytes.Buffer
12097 io.Copy(&snapshot, ringBuffer)
12098 return &smithy.DeserializationError{
12099 Err: fmt.Errorf("failed to decode response body, %w", err),
12100 Snapshot: snapshot.Bytes(),
12101 }
12102 }
12103
12104 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12105 err = awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(&output, decoder)
12106 if err != nil {
12107 var snapshot bytes.Buffer
12108 io.Copy(&snapshot, ringBuffer)
12109 return &smithy.DeserializationError{
12110 Err: fmt.Errorf("failed to decode response body, %w", err),
12111 Snapshot: snapshot.Bytes(),
12112 }
12113 }
12114
12115 return output
12116 }
12117
12118 func awsRestxml_deserializeErrorIncompatibleVersion(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12119 output := &types.IncompatibleVersion{}
12120 var buff [1024]byte
12121 ringBuffer := smithyio.NewRingBuffer(buff[:])
12122 body := io.TeeReader(errorBody, ringBuffer)
12123 rootDecoder := xml.NewDecoder(body)
12124 t, err := smithyxml.FetchRootElement(rootDecoder)
12125 if err == io.EOF {
12126 return output
12127 }
12128 if err != nil {
12129 var snapshot bytes.Buffer
12130 io.Copy(&snapshot, ringBuffer)
12131 return &smithy.DeserializationError{
12132 Err: fmt.Errorf("failed to decode response body, %w", err),
12133 Snapshot: snapshot.Bytes(),
12134 }
12135 }
12136
12137 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12138 t, err = decoder.GetElement("Error")
12139 if err != nil {
12140 var snapshot bytes.Buffer
12141 io.Copy(&snapshot, ringBuffer)
12142 return &smithy.DeserializationError{
12143 Err: fmt.Errorf("failed to decode response body, %w", err),
12144 Snapshot: snapshot.Bytes(),
12145 }
12146 }
12147
12148 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12149 err = awsRestxml_deserializeDocumentIncompatibleVersion(&output, decoder)
12150 if err != nil {
12151 var snapshot bytes.Buffer
12152 io.Copy(&snapshot, ringBuffer)
12153 return &smithy.DeserializationError{
12154 Err: fmt.Errorf("failed to decode response body, %w", err),
12155 Snapshot: snapshot.Bytes(),
12156 }
12157 }
12158
12159 return output
12160 }
12161
12162 func awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12163 output := &types.InsufficientCloudWatchLogsResourcePolicy{}
12164 var buff [1024]byte
12165 ringBuffer := smithyio.NewRingBuffer(buff[:])
12166 body := io.TeeReader(errorBody, ringBuffer)
12167 rootDecoder := xml.NewDecoder(body)
12168 t, err := smithyxml.FetchRootElement(rootDecoder)
12169 if err == io.EOF {
12170 return output
12171 }
12172 if err != nil {
12173 var snapshot bytes.Buffer
12174 io.Copy(&snapshot, ringBuffer)
12175 return &smithy.DeserializationError{
12176 Err: fmt.Errorf("failed to decode response body, %w", err),
12177 Snapshot: snapshot.Bytes(),
12178 }
12179 }
12180
12181 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12182 t, err = decoder.GetElement("Error")
12183 if err != nil {
12184 var snapshot bytes.Buffer
12185 io.Copy(&snapshot, ringBuffer)
12186 return &smithy.DeserializationError{
12187 Err: fmt.Errorf("failed to decode response body, %w", err),
12188 Snapshot: snapshot.Bytes(),
12189 }
12190 }
12191
12192 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12193 err = awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(&output, decoder)
12194 if err != nil {
12195 var snapshot bytes.Buffer
12196 io.Copy(&snapshot, ringBuffer)
12197 return &smithy.DeserializationError{
12198 Err: fmt.Errorf("failed to decode response body, %w", err),
12199 Snapshot: snapshot.Bytes(),
12200 }
12201 }
12202
12203 return output
12204 }
12205
12206 func awsRestxml_deserializeErrorInvalidArgument(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12207 output := &types.InvalidArgument{}
12208 var buff [1024]byte
12209 ringBuffer := smithyio.NewRingBuffer(buff[:])
12210 body := io.TeeReader(errorBody, ringBuffer)
12211 rootDecoder := xml.NewDecoder(body)
12212 t, err := smithyxml.FetchRootElement(rootDecoder)
12213 if err == io.EOF {
12214 return output
12215 }
12216 if err != nil {
12217 var snapshot bytes.Buffer
12218 io.Copy(&snapshot, ringBuffer)
12219 return &smithy.DeserializationError{
12220 Err: fmt.Errorf("failed to decode response body, %w", err),
12221 Snapshot: snapshot.Bytes(),
12222 }
12223 }
12224
12225 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12226 t, err = decoder.GetElement("Error")
12227 if err != nil {
12228 var snapshot bytes.Buffer
12229 io.Copy(&snapshot, ringBuffer)
12230 return &smithy.DeserializationError{
12231 Err: fmt.Errorf("failed to decode response body, %w", err),
12232 Snapshot: snapshot.Bytes(),
12233 }
12234 }
12235
12236 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12237 err = awsRestxml_deserializeDocumentInvalidArgument(&output, decoder)
12238 if err != nil {
12239 var snapshot bytes.Buffer
12240 io.Copy(&snapshot, ringBuffer)
12241 return &smithy.DeserializationError{
12242 Err: fmt.Errorf("failed to decode response body, %w", err),
12243 Snapshot: snapshot.Bytes(),
12244 }
12245 }
12246
12247 return output
12248 }
12249
12250 func awsRestxml_deserializeErrorInvalidChangeBatch(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12251 output := &types.InvalidChangeBatch{}
12252 var buff [1024]byte
12253 ringBuffer := smithyio.NewRingBuffer(buff[:])
12254 body := io.TeeReader(errorBody, ringBuffer)
12255 rootDecoder := xml.NewDecoder(body)
12256 t, err := smithyxml.FetchRootElement(rootDecoder)
12257 if err == io.EOF {
12258 return output
12259 }
12260 if err != nil {
12261 var snapshot bytes.Buffer
12262 io.Copy(&snapshot, ringBuffer)
12263 return &smithy.DeserializationError{
12264 Err: fmt.Errorf("failed to decode response body, %w", err),
12265 Snapshot: snapshot.Bytes(),
12266 }
12267 }
12268
12269 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12270 t, err = decoder.GetElement("Error")
12271 if err != nil {
12272 var snapshot bytes.Buffer
12273 io.Copy(&snapshot, ringBuffer)
12274 return &smithy.DeserializationError{
12275 Err: fmt.Errorf("failed to decode response body, %w", err),
12276 Snapshot: snapshot.Bytes(),
12277 }
12278 }
12279
12280 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12281 err = awsRestxml_deserializeDocumentInvalidChangeBatch(&output, decoder)
12282 if err != nil {
12283 var snapshot bytes.Buffer
12284 io.Copy(&snapshot, ringBuffer)
12285 return &smithy.DeserializationError{
12286 Err: fmt.Errorf("failed to decode response body, %w", err),
12287 Snapshot: snapshot.Bytes(),
12288 }
12289 }
12290
12291 return output
12292 }
12293
12294 func awsRestxml_deserializeErrorInvalidDomainName(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12295 output := &types.InvalidDomainName{}
12296 var buff [1024]byte
12297 ringBuffer := smithyio.NewRingBuffer(buff[:])
12298 body := io.TeeReader(errorBody, ringBuffer)
12299 rootDecoder := xml.NewDecoder(body)
12300 t, err := smithyxml.FetchRootElement(rootDecoder)
12301 if err == io.EOF {
12302 return output
12303 }
12304 if err != nil {
12305 var snapshot bytes.Buffer
12306 io.Copy(&snapshot, ringBuffer)
12307 return &smithy.DeserializationError{
12308 Err: fmt.Errorf("failed to decode response body, %w", err),
12309 Snapshot: snapshot.Bytes(),
12310 }
12311 }
12312
12313 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12314 t, err = decoder.GetElement("Error")
12315 if err != nil {
12316 var snapshot bytes.Buffer
12317 io.Copy(&snapshot, ringBuffer)
12318 return &smithy.DeserializationError{
12319 Err: fmt.Errorf("failed to decode response body, %w", err),
12320 Snapshot: snapshot.Bytes(),
12321 }
12322 }
12323
12324 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12325 err = awsRestxml_deserializeDocumentInvalidDomainName(&output, decoder)
12326 if err != nil {
12327 var snapshot bytes.Buffer
12328 io.Copy(&snapshot, ringBuffer)
12329 return &smithy.DeserializationError{
12330 Err: fmt.Errorf("failed to decode response body, %w", err),
12331 Snapshot: snapshot.Bytes(),
12332 }
12333 }
12334
12335 return output
12336 }
12337
12338 func awsRestxml_deserializeErrorInvalidInput(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12339 output := &types.InvalidInput{}
12340 var buff [1024]byte
12341 ringBuffer := smithyio.NewRingBuffer(buff[:])
12342 body := io.TeeReader(errorBody, ringBuffer)
12343 rootDecoder := xml.NewDecoder(body)
12344 t, err := smithyxml.FetchRootElement(rootDecoder)
12345 if err == io.EOF {
12346 return output
12347 }
12348 if err != nil {
12349 var snapshot bytes.Buffer
12350 io.Copy(&snapshot, ringBuffer)
12351 return &smithy.DeserializationError{
12352 Err: fmt.Errorf("failed to decode response body, %w", err),
12353 Snapshot: snapshot.Bytes(),
12354 }
12355 }
12356
12357 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12358 t, err = decoder.GetElement("Error")
12359 if err != nil {
12360 var snapshot bytes.Buffer
12361 io.Copy(&snapshot, ringBuffer)
12362 return &smithy.DeserializationError{
12363 Err: fmt.Errorf("failed to decode response body, %w", err),
12364 Snapshot: snapshot.Bytes(),
12365 }
12366 }
12367
12368 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12369 err = awsRestxml_deserializeDocumentInvalidInput(&output, decoder)
12370 if err != nil {
12371 var snapshot bytes.Buffer
12372 io.Copy(&snapshot, ringBuffer)
12373 return &smithy.DeserializationError{
12374 Err: fmt.Errorf("failed to decode response body, %w", err),
12375 Snapshot: snapshot.Bytes(),
12376 }
12377 }
12378
12379 return output
12380 }
12381
12382 func awsRestxml_deserializeErrorInvalidKeySigningKeyName(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12383 output := &types.InvalidKeySigningKeyName{}
12384 var buff [1024]byte
12385 ringBuffer := smithyio.NewRingBuffer(buff[:])
12386 body := io.TeeReader(errorBody, ringBuffer)
12387 rootDecoder := xml.NewDecoder(body)
12388 t, err := smithyxml.FetchRootElement(rootDecoder)
12389 if err == io.EOF {
12390 return output
12391 }
12392 if err != nil {
12393 var snapshot bytes.Buffer
12394 io.Copy(&snapshot, ringBuffer)
12395 return &smithy.DeserializationError{
12396 Err: fmt.Errorf("failed to decode response body, %w", err),
12397 Snapshot: snapshot.Bytes(),
12398 }
12399 }
12400
12401 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12402 t, err = decoder.GetElement("Error")
12403 if err != nil {
12404 var snapshot bytes.Buffer
12405 io.Copy(&snapshot, ringBuffer)
12406 return &smithy.DeserializationError{
12407 Err: fmt.Errorf("failed to decode response body, %w", err),
12408 Snapshot: snapshot.Bytes(),
12409 }
12410 }
12411
12412 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12413 err = awsRestxml_deserializeDocumentInvalidKeySigningKeyName(&output, decoder)
12414 if err != nil {
12415 var snapshot bytes.Buffer
12416 io.Copy(&snapshot, ringBuffer)
12417 return &smithy.DeserializationError{
12418 Err: fmt.Errorf("failed to decode response body, %w", err),
12419 Snapshot: snapshot.Bytes(),
12420 }
12421 }
12422
12423 return output
12424 }
12425
12426 func awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12427 output := &types.InvalidKeySigningKeyStatus{}
12428 var buff [1024]byte
12429 ringBuffer := smithyio.NewRingBuffer(buff[:])
12430 body := io.TeeReader(errorBody, ringBuffer)
12431 rootDecoder := xml.NewDecoder(body)
12432 t, err := smithyxml.FetchRootElement(rootDecoder)
12433 if err == io.EOF {
12434 return output
12435 }
12436 if err != nil {
12437 var snapshot bytes.Buffer
12438 io.Copy(&snapshot, ringBuffer)
12439 return &smithy.DeserializationError{
12440 Err: fmt.Errorf("failed to decode response body, %w", err),
12441 Snapshot: snapshot.Bytes(),
12442 }
12443 }
12444
12445 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12446 t, err = decoder.GetElement("Error")
12447 if err != nil {
12448 var snapshot bytes.Buffer
12449 io.Copy(&snapshot, ringBuffer)
12450 return &smithy.DeserializationError{
12451 Err: fmt.Errorf("failed to decode response body, %w", err),
12452 Snapshot: snapshot.Bytes(),
12453 }
12454 }
12455
12456 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12457 err = awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(&output, decoder)
12458 if err != nil {
12459 var snapshot bytes.Buffer
12460 io.Copy(&snapshot, ringBuffer)
12461 return &smithy.DeserializationError{
12462 Err: fmt.Errorf("failed to decode response body, %w", err),
12463 Snapshot: snapshot.Bytes(),
12464 }
12465 }
12466
12467 return output
12468 }
12469
12470 func awsRestxml_deserializeErrorInvalidKMSArn(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12471 output := &types.InvalidKMSArn{}
12472 var buff [1024]byte
12473 ringBuffer := smithyio.NewRingBuffer(buff[:])
12474 body := io.TeeReader(errorBody, ringBuffer)
12475 rootDecoder := xml.NewDecoder(body)
12476 t, err := smithyxml.FetchRootElement(rootDecoder)
12477 if err == io.EOF {
12478 return output
12479 }
12480 if err != nil {
12481 var snapshot bytes.Buffer
12482 io.Copy(&snapshot, ringBuffer)
12483 return &smithy.DeserializationError{
12484 Err: fmt.Errorf("failed to decode response body, %w", err),
12485 Snapshot: snapshot.Bytes(),
12486 }
12487 }
12488
12489 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12490 t, err = decoder.GetElement("Error")
12491 if err != nil {
12492 var snapshot bytes.Buffer
12493 io.Copy(&snapshot, ringBuffer)
12494 return &smithy.DeserializationError{
12495 Err: fmt.Errorf("failed to decode response body, %w", err),
12496 Snapshot: snapshot.Bytes(),
12497 }
12498 }
12499
12500 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12501 err = awsRestxml_deserializeDocumentInvalidKMSArn(&output, decoder)
12502 if err != nil {
12503 var snapshot bytes.Buffer
12504 io.Copy(&snapshot, ringBuffer)
12505 return &smithy.DeserializationError{
12506 Err: fmt.Errorf("failed to decode response body, %w", err),
12507 Snapshot: snapshot.Bytes(),
12508 }
12509 }
12510
12511 return output
12512 }
12513
12514 func awsRestxml_deserializeErrorInvalidPaginationToken(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12515 output := &types.InvalidPaginationToken{}
12516 var buff [1024]byte
12517 ringBuffer := smithyio.NewRingBuffer(buff[:])
12518 body := io.TeeReader(errorBody, ringBuffer)
12519 rootDecoder := xml.NewDecoder(body)
12520 t, err := smithyxml.FetchRootElement(rootDecoder)
12521 if err == io.EOF {
12522 return output
12523 }
12524 if err != nil {
12525 var snapshot bytes.Buffer
12526 io.Copy(&snapshot, ringBuffer)
12527 return &smithy.DeserializationError{
12528 Err: fmt.Errorf("failed to decode response body, %w", err),
12529 Snapshot: snapshot.Bytes(),
12530 }
12531 }
12532
12533 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12534 t, err = decoder.GetElement("Error")
12535 if err != nil {
12536 var snapshot bytes.Buffer
12537 io.Copy(&snapshot, ringBuffer)
12538 return &smithy.DeserializationError{
12539 Err: fmt.Errorf("failed to decode response body, %w", err),
12540 Snapshot: snapshot.Bytes(),
12541 }
12542 }
12543
12544 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12545 err = awsRestxml_deserializeDocumentInvalidPaginationToken(&output, decoder)
12546 if err != nil {
12547 var snapshot bytes.Buffer
12548 io.Copy(&snapshot, ringBuffer)
12549 return &smithy.DeserializationError{
12550 Err: fmt.Errorf("failed to decode response body, %w", err),
12551 Snapshot: snapshot.Bytes(),
12552 }
12553 }
12554
12555 return output
12556 }
12557
12558 func awsRestxml_deserializeErrorInvalidSigningStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12559 output := &types.InvalidSigningStatus{}
12560 var buff [1024]byte
12561 ringBuffer := smithyio.NewRingBuffer(buff[:])
12562 body := io.TeeReader(errorBody, ringBuffer)
12563 rootDecoder := xml.NewDecoder(body)
12564 t, err := smithyxml.FetchRootElement(rootDecoder)
12565 if err == io.EOF {
12566 return output
12567 }
12568 if err != nil {
12569 var snapshot bytes.Buffer
12570 io.Copy(&snapshot, ringBuffer)
12571 return &smithy.DeserializationError{
12572 Err: fmt.Errorf("failed to decode response body, %w", err),
12573 Snapshot: snapshot.Bytes(),
12574 }
12575 }
12576
12577 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12578 t, err = decoder.GetElement("Error")
12579 if err != nil {
12580 var snapshot bytes.Buffer
12581 io.Copy(&snapshot, ringBuffer)
12582 return &smithy.DeserializationError{
12583 Err: fmt.Errorf("failed to decode response body, %w", err),
12584 Snapshot: snapshot.Bytes(),
12585 }
12586 }
12587
12588 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12589 err = awsRestxml_deserializeDocumentInvalidSigningStatus(&output, decoder)
12590 if err != nil {
12591 var snapshot bytes.Buffer
12592 io.Copy(&snapshot, ringBuffer)
12593 return &smithy.DeserializationError{
12594 Err: fmt.Errorf("failed to decode response body, %w", err),
12595 Snapshot: snapshot.Bytes(),
12596 }
12597 }
12598
12599 return output
12600 }
12601
12602 func awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12603 output := &types.InvalidTrafficPolicyDocument{}
12604 var buff [1024]byte
12605 ringBuffer := smithyio.NewRingBuffer(buff[:])
12606 body := io.TeeReader(errorBody, ringBuffer)
12607 rootDecoder := xml.NewDecoder(body)
12608 t, err := smithyxml.FetchRootElement(rootDecoder)
12609 if err == io.EOF {
12610 return output
12611 }
12612 if err != nil {
12613 var snapshot bytes.Buffer
12614 io.Copy(&snapshot, ringBuffer)
12615 return &smithy.DeserializationError{
12616 Err: fmt.Errorf("failed to decode response body, %w", err),
12617 Snapshot: snapshot.Bytes(),
12618 }
12619 }
12620
12621 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12622 t, err = decoder.GetElement("Error")
12623 if err != nil {
12624 var snapshot bytes.Buffer
12625 io.Copy(&snapshot, ringBuffer)
12626 return &smithy.DeserializationError{
12627 Err: fmt.Errorf("failed to decode response body, %w", err),
12628 Snapshot: snapshot.Bytes(),
12629 }
12630 }
12631
12632 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12633 err = awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(&output, decoder)
12634 if err != nil {
12635 var snapshot bytes.Buffer
12636 io.Copy(&snapshot, ringBuffer)
12637 return &smithy.DeserializationError{
12638 Err: fmt.Errorf("failed to decode response body, %w", err),
12639 Snapshot: snapshot.Bytes(),
12640 }
12641 }
12642
12643 return output
12644 }
12645
12646 func awsRestxml_deserializeErrorInvalidVPCId(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12647 output := &types.InvalidVPCId{}
12648 var buff [1024]byte
12649 ringBuffer := smithyio.NewRingBuffer(buff[:])
12650 body := io.TeeReader(errorBody, ringBuffer)
12651 rootDecoder := xml.NewDecoder(body)
12652 t, err := smithyxml.FetchRootElement(rootDecoder)
12653 if err == io.EOF {
12654 return output
12655 }
12656 if err != nil {
12657 var snapshot bytes.Buffer
12658 io.Copy(&snapshot, ringBuffer)
12659 return &smithy.DeserializationError{
12660 Err: fmt.Errorf("failed to decode response body, %w", err),
12661 Snapshot: snapshot.Bytes(),
12662 }
12663 }
12664
12665 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12666 t, err = decoder.GetElement("Error")
12667 if err != nil {
12668 var snapshot bytes.Buffer
12669 io.Copy(&snapshot, ringBuffer)
12670 return &smithy.DeserializationError{
12671 Err: fmt.Errorf("failed to decode response body, %w", err),
12672 Snapshot: snapshot.Bytes(),
12673 }
12674 }
12675
12676 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12677 err = awsRestxml_deserializeDocumentInvalidVPCId(&output, decoder)
12678 if err != nil {
12679 var snapshot bytes.Buffer
12680 io.Copy(&snapshot, ringBuffer)
12681 return &smithy.DeserializationError{
12682 Err: fmt.Errorf("failed to decode response body, %w", err),
12683 Snapshot: snapshot.Bytes(),
12684 }
12685 }
12686
12687 return output
12688 }
12689
12690 func awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12691 output := &types.KeySigningKeyAlreadyExists{}
12692 var buff [1024]byte
12693 ringBuffer := smithyio.NewRingBuffer(buff[:])
12694 body := io.TeeReader(errorBody, ringBuffer)
12695 rootDecoder := xml.NewDecoder(body)
12696 t, err := smithyxml.FetchRootElement(rootDecoder)
12697 if err == io.EOF {
12698 return output
12699 }
12700 if err != nil {
12701 var snapshot bytes.Buffer
12702 io.Copy(&snapshot, ringBuffer)
12703 return &smithy.DeserializationError{
12704 Err: fmt.Errorf("failed to decode response body, %w", err),
12705 Snapshot: snapshot.Bytes(),
12706 }
12707 }
12708
12709 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12710 t, err = decoder.GetElement("Error")
12711 if err != nil {
12712 var snapshot bytes.Buffer
12713 io.Copy(&snapshot, ringBuffer)
12714 return &smithy.DeserializationError{
12715 Err: fmt.Errorf("failed to decode response body, %w", err),
12716 Snapshot: snapshot.Bytes(),
12717 }
12718 }
12719
12720 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12721 err = awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(&output, decoder)
12722 if err != nil {
12723 var snapshot bytes.Buffer
12724 io.Copy(&snapshot, ringBuffer)
12725 return &smithy.DeserializationError{
12726 Err: fmt.Errorf("failed to decode response body, %w", err),
12727 Snapshot: snapshot.Bytes(),
12728 }
12729 }
12730
12731 return output
12732 }
12733
12734 func awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12735 output := &types.KeySigningKeyInParentDSRecord{}
12736 var buff [1024]byte
12737 ringBuffer := smithyio.NewRingBuffer(buff[:])
12738 body := io.TeeReader(errorBody, ringBuffer)
12739 rootDecoder := xml.NewDecoder(body)
12740 t, err := smithyxml.FetchRootElement(rootDecoder)
12741 if err == io.EOF {
12742 return output
12743 }
12744 if err != nil {
12745 var snapshot bytes.Buffer
12746 io.Copy(&snapshot, ringBuffer)
12747 return &smithy.DeserializationError{
12748 Err: fmt.Errorf("failed to decode response body, %w", err),
12749 Snapshot: snapshot.Bytes(),
12750 }
12751 }
12752
12753 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12754 t, err = decoder.GetElement("Error")
12755 if err != nil {
12756 var snapshot bytes.Buffer
12757 io.Copy(&snapshot, ringBuffer)
12758 return &smithy.DeserializationError{
12759 Err: fmt.Errorf("failed to decode response body, %w", err),
12760 Snapshot: snapshot.Bytes(),
12761 }
12762 }
12763
12764 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12765 err = awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(&output, decoder)
12766 if err != nil {
12767 var snapshot bytes.Buffer
12768 io.Copy(&snapshot, ringBuffer)
12769 return &smithy.DeserializationError{
12770 Err: fmt.Errorf("failed to decode response body, %w", err),
12771 Snapshot: snapshot.Bytes(),
12772 }
12773 }
12774
12775 return output
12776 }
12777
12778 func awsRestxml_deserializeErrorKeySigningKeyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12779 output := &types.KeySigningKeyInUse{}
12780 var buff [1024]byte
12781 ringBuffer := smithyio.NewRingBuffer(buff[:])
12782 body := io.TeeReader(errorBody, ringBuffer)
12783 rootDecoder := xml.NewDecoder(body)
12784 t, err := smithyxml.FetchRootElement(rootDecoder)
12785 if err == io.EOF {
12786 return output
12787 }
12788 if err != nil {
12789 var snapshot bytes.Buffer
12790 io.Copy(&snapshot, ringBuffer)
12791 return &smithy.DeserializationError{
12792 Err: fmt.Errorf("failed to decode response body, %w", err),
12793 Snapshot: snapshot.Bytes(),
12794 }
12795 }
12796
12797 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12798 t, err = decoder.GetElement("Error")
12799 if err != nil {
12800 var snapshot bytes.Buffer
12801 io.Copy(&snapshot, ringBuffer)
12802 return &smithy.DeserializationError{
12803 Err: fmt.Errorf("failed to decode response body, %w", err),
12804 Snapshot: snapshot.Bytes(),
12805 }
12806 }
12807
12808 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12809 err = awsRestxml_deserializeDocumentKeySigningKeyInUse(&output, decoder)
12810 if err != nil {
12811 var snapshot bytes.Buffer
12812 io.Copy(&snapshot, ringBuffer)
12813 return &smithy.DeserializationError{
12814 Err: fmt.Errorf("failed to decode response body, %w", err),
12815 Snapshot: snapshot.Bytes(),
12816 }
12817 }
12818
12819 return output
12820 }
12821
12822 func awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12823 output := &types.KeySigningKeyWithActiveStatusNotFound{}
12824 var buff [1024]byte
12825 ringBuffer := smithyio.NewRingBuffer(buff[:])
12826 body := io.TeeReader(errorBody, ringBuffer)
12827 rootDecoder := xml.NewDecoder(body)
12828 t, err := smithyxml.FetchRootElement(rootDecoder)
12829 if err == io.EOF {
12830 return output
12831 }
12832 if err != nil {
12833 var snapshot bytes.Buffer
12834 io.Copy(&snapshot, ringBuffer)
12835 return &smithy.DeserializationError{
12836 Err: fmt.Errorf("failed to decode response body, %w", err),
12837 Snapshot: snapshot.Bytes(),
12838 }
12839 }
12840
12841 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12842 t, err = decoder.GetElement("Error")
12843 if err != nil {
12844 var snapshot bytes.Buffer
12845 io.Copy(&snapshot, ringBuffer)
12846 return &smithy.DeserializationError{
12847 Err: fmt.Errorf("failed to decode response body, %w", err),
12848 Snapshot: snapshot.Bytes(),
12849 }
12850 }
12851
12852 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12853 err = awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(&output, decoder)
12854 if err != nil {
12855 var snapshot bytes.Buffer
12856 io.Copy(&snapshot, ringBuffer)
12857 return &smithy.DeserializationError{
12858 Err: fmt.Errorf("failed to decode response body, %w", err),
12859 Snapshot: snapshot.Bytes(),
12860 }
12861 }
12862
12863 return output
12864 }
12865
12866 func awsRestxml_deserializeErrorLastVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12867 output := &types.LastVPCAssociation{}
12868 var buff [1024]byte
12869 ringBuffer := smithyio.NewRingBuffer(buff[:])
12870 body := io.TeeReader(errorBody, ringBuffer)
12871 rootDecoder := xml.NewDecoder(body)
12872 t, err := smithyxml.FetchRootElement(rootDecoder)
12873 if err == io.EOF {
12874 return output
12875 }
12876 if err != nil {
12877 var snapshot bytes.Buffer
12878 io.Copy(&snapshot, ringBuffer)
12879 return &smithy.DeserializationError{
12880 Err: fmt.Errorf("failed to decode response body, %w", err),
12881 Snapshot: snapshot.Bytes(),
12882 }
12883 }
12884
12885 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12886 t, err = decoder.GetElement("Error")
12887 if err != nil {
12888 var snapshot bytes.Buffer
12889 io.Copy(&snapshot, ringBuffer)
12890 return &smithy.DeserializationError{
12891 Err: fmt.Errorf("failed to decode response body, %w", err),
12892 Snapshot: snapshot.Bytes(),
12893 }
12894 }
12895
12896 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12897 err = awsRestxml_deserializeDocumentLastVPCAssociation(&output, decoder)
12898 if err != nil {
12899 var snapshot bytes.Buffer
12900 io.Copy(&snapshot, ringBuffer)
12901 return &smithy.DeserializationError{
12902 Err: fmt.Errorf("failed to decode response body, %w", err),
12903 Snapshot: snapshot.Bytes(),
12904 }
12905 }
12906
12907 return output
12908 }
12909
12910 func awsRestxml_deserializeErrorLimitsExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12911 output := &types.LimitsExceeded{}
12912 var buff [1024]byte
12913 ringBuffer := smithyio.NewRingBuffer(buff[:])
12914 body := io.TeeReader(errorBody, ringBuffer)
12915 rootDecoder := xml.NewDecoder(body)
12916 t, err := smithyxml.FetchRootElement(rootDecoder)
12917 if err == io.EOF {
12918 return output
12919 }
12920 if err != nil {
12921 var snapshot bytes.Buffer
12922 io.Copy(&snapshot, ringBuffer)
12923 return &smithy.DeserializationError{
12924 Err: fmt.Errorf("failed to decode response body, %w", err),
12925 Snapshot: snapshot.Bytes(),
12926 }
12927 }
12928
12929 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12930 t, err = decoder.GetElement("Error")
12931 if err != nil {
12932 var snapshot bytes.Buffer
12933 io.Copy(&snapshot, ringBuffer)
12934 return &smithy.DeserializationError{
12935 Err: fmt.Errorf("failed to decode response body, %w", err),
12936 Snapshot: snapshot.Bytes(),
12937 }
12938 }
12939
12940 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12941 err = awsRestxml_deserializeDocumentLimitsExceeded(&output, decoder)
12942 if err != nil {
12943 var snapshot bytes.Buffer
12944 io.Copy(&snapshot, ringBuffer)
12945 return &smithy.DeserializationError{
12946 Err: fmt.Errorf("failed to decode response body, %w", err),
12947 Snapshot: snapshot.Bytes(),
12948 }
12949 }
12950
12951 return output
12952 }
12953
12954 func awsRestxml_deserializeErrorNoSuchChange(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12955 output := &types.NoSuchChange{}
12956 var buff [1024]byte
12957 ringBuffer := smithyio.NewRingBuffer(buff[:])
12958 body := io.TeeReader(errorBody, ringBuffer)
12959 rootDecoder := xml.NewDecoder(body)
12960 t, err := smithyxml.FetchRootElement(rootDecoder)
12961 if err == io.EOF {
12962 return output
12963 }
12964 if err != nil {
12965 var snapshot bytes.Buffer
12966 io.Copy(&snapshot, ringBuffer)
12967 return &smithy.DeserializationError{
12968 Err: fmt.Errorf("failed to decode response body, %w", err),
12969 Snapshot: snapshot.Bytes(),
12970 }
12971 }
12972
12973 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
12974 t, err = decoder.GetElement("Error")
12975 if err != nil {
12976 var snapshot bytes.Buffer
12977 io.Copy(&snapshot, ringBuffer)
12978 return &smithy.DeserializationError{
12979 Err: fmt.Errorf("failed to decode response body, %w", err),
12980 Snapshot: snapshot.Bytes(),
12981 }
12982 }
12983
12984 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12985 err = awsRestxml_deserializeDocumentNoSuchChange(&output, decoder)
12986 if err != nil {
12987 var snapshot bytes.Buffer
12988 io.Copy(&snapshot, ringBuffer)
12989 return &smithy.DeserializationError{
12990 Err: fmt.Errorf("failed to decode response body, %w", err),
12991 Snapshot: snapshot.Bytes(),
12992 }
12993 }
12994
12995 return output
12996 }
12997
12998 func awsRestxml_deserializeErrorNoSuchCidrCollectionException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
12999 output := &types.NoSuchCidrCollectionException{}
13000 var buff [1024]byte
13001 ringBuffer := smithyio.NewRingBuffer(buff[:])
13002 body := io.TeeReader(errorBody, ringBuffer)
13003 rootDecoder := xml.NewDecoder(body)
13004 t, err := smithyxml.FetchRootElement(rootDecoder)
13005 if err == io.EOF {
13006 return output
13007 }
13008 if err != nil {
13009 var snapshot bytes.Buffer
13010 io.Copy(&snapshot, ringBuffer)
13011 return &smithy.DeserializationError{
13012 Err: fmt.Errorf("failed to decode response body, %w", err),
13013 Snapshot: snapshot.Bytes(),
13014 }
13015 }
13016
13017 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13018 t, err = decoder.GetElement("Error")
13019 if err != nil {
13020 var snapshot bytes.Buffer
13021 io.Copy(&snapshot, ringBuffer)
13022 return &smithy.DeserializationError{
13023 Err: fmt.Errorf("failed to decode response body, %w", err),
13024 Snapshot: snapshot.Bytes(),
13025 }
13026 }
13027
13028 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13029 err = awsRestxml_deserializeDocumentNoSuchCidrCollectionException(&output, decoder)
13030 if err != nil {
13031 var snapshot bytes.Buffer
13032 io.Copy(&snapshot, ringBuffer)
13033 return &smithy.DeserializationError{
13034 Err: fmt.Errorf("failed to decode response body, %w", err),
13035 Snapshot: snapshot.Bytes(),
13036 }
13037 }
13038
13039 return output
13040 }
13041
13042 func awsRestxml_deserializeErrorNoSuchCidrLocationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13043 output := &types.NoSuchCidrLocationException{}
13044 var buff [1024]byte
13045 ringBuffer := smithyio.NewRingBuffer(buff[:])
13046 body := io.TeeReader(errorBody, ringBuffer)
13047 rootDecoder := xml.NewDecoder(body)
13048 t, err := smithyxml.FetchRootElement(rootDecoder)
13049 if err == io.EOF {
13050 return output
13051 }
13052 if err != nil {
13053 var snapshot bytes.Buffer
13054 io.Copy(&snapshot, ringBuffer)
13055 return &smithy.DeserializationError{
13056 Err: fmt.Errorf("failed to decode response body, %w", err),
13057 Snapshot: snapshot.Bytes(),
13058 }
13059 }
13060
13061 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13062 t, err = decoder.GetElement("Error")
13063 if err != nil {
13064 var snapshot bytes.Buffer
13065 io.Copy(&snapshot, ringBuffer)
13066 return &smithy.DeserializationError{
13067 Err: fmt.Errorf("failed to decode response body, %w", err),
13068 Snapshot: snapshot.Bytes(),
13069 }
13070 }
13071
13072 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13073 err = awsRestxml_deserializeDocumentNoSuchCidrLocationException(&output, decoder)
13074 if err != nil {
13075 var snapshot bytes.Buffer
13076 io.Copy(&snapshot, ringBuffer)
13077 return &smithy.DeserializationError{
13078 Err: fmt.Errorf("failed to decode response body, %w", err),
13079 Snapshot: snapshot.Bytes(),
13080 }
13081 }
13082
13083 return output
13084 }
13085
13086 func awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13087 output := &types.NoSuchCloudWatchLogsLogGroup{}
13088 var buff [1024]byte
13089 ringBuffer := smithyio.NewRingBuffer(buff[:])
13090 body := io.TeeReader(errorBody, ringBuffer)
13091 rootDecoder := xml.NewDecoder(body)
13092 t, err := smithyxml.FetchRootElement(rootDecoder)
13093 if err == io.EOF {
13094 return output
13095 }
13096 if err != nil {
13097 var snapshot bytes.Buffer
13098 io.Copy(&snapshot, ringBuffer)
13099 return &smithy.DeserializationError{
13100 Err: fmt.Errorf("failed to decode response body, %w", err),
13101 Snapshot: snapshot.Bytes(),
13102 }
13103 }
13104
13105 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13106 t, err = decoder.GetElement("Error")
13107 if err != nil {
13108 var snapshot bytes.Buffer
13109 io.Copy(&snapshot, ringBuffer)
13110 return &smithy.DeserializationError{
13111 Err: fmt.Errorf("failed to decode response body, %w", err),
13112 Snapshot: snapshot.Bytes(),
13113 }
13114 }
13115
13116 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13117 err = awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(&output, decoder)
13118 if err != nil {
13119 var snapshot bytes.Buffer
13120 io.Copy(&snapshot, ringBuffer)
13121 return &smithy.DeserializationError{
13122 Err: fmt.Errorf("failed to decode response body, %w", err),
13123 Snapshot: snapshot.Bytes(),
13124 }
13125 }
13126
13127 return output
13128 }
13129
13130 func awsRestxml_deserializeErrorNoSuchDelegationSet(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13131 output := &types.NoSuchDelegationSet{}
13132 var buff [1024]byte
13133 ringBuffer := smithyio.NewRingBuffer(buff[:])
13134 body := io.TeeReader(errorBody, ringBuffer)
13135 rootDecoder := xml.NewDecoder(body)
13136 t, err := smithyxml.FetchRootElement(rootDecoder)
13137 if err == io.EOF {
13138 return output
13139 }
13140 if err != nil {
13141 var snapshot bytes.Buffer
13142 io.Copy(&snapshot, ringBuffer)
13143 return &smithy.DeserializationError{
13144 Err: fmt.Errorf("failed to decode response body, %w", err),
13145 Snapshot: snapshot.Bytes(),
13146 }
13147 }
13148
13149 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13150 t, err = decoder.GetElement("Error")
13151 if err != nil {
13152 var snapshot bytes.Buffer
13153 io.Copy(&snapshot, ringBuffer)
13154 return &smithy.DeserializationError{
13155 Err: fmt.Errorf("failed to decode response body, %w", err),
13156 Snapshot: snapshot.Bytes(),
13157 }
13158 }
13159
13160 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13161 err = awsRestxml_deserializeDocumentNoSuchDelegationSet(&output, decoder)
13162 if err != nil {
13163 var snapshot bytes.Buffer
13164 io.Copy(&snapshot, ringBuffer)
13165 return &smithy.DeserializationError{
13166 Err: fmt.Errorf("failed to decode response body, %w", err),
13167 Snapshot: snapshot.Bytes(),
13168 }
13169 }
13170
13171 return output
13172 }
13173
13174 func awsRestxml_deserializeErrorNoSuchGeoLocation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13175 output := &types.NoSuchGeoLocation{}
13176 var buff [1024]byte
13177 ringBuffer := smithyio.NewRingBuffer(buff[:])
13178 body := io.TeeReader(errorBody, ringBuffer)
13179 rootDecoder := xml.NewDecoder(body)
13180 t, err := smithyxml.FetchRootElement(rootDecoder)
13181 if err == io.EOF {
13182 return output
13183 }
13184 if err != nil {
13185 var snapshot bytes.Buffer
13186 io.Copy(&snapshot, ringBuffer)
13187 return &smithy.DeserializationError{
13188 Err: fmt.Errorf("failed to decode response body, %w", err),
13189 Snapshot: snapshot.Bytes(),
13190 }
13191 }
13192
13193 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13194 t, err = decoder.GetElement("Error")
13195 if err != nil {
13196 var snapshot bytes.Buffer
13197 io.Copy(&snapshot, ringBuffer)
13198 return &smithy.DeserializationError{
13199 Err: fmt.Errorf("failed to decode response body, %w", err),
13200 Snapshot: snapshot.Bytes(),
13201 }
13202 }
13203
13204 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13205 err = awsRestxml_deserializeDocumentNoSuchGeoLocation(&output, decoder)
13206 if err != nil {
13207 var snapshot bytes.Buffer
13208 io.Copy(&snapshot, ringBuffer)
13209 return &smithy.DeserializationError{
13210 Err: fmt.Errorf("failed to decode response body, %w", err),
13211 Snapshot: snapshot.Bytes(),
13212 }
13213 }
13214
13215 return output
13216 }
13217
13218 func awsRestxml_deserializeErrorNoSuchHealthCheck(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13219 output := &types.NoSuchHealthCheck{}
13220 var buff [1024]byte
13221 ringBuffer := smithyio.NewRingBuffer(buff[:])
13222 body := io.TeeReader(errorBody, ringBuffer)
13223 rootDecoder := xml.NewDecoder(body)
13224 t, err := smithyxml.FetchRootElement(rootDecoder)
13225 if err == io.EOF {
13226 return output
13227 }
13228 if err != nil {
13229 var snapshot bytes.Buffer
13230 io.Copy(&snapshot, ringBuffer)
13231 return &smithy.DeserializationError{
13232 Err: fmt.Errorf("failed to decode response body, %w", err),
13233 Snapshot: snapshot.Bytes(),
13234 }
13235 }
13236
13237 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13238 t, err = decoder.GetElement("Error")
13239 if err != nil {
13240 var snapshot bytes.Buffer
13241 io.Copy(&snapshot, ringBuffer)
13242 return &smithy.DeserializationError{
13243 Err: fmt.Errorf("failed to decode response body, %w", err),
13244 Snapshot: snapshot.Bytes(),
13245 }
13246 }
13247
13248 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13249 err = awsRestxml_deserializeDocumentNoSuchHealthCheck(&output, decoder)
13250 if err != nil {
13251 var snapshot bytes.Buffer
13252 io.Copy(&snapshot, ringBuffer)
13253 return &smithy.DeserializationError{
13254 Err: fmt.Errorf("failed to decode response body, %w", err),
13255 Snapshot: snapshot.Bytes(),
13256 }
13257 }
13258
13259 return output
13260 }
13261
13262 func awsRestxml_deserializeErrorNoSuchHostedZone(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13263 output := &types.NoSuchHostedZone{}
13264 var buff [1024]byte
13265 ringBuffer := smithyio.NewRingBuffer(buff[:])
13266 body := io.TeeReader(errorBody, ringBuffer)
13267 rootDecoder := xml.NewDecoder(body)
13268 t, err := smithyxml.FetchRootElement(rootDecoder)
13269 if err == io.EOF {
13270 return output
13271 }
13272 if err != nil {
13273 var snapshot bytes.Buffer
13274 io.Copy(&snapshot, ringBuffer)
13275 return &smithy.DeserializationError{
13276 Err: fmt.Errorf("failed to decode response body, %w", err),
13277 Snapshot: snapshot.Bytes(),
13278 }
13279 }
13280
13281 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13282 t, err = decoder.GetElement("Error")
13283 if err != nil {
13284 var snapshot bytes.Buffer
13285 io.Copy(&snapshot, ringBuffer)
13286 return &smithy.DeserializationError{
13287 Err: fmt.Errorf("failed to decode response body, %w", err),
13288 Snapshot: snapshot.Bytes(),
13289 }
13290 }
13291
13292 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13293 err = awsRestxml_deserializeDocumentNoSuchHostedZone(&output, decoder)
13294 if err != nil {
13295 var snapshot bytes.Buffer
13296 io.Copy(&snapshot, ringBuffer)
13297 return &smithy.DeserializationError{
13298 Err: fmt.Errorf("failed to decode response body, %w", err),
13299 Snapshot: snapshot.Bytes(),
13300 }
13301 }
13302
13303 return output
13304 }
13305
13306 func awsRestxml_deserializeErrorNoSuchKeySigningKey(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13307 output := &types.NoSuchKeySigningKey{}
13308 var buff [1024]byte
13309 ringBuffer := smithyio.NewRingBuffer(buff[:])
13310 body := io.TeeReader(errorBody, ringBuffer)
13311 rootDecoder := xml.NewDecoder(body)
13312 t, err := smithyxml.FetchRootElement(rootDecoder)
13313 if err == io.EOF {
13314 return output
13315 }
13316 if err != nil {
13317 var snapshot bytes.Buffer
13318 io.Copy(&snapshot, ringBuffer)
13319 return &smithy.DeserializationError{
13320 Err: fmt.Errorf("failed to decode response body, %w", err),
13321 Snapshot: snapshot.Bytes(),
13322 }
13323 }
13324
13325 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13326 t, err = decoder.GetElement("Error")
13327 if err != nil {
13328 var snapshot bytes.Buffer
13329 io.Copy(&snapshot, ringBuffer)
13330 return &smithy.DeserializationError{
13331 Err: fmt.Errorf("failed to decode response body, %w", err),
13332 Snapshot: snapshot.Bytes(),
13333 }
13334 }
13335
13336 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13337 err = awsRestxml_deserializeDocumentNoSuchKeySigningKey(&output, decoder)
13338 if err != nil {
13339 var snapshot bytes.Buffer
13340 io.Copy(&snapshot, ringBuffer)
13341 return &smithy.DeserializationError{
13342 Err: fmt.Errorf("failed to decode response body, %w", err),
13343 Snapshot: snapshot.Bytes(),
13344 }
13345 }
13346
13347 return output
13348 }
13349
13350 func awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13351 output := &types.NoSuchQueryLoggingConfig{}
13352 var buff [1024]byte
13353 ringBuffer := smithyio.NewRingBuffer(buff[:])
13354 body := io.TeeReader(errorBody, ringBuffer)
13355 rootDecoder := xml.NewDecoder(body)
13356 t, err := smithyxml.FetchRootElement(rootDecoder)
13357 if err == io.EOF {
13358 return output
13359 }
13360 if err != nil {
13361 var snapshot bytes.Buffer
13362 io.Copy(&snapshot, ringBuffer)
13363 return &smithy.DeserializationError{
13364 Err: fmt.Errorf("failed to decode response body, %w", err),
13365 Snapshot: snapshot.Bytes(),
13366 }
13367 }
13368
13369 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13370 t, err = decoder.GetElement("Error")
13371 if err != nil {
13372 var snapshot bytes.Buffer
13373 io.Copy(&snapshot, ringBuffer)
13374 return &smithy.DeserializationError{
13375 Err: fmt.Errorf("failed to decode response body, %w", err),
13376 Snapshot: snapshot.Bytes(),
13377 }
13378 }
13379
13380 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13381 err = awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(&output, decoder)
13382 if err != nil {
13383 var snapshot bytes.Buffer
13384 io.Copy(&snapshot, ringBuffer)
13385 return &smithy.DeserializationError{
13386 Err: fmt.Errorf("failed to decode response body, %w", err),
13387 Snapshot: snapshot.Bytes(),
13388 }
13389 }
13390
13391 return output
13392 }
13393
13394 func awsRestxml_deserializeErrorNoSuchTrafficPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13395 output := &types.NoSuchTrafficPolicy{}
13396 var buff [1024]byte
13397 ringBuffer := smithyio.NewRingBuffer(buff[:])
13398 body := io.TeeReader(errorBody, ringBuffer)
13399 rootDecoder := xml.NewDecoder(body)
13400 t, err := smithyxml.FetchRootElement(rootDecoder)
13401 if err == io.EOF {
13402 return output
13403 }
13404 if err != nil {
13405 var snapshot bytes.Buffer
13406 io.Copy(&snapshot, ringBuffer)
13407 return &smithy.DeserializationError{
13408 Err: fmt.Errorf("failed to decode response body, %w", err),
13409 Snapshot: snapshot.Bytes(),
13410 }
13411 }
13412
13413 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13414 t, err = decoder.GetElement("Error")
13415 if err != nil {
13416 var snapshot bytes.Buffer
13417 io.Copy(&snapshot, ringBuffer)
13418 return &smithy.DeserializationError{
13419 Err: fmt.Errorf("failed to decode response body, %w", err),
13420 Snapshot: snapshot.Bytes(),
13421 }
13422 }
13423
13424 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13425 err = awsRestxml_deserializeDocumentNoSuchTrafficPolicy(&output, decoder)
13426 if err != nil {
13427 var snapshot bytes.Buffer
13428 io.Copy(&snapshot, ringBuffer)
13429 return &smithy.DeserializationError{
13430 Err: fmt.Errorf("failed to decode response body, %w", err),
13431 Snapshot: snapshot.Bytes(),
13432 }
13433 }
13434
13435 return output
13436 }
13437
13438 func awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13439 output := &types.NoSuchTrafficPolicyInstance{}
13440 var buff [1024]byte
13441 ringBuffer := smithyio.NewRingBuffer(buff[:])
13442 body := io.TeeReader(errorBody, ringBuffer)
13443 rootDecoder := xml.NewDecoder(body)
13444 t, err := smithyxml.FetchRootElement(rootDecoder)
13445 if err == io.EOF {
13446 return output
13447 }
13448 if err != nil {
13449 var snapshot bytes.Buffer
13450 io.Copy(&snapshot, ringBuffer)
13451 return &smithy.DeserializationError{
13452 Err: fmt.Errorf("failed to decode response body, %w", err),
13453 Snapshot: snapshot.Bytes(),
13454 }
13455 }
13456
13457 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13458 t, err = decoder.GetElement("Error")
13459 if err != nil {
13460 var snapshot bytes.Buffer
13461 io.Copy(&snapshot, ringBuffer)
13462 return &smithy.DeserializationError{
13463 Err: fmt.Errorf("failed to decode response body, %w", err),
13464 Snapshot: snapshot.Bytes(),
13465 }
13466 }
13467
13468 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13469 err = awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(&output, decoder)
13470 if err != nil {
13471 var snapshot bytes.Buffer
13472 io.Copy(&snapshot, ringBuffer)
13473 return &smithy.DeserializationError{
13474 Err: fmt.Errorf("failed to decode response body, %w", err),
13475 Snapshot: snapshot.Bytes(),
13476 }
13477 }
13478
13479 return output
13480 }
13481
13482 func awsRestxml_deserializeErrorNotAuthorizedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13483 output := &types.NotAuthorizedException{}
13484 var buff [1024]byte
13485 ringBuffer := smithyio.NewRingBuffer(buff[:])
13486 body := io.TeeReader(errorBody, ringBuffer)
13487 rootDecoder := xml.NewDecoder(body)
13488 t, err := smithyxml.FetchRootElement(rootDecoder)
13489 if err == io.EOF {
13490 return output
13491 }
13492 if err != nil {
13493 var snapshot bytes.Buffer
13494 io.Copy(&snapshot, ringBuffer)
13495 return &smithy.DeserializationError{
13496 Err: fmt.Errorf("failed to decode response body, %w", err),
13497 Snapshot: snapshot.Bytes(),
13498 }
13499 }
13500
13501 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13502 t, err = decoder.GetElement("Error")
13503 if err != nil {
13504 var snapshot bytes.Buffer
13505 io.Copy(&snapshot, ringBuffer)
13506 return &smithy.DeserializationError{
13507 Err: fmt.Errorf("failed to decode response body, %w", err),
13508 Snapshot: snapshot.Bytes(),
13509 }
13510 }
13511
13512 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13513 err = awsRestxml_deserializeDocumentNotAuthorizedException(&output, decoder)
13514 if err != nil {
13515 var snapshot bytes.Buffer
13516 io.Copy(&snapshot, ringBuffer)
13517 return &smithy.DeserializationError{
13518 Err: fmt.Errorf("failed to decode response body, %w", err),
13519 Snapshot: snapshot.Bytes(),
13520 }
13521 }
13522
13523 return output
13524 }
13525
13526 func awsRestxml_deserializeErrorPriorRequestNotComplete(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13527 output := &types.PriorRequestNotComplete{}
13528 var buff [1024]byte
13529 ringBuffer := smithyio.NewRingBuffer(buff[:])
13530 body := io.TeeReader(errorBody, ringBuffer)
13531 rootDecoder := xml.NewDecoder(body)
13532 t, err := smithyxml.FetchRootElement(rootDecoder)
13533 if err == io.EOF {
13534 return output
13535 }
13536 if err != nil {
13537 var snapshot bytes.Buffer
13538 io.Copy(&snapshot, ringBuffer)
13539 return &smithy.DeserializationError{
13540 Err: fmt.Errorf("failed to decode response body, %w", err),
13541 Snapshot: snapshot.Bytes(),
13542 }
13543 }
13544
13545 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13546 t, err = decoder.GetElement("Error")
13547 if err != nil {
13548 var snapshot bytes.Buffer
13549 io.Copy(&snapshot, ringBuffer)
13550 return &smithy.DeserializationError{
13551 Err: fmt.Errorf("failed to decode response body, %w", err),
13552 Snapshot: snapshot.Bytes(),
13553 }
13554 }
13555
13556 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13557 err = awsRestxml_deserializeDocumentPriorRequestNotComplete(&output, decoder)
13558 if err != nil {
13559 var snapshot bytes.Buffer
13560 io.Copy(&snapshot, ringBuffer)
13561 return &smithy.DeserializationError{
13562 Err: fmt.Errorf("failed to decode response body, %w", err),
13563 Snapshot: snapshot.Bytes(),
13564 }
13565 }
13566
13567 return output
13568 }
13569
13570 func awsRestxml_deserializeErrorPublicZoneVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13571 output := &types.PublicZoneVPCAssociation{}
13572 var buff [1024]byte
13573 ringBuffer := smithyio.NewRingBuffer(buff[:])
13574 body := io.TeeReader(errorBody, ringBuffer)
13575 rootDecoder := xml.NewDecoder(body)
13576 t, err := smithyxml.FetchRootElement(rootDecoder)
13577 if err == io.EOF {
13578 return output
13579 }
13580 if err != nil {
13581 var snapshot bytes.Buffer
13582 io.Copy(&snapshot, ringBuffer)
13583 return &smithy.DeserializationError{
13584 Err: fmt.Errorf("failed to decode response body, %w", err),
13585 Snapshot: snapshot.Bytes(),
13586 }
13587 }
13588
13589 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13590 t, err = decoder.GetElement("Error")
13591 if err != nil {
13592 var snapshot bytes.Buffer
13593 io.Copy(&snapshot, ringBuffer)
13594 return &smithy.DeserializationError{
13595 Err: fmt.Errorf("failed to decode response body, %w", err),
13596 Snapshot: snapshot.Bytes(),
13597 }
13598 }
13599
13600 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13601 err = awsRestxml_deserializeDocumentPublicZoneVPCAssociation(&output, decoder)
13602 if err != nil {
13603 var snapshot bytes.Buffer
13604 io.Copy(&snapshot, ringBuffer)
13605 return &smithy.DeserializationError{
13606 Err: fmt.Errorf("failed to decode response body, %w", err),
13607 Snapshot: snapshot.Bytes(),
13608 }
13609 }
13610
13611 return output
13612 }
13613
13614 func awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13615 output := &types.QueryLoggingConfigAlreadyExists{}
13616 var buff [1024]byte
13617 ringBuffer := smithyio.NewRingBuffer(buff[:])
13618 body := io.TeeReader(errorBody, ringBuffer)
13619 rootDecoder := xml.NewDecoder(body)
13620 t, err := smithyxml.FetchRootElement(rootDecoder)
13621 if err == io.EOF {
13622 return output
13623 }
13624 if err != nil {
13625 var snapshot bytes.Buffer
13626 io.Copy(&snapshot, ringBuffer)
13627 return &smithy.DeserializationError{
13628 Err: fmt.Errorf("failed to decode response body, %w", err),
13629 Snapshot: snapshot.Bytes(),
13630 }
13631 }
13632
13633 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13634 t, err = decoder.GetElement("Error")
13635 if err != nil {
13636 var snapshot bytes.Buffer
13637 io.Copy(&snapshot, ringBuffer)
13638 return &smithy.DeserializationError{
13639 Err: fmt.Errorf("failed to decode response body, %w", err),
13640 Snapshot: snapshot.Bytes(),
13641 }
13642 }
13643
13644 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13645 err = awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(&output, decoder)
13646 if err != nil {
13647 var snapshot bytes.Buffer
13648 io.Copy(&snapshot, ringBuffer)
13649 return &smithy.DeserializationError{
13650 Err: fmt.Errorf("failed to decode response body, %w", err),
13651 Snapshot: snapshot.Bytes(),
13652 }
13653 }
13654
13655 return output
13656 }
13657
13658 func awsRestxml_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13659 output := &types.ThrottlingException{}
13660 var buff [1024]byte
13661 ringBuffer := smithyio.NewRingBuffer(buff[:])
13662 body := io.TeeReader(errorBody, ringBuffer)
13663 rootDecoder := xml.NewDecoder(body)
13664 t, err := smithyxml.FetchRootElement(rootDecoder)
13665 if err == io.EOF {
13666 return output
13667 }
13668 if err != nil {
13669 var snapshot bytes.Buffer
13670 io.Copy(&snapshot, ringBuffer)
13671 return &smithy.DeserializationError{
13672 Err: fmt.Errorf("failed to decode response body, %w", err),
13673 Snapshot: snapshot.Bytes(),
13674 }
13675 }
13676
13677 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13678 t, err = decoder.GetElement("Error")
13679 if err != nil {
13680 var snapshot bytes.Buffer
13681 io.Copy(&snapshot, ringBuffer)
13682 return &smithy.DeserializationError{
13683 Err: fmt.Errorf("failed to decode response body, %w", err),
13684 Snapshot: snapshot.Bytes(),
13685 }
13686 }
13687
13688 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13689 err = awsRestxml_deserializeDocumentThrottlingException(&output, decoder)
13690 if err != nil {
13691 var snapshot bytes.Buffer
13692 io.Copy(&snapshot, ringBuffer)
13693 return &smithy.DeserializationError{
13694 Err: fmt.Errorf("failed to decode response body, %w", err),
13695 Snapshot: snapshot.Bytes(),
13696 }
13697 }
13698
13699 return output
13700 }
13701
13702 func awsRestxml_deserializeErrorTooManyHealthChecks(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13703 output := &types.TooManyHealthChecks{}
13704 var buff [1024]byte
13705 ringBuffer := smithyio.NewRingBuffer(buff[:])
13706 body := io.TeeReader(errorBody, ringBuffer)
13707 rootDecoder := xml.NewDecoder(body)
13708 t, err := smithyxml.FetchRootElement(rootDecoder)
13709 if err == io.EOF {
13710 return output
13711 }
13712 if err != nil {
13713 var snapshot bytes.Buffer
13714 io.Copy(&snapshot, ringBuffer)
13715 return &smithy.DeserializationError{
13716 Err: fmt.Errorf("failed to decode response body, %w", err),
13717 Snapshot: snapshot.Bytes(),
13718 }
13719 }
13720
13721 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13722 t, err = decoder.GetElement("Error")
13723 if err != nil {
13724 var snapshot bytes.Buffer
13725 io.Copy(&snapshot, ringBuffer)
13726 return &smithy.DeserializationError{
13727 Err: fmt.Errorf("failed to decode response body, %w", err),
13728 Snapshot: snapshot.Bytes(),
13729 }
13730 }
13731
13732 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13733 err = awsRestxml_deserializeDocumentTooManyHealthChecks(&output, decoder)
13734 if err != nil {
13735 var snapshot bytes.Buffer
13736 io.Copy(&snapshot, ringBuffer)
13737 return &smithy.DeserializationError{
13738 Err: fmt.Errorf("failed to decode response body, %w", err),
13739 Snapshot: snapshot.Bytes(),
13740 }
13741 }
13742
13743 return output
13744 }
13745
13746 func awsRestxml_deserializeErrorTooManyHostedZones(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13747 output := &types.TooManyHostedZones{}
13748 var buff [1024]byte
13749 ringBuffer := smithyio.NewRingBuffer(buff[:])
13750 body := io.TeeReader(errorBody, ringBuffer)
13751 rootDecoder := xml.NewDecoder(body)
13752 t, err := smithyxml.FetchRootElement(rootDecoder)
13753 if err == io.EOF {
13754 return output
13755 }
13756 if err != nil {
13757 var snapshot bytes.Buffer
13758 io.Copy(&snapshot, ringBuffer)
13759 return &smithy.DeserializationError{
13760 Err: fmt.Errorf("failed to decode response body, %w", err),
13761 Snapshot: snapshot.Bytes(),
13762 }
13763 }
13764
13765 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13766 t, err = decoder.GetElement("Error")
13767 if err != nil {
13768 var snapshot bytes.Buffer
13769 io.Copy(&snapshot, ringBuffer)
13770 return &smithy.DeserializationError{
13771 Err: fmt.Errorf("failed to decode response body, %w", err),
13772 Snapshot: snapshot.Bytes(),
13773 }
13774 }
13775
13776 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13777 err = awsRestxml_deserializeDocumentTooManyHostedZones(&output, decoder)
13778 if err != nil {
13779 var snapshot bytes.Buffer
13780 io.Copy(&snapshot, ringBuffer)
13781 return &smithy.DeserializationError{
13782 Err: fmt.Errorf("failed to decode response body, %w", err),
13783 Snapshot: snapshot.Bytes(),
13784 }
13785 }
13786
13787 return output
13788 }
13789
13790 func awsRestxml_deserializeErrorTooManyKeySigningKeys(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13791 output := &types.TooManyKeySigningKeys{}
13792 var buff [1024]byte
13793 ringBuffer := smithyio.NewRingBuffer(buff[:])
13794 body := io.TeeReader(errorBody, ringBuffer)
13795 rootDecoder := xml.NewDecoder(body)
13796 t, err := smithyxml.FetchRootElement(rootDecoder)
13797 if err == io.EOF {
13798 return output
13799 }
13800 if err != nil {
13801 var snapshot bytes.Buffer
13802 io.Copy(&snapshot, ringBuffer)
13803 return &smithy.DeserializationError{
13804 Err: fmt.Errorf("failed to decode response body, %w", err),
13805 Snapshot: snapshot.Bytes(),
13806 }
13807 }
13808
13809 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13810 t, err = decoder.GetElement("Error")
13811 if err != nil {
13812 var snapshot bytes.Buffer
13813 io.Copy(&snapshot, ringBuffer)
13814 return &smithy.DeserializationError{
13815 Err: fmt.Errorf("failed to decode response body, %w", err),
13816 Snapshot: snapshot.Bytes(),
13817 }
13818 }
13819
13820 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13821 err = awsRestxml_deserializeDocumentTooManyKeySigningKeys(&output, decoder)
13822 if err != nil {
13823 var snapshot bytes.Buffer
13824 io.Copy(&snapshot, ringBuffer)
13825 return &smithy.DeserializationError{
13826 Err: fmt.Errorf("failed to decode response body, %w", err),
13827 Snapshot: snapshot.Bytes(),
13828 }
13829 }
13830
13831 return output
13832 }
13833
13834 func awsRestxml_deserializeErrorTooManyTrafficPolicies(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13835 output := &types.TooManyTrafficPolicies{}
13836 var buff [1024]byte
13837 ringBuffer := smithyio.NewRingBuffer(buff[:])
13838 body := io.TeeReader(errorBody, ringBuffer)
13839 rootDecoder := xml.NewDecoder(body)
13840 t, err := smithyxml.FetchRootElement(rootDecoder)
13841 if err == io.EOF {
13842 return output
13843 }
13844 if err != nil {
13845 var snapshot bytes.Buffer
13846 io.Copy(&snapshot, ringBuffer)
13847 return &smithy.DeserializationError{
13848 Err: fmt.Errorf("failed to decode response body, %w", err),
13849 Snapshot: snapshot.Bytes(),
13850 }
13851 }
13852
13853 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13854 t, err = decoder.GetElement("Error")
13855 if err != nil {
13856 var snapshot bytes.Buffer
13857 io.Copy(&snapshot, ringBuffer)
13858 return &smithy.DeserializationError{
13859 Err: fmt.Errorf("failed to decode response body, %w", err),
13860 Snapshot: snapshot.Bytes(),
13861 }
13862 }
13863
13864 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13865 err = awsRestxml_deserializeDocumentTooManyTrafficPolicies(&output, decoder)
13866 if err != nil {
13867 var snapshot bytes.Buffer
13868 io.Copy(&snapshot, ringBuffer)
13869 return &smithy.DeserializationError{
13870 Err: fmt.Errorf("failed to decode response body, %w", err),
13871 Snapshot: snapshot.Bytes(),
13872 }
13873 }
13874
13875 return output
13876 }
13877
13878 func awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13879 output := &types.TooManyTrafficPolicyInstances{}
13880 var buff [1024]byte
13881 ringBuffer := smithyio.NewRingBuffer(buff[:])
13882 body := io.TeeReader(errorBody, ringBuffer)
13883 rootDecoder := xml.NewDecoder(body)
13884 t, err := smithyxml.FetchRootElement(rootDecoder)
13885 if err == io.EOF {
13886 return output
13887 }
13888 if err != nil {
13889 var snapshot bytes.Buffer
13890 io.Copy(&snapshot, ringBuffer)
13891 return &smithy.DeserializationError{
13892 Err: fmt.Errorf("failed to decode response body, %w", err),
13893 Snapshot: snapshot.Bytes(),
13894 }
13895 }
13896
13897 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13898 t, err = decoder.GetElement("Error")
13899 if err != nil {
13900 var snapshot bytes.Buffer
13901 io.Copy(&snapshot, ringBuffer)
13902 return &smithy.DeserializationError{
13903 Err: fmt.Errorf("failed to decode response body, %w", err),
13904 Snapshot: snapshot.Bytes(),
13905 }
13906 }
13907
13908 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13909 err = awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(&output, decoder)
13910 if err != nil {
13911 var snapshot bytes.Buffer
13912 io.Copy(&snapshot, ringBuffer)
13913 return &smithy.DeserializationError{
13914 Err: fmt.Errorf("failed to decode response body, %w", err),
13915 Snapshot: snapshot.Bytes(),
13916 }
13917 }
13918
13919 return output
13920 }
13921
13922 func awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13923 output := &types.TooManyTrafficPolicyVersionsForCurrentPolicy{}
13924 var buff [1024]byte
13925 ringBuffer := smithyio.NewRingBuffer(buff[:])
13926 body := io.TeeReader(errorBody, ringBuffer)
13927 rootDecoder := xml.NewDecoder(body)
13928 t, err := smithyxml.FetchRootElement(rootDecoder)
13929 if err == io.EOF {
13930 return output
13931 }
13932 if err != nil {
13933 var snapshot bytes.Buffer
13934 io.Copy(&snapshot, ringBuffer)
13935 return &smithy.DeserializationError{
13936 Err: fmt.Errorf("failed to decode response body, %w", err),
13937 Snapshot: snapshot.Bytes(),
13938 }
13939 }
13940
13941 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13942 t, err = decoder.GetElement("Error")
13943 if err != nil {
13944 var snapshot bytes.Buffer
13945 io.Copy(&snapshot, ringBuffer)
13946 return &smithy.DeserializationError{
13947 Err: fmt.Errorf("failed to decode response body, %w", err),
13948 Snapshot: snapshot.Bytes(),
13949 }
13950 }
13951
13952 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13953 err = awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(&output, decoder)
13954 if err != nil {
13955 var snapshot bytes.Buffer
13956 io.Copy(&snapshot, ringBuffer)
13957 return &smithy.DeserializationError{
13958 Err: fmt.Errorf("failed to decode response body, %w", err),
13959 Snapshot: snapshot.Bytes(),
13960 }
13961 }
13962
13963 return output
13964 }
13965
13966 func awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response *smithyhttp.Response, errorBody *bytes.Reader) error {
13967 output := &types.TooManyVPCAssociationAuthorizations{}
13968 var buff [1024]byte
13969 ringBuffer := smithyio.NewRingBuffer(buff[:])
13970 body := io.TeeReader(errorBody, ringBuffer)
13971 rootDecoder := xml.NewDecoder(body)
13972 t, err := smithyxml.FetchRootElement(rootDecoder)
13973 if err == io.EOF {
13974 return output
13975 }
13976 if err != nil {
13977 var snapshot bytes.Buffer
13978 io.Copy(&snapshot, ringBuffer)
13979 return &smithy.DeserializationError{
13980 Err: fmt.Errorf("failed to decode response body, %w", err),
13981 Snapshot: snapshot.Bytes(),
13982 }
13983 }
13984
13985 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
13986 t, err = decoder.GetElement("Error")
13987 if err != nil {
13988 var snapshot bytes.Buffer
13989 io.Copy(&snapshot, ringBuffer)
13990 return &smithy.DeserializationError{
13991 Err: fmt.Errorf("failed to decode response body, %w", err),
13992 Snapshot: snapshot.Bytes(),
13993 }
13994 }
13995
13996 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13997 err = awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(&output, decoder)
13998 if err != nil {
13999 var snapshot bytes.Buffer
14000 io.Copy(&snapshot, ringBuffer)
14001 return &smithy.DeserializationError{
14002 Err: fmt.Errorf("failed to decode response body, %w", err),
14003 Snapshot: snapshot.Bytes(),
14004 }
14005 }
14006
14007 return output
14008 }
14009
14010 func awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
14011 output := &types.TrafficPolicyAlreadyExists{}
14012 var buff [1024]byte
14013 ringBuffer := smithyio.NewRingBuffer(buff[:])
14014 body := io.TeeReader(errorBody, ringBuffer)
14015 rootDecoder := xml.NewDecoder(body)
14016 t, err := smithyxml.FetchRootElement(rootDecoder)
14017 if err == io.EOF {
14018 return output
14019 }
14020 if err != nil {
14021 var snapshot bytes.Buffer
14022 io.Copy(&snapshot, ringBuffer)
14023 return &smithy.DeserializationError{
14024 Err: fmt.Errorf("failed to decode response body, %w", err),
14025 Snapshot: snapshot.Bytes(),
14026 }
14027 }
14028
14029 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
14030 t, err = decoder.GetElement("Error")
14031 if err != nil {
14032 var snapshot bytes.Buffer
14033 io.Copy(&snapshot, ringBuffer)
14034 return &smithy.DeserializationError{
14035 Err: fmt.Errorf("failed to decode response body, %w", err),
14036 Snapshot: snapshot.Bytes(),
14037 }
14038 }
14039
14040 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14041 err = awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(&output, decoder)
14042 if err != nil {
14043 var snapshot bytes.Buffer
14044 io.Copy(&snapshot, ringBuffer)
14045 return &smithy.DeserializationError{
14046 Err: fmt.Errorf("failed to decode response body, %w", err),
14047 Snapshot: snapshot.Bytes(),
14048 }
14049 }
14050
14051 return output
14052 }
14053
14054 func awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
14055 output := &types.TrafficPolicyInstanceAlreadyExists{}
14056 var buff [1024]byte
14057 ringBuffer := smithyio.NewRingBuffer(buff[:])
14058 body := io.TeeReader(errorBody, ringBuffer)
14059 rootDecoder := xml.NewDecoder(body)
14060 t, err := smithyxml.FetchRootElement(rootDecoder)
14061 if err == io.EOF {
14062 return output
14063 }
14064 if err != nil {
14065 var snapshot bytes.Buffer
14066 io.Copy(&snapshot, ringBuffer)
14067 return &smithy.DeserializationError{
14068 Err: fmt.Errorf("failed to decode response body, %w", err),
14069 Snapshot: snapshot.Bytes(),
14070 }
14071 }
14072
14073 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
14074 t, err = decoder.GetElement("Error")
14075 if err != nil {
14076 var snapshot bytes.Buffer
14077 io.Copy(&snapshot, ringBuffer)
14078 return &smithy.DeserializationError{
14079 Err: fmt.Errorf("failed to decode response body, %w", err),
14080 Snapshot: snapshot.Bytes(),
14081 }
14082 }
14083
14084 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14085 err = awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(&output, decoder)
14086 if err != nil {
14087 var snapshot bytes.Buffer
14088 io.Copy(&snapshot, ringBuffer)
14089 return &smithy.DeserializationError{
14090 Err: fmt.Errorf("failed to decode response body, %w", err),
14091 Snapshot: snapshot.Bytes(),
14092 }
14093 }
14094
14095 return output
14096 }
14097
14098 func awsRestxml_deserializeErrorTrafficPolicyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
14099 output := &types.TrafficPolicyInUse{}
14100 var buff [1024]byte
14101 ringBuffer := smithyio.NewRingBuffer(buff[:])
14102 body := io.TeeReader(errorBody, ringBuffer)
14103 rootDecoder := xml.NewDecoder(body)
14104 t, err := smithyxml.FetchRootElement(rootDecoder)
14105 if err == io.EOF {
14106 return output
14107 }
14108 if err != nil {
14109 var snapshot bytes.Buffer
14110 io.Copy(&snapshot, ringBuffer)
14111 return &smithy.DeserializationError{
14112 Err: fmt.Errorf("failed to decode response body, %w", err),
14113 Snapshot: snapshot.Bytes(),
14114 }
14115 }
14116
14117 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
14118 t, err = decoder.GetElement("Error")
14119 if err != nil {
14120 var snapshot bytes.Buffer
14121 io.Copy(&snapshot, ringBuffer)
14122 return &smithy.DeserializationError{
14123 Err: fmt.Errorf("failed to decode response body, %w", err),
14124 Snapshot: snapshot.Bytes(),
14125 }
14126 }
14127
14128 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14129 err = awsRestxml_deserializeDocumentTrafficPolicyInUse(&output, decoder)
14130 if err != nil {
14131 var snapshot bytes.Buffer
14132 io.Copy(&snapshot, ringBuffer)
14133 return &smithy.DeserializationError{
14134 Err: fmt.Errorf("failed to decode response body, %w", err),
14135 Snapshot: snapshot.Bytes(),
14136 }
14137 }
14138
14139 return output
14140 }
14141
14142 func awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
14143 output := &types.VPCAssociationAuthorizationNotFound{}
14144 var buff [1024]byte
14145 ringBuffer := smithyio.NewRingBuffer(buff[:])
14146 body := io.TeeReader(errorBody, ringBuffer)
14147 rootDecoder := xml.NewDecoder(body)
14148 t, err := smithyxml.FetchRootElement(rootDecoder)
14149 if err == io.EOF {
14150 return output
14151 }
14152 if err != nil {
14153 var snapshot bytes.Buffer
14154 io.Copy(&snapshot, ringBuffer)
14155 return &smithy.DeserializationError{
14156 Err: fmt.Errorf("failed to decode response body, %w", err),
14157 Snapshot: snapshot.Bytes(),
14158 }
14159 }
14160
14161 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
14162 t, err = decoder.GetElement("Error")
14163 if err != nil {
14164 var snapshot bytes.Buffer
14165 io.Copy(&snapshot, ringBuffer)
14166 return &smithy.DeserializationError{
14167 Err: fmt.Errorf("failed to decode response body, %w", err),
14168 Snapshot: snapshot.Bytes(),
14169 }
14170 }
14171
14172 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14173 err = awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(&output, decoder)
14174 if err != nil {
14175 var snapshot bytes.Buffer
14176 io.Copy(&snapshot, ringBuffer)
14177 return &smithy.DeserializationError{
14178 Err: fmt.Errorf("failed to decode response body, %w", err),
14179 Snapshot: snapshot.Bytes(),
14180 }
14181 }
14182
14183 return output
14184 }
14185
14186 func awsRestxml_deserializeErrorVPCAssociationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
14187 output := &types.VPCAssociationNotFound{}
14188 var buff [1024]byte
14189 ringBuffer := smithyio.NewRingBuffer(buff[:])
14190 body := io.TeeReader(errorBody, ringBuffer)
14191 rootDecoder := xml.NewDecoder(body)
14192 t, err := smithyxml.FetchRootElement(rootDecoder)
14193 if err == io.EOF {
14194 return output
14195 }
14196 if err != nil {
14197 var snapshot bytes.Buffer
14198 io.Copy(&snapshot, ringBuffer)
14199 return &smithy.DeserializationError{
14200 Err: fmt.Errorf("failed to decode response body, %w", err),
14201 Snapshot: snapshot.Bytes(),
14202 }
14203 }
14204
14205 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
14206 t, err = decoder.GetElement("Error")
14207 if err != nil {
14208 var snapshot bytes.Buffer
14209 io.Copy(&snapshot, ringBuffer)
14210 return &smithy.DeserializationError{
14211 Err: fmt.Errorf("failed to decode response body, %w", err),
14212 Snapshot: snapshot.Bytes(),
14213 }
14214 }
14215
14216 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14217 err = awsRestxml_deserializeDocumentVPCAssociationNotFound(&output, decoder)
14218 if err != nil {
14219 var snapshot bytes.Buffer
14220 io.Copy(&snapshot, ringBuffer)
14221 return &smithy.DeserializationError{
14222 Err: fmt.Errorf("failed to decode response body, %w", err),
14223 Snapshot: snapshot.Bytes(),
14224 }
14225 }
14226
14227 return output
14228 }
14229
14230 func awsRestxml_deserializeDocumentAccountLimit(v **types.AccountLimit, decoder smithyxml.NodeDecoder) error {
14231 if v == nil {
14232 return fmt.Errorf("unexpected nil of type %T", v)
14233 }
14234 var sv *types.AccountLimit
14235 if *v == nil {
14236 sv = &types.AccountLimit{}
14237 } else {
14238 sv = *v
14239 }
14240
14241 for {
14242 t, done, err := decoder.Token()
14243 if err != nil {
14244 return err
14245 }
14246 if done {
14247 break
14248 }
14249 originalDecoder := decoder
14250 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14251 switch {
14252 case strings.EqualFold("Type", t.Name.Local):
14253 val, err := decoder.Value()
14254 if err != nil {
14255 return err
14256 }
14257 if val == nil {
14258 break
14259 }
14260 {
14261 xtv := string(val)
14262 sv.Type = types.AccountLimitType(xtv)
14263 }
14264
14265 case strings.EqualFold("Value", t.Name.Local):
14266 val, err := decoder.Value()
14267 if err != nil {
14268 return err
14269 }
14270 if val == nil {
14271 break
14272 }
14273 {
14274 xtv := string(val)
14275 i64, err := strconv.ParseInt(xtv, 10, 64)
14276 if err != nil {
14277 return err
14278 }
14279 sv.Value = ptr.Int64(i64)
14280 }
14281
14282 default:
14283 // Do nothing and ignore the unexpected tag element
14284 err = decoder.Decoder.Skip()
14285 if err != nil {
14286 return err
14287 }
14288
14289 }
14290 decoder = originalDecoder
14291 }
14292 *v = sv
14293 return nil
14294 }
14295
14296 func awsRestxml_deserializeDocumentAlarmIdentifier(v **types.AlarmIdentifier, decoder smithyxml.NodeDecoder) error {
14297 if v == nil {
14298 return fmt.Errorf("unexpected nil of type %T", v)
14299 }
14300 var sv *types.AlarmIdentifier
14301 if *v == nil {
14302 sv = &types.AlarmIdentifier{}
14303 } else {
14304 sv = *v
14305 }
14306
14307 for {
14308 t, done, err := decoder.Token()
14309 if err != nil {
14310 return err
14311 }
14312 if done {
14313 break
14314 }
14315 originalDecoder := decoder
14316 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14317 switch {
14318 case strings.EqualFold("Name", t.Name.Local):
14319 val, err := decoder.Value()
14320 if err != nil {
14321 return err
14322 }
14323 if val == nil {
14324 break
14325 }
14326 {
14327 xtv := string(val)
14328 sv.Name = ptr.String(xtv)
14329 }
14330
14331 case strings.EqualFold("Region", t.Name.Local):
14332 val, err := decoder.Value()
14333 if err != nil {
14334 return err
14335 }
14336 if val == nil {
14337 break
14338 }
14339 {
14340 xtv := string(val)
14341 sv.Region = types.CloudWatchRegion(xtv)
14342 }
14343
14344 default:
14345 // Do nothing and ignore the unexpected tag element
14346 err = decoder.Decoder.Skip()
14347 if err != nil {
14348 return err
14349 }
14350
14351 }
14352 decoder = originalDecoder
14353 }
14354 *v = sv
14355 return nil
14356 }
14357
14358 func awsRestxml_deserializeDocumentAliasTarget(v **types.AliasTarget, decoder smithyxml.NodeDecoder) error {
14359 if v == nil {
14360 return fmt.Errorf("unexpected nil of type %T", v)
14361 }
14362 var sv *types.AliasTarget
14363 if *v == nil {
14364 sv = &types.AliasTarget{}
14365 } else {
14366 sv = *v
14367 }
14368
14369 for {
14370 t, done, err := decoder.Token()
14371 if err != nil {
14372 return err
14373 }
14374 if done {
14375 break
14376 }
14377 originalDecoder := decoder
14378 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14379 switch {
14380 case strings.EqualFold("DNSName", t.Name.Local):
14381 val, err := decoder.Value()
14382 if err != nil {
14383 return err
14384 }
14385 if val == nil {
14386 break
14387 }
14388 {
14389 xtv := string(val)
14390 sv.DNSName = ptr.String(xtv)
14391 }
14392
14393 case strings.EqualFold("EvaluateTargetHealth", t.Name.Local):
14394 val, err := decoder.Value()
14395 if err != nil {
14396 return err
14397 }
14398 if val == nil {
14399 break
14400 }
14401 {
14402 xtv, err := strconv.ParseBool(string(val))
14403 if err != nil {
14404 return fmt.Errorf("expected AliasHealthEnabled to be of type *bool, got %T instead", val)
14405 }
14406 sv.EvaluateTargetHealth = xtv
14407 }
14408
14409 case strings.EqualFold("HostedZoneId", 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.HostedZoneId = ptr.String(xtv)
14420 }
14421
14422 default:
14423 // Do nothing and ignore the unexpected tag element
14424 err = decoder.Decoder.Skip()
14425 if err != nil {
14426 return err
14427 }
14428
14429 }
14430 decoder = originalDecoder
14431 }
14432 *v = sv
14433 return nil
14434 }
14435
14436 func awsRestxml_deserializeDocumentChangeInfo(v **types.ChangeInfo, decoder smithyxml.NodeDecoder) error {
14437 if v == nil {
14438 return fmt.Errorf("unexpected nil of type %T", v)
14439 }
14440 var sv *types.ChangeInfo
14441 if *v == nil {
14442 sv = &types.ChangeInfo{}
14443 } else {
14444 sv = *v
14445 }
14446
14447 for {
14448 t, done, err := decoder.Token()
14449 if err != nil {
14450 return err
14451 }
14452 if done {
14453 break
14454 }
14455 originalDecoder := decoder
14456 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14457 switch {
14458 case strings.EqualFold("Comment", t.Name.Local):
14459 val, err := decoder.Value()
14460 if err != nil {
14461 return err
14462 }
14463 if val == nil {
14464 break
14465 }
14466 {
14467 xtv := string(val)
14468 sv.Comment = ptr.String(xtv)
14469 }
14470
14471 case strings.EqualFold("Id", t.Name.Local):
14472 val, err := decoder.Value()
14473 if err != nil {
14474 return err
14475 }
14476 if val == nil {
14477 break
14478 }
14479 {
14480 xtv := string(val)
14481 sv.Id = ptr.String(xtv)
14482 }
14483
14484 case strings.EqualFold("Status", t.Name.Local):
14485 val, err := decoder.Value()
14486 if err != nil {
14487 return err
14488 }
14489 if val == nil {
14490 break
14491 }
14492 {
14493 xtv := string(val)
14494 sv.Status = types.ChangeStatus(xtv)
14495 }
14496
14497 case strings.EqualFold("SubmittedAt", t.Name.Local):
14498 val, err := decoder.Value()
14499 if err != nil {
14500 return err
14501 }
14502 if val == nil {
14503 break
14504 }
14505 {
14506 xtv := string(val)
14507 t, err := smithytime.ParseDateTime(xtv)
14508 if err != nil {
14509 return err
14510 }
14511 sv.SubmittedAt = ptr.Time(t)
14512 }
14513
14514 default:
14515 // Do nothing and ignore the unexpected tag element
14516 err = decoder.Decoder.Skip()
14517 if err != nil {
14518 return err
14519 }
14520
14521 }
14522 decoder = originalDecoder
14523 }
14524 *v = sv
14525 return nil
14526 }
14527
14528 func awsRestxml_deserializeDocumentCheckerIpRanges(v *[]string, decoder smithyxml.NodeDecoder) error {
14529 if v == nil {
14530 return fmt.Errorf("unexpected nil of type %T", v)
14531 }
14532 var sv []string
14533 if *v == nil {
14534 sv = make([]string, 0)
14535 } else {
14536 sv = *v
14537 }
14538
14539 originalDecoder := decoder
14540 for {
14541 t, done, err := decoder.Token()
14542 if err != nil {
14543 return err
14544 }
14545 if done {
14546 break
14547 }
14548 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14549 decoder = memberDecoder
14550 switch {
14551 case strings.EqualFold("member", t.Name.Local):
14552 var col string
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 col = xtv
14563 }
14564 sv = append(sv, col)
14565
14566 default:
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
14579 func awsRestxml_deserializeDocumentCheckerIpRangesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
14580 var sv []string
14581 if *v == nil {
14582 sv = make([]string, 0)
14583 } else {
14584 sv = *v
14585 }
14586
14587 switch {
14588 default:
14589 var mv string
14590 t := decoder.StartEl
14591 _ = t
14592 val, err := decoder.Value()
14593 if err != nil {
14594 return err
14595 }
14596 if val == nil {
14597 break
14598 }
14599 {
14600 xtv := string(val)
14601 mv = xtv
14602 }
14603 sv = append(sv, mv)
14604 }
14605 *v = sv
14606 return nil
14607 }
14608 func awsRestxml_deserializeDocumentChildHealthCheckList(v *[]string, decoder smithyxml.NodeDecoder) error {
14609 if v == nil {
14610 return fmt.Errorf("unexpected nil of type %T", v)
14611 }
14612 var sv []string
14613 if *v == nil {
14614 sv = make([]string, 0)
14615 } else {
14616 sv = *v
14617 }
14618
14619 originalDecoder := decoder
14620 for {
14621 t, done, err := decoder.Token()
14622 if err != nil {
14623 return err
14624 }
14625 if done {
14626 break
14627 }
14628 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14629 decoder = memberDecoder
14630 switch {
14631 case strings.EqualFold("ChildHealthCheck", t.Name.Local):
14632 var col string
14633 val, err := decoder.Value()
14634 if err != nil {
14635 return err
14636 }
14637 if val == nil {
14638 break
14639 }
14640 {
14641 xtv := string(val)
14642 col = xtv
14643 }
14644 sv = append(sv, col)
14645
14646 default:
14647 err = decoder.Decoder.Skip()
14648 if err != nil {
14649 return err
14650 }
14651
14652 }
14653 decoder = originalDecoder
14654 }
14655 *v = sv
14656 return nil
14657 }
14658
14659 func awsRestxml_deserializeDocumentChildHealthCheckListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
14660 var sv []string
14661 if *v == nil {
14662 sv = make([]string, 0)
14663 } else {
14664 sv = *v
14665 }
14666
14667 switch {
14668 default:
14669 var mv string
14670 t := decoder.StartEl
14671 _ = t
14672 val, err := decoder.Value()
14673 if err != nil {
14674 return err
14675 }
14676 if val == nil {
14677 break
14678 }
14679 {
14680 xtv := string(val)
14681 mv = xtv
14682 }
14683 sv = append(sv, mv)
14684 }
14685 *v = sv
14686 return nil
14687 }
14688 func awsRestxml_deserializeDocumentCidrBlockInUseException(v **types.CidrBlockInUseException, decoder smithyxml.NodeDecoder) error {
14689 if v == nil {
14690 return fmt.Errorf("unexpected nil of type %T", v)
14691 }
14692 var sv *types.CidrBlockInUseException
14693 if *v == nil {
14694 sv = &types.CidrBlockInUseException{}
14695 } else {
14696 sv = *v
14697 }
14698
14699 for {
14700 t, done, err := decoder.Token()
14701 if err != nil {
14702 return err
14703 }
14704 if done {
14705 break
14706 }
14707 originalDecoder := decoder
14708 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14709 switch {
14710 case strings.EqualFold("Message", t.Name.Local):
14711 val, err := decoder.Value()
14712 if err != nil {
14713 return err
14714 }
14715 if val == nil {
14716 break
14717 }
14718 {
14719 xtv := string(val)
14720 sv.Message = ptr.String(xtv)
14721 }
14722
14723 default:
14724 // Do nothing and ignore the unexpected tag element
14725 err = decoder.Decoder.Skip()
14726 if err != nil {
14727 return err
14728 }
14729
14730 }
14731 decoder = originalDecoder
14732 }
14733 *v = sv
14734 return nil
14735 }
14736
14737 func awsRestxml_deserializeDocumentCidrBlockSummaries(v *[]types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
14738 if v == nil {
14739 return fmt.Errorf("unexpected nil of type %T", v)
14740 }
14741 var sv []types.CidrBlockSummary
14742 if *v == nil {
14743 sv = make([]types.CidrBlockSummary, 0)
14744 } else {
14745 sv = *v
14746 }
14747
14748 originalDecoder := decoder
14749 for {
14750 t, done, err := decoder.Token()
14751 if err != nil {
14752 return err
14753 }
14754 if done {
14755 break
14756 }
14757 switch {
14758 case strings.EqualFold("member", t.Name.Local):
14759 var col types.CidrBlockSummary
14760 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14761 destAddr := &col
14762 if err := awsRestxml_deserializeDocumentCidrBlockSummary(&destAddr, nodeDecoder); err != nil {
14763 return err
14764 }
14765 col = *destAddr
14766 sv = append(sv, col)
14767
14768 default:
14769 err = decoder.Decoder.Skip()
14770 if err != nil {
14771 return err
14772 }
14773
14774 }
14775 decoder = originalDecoder
14776 }
14777 *v = sv
14778 return nil
14779 }
14780
14781 func awsRestxml_deserializeDocumentCidrBlockSummariesUnwrapped(v *[]types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
14782 var sv []types.CidrBlockSummary
14783 if *v == nil {
14784 sv = make([]types.CidrBlockSummary, 0)
14785 } else {
14786 sv = *v
14787 }
14788
14789 switch {
14790 default:
14791 var mv types.CidrBlockSummary
14792 t := decoder.StartEl
14793 _ = t
14794 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14795 destAddr := &mv
14796 if err := awsRestxml_deserializeDocumentCidrBlockSummary(&destAddr, nodeDecoder); err != nil {
14797 return err
14798 }
14799 mv = *destAddr
14800 sv = append(sv, mv)
14801 }
14802 *v = sv
14803 return nil
14804 }
14805 func awsRestxml_deserializeDocumentCidrBlockSummary(v **types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
14806 if v == nil {
14807 return fmt.Errorf("unexpected nil of type %T", v)
14808 }
14809 var sv *types.CidrBlockSummary
14810 if *v == nil {
14811 sv = &types.CidrBlockSummary{}
14812 } else {
14813 sv = *v
14814 }
14815
14816 for {
14817 t, done, err := decoder.Token()
14818 if err != nil {
14819 return err
14820 }
14821 if done {
14822 break
14823 }
14824 originalDecoder := decoder
14825 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14826 switch {
14827 case strings.EqualFold("CidrBlock", t.Name.Local):
14828 val, err := decoder.Value()
14829 if err != nil {
14830 return err
14831 }
14832 if val == nil {
14833 break
14834 }
14835 {
14836 xtv := string(val)
14837 sv.CidrBlock = ptr.String(xtv)
14838 }
14839
14840 case strings.EqualFold("LocationName", t.Name.Local):
14841 val, err := decoder.Value()
14842 if err != nil {
14843 return err
14844 }
14845 if val == nil {
14846 break
14847 }
14848 {
14849 xtv := string(val)
14850 sv.LocationName = ptr.String(xtv)
14851 }
14852
14853 default:
14854 // Do nothing and ignore the unexpected tag element
14855 err = decoder.Decoder.Skip()
14856 if err != nil {
14857 return err
14858 }
14859
14860 }
14861 decoder = originalDecoder
14862 }
14863 *v = sv
14864 return nil
14865 }
14866
14867 func awsRestxml_deserializeDocumentCidrCollection(v **types.CidrCollection, decoder smithyxml.NodeDecoder) error {
14868 if v == nil {
14869 return fmt.Errorf("unexpected nil of type %T", v)
14870 }
14871 var sv *types.CidrCollection
14872 if *v == nil {
14873 sv = &types.CidrCollection{}
14874 } else {
14875 sv = *v
14876 }
14877
14878 for {
14879 t, done, err := decoder.Token()
14880 if err != nil {
14881 return err
14882 }
14883 if done {
14884 break
14885 }
14886 originalDecoder := decoder
14887 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14888 switch {
14889 case strings.EqualFold("Arn", t.Name.Local):
14890 val, err := decoder.Value()
14891 if err != nil {
14892 return err
14893 }
14894 if val == nil {
14895 break
14896 }
14897 {
14898 xtv := string(val)
14899 sv.Arn = ptr.String(xtv)
14900 }
14901
14902 case strings.EqualFold("Id", t.Name.Local):
14903 val, err := decoder.Value()
14904 if err != nil {
14905 return err
14906 }
14907 if val == nil {
14908 break
14909 }
14910 {
14911 xtv := string(val)
14912 sv.Id = ptr.String(xtv)
14913 }
14914
14915 case strings.EqualFold("Name", t.Name.Local):
14916 val, err := decoder.Value()
14917 if err != nil {
14918 return err
14919 }
14920 if val == nil {
14921 break
14922 }
14923 {
14924 xtv := string(val)
14925 sv.Name = ptr.String(xtv)
14926 }
14927
14928 case strings.EqualFold("Version", t.Name.Local):
14929 val, err := decoder.Value()
14930 if err != nil {
14931 return err
14932 }
14933 if val == nil {
14934 break
14935 }
14936 {
14937 xtv := string(val)
14938 i64, err := strconv.ParseInt(xtv, 10, 64)
14939 if err != nil {
14940 return err
14941 }
14942 sv.Version = ptr.Int64(i64)
14943 }
14944
14945 default:
14946 // Do nothing and ignore the unexpected tag element
14947 err = decoder.Decoder.Skip()
14948 if err != nil {
14949 return err
14950 }
14951
14952 }
14953 decoder = originalDecoder
14954 }
14955 *v = sv
14956 return nil
14957 }
14958
14959 func awsRestxml_deserializeDocumentCidrCollectionAlreadyExistsException(v **types.CidrCollectionAlreadyExistsException, decoder smithyxml.NodeDecoder) error {
14960 if v == nil {
14961 return fmt.Errorf("unexpected nil of type %T", v)
14962 }
14963 var sv *types.CidrCollectionAlreadyExistsException
14964 if *v == nil {
14965 sv = &types.CidrCollectionAlreadyExistsException{}
14966 } else {
14967 sv = *v
14968 }
14969
14970 for {
14971 t, done, err := decoder.Token()
14972 if err != nil {
14973 return err
14974 }
14975 if done {
14976 break
14977 }
14978 originalDecoder := decoder
14979 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14980 switch {
14981 case strings.EqualFold("Message", t.Name.Local):
14982 val, err := decoder.Value()
14983 if err != nil {
14984 return err
14985 }
14986 if val == nil {
14987 break
14988 }
14989 {
14990 xtv := string(val)
14991 sv.Message = ptr.String(xtv)
14992 }
14993
14994 default:
14995 // Do nothing and ignore the unexpected tag element
14996 err = decoder.Decoder.Skip()
14997 if err != nil {
14998 return err
14999 }
15000
15001 }
15002 decoder = originalDecoder
15003 }
15004 *v = sv
15005 return nil
15006 }
15007
15008 func awsRestxml_deserializeDocumentCidrCollectionInUseException(v **types.CidrCollectionInUseException, decoder smithyxml.NodeDecoder) error {
15009 if v == nil {
15010 return fmt.Errorf("unexpected nil of type %T", v)
15011 }
15012 var sv *types.CidrCollectionInUseException
15013 if *v == nil {
15014 sv = &types.CidrCollectionInUseException{}
15015 } else {
15016 sv = *v
15017 }
15018
15019 for {
15020 t, done, err := decoder.Token()
15021 if err != nil {
15022 return err
15023 }
15024 if done {
15025 break
15026 }
15027 originalDecoder := decoder
15028 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15029 switch {
15030 case strings.EqualFold("Message", t.Name.Local):
15031 val, err := decoder.Value()
15032 if err != nil {
15033 return err
15034 }
15035 if val == nil {
15036 break
15037 }
15038 {
15039 xtv := string(val)
15040 sv.Message = ptr.String(xtv)
15041 }
15042
15043 default:
15044 // Do nothing and ignore the unexpected tag element
15045 err = decoder.Decoder.Skip()
15046 if err != nil {
15047 return err
15048 }
15049
15050 }
15051 decoder = originalDecoder
15052 }
15053 *v = sv
15054 return nil
15055 }
15056
15057 func awsRestxml_deserializeDocumentCidrCollectionVersionMismatchException(v **types.CidrCollectionVersionMismatchException, decoder smithyxml.NodeDecoder) error {
15058 if v == nil {
15059 return fmt.Errorf("unexpected nil of type %T", v)
15060 }
15061 var sv *types.CidrCollectionVersionMismatchException
15062 if *v == nil {
15063 sv = &types.CidrCollectionVersionMismatchException{}
15064 } else {
15065 sv = *v
15066 }
15067
15068 for {
15069 t, done, err := decoder.Token()
15070 if err != nil {
15071 return err
15072 }
15073 if done {
15074 break
15075 }
15076 originalDecoder := decoder
15077 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15078 switch {
15079 case strings.EqualFold("Message", t.Name.Local):
15080 val, err := decoder.Value()
15081 if err != nil {
15082 return err
15083 }
15084 if val == nil {
15085 break
15086 }
15087 {
15088 xtv := string(val)
15089 sv.Message = ptr.String(xtv)
15090 }
15091
15092 default:
15093 // Do nothing and ignore the unexpected tag element
15094 err = decoder.Decoder.Skip()
15095 if err != nil {
15096 return err
15097 }
15098
15099 }
15100 decoder = originalDecoder
15101 }
15102 *v = sv
15103 return nil
15104 }
15105
15106 func awsRestxml_deserializeDocumentCidrRoutingConfig(v **types.CidrRoutingConfig, decoder smithyxml.NodeDecoder) error {
15107 if v == nil {
15108 return fmt.Errorf("unexpected nil of type %T", v)
15109 }
15110 var sv *types.CidrRoutingConfig
15111 if *v == nil {
15112 sv = &types.CidrRoutingConfig{}
15113 } else {
15114 sv = *v
15115 }
15116
15117 for {
15118 t, done, err := decoder.Token()
15119 if err != nil {
15120 return err
15121 }
15122 if done {
15123 break
15124 }
15125 originalDecoder := decoder
15126 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15127 switch {
15128 case strings.EqualFold("CollectionId", t.Name.Local):
15129 val, err := decoder.Value()
15130 if err != nil {
15131 return err
15132 }
15133 if val == nil {
15134 break
15135 }
15136 {
15137 xtv := string(val)
15138 sv.CollectionId = ptr.String(xtv)
15139 }
15140
15141 case strings.EqualFold("LocationName", t.Name.Local):
15142 val, err := decoder.Value()
15143 if err != nil {
15144 return err
15145 }
15146 if val == nil {
15147 break
15148 }
15149 {
15150 xtv := string(val)
15151 sv.LocationName = ptr.String(xtv)
15152 }
15153
15154 default:
15155 // Do nothing and ignore the unexpected tag element
15156 err = decoder.Decoder.Skip()
15157 if err != nil {
15158 return err
15159 }
15160
15161 }
15162 decoder = originalDecoder
15163 }
15164 *v = sv
15165 return nil
15166 }
15167
15168 func awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(v **types.CloudWatchAlarmConfiguration, decoder smithyxml.NodeDecoder) error {
15169 if v == nil {
15170 return fmt.Errorf("unexpected nil of type %T", v)
15171 }
15172 var sv *types.CloudWatchAlarmConfiguration
15173 if *v == nil {
15174 sv = &types.CloudWatchAlarmConfiguration{}
15175 } else {
15176 sv = *v
15177 }
15178
15179 for {
15180 t, done, err := decoder.Token()
15181 if err != nil {
15182 return err
15183 }
15184 if done {
15185 break
15186 }
15187 originalDecoder := decoder
15188 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15189 switch {
15190 case strings.EqualFold("ComparisonOperator", t.Name.Local):
15191 val, err := decoder.Value()
15192 if err != nil {
15193 return err
15194 }
15195 if val == nil {
15196 break
15197 }
15198 {
15199 xtv := string(val)
15200 sv.ComparisonOperator = types.ComparisonOperator(xtv)
15201 }
15202
15203 case strings.EqualFold("Dimensions", t.Name.Local):
15204 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
15205 if err := awsRestxml_deserializeDocumentDimensionList(&sv.Dimensions, nodeDecoder); err != nil {
15206 return err
15207 }
15208
15209 case strings.EqualFold("EvaluationPeriods", t.Name.Local):
15210 val, err := decoder.Value()
15211 if err != nil {
15212 return err
15213 }
15214 if val == nil {
15215 break
15216 }
15217 {
15218 xtv := string(val)
15219 i64, err := strconv.ParseInt(xtv, 10, 64)
15220 if err != nil {
15221 return err
15222 }
15223 sv.EvaluationPeriods = ptr.Int32(int32(i64))
15224 }
15225
15226 case strings.EqualFold("MetricName", t.Name.Local):
15227 val, err := decoder.Value()
15228 if err != nil {
15229 return err
15230 }
15231 if val == nil {
15232 break
15233 }
15234 {
15235 xtv := string(val)
15236 sv.MetricName = ptr.String(xtv)
15237 }
15238
15239 case strings.EqualFold("Namespace", t.Name.Local):
15240 val, err := decoder.Value()
15241 if err != nil {
15242 return err
15243 }
15244 if val == nil {
15245 break
15246 }
15247 {
15248 xtv := string(val)
15249 sv.Namespace = ptr.String(xtv)
15250 }
15251
15252 case strings.EqualFold("Period", t.Name.Local):
15253 val, err := decoder.Value()
15254 if err != nil {
15255 return err
15256 }
15257 if val == nil {
15258 break
15259 }
15260 {
15261 xtv := string(val)
15262 i64, err := strconv.ParseInt(xtv, 10, 64)
15263 if err != nil {
15264 return err
15265 }
15266 sv.Period = ptr.Int32(int32(i64))
15267 }
15268
15269 case strings.EqualFold("Statistic", t.Name.Local):
15270 val, err := decoder.Value()
15271 if err != nil {
15272 return err
15273 }
15274 if val == nil {
15275 break
15276 }
15277 {
15278 xtv := string(val)
15279 sv.Statistic = types.Statistic(xtv)
15280 }
15281
15282 case strings.EqualFold("Threshold", t.Name.Local):
15283 val, err := decoder.Value()
15284 if err != nil {
15285 return err
15286 }
15287 if val == nil {
15288 break
15289 }
15290 {
15291 xtv := string(val)
15292 f64, err := strconv.ParseFloat(xtv, 64)
15293 if err != nil {
15294 return err
15295 }
15296 sv.Threshold = ptr.Float64(f64)
15297 }
15298
15299 default:
15300 // Do nothing and ignore the unexpected tag element
15301 err = decoder.Decoder.Skip()
15302 if err != nil {
15303 return err
15304 }
15305
15306 }
15307 decoder = originalDecoder
15308 }
15309 *v = sv
15310 return nil
15311 }
15312
15313 func awsRestxml_deserializeDocumentCollectionSummaries(v *[]types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
15314 if v == nil {
15315 return fmt.Errorf("unexpected nil of type %T", v)
15316 }
15317 var sv []types.CollectionSummary
15318 if *v == nil {
15319 sv = make([]types.CollectionSummary, 0)
15320 } else {
15321 sv = *v
15322 }
15323
15324 originalDecoder := decoder
15325 for {
15326 t, done, err := decoder.Token()
15327 if err != nil {
15328 return err
15329 }
15330 if done {
15331 break
15332 }
15333 switch {
15334 case strings.EqualFold("member", t.Name.Local):
15335 var col types.CollectionSummary
15336 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
15337 destAddr := &col
15338 if err := awsRestxml_deserializeDocumentCollectionSummary(&destAddr, nodeDecoder); err != nil {
15339 return err
15340 }
15341 col = *destAddr
15342 sv = append(sv, col)
15343
15344 default:
15345 err = decoder.Decoder.Skip()
15346 if err != nil {
15347 return err
15348 }
15349
15350 }
15351 decoder = originalDecoder
15352 }
15353 *v = sv
15354 return nil
15355 }
15356
15357 func awsRestxml_deserializeDocumentCollectionSummariesUnwrapped(v *[]types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
15358 var sv []types.CollectionSummary
15359 if *v == nil {
15360 sv = make([]types.CollectionSummary, 0)
15361 } else {
15362 sv = *v
15363 }
15364
15365 switch {
15366 default:
15367 var mv types.CollectionSummary
15368 t := decoder.StartEl
15369 _ = t
15370 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
15371 destAddr := &mv
15372 if err := awsRestxml_deserializeDocumentCollectionSummary(&destAddr, nodeDecoder); err != nil {
15373 return err
15374 }
15375 mv = *destAddr
15376 sv = append(sv, mv)
15377 }
15378 *v = sv
15379 return nil
15380 }
15381 func awsRestxml_deserializeDocumentCollectionSummary(v **types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
15382 if v == nil {
15383 return fmt.Errorf("unexpected nil of type %T", v)
15384 }
15385 var sv *types.CollectionSummary
15386 if *v == nil {
15387 sv = &types.CollectionSummary{}
15388 } else {
15389 sv = *v
15390 }
15391
15392 for {
15393 t, done, err := decoder.Token()
15394 if err != nil {
15395 return err
15396 }
15397 if done {
15398 break
15399 }
15400 originalDecoder := decoder
15401 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15402 switch {
15403 case strings.EqualFold("Arn", t.Name.Local):
15404 val, err := decoder.Value()
15405 if err != nil {
15406 return err
15407 }
15408 if val == nil {
15409 break
15410 }
15411 {
15412 xtv := string(val)
15413 sv.Arn = ptr.String(xtv)
15414 }
15415
15416 case strings.EqualFold("Id", t.Name.Local):
15417 val, err := decoder.Value()
15418 if err != nil {
15419 return err
15420 }
15421 if val == nil {
15422 break
15423 }
15424 {
15425 xtv := string(val)
15426 sv.Id = ptr.String(xtv)
15427 }
15428
15429 case strings.EqualFold("Name", t.Name.Local):
15430 val, err := decoder.Value()
15431 if err != nil {
15432 return err
15433 }
15434 if val == nil {
15435 break
15436 }
15437 {
15438 xtv := string(val)
15439 sv.Name = ptr.String(xtv)
15440 }
15441
15442 case strings.EqualFold("Version", t.Name.Local):
15443 val, err := decoder.Value()
15444 if err != nil {
15445 return err
15446 }
15447 if val == nil {
15448 break
15449 }
15450 {
15451 xtv := string(val)
15452 i64, err := strconv.ParseInt(xtv, 10, 64)
15453 if err != nil {
15454 return err
15455 }
15456 sv.Version = ptr.Int64(i64)
15457 }
15458
15459 default:
15460 // Do nothing and ignore the unexpected tag element
15461 err = decoder.Decoder.Skip()
15462 if err != nil {
15463 return err
15464 }
15465
15466 }
15467 decoder = originalDecoder
15468 }
15469 *v = sv
15470 return nil
15471 }
15472
15473 func awsRestxml_deserializeDocumentConcurrentModification(v **types.ConcurrentModification, decoder smithyxml.NodeDecoder) error {
15474 if v == nil {
15475 return fmt.Errorf("unexpected nil of type %T", v)
15476 }
15477 var sv *types.ConcurrentModification
15478 if *v == nil {
15479 sv = &types.ConcurrentModification{}
15480 } else {
15481 sv = *v
15482 }
15483
15484 for {
15485 t, done, err := decoder.Token()
15486 if err != nil {
15487 return err
15488 }
15489 if done {
15490 break
15491 }
15492 originalDecoder := decoder
15493 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15494 switch {
15495 case strings.EqualFold("message", t.Name.Local):
15496 val, err := decoder.Value()
15497 if err != nil {
15498 return err
15499 }
15500 if val == nil {
15501 break
15502 }
15503 {
15504 xtv := string(val)
15505 sv.Message = ptr.String(xtv)
15506 }
15507
15508 default:
15509 // Do nothing and ignore the unexpected tag element
15510 err = decoder.Decoder.Skip()
15511 if err != nil {
15512 return err
15513 }
15514
15515 }
15516 decoder = originalDecoder
15517 }
15518 *v = sv
15519 return nil
15520 }
15521
15522 func awsRestxml_deserializeDocumentConflictingDomainExists(v **types.ConflictingDomainExists, decoder smithyxml.NodeDecoder) error {
15523 if v == nil {
15524 return fmt.Errorf("unexpected nil of type %T", v)
15525 }
15526 var sv *types.ConflictingDomainExists
15527 if *v == nil {
15528 sv = &types.ConflictingDomainExists{}
15529 } else {
15530 sv = *v
15531 }
15532
15533 for {
15534 t, done, err := decoder.Token()
15535 if err != nil {
15536 return err
15537 }
15538 if done {
15539 break
15540 }
15541 originalDecoder := decoder
15542 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15543 switch {
15544 case strings.EqualFold("message", t.Name.Local):
15545 val, err := decoder.Value()
15546 if err != nil {
15547 return err
15548 }
15549 if val == nil {
15550 break
15551 }
15552 {
15553 xtv := string(val)
15554 sv.Message = ptr.String(xtv)
15555 }
15556
15557 default:
15558 // Do nothing and ignore the unexpected tag element
15559 err = decoder.Decoder.Skip()
15560 if err != nil {
15561 return err
15562 }
15563
15564 }
15565 decoder = originalDecoder
15566 }
15567 *v = sv
15568 return nil
15569 }
15570
15571 func awsRestxml_deserializeDocumentConflictingTypes(v **types.ConflictingTypes, decoder smithyxml.NodeDecoder) error {
15572 if v == nil {
15573 return fmt.Errorf("unexpected nil of type %T", v)
15574 }
15575 var sv *types.ConflictingTypes
15576 if *v == nil {
15577 sv = &types.ConflictingTypes{}
15578 } else {
15579 sv = *v
15580 }
15581
15582 for {
15583 t, done, err := decoder.Token()
15584 if err != nil {
15585 return err
15586 }
15587 if done {
15588 break
15589 }
15590 originalDecoder := decoder
15591 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15592 switch {
15593 case strings.EqualFold("message", t.Name.Local):
15594 val, err := decoder.Value()
15595 if err != nil {
15596 return err
15597 }
15598 if val == nil {
15599 break
15600 }
15601 {
15602 xtv := string(val)
15603 sv.Message = ptr.String(xtv)
15604 }
15605
15606 default:
15607 // Do nothing and ignore the unexpected tag element
15608 err = decoder.Decoder.Skip()
15609 if err != nil {
15610 return err
15611 }
15612
15613 }
15614 decoder = originalDecoder
15615 }
15616 *v = sv
15617 return nil
15618 }
15619
15620 func awsRestxml_deserializeDocumentCoordinates(v **types.Coordinates, decoder smithyxml.NodeDecoder) error {
15621 if v == nil {
15622 return fmt.Errorf("unexpected nil of type %T", v)
15623 }
15624 var sv *types.Coordinates
15625 if *v == nil {
15626 sv = &types.Coordinates{}
15627 } else {
15628 sv = *v
15629 }
15630
15631 for {
15632 t, done, err := decoder.Token()
15633 if err != nil {
15634 return err
15635 }
15636 if done {
15637 break
15638 }
15639 originalDecoder := decoder
15640 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15641 switch {
15642 case strings.EqualFold("Latitude", t.Name.Local):
15643 val, err := decoder.Value()
15644 if err != nil {
15645 return err
15646 }
15647 if val == nil {
15648 break
15649 }
15650 {
15651 xtv := string(val)
15652 sv.Latitude = ptr.String(xtv)
15653 }
15654
15655 case strings.EqualFold("Longitude", t.Name.Local):
15656 val, err := decoder.Value()
15657 if err != nil {
15658 return err
15659 }
15660 if val == nil {
15661 break
15662 }
15663 {
15664 xtv := string(val)
15665 sv.Longitude = ptr.String(xtv)
15666 }
15667
15668 default:
15669 // Do nothing and ignore the unexpected tag element
15670 err = decoder.Decoder.Skip()
15671 if err != nil {
15672 return err
15673 }
15674
15675 }
15676 decoder = originalDecoder
15677 }
15678 *v = sv
15679 return nil
15680 }
15681
15682 func awsRestxml_deserializeDocumentDelegationSet(v **types.DelegationSet, decoder smithyxml.NodeDecoder) error {
15683 if v == nil {
15684 return fmt.Errorf("unexpected nil of type %T", v)
15685 }
15686 var sv *types.DelegationSet
15687 if *v == nil {
15688 sv = &types.DelegationSet{}
15689 } else {
15690 sv = *v
15691 }
15692
15693 for {
15694 t, done, err := decoder.Token()
15695 if err != nil {
15696 return err
15697 }
15698 if done {
15699 break
15700 }
15701 originalDecoder := decoder
15702 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15703 switch {
15704 case strings.EqualFold("CallerReference", t.Name.Local):
15705 val, err := decoder.Value()
15706 if err != nil {
15707 return err
15708 }
15709 if val == nil {
15710 break
15711 }
15712 {
15713 xtv := string(val)
15714 sv.CallerReference = ptr.String(xtv)
15715 }
15716
15717 case strings.EqualFold("Id", t.Name.Local):
15718 val, err := decoder.Value()
15719 if err != nil {
15720 return err
15721 }
15722 if val == nil {
15723 break
15724 }
15725 {
15726 xtv := string(val)
15727 sv.Id = ptr.String(xtv)
15728 }
15729
15730 case strings.EqualFold("NameServers", t.Name.Local):
15731 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
15732 if err := awsRestxml_deserializeDocumentDelegationSetNameServers(&sv.NameServers, nodeDecoder); err != nil {
15733 return err
15734 }
15735
15736 default:
15737 // Do nothing and ignore the unexpected tag element
15738 err = decoder.Decoder.Skip()
15739 if err != nil {
15740 return err
15741 }
15742
15743 }
15744 decoder = originalDecoder
15745 }
15746 *v = sv
15747 return nil
15748 }
15749
15750 func awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(v **types.DelegationSetAlreadyCreated, decoder smithyxml.NodeDecoder) error {
15751 if v == nil {
15752 return fmt.Errorf("unexpected nil of type %T", v)
15753 }
15754 var sv *types.DelegationSetAlreadyCreated
15755 if *v == nil {
15756 sv = &types.DelegationSetAlreadyCreated{}
15757 } else {
15758 sv = *v
15759 }
15760
15761 for {
15762 t, done, err := decoder.Token()
15763 if err != nil {
15764 return err
15765 }
15766 if done {
15767 break
15768 }
15769 originalDecoder := decoder
15770 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15771 switch {
15772 case strings.EqualFold("message", t.Name.Local):
15773 val, err := decoder.Value()
15774 if err != nil {
15775 return err
15776 }
15777 if val == nil {
15778 break
15779 }
15780 {
15781 xtv := string(val)
15782 sv.Message = ptr.String(xtv)
15783 }
15784
15785 default:
15786 // Do nothing and ignore the unexpected tag element
15787 err = decoder.Decoder.Skip()
15788 if err != nil {
15789 return err
15790 }
15791
15792 }
15793 decoder = originalDecoder
15794 }
15795 *v = sv
15796 return nil
15797 }
15798
15799 func awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(v **types.DelegationSetAlreadyReusable, decoder smithyxml.NodeDecoder) error {
15800 if v == nil {
15801 return fmt.Errorf("unexpected nil of type %T", v)
15802 }
15803 var sv *types.DelegationSetAlreadyReusable
15804 if *v == nil {
15805 sv = &types.DelegationSetAlreadyReusable{}
15806 } else {
15807 sv = *v
15808 }
15809
15810 for {
15811 t, done, err := decoder.Token()
15812 if err != nil {
15813 return err
15814 }
15815 if done {
15816 break
15817 }
15818 originalDecoder := decoder
15819 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15820 switch {
15821 case strings.EqualFold("message", t.Name.Local):
15822 val, err := decoder.Value()
15823 if err != nil {
15824 return err
15825 }
15826 if val == nil {
15827 break
15828 }
15829 {
15830 xtv := string(val)
15831 sv.Message = ptr.String(xtv)
15832 }
15833
15834 default:
15835 // Do nothing and ignore the unexpected tag element
15836 err = decoder.Decoder.Skip()
15837 if err != nil {
15838 return err
15839 }
15840
15841 }
15842 decoder = originalDecoder
15843 }
15844 *v = sv
15845 return nil
15846 }
15847
15848 func awsRestxml_deserializeDocumentDelegationSetInUse(v **types.DelegationSetInUse, decoder smithyxml.NodeDecoder) error {
15849 if v == nil {
15850 return fmt.Errorf("unexpected nil of type %T", v)
15851 }
15852 var sv *types.DelegationSetInUse
15853 if *v == nil {
15854 sv = &types.DelegationSetInUse{}
15855 } else {
15856 sv = *v
15857 }
15858
15859 for {
15860 t, done, err := decoder.Token()
15861 if err != nil {
15862 return err
15863 }
15864 if done {
15865 break
15866 }
15867 originalDecoder := decoder
15868 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15869 switch {
15870 case strings.EqualFold("message", t.Name.Local):
15871 val, err := decoder.Value()
15872 if err != nil {
15873 return err
15874 }
15875 if val == nil {
15876 break
15877 }
15878 {
15879 xtv := string(val)
15880 sv.Message = ptr.String(xtv)
15881 }
15882
15883 default:
15884 // Do nothing and ignore the unexpected tag element
15885 err = decoder.Decoder.Skip()
15886 if err != nil {
15887 return err
15888 }
15889
15890 }
15891 decoder = originalDecoder
15892 }
15893 *v = sv
15894 return nil
15895 }
15896
15897 func awsRestxml_deserializeDocumentDelegationSetNameServers(v *[]string, decoder smithyxml.NodeDecoder) error {
15898 if v == nil {
15899 return fmt.Errorf("unexpected nil of type %T", v)
15900 }
15901 var sv []string
15902 if *v == nil {
15903 sv = make([]string, 0)
15904 } else {
15905 sv = *v
15906 }
15907
15908 originalDecoder := decoder
15909 for {
15910 t, done, err := decoder.Token()
15911 if err != nil {
15912 return err
15913 }
15914 if done {
15915 break
15916 }
15917 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
15918 decoder = memberDecoder
15919 switch {
15920 case strings.EqualFold("NameServer", t.Name.Local):
15921 var col string
15922 val, err := decoder.Value()
15923 if err != nil {
15924 return err
15925 }
15926 if val == nil {
15927 break
15928 }
15929 {
15930 xtv := string(val)
15931 col = xtv
15932 }
15933 sv = append(sv, col)
15934
15935 default:
15936 err = decoder.Decoder.Skip()
15937 if err != nil {
15938 return err
15939 }
15940
15941 }
15942 decoder = originalDecoder
15943 }
15944 *v = sv
15945 return nil
15946 }
15947
15948 func awsRestxml_deserializeDocumentDelegationSetNameServersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
15949 var sv []string
15950 if *v == nil {
15951 sv = make([]string, 0)
15952 } else {
15953 sv = *v
15954 }
15955
15956 switch {
15957 default:
15958 var mv string
15959 t := decoder.StartEl
15960 _ = t
15961 val, err := decoder.Value()
15962 if err != nil {
15963 return err
15964 }
15965 if val == nil {
15966 break
15967 }
15968 {
15969 xtv := string(val)
15970 mv = xtv
15971 }
15972 sv = append(sv, mv)
15973 }
15974 *v = sv
15975 return nil
15976 }
15977 func awsRestxml_deserializeDocumentDelegationSetNotAvailable(v **types.DelegationSetNotAvailable, decoder smithyxml.NodeDecoder) error {
15978 if v == nil {
15979 return fmt.Errorf("unexpected nil of type %T", v)
15980 }
15981 var sv *types.DelegationSetNotAvailable
15982 if *v == nil {
15983 sv = &types.DelegationSetNotAvailable{}
15984 } else {
15985 sv = *v
15986 }
15987
15988 for {
15989 t, done, err := decoder.Token()
15990 if err != nil {
15991 return err
15992 }
15993 if done {
15994 break
15995 }
15996 originalDecoder := decoder
15997 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15998 switch {
15999 case strings.EqualFold("message", t.Name.Local):
16000 val, err := decoder.Value()
16001 if err != nil {
16002 return err
16003 }
16004 if val == nil {
16005 break
16006 }
16007 {
16008 xtv := string(val)
16009 sv.Message = ptr.String(xtv)
16010 }
16011
16012 default:
16013 // Do nothing and ignore the unexpected tag element
16014 err = decoder.Decoder.Skip()
16015 if err != nil {
16016 return err
16017 }
16018
16019 }
16020 decoder = originalDecoder
16021 }
16022 *v = sv
16023 return nil
16024 }
16025
16026 func awsRestxml_deserializeDocumentDelegationSetNotReusable(v **types.DelegationSetNotReusable, decoder smithyxml.NodeDecoder) error {
16027 if v == nil {
16028 return fmt.Errorf("unexpected nil of type %T", v)
16029 }
16030 var sv *types.DelegationSetNotReusable
16031 if *v == nil {
16032 sv = &types.DelegationSetNotReusable{}
16033 } else {
16034 sv = *v
16035 }
16036
16037 for {
16038 t, done, err := decoder.Token()
16039 if err != nil {
16040 return err
16041 }
16042 if done {
16043 break
16044 }
16045 originalDecoder := decoder
16046 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16047 switch {
16048 case strings.EqualFold("message", t.Name.Local):
16049 val, err := decoder.Value()
16050 if err != nil {
16051 return err
16052 }
16053 if val == nil {
16054 break
16055 }
16056 {
16057 xtv := string(val)
16058 sv.Message = ptr.String(xtv)
16059 }
16060
16061 default:
16062 // Do nothing and ignore the unexpected tag element
16063 err = decoder.Decoder.Skip()
16064 if err != nil {
16065 return err
16066 }
16067
16068 }
16069 decoder = originalDecoder
16070 }
16071 *v = sv
16072 return nil
16073 }
16074
16075 func awsRestxml_deserializeDocumentDelegationSets(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error {
16076 if v == nil {
16077 return fmt.Errorf("unexpected nil of type %T", v)
16078 }
16079 var sv []types.DelegationSet
16080 if *v == nil {
16081 sv = make([]types.DelegationSet, 0)
16082 } else {
16083 sv = *v
16084 }
16085
16086 originalDecoder := decoder
16087 for {
16088 t, done, err := decoder.Token()
16089 if err != nil {
16090 return err
16091 }
16092 if done {
16093 break
16094 }
16095 switch {
16096 case strings.EqualFold("DelegationSet", t.Name.Local):
16097 var col types.DelegationSet
16098 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16099 destAddr := &col
16100 if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil {
16101 return err
16102 }
16103 col = *destAddr
16104 sv = append(sv, col)
16105
16106 default:
16107 err = decoder.Decoder.Skip()
16108 if err != nil {
16109 return err
16110 }
16111
16112 }
16113 decoder = originalDecoder
16114 }
16115 *v = sv
16116 return nil
16117 }
16118
16119 func awsRestxml_deserializeDocumentDelegationSetsUnwrapped(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error {
16120 var sv []types.DelegationSet
16121 if *v == nil {
16122 sv = make([]types.DelegationSet, 0)
16123 } else {
16124 sv = *v
16125 }
16126
16127 switch {
16128 default:
16129 var mv types.DelegationSet
16130 t := decoder.StartEl
16131 _ = t
16132 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16133 destAddr := &mv
16134 if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil {
16135 return err
16136 }
16137 mv = *destAddr
16138 sv = append(sv, mv)
16139 }
16140 *v = sv
16141 return nil
16142 }
16143 func awsRestxml_deserializeDocumentDimension(v **types.Dimension, decoder smithyxml.NodeDecoder) error {
16144 if v == nil {
16145 return fmt.Errorf("unexpected nil of type %T", v)
16146 }
16147 var sv *types.Dimension
16148 if *v == nil {
16149 sv = &types.Dimension{}
16150 } else {
16151 sv = *v
16152 }
16153
16154 for {
16155 t, done, err := decoder.Token()
16156 if err != nil {
16157 return err
16158 }
16159 if done {
16160 break
16161 }
16162 originalDecoder := decoder
16163 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16164 switch {
16165 case strings.EqualFold("Name", t.Name.Local):
16166 val, err := decoder.Value()
16167 if err != nil {
16168 return err
16169 }
16170 if val == nil {
16171 break
16172 }
16173 {
16174 xtv := string(val)
16175 sv.Name = ptr.String(xtv)
16176 }
16177
16178 case strings.EqualFold("Value", t.Name.Local):
16179 val, err := decoder.Value()
16180 if err != nil {
16181 return err
16182 }
16183 if val == nil {
16184 break
16185 }
16186 {
16187 xtv := string(val)
16188 sv.Value = ptr.String(xtv)
16189 }
16190
16191 default:
16192 // Do nothing and ignore the unexpected tag element
16193 err = decoder.Decoder.Skip()
16194 if err != nil {
16195 return err
16196 }
16197
16198 }
16199 decoder = originalDecoder
16200 }
16201 *v = sv
16202 return nil
16203 }
16204
16205 func awsRestxml_deserializeDocumentDimensionList(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error {
16206 if v == nil {
16207 return fmt.Errorf("unexpected nil of type %T", v)
16208 }
16209 var sv []types.Dimension
16210 if *v == nil {
16211 sv = make([]types.Dimension, 0)
16212 } else {
16213 sv = *v
16214 }
16215
16216 originalDecoder := decoder
16217 for {
16218 t, done, err := decoder.Token()
16219 if err != nil {
16220 return err
16221 }
16222 if done {
16223 break
16224 }
16225 switch {
16226 case strings.EqualFold("Dimension", t.Name.Local):
16227 var col types.Dimension
16228 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16229 destAddr := &col
16230 if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil {
16231 return err
16232 }
16233 col = *destAddr
16234 sv = append(sv, col)
16235
16236 default:
16237 err = decoder.Decoder.Skip()
16238 if err != nil {
16239 return err
16240 }
16241
16242 }
16243 decoder = originalDecoder
16244 }
16245 *v = sv
16246 return nil
16247 }
16248
16249 func awsRestxml_deserializeDocumentDimensionListUnwrapped(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error {
16250 var sv []types.Dimension
16251 if *v == nil {
16252 sv = make([]types.Dimension, 0)
16253 } else {
16254 sv = *v
16255 }
16256
16257 switch {
16258 default:
16259 var mv types.Dimension
16260 t := decoder.StartEl
16261 _ = t
16262 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16263 destAddr := &mv
16264 if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil {
16265 return err
16266 }
16267 mv = *destAddr
16268 sv = append(sv, mv)
16269 }
16270 *v = sv
16271 return nil
16272 }
16273 func awsRestxml_deserializeDocumentDNSSECNotFound(v **types.DNSSECNotFound, decoder smithyxml.NodeDecoder) error {
16274 if v == nil {
16275 return fmt.Errorf("unexpected nil of type %T", v)
16276 }
16277 var sv *types.DNSSECNotFound
16278 if *v == nil {
16279 sv = &types.DNSSECNotFound{}
16280 } else {
16281 sv = *v
16282 }
16283
16284 for {
16285 t, done, err := decoder.Token()
16286 if err != nil {
16287 return err
16288 }
16289 if done {
16290 break
16291 }
16292 originalDecoder := decoder
16293 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16294 switch {
16295 case strings.EqualFold("message", t.Name.Local):
16296 val, err := decoder.Value()
16297 if err != nil {
16298 return err
16299 }
16300 if val == nil {
16301 break
16302 }
16303 {
16304 xtv := string(val)
16305 sv.Message = ptr.String(xtv)
16306 }
16307
16308 default:
16309 // Do nothing and ignore the unexpected tag element
16310 err = decoder.Decoder.Skip()
16311 if err != nil {
16312 return err
16313 }
16314
16315 }
16316 decoder = originalDecoder
16317 }
16318 *v = sv
16319 return nil
16320 }
16321
16322 func awsRestxml_deserializeDocumentDNSSECStatus(v **types.DNSSECStatus, decoder smithyxml.NodeDecoder) error {
16323 if v == nil {
16324 return fmt.Errorf("unexpected nil of type %T", v)
16325 }
16326 var sv *types.DNSSECStatus
16327 if *v == nil {
16328 sv = &types.DNSSECStatus{}
16329 } else {
16330 sv = *v
16331 }
16332
16333 for {
16334 t, done, err := decoder.Token()
16335 if err != nil {
16336 return err
16337 }
16338 if done {
16339 break
16340 }
16341 originalDecoder := decoder
16342 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16343 switch {
16344 case strings.EqualFold("ServeSignature", t.Name.Local):
16345 val, err := decoder.Value()
16346 if err != nil {
16347 return err
16348 }
16349 if val == nil {
16350 break
16351 }
16352 {
16353 xtv := string(val)
16354 sv.ServeSignature = ptr.String(xtv)
16355 }
16356
16357 case strings.EqualFold("StatusMessage", t.Name.Local):
16358 val, err := decoder.Value()
16359 if err != nil {
16360 return err
16361 }
16362 if val == nil {
16363 break
16364 }
16365 {
16366 xtv := string(val)
16367 sv.StatusMessage = ptr.String(xtv)
16368 }
16369
16370 default:
16371 // Do nothing and ignore the unexpected tag element
16372 err = decoder.Decoder.Skip()
16373 if err != nil {
16374 return err
16375 }
16376
16377 }
16378 decoder = originalDecoder
16379 }
16380 *v = sv
16381 return nil
16382 }
16383
16384 func awsRestxml_deserializeDocumentErrorMessages(v *[]string, decoder smithyxml.NodeDecoder) error {
16385 if v == nil {
16386 return fmt.Errorf("unexpected nil of type %T", v)
16387 }
16388 var sv []string
16389 if *v == nil {
16390 sv = make([]string, 0)
16391 } else {
16392 sv = *v
16393 }
16394
16395 originalDecoder := decoder
16396 for {
16397 t, done, err := decoder.Token()
16398 if err != nil {
16399 return err
16400 }
16401 if done {
16402 break
16403 }
16404 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16405 decoder = memberDecoder
16406 switch {
16407 case strings.EqualFold("Message", t.Name.Local):
16408 var col string
16409 val, err := decoder.Value()
16410 if err != nil {
16411 return err
16412 }
16413 if val == nil {
16414 break
16415 }
16416 {
16417 xtv := string(val)
16418 col = xtv
16419 }
16420 sv = append(sv, col)
16421
16422 default:
16423 err = decoder.Decoder.Skip()
16424 if err != nil {
16425 return err
16426 }
16427
16428 }
16429 decoder = originalDecoder
16430 }
16431 *v = sv
16432 return nil
16433 }
16434
16435 func awsRestxml_deserializeDocumentErrorMessagesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
16436 var sv []string
16437 if *v == nil {
16438 sv = make([]string, 0)
16439 } else {
16440 sv = *v
16441 }
16442
16443 switch {
16444 default:
16445 var mv string
16446 t := decoder.StartEl
16447 _ = t
16448 val, err := decoder.Value()
16449 if err != nil {
16450 return err
16451 }
16452 if val == nil {
16453 break
16454 }
16455 {
16456 xtv := string(val)
16457 mv = xtv
16458 }
16459 sv = append(sv, mv)
16460 }
16461 *v = sv
16462 return nil
16463 }
16464 func awsRestxml_deserializeDocumentGeoLocation(v **types.GeoLocation, decoder smithyxml.NodeDecoder) error {
16465 if v == nil {
16466 return fmt.Errorf("unexpected nil of type %T", v)
16467 }
16468 var sv *types.GeoLocation
16469 if *v == nil {
16470 sv = &types.GeoLocation{}
16471 } else {
16472 sv = *v
16473 }
16474
16475 for {
16476 t, done, err := decoder.Token()
16477 if err != nil {
16478 return err
16479 }
16480 if done {
16481 break
16482 }
16483 originalDecoder := decoder
16484 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16485 switch {
16486 case strings.EqualFold("ContinentCode", t.Name.Local):
16487 val, err := decoder.Value()
16488 if err != nil {
16489 return err
16490 }
16491 if val == nil {
16492 break
16493 }
16494 {
16495 xtv := string(val)
16496 sv.ContinentCode = ptr.String(xtv)
16497 }
16498
16499 case strings.EqualFold("CountryCode", t.Name.Local):
16500 val, err := decoder.Value()
16501 if err != nil {
16502 return err
16503 }
16504 if val == nil {
16505 break
16506 }
16507 {
16508 xtv := string(val)
16509 sv.CountryCode = ptr.String(xtv)
16510 }
16511
16512 case strings.EqualFold("SubdivisionCode", t.Name.Local):
16513 val, err := decoder.Value()
16514 if err != nil {
16515 return err
16516 }
16517 if val == nil {
16518 break
16519 }
16520 {
16521 xtv := string(val)
16522 sv.SubdivisionCode = ptr.String(xtv)
16523 }
16524
16525 default:
16526 // Do nothing and ignore the unexpected tag element
16527 err = decoder.Decoder.Skip()
16528 if err != nil {
16529 return err
16530 }
16531
16532 }
16533 decoder = originalDecoder
16534 }
16535 *v = sv
16536 return nil
16537 }
16538
16539 func awsRestxml_deserializeDocumentGeoLocationDetails(v **types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
16540 if v == nil {
16541 return fmt.Errorf("unexpected nil of type %T", v)
16542 }
16543 var sv *types.GeoLocationDetails
16544 if *v == nil {
16545 sv = &types.GeoLocationDetails{}
16546 } else {
16547 sv = *v
16548 }
16549
16550 for {
16551 t, done, err := decoder.Token()
16552 if err != nil {
16553 return err
16554 }
16555 if done {
16556 break
16557 }
16558 originalDecoder := decoder
16559 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16560 switch {
16561 case strings.EqualFold("ContinentCode", t.Name.Local):
16562 val, err := decoder.Value()
16563 if err != nil {
16564 return err
16565 }
16566 if val == nil {
16567 break
16568 }
16569 {
16570 xtv := string(val)
16571 sv.ContinentCode = ptr.String(xtv)
16572 }
16573
16574 case strings.EqualFold("ContinentName", t.Name.Local):
16575 val, err := decoder.Value()
16576 if err != nil {
16577 return err
16578 }
16579 if val == nil {
16580 break
16581 }
16582 {
16583 xtv := string(val)
16584 sv.ContinentName = ptr.String(xtv)
16585 }
16586
16587 case strings.EqualFold("CountryCode", t.Name.Local):
16588 val, err := decoder.Value()
16589 if err != nil {
16590 return err
16591 }
16592 if val == nil {
16593 break
16594 }
16595 {
16596 xtv := string(val)
16597 sv.CountryCode = ptr.String(xtv)
16598 }
16599
16600 case strings.EqualFold("CountryName", t.Name.Local):
16601 val, err := decoder.Value()
16602 if err != nil {
16603 return err
16604 }
16605 if val == nil {
16606 break
16607 }
16608 {
16609 xtv := string(val)
16610 sv.CountryName = ptr.String(xtv)
16611 }
16612
16613 case strings.EqualFold("SubdivisionCode", t.Name.Local):
16614 val, err := decoder.Value()
16615 if err != nil {
16616 return err
16617 }
16618 if val == nil {
16619 break
16620 }
16621 {
16622 xtv := string(val)
16623 sv.SubdivisionCode = ptr.String(xtv)
16624 }
16625
16626 case strings.EqualFold("SubdivisionName", t.Name.Local):
16627 val, err := decoder.Value()
16628 if err != nil {
16629 return err
16630 }
16631 if val == nil {
16632 break
16633 }
16634 {
16635 xtv := string(val)
16636 sv.SubdivisionName = ptr.String(xtv)
16637 }
16638
16639 default:
16640 // Do nothing and ignore the unexpected tag element
16641 err = decoder.Decoder.Skip()
16642 if err != nil {
16643 return err
16644 }
16645
16646 }
16647 decoder = originalDecoder
16648 }
16649 *v = sv
16650 return nil
16651 }
16652
16653 func awsRestxml_deserializeDocumentGeoLocationDetailsList(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
16654 if v == nil {
16655 return fmt.Errorf("unexpected nil of type %T", v)
16656 }
16657 var sv []types.GeoLocationDetails
16658 if *v == nil {
16659 sv = make([]types.GeoLocationDetails, 0)
16660 } else {
16661 sv = *v
16662 }
16663
16664 originalDecoder := decoder
16665 for {
16666 t, done, err := decoder.Token()
16667 if err != nil {
16668 return err
16669 }
16670 if done {
16671 break
16672 }
16673 switch {
16674 case strings.EqualFold("GeoLocationDetails", t.Name.Local):
16675 var col types.GeoLocationDetails
16676 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16677 destAddr := &col
16678 if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil {
16679 return err
16680 }
16681 col = *destAddr
16682 sv = append(sv, col)
16683
16684 default:
16685 err = decoder.Decoder.Skip()
16686 if err != nil {
16687 return err
16688 }
16689
16690 }
16691 decoder = originalDecoder
16692 }
16693 *v = sv
16694 return nil
16695 }
16696
16697 func awsRestxml_deserializeDocumentGeoLocationDetailsListUnwrapped(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
16698 var sv []types.GeoLocationDetails
16699 if *v == nil {
16700 sv = make([]types.GeoLocationDetails, 0)
16701 } else {
16702 sv = *v
16703 }
16704
16705 switch {
16706 default:
16707 var mv types.GeoLocationDetails
16708 t := decoder.StartEl
16709 _ = t
16710 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16711 destAddr := &mv
16712 if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil {
16713 return err
16714 }
16715 mv = *destAddr
16716 sv = append(sv, mv)
16717 }
16718 *v = sv
16719 return nil
16720 }
16721 func awsRestxml_deserializeDocumentGeoProximityLocation(v **types.GeoProximityLocation, decoder smithyxml.NodeDecoder) error {
16722 if v == nil {
16723 return fmt.Errorf("unexpected nil of type %T", v)
16724 }
16725 var sv *types.GeoProximityLocation
16726 if *v == nil {
16727 sv = &types.GeoProximityLocation{}
16728 } else {
16729 sv = *v
16730 }
16731
16732 for {
16733 t, done, err := decoder.Token()
16734 if err != nil {
16735 return err
16736 }
16737 if done {
16738 break
16739 }
16740 originalDecoder := decoder
16741 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16742 switch {
16743 case strings.EqualFold("AWSRegion", t.Name.Local):
16744 val, err := decoder.Value()
16745 if err != nil {
16746 return err
16747 }
16748 if val == nil {
16749 break
16750 }
16751 {
16752 xtv := string(val)
16753 sv.AWSRegion = ptr.String(xtv)
16754 }
16755
16756 case strings.EqualFold("Bias", t.Name.Local):
16757 val, err := decoder.Value()
16758 if err != nil {
16759 return err
16760 }
16761 if val == nil {
16762 break
16763 }
16764 {
16765 xtv := string(val)
16766 i64, err := strconv.ParseInt(xtv, 10, 64)
16767 if err != nil {
16768 return err
16769 }
16770 sv.Bias = ptr.Int32(int32(i64))
16771 }
16772
16773 case strings.EqualFold("Coordinates", t.Name.Local):
16774 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16775 if err := awsRestxml_deserializeDocumentCoordinates(&sv.Coordinates, nodeDecoder); err != nil {
16776 return err
16777 }
16778
16779 case strings.EqualFold("LocalZoneGroup", t.Name.Local):
16780 val, err := decoder.Value()
16781 if err != nil {
16782 return err
16783 }
16784 if val == nil {
16785 break
16786 }
16787 {
16788 xtv := string(val)
16789 sv.LocalZoneGroup = ptr.String(xtv)
16790 }
16791
16792 default:
16793 // Do nothing and ignore the unexpected tag element
16794 err = decoder.Decoder.Skip()
16795 if err != nil {
16796 return err
16797 }
16798
16799 }
16800 decoder = originalDecoder
16801 }
16802 *v = sv
16803 return nil
16804 }
16805
16806 func awsRestxml_deserializeDocumentHealthCheck(v **types.HealthCheck, decoder smithyxml.NodeDecoder) error {
16807 if v == nil {
16808 return fmt.Errorf("unexpected nil of type %T", v)
16809 }
16810 var sv *types.HealthCheck
16811 if *v == nil {
16812 sv = &types.HealthCheck{}
16813 } else {
16814 sv = *v
16815 }
16816
16817 for {
16818 t, done, err := decoder.Token()
16819 if err != nil {
16820 return err
16821 }
16822 if done {
16823 break
16824 }
16825 originalDecoder := decoder
16826 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16827 switch {
16828 case strings.EqualFold("CallerReference", t.Name.Local):
16829 val, err := decoder.Value()
16830 if err != nil {
16831 return err
16832 }
16833 if val == nil {
16834 break
16835 }
16836 {
16837 xtv := string(val)
16838 sv.CallerReference = ptr.String(xtv)
16839 }
16840
16841 case strings.EqualFold("CloudWatchAlarmConfiguration", t.Name.Local):
16842 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16843 if err := awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(&sv.CloudWatchAlarmConfiguration, nodeDecoder); err != nil {
16844 return err
16845 }
16846
16847 case strings.EqualFold("HealthCheckConfig", t.Name.Local):
16848 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16849 if err := awsRestxml_deserializeDocumentHealthCheckConfig(&sv.HealthCheckConfig, nodeDecoder); err != nil {
16850 return err
16851 }
16852
16853 case strings.EqualFold("HealthCheckVersion", t.Name.Local):
16854 val, err := decoder.Value()
16855 if err != nil {
16856 return err
16857 }
16858 if val == nil {
16859 break
16860 }
16861 {
16862 xtv := string(val)
16863 i64, err := strconv.ParseInt(xtv, 10, 64)
16864 if err != nil {
16865 return err
16866 }
16867 sv.HealthCheckVersion = ptr.Int64(i64)
16868 }
16869
16870 case strings.EqualFold("Id", 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.Id = ptr.String(xtv)
16881 }
16882
16883 case strings.EqualFold("LinkedService", t.Name.Local):
16884 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16885 if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil {
16886 return err
16887 }
16888
16889 default:
16890 // Do nothing and ignore the unexpected tag element
16891 err = decoder.Decoder.Skip()
16892 if err != nil {
16893 return err
16894 }
16895
16896 }
16897 decoder = originalDecoder
16898 }
16899 *v = sv
16900 return nil
16901 }
16902
16903 func awsRestxml_deserializeDocumentHealthCheckAlreadyExists(v **types.HealthCheckAlreadyExists, decoder smithyxml.NodeDecoder) error {
16904 if v == nil {
16905 return fmt.Errorf("unexpected nil of type %T", v)
16906 }
16907 var sv *types.HealthCheckAlreadyExists
16908 if *v == nil {
16909 sv = &types.HealthCheckAlreadyExists{}
16910 } else {
16911 sv = *v
16912 }
16913
16914 for {
16915 t, done, err := decoder.Token()
16916 if err != nil {
16917 return err
16918 }
16919 if done {
16920 break
16921 }
16922 originalDecoder := decoder
16923 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16924 switch {
16925 case strings.EqualFold("message", t.Name.Local):
16926 val, err := decoder.Value()
16927 if err != nil {
16928 return err
16929 }
16930 if val == nil {
16931 break
16932 }
16933 {
16934 xtv := string(val)
16935 sv.Message = ptr.String(xtv)
16936 }
16937
16938 default:
16939 // Do nothing and ignore the unexpected tag element
16940 err = decoder.Decoder.Skip()
16941 if err != nil {
16942 return err
16943 }
16944
16945 }
16946 decoder = originalDecoder
16947 }
16948 *v = sv
16949 return nil
16950 }
16951
16952 func awsRestxml_deserializeDocumentHealthCheckConfig(v **types.HealthCheckConfig, decoder smithyxml.NodeDecoder) error {
16953 if v == nil {
16954 return fmt.Errorf("unexpected nil of type %T", v)
16955 }
16956 var sv *types.HealthCheckConfig
16957 if *v == nil {
16958 sv = &types.HealthCheckConfig{}
16959 } else {
16960 sv = *v
16961 }
16962
16963 for {
16964 t, done, err := decoder.Token()
16965 if err != nil {
16966 return err
16967 }
16968 if done {
16969 break
16970 }
16971 originalDecoder := decoder
16972 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16973 switch {
16974 case strings.EqualFold("AlarmIdentifier", t.Name.Local):
16975 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16976 if err := awsRestxml_deserializeDocumentAlarmIdentifier(&sv.AlarmIdentifier, nodeDecoder); err != nil {
16977 return err
16978 }
16979
16980 case strings.EqualFold("ChildHealthChecks", t.Name.Local):
16981 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16982 if err := awsRestxml_deserializeDocumentChildHealthCheckList(&sv.ChildHealthChecks, nodeDecoder); err != nil {
16983 return err
16984 }
16985
16986 case strings.EqualFold("Disabled", t.Name.Local):
16987 val, err := decoder.Value()
16988 if err != nil {
16989 return err
16990 }
16991 if val == nil {
16992 break
16993 }
16994 {
16995 xtv, err := strconv.ParseBool(string(val))
16996 if err != nil {
16997 return fmt.Errorf("expected Disabled to be of type *bool, got %T instead", val)
16998 }
16999 sv.Disabled = ptr.Bool(xtv)
17000 }
17001
17002 case strings.EqualFold("EnableSNI", t.Name.Local):
17003 val, err := decoder.Value()
17004 if err != nil {
17005 return err
17006 }
17007 if val == nil {
17008 break
17009 }
17010 {
17011 xtv, err := strconv.ParseBool(string(val))
17012 if err != nil {
17013 return fmt.Errorf("expected EnableSNI to be of type *bool, got %T instead", val)
17014 }
17015 sv.EnableSNI = ptr.Bool(xtv)
17016 }
17017
17018 case strings.EqualFold("FailureThreshold", t.Name.Local):
17019 val, err := decoder.Value()
17020 if err != nil {
17021 return err
17022 }
17023 if val == nil {
17024 break
17025 }
17026 {
17027 xtv := string(val)
17028 i64, err := strconv.ParseInt(xtv, 10, 64)
17029 if err != nil {
17030 return err
17031 }
17032 sv.FailureThreshold = ptr.Int32(int32(i64))
17033 }
17034
17035 case strings.EqualFold("FullyQualifiedDomainName", t.Name.Local):
17036 val, err := decoder.Value()
17037 if err != nil {
17038 return err
17039 }
17040 if val == nil {
17041 break
17042 }
17043 {
17044 xtv := string(val)
17045 sv.FullyQualifiedDomainName = ptr.String(xtv)
17046 }
17047
17048 case strings.EqualFold("HealthThreshold", t.Name.Local):
17049 val, err := decoder.Value()
17050 if err != nil {
17051 return err
17052 }
17053 if val == nil {
17054 break
17055 }
17056 {
17057 xtv := string(val)
17058 i64, err := strconv.ParseInt(xtv, 10, 64)
17059 if err != nil {
17060 return err
17061 }
17062 sv.HealthThreshold = ptr.Int32(int32(i64))
17063 }
17064
17065 case strings.EqualFold("InsufficientDataHealthStatus", t.Name.Local):
17066 val, err := decoder.Value()
17067 if err != nil {
17068 return err
17069 }
17070 if val == nil {
17071 break
17072 }
17073 {
17074 xtv := string(val)
17075 sv.InsufficientDataHealthStatus = types.InsufficientDataHealthStatus(xtv)
17076 }
17077
17078 case strings.EqualFold("Inverted", t.Name.Local):
17079 val, err := decoder.Value()
17080 if err != nil {
17081 return err
17082 }
17083 if val == nil {
17084 break
17085 }
17086 {
17087 xtv, err := strconv.ParseBool(string(val))
17088 if err != nil {
17089 return fmt.Errorf("expected Inverted to be of type *bool, got %T instead", val)
17090 }
17091 sv.Inverted = ptr.Bool(xtv)
17092 }
17093
17094 case strings.EqualFold("IPAddress", t.Name.Local):
17095 val, err := decoder.Value()
17096 if err != nil {
17097 return err
17098 }
17099 if val == nil {
17100 break
17101 }
17102 {
17103 xtv := string(val)
17104 sv.IPAddress = ptr.String(xtv)
17105 }
17106
17107 case strings.EqualFold("MeasureLatency", t.Name.Local):
17108 val, err := decoder.Value()
17109 if err != nil {
17110 return err
17111 }
17112 if val == nil {
17113 break
17114 }
17115 {
17116 xtv, err := strconv.ParseBool(string(val))
17117 if err != nil {
17118 return fmt.Errorf("expected MeasureLatency to be of type *bool, got %T instead", val)
17119 }
17120 sv.MeasureLatency = ptr.Bool(xtv)
17121 }
17122
17123 case strings.EqualFold("Port", t.Name.Local):
17124 val, err := decoder.Value()
17125 if err != nil {
17126 return err
17127 }
17128 if val == nil {
17129 break
17130 }
17131 {
17132 xtv := string(val)
17133 i64, err := strconv.ParseInt(xtv, 10, 64)
17134 if err != nil {
17135 return err
17136 }
17137 sv.Port = ptr.Int32(int32(i64))
17138 }
17139
17140 case strings.EqualFold("Regions", t.Name.Local):
17141 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17142 if err := awsRestxml_deserializeDocumentHealthCheckRegionList(&sv.Regions, nodeDecoder); err != nil {
17143 return err
17144 }
17145
17146 case strings.EqualFold("RequestInterval", t.Name.Local):
17147 val, err := decoder.Value()
17148 if err != nil {
17149 return err
17150 }
17151 if val == nil {
17152 break
17153 }
17154 {
17155 xtv := string(val)
17156 i64, err := strconv.ParseInt(xtv, 10, 64)
17157 if err != nil {
17158 return err
17159 }
17160 sv.RequestInterval = ptr.Int32(int32(i64))
17161 }
17162
17163 case strings.EqualFold("ResourcePath", t.Name.Local):
17164 val, err := decoder.Value()
17165 if err != nil {
17166 return err
17167 }
17168 if val == nil {
17169 break
17170 }
17171 {
17172 xtv := string(val)
17173 sv.ResourcePath = ptr.String(xtv)
17174 }
17175
17176 case strings.EqualFold("RoutingControlArn", t.Name.Local):
17177 val, err := decoder.Value()
17178 if err != nil {
17179 return err
17180 }
17181 if val == nil {
17182 break
17183 }
17184 {
17185 xtv := string(val)
17186 sv.RoutingControlArn = ptr.String(xtv)
17187 }
17188
17189 case strings.EqualFold("SearchString", t.Name.Local):
17190 val, err := decoder.Value()
17191 if err != nil {
17192 return err
17193 }
17194 if val == nil {
17195 break
17196 }
17197 {
17198 xtv := string(val)
17199 sv.SearchString = ptr.String(xtv)
17200 }
17201
17202 case strings.EqualFold("Type", t.Name.Local):
17203 val, err := decoder.Value()
17204 if err != nil {
17205 return err
17206 }
17207 if val == nil {
17208 break
17209 }
17210 {
17211 xtv := string(val)
17212 sv.Type = types.HealthCheckType(xtv)
17213 }
17214
17215 default:
17216 // Do nothing and ignore the unexpected tag element
17217 err = decoder.Decoder.Skip()
17218 if err != nil {
17219 return err
17220 }
17221
17222 }
17223 decoder = originalDecoder
17224 }
17225 *v = sv
17226 return nil
17227 }
17228
17229 func awsRestxml_deserializeDocumentHealthCheckInUse(v **types.HealthCheckInUse, decoder smithyxml.NodeDecoder) error {
17230 if v == nil {
17231 return fmt.Errorf("unexpected nil of type %T", v)
17232 }
17233 var sv *types.HealthCheckInUse
17234 if *v == nil {
17235 sv = &types.HealthCheckInUse{}
17236 } else {
17237 sv = *v
17238 }
17239
17240 for {
17241 t, done, err := decoder.Token()
17242 if err != nil {
17243 return err
17244 }
17245 if done {
17246 break
17247 }
17248 originalDecoder := decoder
17249 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17250 switch {
17251 case strings.EqualFold("message", t.Name.Local):
17252 val, err := decoder.Value()
17253 if err != nil {
17254 return err
17255 }
17256 if val == nil {
17257 break
17258 }
17259 {
17260 xtv := string(val)
17261 sv.Message = ptr.String(xtv)
17262 }
17263
17264 default:
17265 // Do nothing and ignore the unexpected tag element
17266 err = decoder.Decoder.Skip()
17267 if err != nil {
17268 return err
17269 }
17270
17271 }
17272 decoder = originalDecoder
17273 }
17274 *v = sv
17275 return nil
17276 }
17277
17278 func awsRestxml_deserializeDocumentHealthCheckObservation(v **types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
17279 if v == nil {
17280 return fmt.Errorf("unexpected nil of type %T", v)
17281 }
17282 var sv *types.HealthCheckObservation
17283 if *v == nil {
17284 sv = &types.HealthCheckObservation{}
17285 } else {
17286 sv = *v
17287 }
17288
17289 for {
17290 t, done, err := decoder.Token()
17291 if err != nil {
17292 return err
17293 }
17294 if done {
17295 break
17296 }
17297 originalDecoder := decoder
17298 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17299 switch {
17300 case strings.EqualFold("IPAddress", t.Name.Local):
17301 val, err := decoder.Value()
17302 if err != nil {
17303 return err
17304 }
17305 if val == nil {
17306 break
17307 }
17308 {
17309 xtv := string(val)
17310 sv.IPAddress = ptr.String(xtv)
17311 }
17312
17313 case strings.EqualFold("Region", t.Name.Local):
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 sv.Region = types.HealthCheckRegion(xtv)
17324 }
17325
17326 case strings.EqualFold("StatusReport", t.Name.Local):
17327 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17328 if err := awsRestxml_deserializeDocumentStatusReport(&sv.StatusReport, nodeDecoder); err != nil {
17329 return err
17330 }
17331
17332 default:
17333 // Do nothing and ignore the unexpected tag element
17334 err = decoder.Decoder.Skip()
17335 if err != nil {
17336 return err
17337 }
17338
17339 }
17340 decoder = originalDecoder
17341 }
17342 *v = sv
17343 return nil
17344 }
17345
17346 func awsRestxml_deserializeDocumentHealthCheckObservations(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
17347 if v == nil {
17348 return fmt.Errorf("unexpected nil of type %T", v)
17349 }
17350 var sv []types.HealthCheckObservation
17351 if *v == nil {
17352 sv = make([]types.HealthCheckObservation, 0)
17353 } else {
17354 sv = *v
17355 }
17356
17357 originalDecoder := decoder
17358 for {
17359 t, done, err := decoder.Token()
17360 if err != nil {
17361 return err
17362 }
17363 if done {
17364 break
17365 }
17366 switch {
17367 case strings.EqualFold("HealthCheckObservation", t.Name.Local):
17368 var col types.HealthCheckObservation
17369 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17370 destAddr := &col
17371 if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil {
17372 return err
17373 }
17374 col = *destAddr
17375 sv = append(sv, col)
17376
17377 default:
17378 err = decoder.Decoder.Skip()
17379 if err != nil {
17380 return err
17381 }
17382
17383 }
17384 decoder = originalDecoder
17385 }
17386 *v = sv
17387 return nil
17388 }
17389
17390 func awsRestxml_deserializeDocumentHealthCheckObservationsUnwrapped(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
17391 var sv []types.HealthCheckObservation
17392 if *v == nil {
17393 sv = make([]types.HealthCheckObservation, 0)
17394 } else {
17395 sv = *v
17396 }
17397
17398 switch {
17399 default:
17400 var mv types.HealthCheckObservation
17401 t := decoder.StartEl
17402 _ = t
17403 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17404 destAddr := &mv
17405 if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil {
17406 return err
17407 }
17408 mv = *destAddr
17409 sv = append(sv, mv)
17410 }
17411 *v = sv
17412 return nil
17413 }
17414 func awsRestxml_deserializeDocumentHealthCheckRegionList(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error {
17415 if v == nil {
17416 return fmt.Errorf("unexpected nil of type %T", v)
17417 }
17418 var sv []types.HealthCheckRegion
17419 if *v == nil {
17420 sv = make([]types.HealthCheckRegion, 0)
17421 } else {
17422 sv = *v
17423 }
17424
17425 originalDecoder := decoder
17426 for {
17427 t, done, err := decoder.Token()
17428 if err != nil {
17429 return err
17430 }
17431 if done {
17432 break
17433 }
17434 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17435 decoder = memberDecoder
17436 switch {
17437 case strings.EqualFold("Region", t.Name.Local):
17438 var col types.HealthCheckRegion
17439 val, err := decoder.Value()
17440 if err != nil {
17441 return err
17442 }
17443 if val == nil {
17444 break
17445 }
17446 {
17447 xtv := string(val)
17448 col = types.HealthCheckRegion(xtv)
17449 }
17450 sv = append(sv, col)
17451
17452 default:
17453 err = decoder.Decoder.Skip()
17454 if err != nil {
17455 return err
17456 }
17457
17458 }
17459 decoder = originalDecoder
17460 }
17461 *v = sv
17462 return nil
17463 }
17464
17465 func awsRestxml_deserializeDocumentHealthCheckRegionListUnwrapped(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error {
17466 var sv []types.HealthCheckRegion
17467 if *v == nil {
17468 sv = make([]types.HealthCheckRegion, 0)
17469 } else {
17470 sv = *v
17471 }
17472
17473 switch {
17474 default:
17475 var mv types.HealthCheckRegion
17476 t := decoder.StartEl
17477 _ = t
17478 val, err := decoder.Value()
17479 if err != nil {
17480 return err
17481 }
17482 if val == nil {
17483 break
17484 }
17485 {
17486 xtv := string(val)
17487 mv = types.HealthCheckRegion(xtv)
17488 }
17489 sv = append(sv, mv)
17490 }
17491 *v = sv
17492 return nil
17493 }
17494 func awsRestxml_deserializeDocumentHealthChecks(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error {
17495 if v == nil {
17496 return fmt.Errorf("unexpected nil of type %T", v)
17497 }
17498 var sv []types.HealthCheck
17499 if *v == nil {
17500 sv = make([]types.HealthCheck, 0)
17501 } else {
17502 sv = *v
17503 }
17504
17505 originalDecoder := decoder
17506 for {
17507 t, done, err := decoder.Token()
17508 if err != nil {
17509 return err
17510 }
17511 if done {
17512 break
17513 }
17514 switch {
17515 case strings.EqualFold("HealthCheck", t.Name.Local):
17516 var col types.HealthCheck
17517 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17518 destAddr := &col
17519 if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil {
17520 return err
17521 }
17522 col = *destAddr
17523 sv = append(sv, col)
17524
17525 default:
17526 err = decoder.Decoder.Skip()
17527 if err != nil {
17528 return err
17529 }
17530
17531 }
17532 decoder = originalDecoder
17533 }
17534 *v = sv
17535 return nil
17536 }
17537
17538 func awsRestxml_deserializeDocumentHealthChecksUnwrapped(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error {
17539 var sv []types.HealthCheck
17540 if *v == nil {
17541 sv = make([]types.HealthCheck, 0)
17542 } else {
17543 sv = *v
17544 }
17545
17546 switch {
17547 default:
17548 var mv types.HealthCheck
17549 t := decoder.StartEl
17550 _ = t
17551 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17552 destAddr := &mv
17553 if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil {
17554 return err
17555 }
17556 mv = *destAddr
17557 sv = append(sv, mv)
17558 }
17559 *v = sv
17560 return nil
17561 }
17562 func awsRestxml_deserializeDocumentHealthCheckVersionMismatch(v **types.HealthCheckVersionMismatch, decoder smithyxml.NodeDecoder) error {
17563 if v == nil {
17564 return fmt.Errorf("unexpected nil of type %T", v)
17565 }
17566 var sv *types.HealthCheckVersionMismatch
17567 if *v == nil {
17568 sv = &types.HealthCheckVersionMismatch{}
17569 } else {
17570 sv = *v
17571 }
17572
17573 for {
17574 t, done, err := decoder.Token()
17575 if err != nil {
17576 return err
17577 }
17578 if done {
17579 break
17580 }
17581 originalDecoder := decoder
17582 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17583 switch {
17584 case strings.EqualFold("message", t.Name.Local):
17585 val, err := decoder.Value()
17586 if err != nil {
17587 return err
17588 }
17589 if val == nil {
17590 break
17591 }
17592 {
17593 xtv := string(val)
17594 sv.Message = ptr.String(xtv)
17595 }
17596
17597 default:
17598 // Do nothing and ignore the unexpected tag element
17599 err = decoder.Decoder.Skip()
17600 if err != nil {
17601 return err
17602 }
17603
17604 }
17605 decoder = originalDecoder
17606 }
17607 *v = sv
17608 return nil
17609 }
17610
17611 func awsRestxml_deserializeDocumentHostedZone(v **types.HostedZone, decoder smithyxml.NodeDecoder) error {
17612 if v == nil {
17613 return fmt.Errorf("unexpected nil of type %T", v)
17614 }
17615 var sv *types.HostedZone
17616 if *v == nil {
17617 sv = &types.HostedZone{}
17618 } else {
17619 sv = *v
17620 }
17621
17622 for {
17623 t, done, err := decoder.Token()
17624 if err != nil {
17625 return err
17626 }
17627 if done {
17628 break
17629 }
17630 originalDecoder := decoder
17631 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17632 switch {
17633 case strings.EqualFold("CallerReference", t.Name.Local):
17634 val, err := decoder.Value()
17635 if err != nil {
17636 return err
17637 }
17638 if val == nil {
17639 break
17640 }
17641 {
17642 xtv := string(val)
17643 sv.CallerReference = ptr.String(xtv)
17644 }
17645
17646 case strings.EqualFold("Config", t.Name.Local):
17647 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17648 if err := awsRestxml_deserializeDocumentHostedZoneConfig(&sv.Config, nodeDecoder); err != nil {
17649 return err
17650 }
17651
17652 case strings.EqualFold("Features", t.Name.Local):
17653 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17654 if err := awsRestxml_deserializeDocumentHostedZoneFeatures(&sv.Features, nodeDecoder); err != nil {
17655 return err
17656 }
17657
17658 case strings.EqualFold("Id", t.Name.Local):
17659 val, err := decoder.Value()
17660 if err != nil {
17661 return err
17662 }
17663 if val == nil {
17664 break
17665 }
17666 {
17667 xtv := string(val)
17668 sv.Id = ptr.String(xtv)
17669 }
17670
17671 case strings.EqualFold("LinkedService", t.Name.Local):
17672 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17673 if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil {
17674 return err
17675 }
17676
17677 case strings.EqualFold("Name", t.Name.Local):
17678 val, err := decoder.Value()
17679 if err != nil {
17680 return err
17681 }
17682 if val == nil {
17683 break
17684 }
17685 {
17686 xtv := string(val)
17687 sv.Name = ptr.String(xtv)
17688 }
17689
17690 case strings.EqualFold("ResourceRecordSetCount", t.Name.Local):
17691 val, err := decoder.Value()
17692 if err != nil {
17693 return err
17694 }
17695 if val == nil {
17696 break
17697 }
17698 {
17699 xtv := string(val)
17700 i64, err := strconv.ParseInt(xtv, 10, 64)
17701 if err != nil {
17702 return err
17703 }
17704 sv.ResourceRecordSetCount = ptr.Int64(i64)
17705 }
17706
17707 default:
17708 // Do nothing and ignore the unexpected tag element
17709 err = decoder.Decoder.Skip()
17710 if err != nil {
17711 return err
17712 }
17713
17714 }
17715 decoder = originalDecoder
17716 }
17717 *v = sv
17718 return nil
17719 }
17720
17721 func awsRestxml_deserializeDocumentHostedZoneAlreadyExists(v **types.HostedZoneAlreadyExists, decoder smithyxml.NodeDecoder) error {
17722 if v == nil {
17723 return fmt.Errorf("unexpected nil of type %T", v)
17724 }
17725 var sv *types.HostedZoneAlreadyExists
17726 if *v == nil {
17727 sv = &types.HostedZoneAlreadyExists{}
17728 } else {
17729 sv = *v
17730 }
17731
17732 for {
17733 t, done, err := decoder.Token()
17734 if err != nil {
17735 return err
17736 }
17737 if done {
17738 break
17739 }
17740 originalDecoder := decoder
17741 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17742 switch {
17743 case strings.EqualFold("message", t.Name.Local):
17744 val, err := decoder.Value()
17745 if err != nil {
17746 return err
17747 }
17748 if val == nil {
17749 break
17750 }
17751 {
17752 xtv := string(val)
17753 sv.Message = ptr.String(xtv)
17754 }
17755
17756 default:
17757 // Do nothing and ignore the unexpected tag element
17758 err = decoder.Decoder.Skip()
17759 if err != nil {
17760 return err
17761 }
17762
17763 }
17764 decoder = originalDecoder
17765 }
17766 *v = sv
17767 return nil
17768 }
17769
17770 func awsRestxml_deserializeDocumentHostedZoneConfig(v **types.HostedZoneConfig, decoder smithyxml.NodeDecoder) error {
17771 if v == nil {
17772 return fmt.Errorf("unexpected nil of type %T", v)
17773 }
17774 var sv *types.HostedZoneConfig
17775 if *v == nil {
17776 sv = &types.HostedZoneConfig{}
17777 } else {
17778 sv = *v
17779 }
17780
17781 for {
17782 t, done, err := decoder.Token()
17783 if err != nil {
17784 return err
17785 }
17786 if done {
17787 break
17788 }
17789 originalDecoder := decoder
17790 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17791 switch {
17792 case strings.EqualFold("Comment", t.Name.Local):
17793 val, err := decoder.Value()
17794 if err != nil {
17795 return err
17796 }
17797 if val == nil {
17798 break
17799 }
17800 {
17801 xtv := string(val)
17802 sv.Comment = ptr.String(xtv)
17803 }
17804
17805 case strings.EqualFold("PrivateZone", t.Name.Local):
17806 val, err := decoder.Value()
17807 if err != nil {
17808 return err
17809 }
17810 if val == nil {
17811 break
17812 }
17813 {
17814 xtv, err := strconv.ParseBool(string(val))
17815 if err != nil {
17816 return fmt.Errorf("expected IsPrivateZone to be of type *bool, got %T instead", val)
17817 }
17818 sv.PrivateZone = xtv
17819 }
17820
17821 default:
17822 // Do nothing and ignore the unexpected tag element
17823 err = decoder.Decoder.Skip()
17824 if err != nil {
17825 return err
17826 }
17827
17828 }
17829 decoder = originalDecoder
17830 }
17831 *v = sv
17832 return nil
17833 }
17834
17835 func awsRestxml_deserializeDocumentHostedZoneFailureReasons(v **types.HostedZoneFailureReasons, decoder smithyxml.NodeDecoder) error {
17836 if v == nil {
17837 return fmt.Errorf("unexpected nil of type %T", v)
17838 }
17839 var sv *types.HostedZoneFailureReasons
17840 if *v == nil {
17841 sv = &types.HostedZoneFailureReasons{}
17842 } else {
17843 sv = *v
17844 }
17845
17846 for {
17847 t, done, err := decoder.Token()
17848 if err != nil {
17849 return err
17850 }
17851 if done {
17852 break
17853 }
17854 originalDecoder := decoder
17855 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17856 switch {
17857 case strings.EqualFold("AcceleratedRecovery", t.Name.Local):
17858 val, err := decoder.Value()
17859 if err != nil {
17860 return err
17861 }
17862 if val == nil {
17863 break
17864 }
17865 {
17866 xtv := string(val)
17867 sv.AcceleratedRecovery = ptr.String(xtv)
17868 }
17869
17870 default:
17871 // Do nothing and ignore the unexpected tag element
17872 err = decoder.Decoder.Skip()
17873 if err != nil {
17874 return err
17875 }
17876
17877 }
17878 decoder = originalDecoder
17879 }
17880 *v = sv
17881 return nil
17882 }
17883
17884 func awsRestxml_deserializeDocumentHostedZoneFeatures(v **types.HostedZoneFeatures, decoder smithyxml.NodeDecoder) error {
17885 if v == nil {
17886 return fmt.Errorf("unexpected nil of type %T", v)
17887 }
17888 var sv *types.HostedZoneFeatures
17889 if *v == nil {
17890 sv = &types.HostedZoneFeatures{}
17891 } else {
17892 sv = *v
17893 }
17894
17895 for {
17896 t, done, err := decoder.Token()
17897 if err != nil {
17898 return err
17899 }
17900 if done {
17901 break
17902 }
17903 originalDecoder := decoder
17904 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17905 switch {
17906 case strings.EqualFold("AcceleratedRecoveryStatus", t.Name.Local):
17907 val, err := decoder.Value()
17908 if err != nil {
17909 return err
17910 }
17911 if val == nil {
17912 break
17913 }
17914 {
17915 xtv := string(val)
17916 sv.AcceleratedRecoveryStatus = types.AcceleratedRecoveryStatus(xtv)
17917 }
17918
17919 case strings.EqualFold("FailureReasons", t.Name.Local):
17920 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17921 if err := awsRestxml_deserializeDocumentHostedZoneFailureReasons(&sv.FailureReasons, nodeDecoder); err != nil {
17922 return err
17923 }
17924
17925 default:
17926 // Do nothing and ignore the unexpected tag element
17927 err = decoder.Decoder.Skip()
17928 if err != nil {
17929 return err
17930 }
17931
17932 }
17933 decoder = originalDecoder
17934 }
17935 *v = sv
17936 return nil
17937 }
17938
17939 func awsRestxml_deserializeDocumentHostedZoneLimit(v **types.HostedZoneLimit, decoder smithyxml.NodeDecoder) error {
17940 if v == nil {
17941 return fmt.Errorf("unexpected nil of type %T", v)
17942 }
17943 var sv *types.HostedZoneLimit
17944 if *v == nil {
17945 sv = &types.HostedZoneLimit{}
17946 } else {
17947 sv = *v
17948 }
17949
17950 for {
17951 t, done, err := decoder.Token()
17952 if err != nil {
17953 return err
17954 }
17955 if done {
17956 break
17957 }
17958 originalDecoder := decoder
17959 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17960 switch {
17961 case strings.EqualFold("Type", t.Name.Local):
17962 val, err := decoder.Value()
17963 if err != nil {
17964 return err
17965 }
17966 if val == nil {
17967 break
17968 }
17969 {
17970 xtv := string(val)
17971 sv.Type = types.HostedZoneLimitType(xtv)
17972 }
17973
17974 case strings.EqualFold("Value", t.Name.Local):
17975 val, err := decoder.Value()
17976 if err != nil {
17977 return err
17978 }
17979 if val == nil {
17980 break
17981 }
17982 {
17983 xtv := string(val)
17984 i64, err := strconv.ParseInt(xtv, 10, 64)
17985 if err != nil {
17986 return err
17987 }
17988 sv.Value = ptr.Int64(i64)
17989 }
17990
17991 default:
17992 // Do nothing and ignore the unexpected tag element
17993 err = decoder.Decoder.Skip()
17994 if err != nil {
17995 return err
17996 }
17997
17998 }
17999 decoder = originalDecoder
18000 }
18001 *v = sv
18002 return nil
18003 }
18004
18005 func awsRestxml_deserializeDocumentHostedZoneNotEmpty(v **types.HostedZoneNotEmpty, decoder smithyxml.NodeDecoder) error {
18006 if v == nil {
18007 return fmt.Errorf("unexpected nil of type %T", v)
18008 }
18009 var sv *types.HostedZoneNotEmpty
18010 if *v == nil {
18011 sv = &types.HostedZoneNotEmpty{}
18012 } else {
18013 sv = *v
18014 }
18015
18016 for {
18017 t, done, err := decoder.Token()
18018 if err != nil {
18019 return err
18020 }
18021 if done {
18022 break
18023 }
18024 originalDecoder := decoder
18025 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18026 switch {
18027 case strings.EqualFold("message", 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.Message = ptr.String(xtv)
18038 }
18039
18040 default:
18041 // Do nothing and ignore the unexpected tag element
18042 err = decoder.Decoder.Skip()
18043 if err != nil {
18044 return err
18045 }
18046
18047 }
18048 decoder = originalDecoder
18049 }
18050 *v = sv
18051 return nil
18052 }
18053
18054 func awsRestxml_deserializeDocumentHostedZoneNotFound(v **types.HostedZoneNotFound, decoder smithyxml.NodeDecoder) error {
18055 if v == nil {
18056 return fmt.Errorf("unexpected nil of type %T", v)
18057 }
18058 var sv *types.HostedZoneNotFound
18059 if *v == nil {
18060 sv = &types.HostedZoneNotFound{}
18061 } else {
18062 sv = *v
18063 }
18064
18065 for {
18066 t, done, err := decoder.Token()
18067 if err != nil {
18068 return err
18069 }
18070 if done {
18071 break
18072 }
18073 originalDecoder := decoder
18074 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18075 switch {
18076 case strings.EqualFold("message", t.Name.Local):
18077 val, err := decoder.Value()
18078 if err != nil {
18079 return err
18080 }
18081 if val == nil {
18082 break
18083 }
18084 {
18085 xtv := string(val)
18086 sv.Message = ptr.String(xtv)
18087 }
18088
18089 default:
18090 // Do nothing and ignore the unexpected tag element
18091 err = decoder.Decoder.Skip()
18092 if err != nil {
18093 return err
18094 }
18095
18096 }
18097 decoder = originalDecoder
18098 }
18099 *v = sv
18100 return nil
18101 }
18102
18103 func awsRestxml_deserializeDocumentHostedZoneNotPrivate(v **types.HostedZoneNotPrivate, decoder smithyxml.NodeDecoder) error {
18104 if v == nil {
18105 return fmt.Errorf("unexpected nil of type %T", v)
18106 }
18107 var sv *types.HostedZoneNotPrivate
18108 if *v == nil {
18109 sv = &types.HostedZoneNotPrivate{}
18110 } else {
18111 sv = *v
18112 }
18113
18114 for {
18115 t, done, err := decoder.Token()
18116 if err != nil {
18117 return err
18118 }
18119 if done {
18120 break
18121 }
18122 originalDecoder := decoder
18123 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18124 switch {
18125 case strings.EqualFold("message", t.Name.Local):
18126 val, err := decoder.Value()
18127 if err != nil {
18128 return err
18129 }
18130 if val == nil {
18131 break
18132 }
18133 {
18134 xtv := string(val)
18135 sv.Message = ptr.String(xtv)
18136 }
18137
18138 default:
18139 // Do nothing and ignore the unexpected tag element
18140 err = decoder.Decoder.Skip()
18141 if err != nil {
18142 return err
18143 }
18144
18145 }
18146 decoder = originalDecoder
18147 }
18148 *v = sv
18149 return nil
18150 }
18151
18152 func awsRestxml_deserializeDocumentHostedZoneOwner(v **types.HostedZoneOwner, decoder smithyxml.NodeDecoder) error {
18153 if v == nil {
18154 return fmt.Errorf("unexpected nil of type %T", v)
18155 }
18156 var sv *types.HostedZoneOwner
18157 if *v == nil {
18158 sv = &types.HostedZoneOwner{}
18159 } else {
18160 sv = *v
18161 }
18162
18163 for {
18164 t, done, err := decoder.Token()
18165 if err != nil {
18166 return err
18167 }
18168 if done {
18169 break
18170 }
18171 originalDecoder := decoder
18172 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18173 switch {
18174 case strings.EqualFold("OwningAccount", t.Name.Local):
18175 val, err := decoder.Value()
18176 if err != nil {
18177 return err
18178 }
18179 if val == nil {
18180 break
18181 }
18182 {
18183 xtv := string(val)
18184 sv.OwningAccount = ptr.String(xtv)
18185 }
18186
18187 case strings.EqualFold("OwningService", t.Name.Local):
18188 val, err := decoder.Value()
18189 if err != nil {
18190 return err
18191 }
18192 if val == nil {
18193 break
18194 }
18195 {
18196 xtv := string(val)
18197 sv.OwningService = ptr.String(xtv)
18198 }
18199
18200 default:
18201 // Do nothing and ignore the unexpected tag element
18202 err = decoder.Decoder.Skip()
18203 if err != nil {
18204 return err
18205 }
18206
18207 }
18208 decoder = originalDecoder
18209 }
18210 *v = sv
18211 return nil
18212 }
18213
18214 func awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(v **types.HostedZonePartiallyDelegated, decoder smithyxml.NodeDecoder) error {
18215 if v == nil {
18216 return fmt.Errorf("unexpected nil of type %T", v)
18217 }
18218 var sv *types.HostedZonePartiallyDelegated
18219 if *v == nil {
18220 sv = &types.HostedZonePartiallyDelegated{}
18221 } else {
18222 sv = *v
18223 }
18224
18225 for {
18226 t, done, err := decoder.Token()
18227 if err != nil {
18228 return err
18229 }
18230 if done {
18231 break
18232 }
18233 originalDecoder := decoder
18234 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18235 switch {
18236 case strings.EqualFold("message", t.Name.Local):
18237 val, err := decoder.Value()
18238 if err != nil {
18239 return err
18240 }
18241 if val == nil {
18242 break
18243 }
18244 {
18245 xtv := string(val)
18246 sv.Message = ptr.String(xtv)
18247 }
18248
18249 default:
18250 // Do nothing and ignore the unexpected tag element
18251 err = decoder.Decoder.Skip()
18252 if err != nil {
18253 return err
18254 }
18255
18256 }
18257 decoder = originalDecoder
18258 }
18259 *v = sv
18260 return nil
18261 }
18262
18263 func awsRestxml_deserializeDocumentHostedZones(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error {
18264 if v == nil {
18265 return fmt.Errorf("unexpected nil of type %T", v)
18266 }
18267 var sv []types.HostedZone
18268 if *v == nil {
18269 sv = make([]types.HostedZone, 0)
18270 } else {
18271 sv = *v
18272 }
18273
18274 originalDecoder := decoder
18275 for {
18276 t, done, err := decoder.Token()
18277 if err != nil {
18278 return err
18279 }
18280 if done {
18281 break
18282 }
18283 switch {
18284 case strings.EqualFold("HostedZone", t.Name.Local):
18285 var col types.HostedZone
18286 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18287 destAddr := &col
18288 if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil {
18289 return err
18290 }
18291 col = *destAddr
18292 sv = append(sv, col)
18293
18294 default:
18295 err = decoder.Decoder.Skip()
18296 if err != nil {
18297 return err
18298 }
18299
18300 }
18301 decoder = originalDecoder
18302 }
18303 *v = sv
18304 return nil
18305 }
18306
18307 func awsRestxml_deserializeDocumentHostedZonesUnwrapped(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error {
18308 var sv []types.HostedZone
18309 if *v == nil {
18310 sv = make([]types.HostedZone, 0)
18311 } else {
18312 sv = *v
18313 }
18314
18315 switch {
18316 default:
18317 var mv types.HostedZone
18318 t := decoder.StartEl
18319 _ = t
18320 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18321 destAddr := &mv
18322 if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil {
18323 return err
18324 }
18325 mv = *destAddr
18326 sv = append(sv, mv)
18327 }
18328 *v = sv
18329 return nil
18330 }
18331 func awsRestxml_deserializeDocumentHostedZoneSummaries(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
18332 if v == nil {
18333 return fmt.Errorf("unexpected nil of type %T", v)
18334 }
18335 var sv []types.HostedZoneSummary
18336 if *v == nil {
18337 sv = make([]types.HostedZoneSummary, 0)
18338 } else {
18339 sv = *v
18340 }
18341
18342 originalDecoder := decoder
18343 for {
18344 t, done, err := decoder.Token()
18345 if err != nil {
18346 return err
18347 }
18348 if done {
18349 break
18350 }
18351 switch {
18352 case strings.EqualFold("HostedZoneSummary", t.Name.Local):
18353 var col types.HostedZoneSummary
18354 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18355 destAddr := &col
18356 if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil {
18357 return err
18358 }
18359 col = *destAddr
18360 sv = append(sv, col)
18361
18362 default:
18363 err = decoder.Decoder.Skip()
18364 if err != nil {
18365 return err
18366 }
18367
18368 }
18369 decoder = originalDecoder
18370 }
18371 *v = sv
18372 return nil
18373 }
18374
18375 func awsRestxml_deserializeDocumentHostedZoneSummariesUnwrapped(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
18376 var sv []types.HostedZoneSummary
18377 if *v == nil {
18378 sv = make([]types.HostedZoneSummary, 0)
18379 } else {
18380 sv = *v
18381 }
18382
18383 switch {
18384 default:
18385 var mv types.HostedZoneSummary
18386 t := decoder.StartEl
18387 _ = t
18388 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18389 destAddr := &mv
18390 if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil {
18391 return err
18392 }
18393 mv = *destAddr
18394 sv = append(sv, mv)
18395 }
18396 *v = sv
18397 return nil
18398 }
18399 func awsRestxml_deserializeDocumentHostedZoneSummary(v **types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
18400 if v == nil {
18401 return fmt.Errorf("unexpected nil of type %T", v)
18402 }
18403 var sv *types.HostedZoneSummary
18404 if *v == nil {
18405 sv = &types.HostedZoneSummary{}
18406 } else {
18407 sv = *v
18408 }
18409
18410 for {
18411 t, done, err := decoder.Token()
18412 if err != nil {
18413 return err
18414 }
18415 if done {
18416 break
18417 }
18418 originalDecoder := decoder
18419 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18420 switch {
18421 case strings.EqualFold("HostedZoneId", t.Name.Local):
18422 val, err := decoder.Value()
18423 if err != nil {
18424 return err
18425 }
18426 if val == nil {
18427 break
18428 }
18429 {
18430 xtv := string(val)
18431 sv.HostedZoneId = ptr.String(xtv)
18432 }
18433
18434 case strings.EqualFold("Name", t.Name.Local):
18435 val, err := decoder.Value()
18436 if err != nil {
18437 return err
18438 }
18439 if val == nil {
18440 break
18441 }
18442 {
18443 xtv := string(val)
18444 sv.Name = ptr.String(xtv)
18445 }
18446
18447 case strings.EqualFold("Owner", t.Name.Local):
18448 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18449 if err := awsRestxml_deserializeDocumentHostedZoneOwner(&sv.Owner, nodeDecoder); err != nil {
18450 return err
18451 }
18452
18453 default:
18454 // Do nothing and ignore the unexpected tag element
18455 err = decoder.Decoder.Skip()
18456 if err != nil {
18457 return err
18458 }
18459
18460 }
18461 decoder = originalDecoder
18462 }
18463 *v = sv
18464 return nil
18465 }
18466
18467 func awsRestxml_deserializeDocumentIncompatibleVersion(v **types.IncompatibleVersion, decoder smithyxml.NodeDecoder) error {
18468 if v == nil {
18469 return fmt.Errorf("unexpected nil of type %T", v)
18470 }
18471 var sv *types.IncompatibleVersion
18472 if *v == nil {
18473 sv = &types.IncompatibleVersion{}
18474 } else {
18475 sv = *v
18476 }
18477
18478 for {
18479 t, done, err := decoder.Token()
18480 if err != nil {
18481 return err
18482 }
18483 if done {
18484 break
18485 }
18486 originalDecoder := decoder
18487 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18488 switch {
18489 case strings.EqualFold("message", t.Name.Local):
18490 val, err := decoder.Value()
18491 if err != nil {
18492 return err
18493 }
18494 if val == nil {
18495 break
18496 }
18497 {
18498 xtv := string(val)
18499 sv.Message = ptr.String(xtv)
18500 }
18501
18502 default:
18503 // Do nothing and ignore the unexpected tag element
18504 err = decoder.Decoder.Skip()
18505 if err != nil {
18506 return err
18507 }
18508
18509 }
18510 decoder = originalDecoder
18511 }
18512 *v = sv
18513 return nil
18514 }
18515
18516 func awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(v **types.InsufficientCloudWatchLogsResourcePolicy, decoder smithyxml.NodeDecoder) error {
18517 if v == nil {
18518 return fmt.Errorf("unexpected nil of type %T", v)
18519 }
18520 var sv *types.InsufficientCloudWatchLogsResourcePolicy
18521 if *v == nil {
18522 sv = &types.InsufficientCloudWatchLogsResourcePolicy{}
18523 } else {
18524 sv = *v
18525 }
18526
18527 for {
18528 t, done, err := decoder.Token()
18529 if err != nil {
18530 return err
18531 }
18532 if done {
18533 break
18534 }
18535 originalDecoder := decoder
18536 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18537 switch {
18538 case strings.EqualFold("message", t.Name.Local):
18539 val, err := decoder.Value()
18540 if err != nil {
18541 return err
18542 }
18543 if val == nil {
18544 break
18545 }
18546 {
18547 xtv := string(val)
18548 sv.Message = ptr.String(xtv)
18549 }
18550
18551 default:
18552 // Do nothing and ignore the unexpected tag element
18553 err = decoder.Decoder.Skip()
18554 if err != nil {
18555 return err
18556 }
18557
18558 }
18559 decoder = originalDecoder
18560 }
18561 *v = sv
18562 return nil
18563 }
18564
18565 func awsRestxml_deserializeDocumentInvalidArgument(v **types.InvalidArgument, decoder smithyxml.NodeDecoder) error {
18566 if v == nil {
18567 return fmt.Errorf("unexpected nil of type %T", v)
18568 }
18569 var sv *types.InvalidArgument
18570 if *v == nil {
18571 sv = &types.InvalidArgument{}
18572 } else {
18573 sv = *v
18574 }
18575
18576 for {
18577 t, done, err := decoder.Token()
18578 if err != nil {
18579 return err
18580 }
18581 if done {
18582 break
18583 }
18584 originalDecoder := decoder
18585 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18586 switch {
18587 case strings.EqualFold("message", t.Name.Local):
18588 val, err := decoder.Value()
18589 if err != nil {
18590 return err
18591 }
18592 if val == nil {
18593 break
18594 }
18595 {
18596 xtv := string(val)
18597 sv.Message = ptr.String(xtv)
18598 }
18599
18600 default:
18601 // Do nothing and ignore the unexpected tag element
18602 err = decoder.Decoder.Skip()
18603 if err != nil {
18604 return err
18605 }
18606
18607 }
18608 decoder = originalDecoder
18609 }
18610 *v = sv
18611 return nil
18612 }
18613
18614 func awsRestxml_deserializeDocumentInvalidChangeBatch(v **types.InvalidChangeBatch, decoder smithyxml.NodeDecoder) error {
18615 if v == nil {
18616 return fmt.Errorf("unexpected nil of type %T", v)
18617 }
18618 var sv *types.InvalidChangeBatch
18619 if *v == nil {
18620 sv = &types.InvalidChangeBatch{}
18621 } else {
18622 sv = *v
18623 }
18624
18625 for {
18626 t, done, err := decoder.Token()
18627 if err != nil {
18628 return err
18629 }
18630 if done {
18631 break
18632 }
18633 originalDecoder := decoder
18634 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18635 switch {
18636 case strings.EqualFold("message", t.Name.Local):
18637 val, err := decoder.Value()
18638 if err != nil {
18639 return err
18640 }
18641 if val == nil {
18642 break
18643 }
18644 {
18645 xtv := string(val)
18646 sv.Message = ptr.String(xtv)
18647 }
18648
18649 case strings.EqualFold("messages", t.Name.Local):
18650 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18651 if err := awsRestxml_deserializeDocumentErrorMessages(&sv.Messages, nodeDecoder); err != nil {
18652 return err
18653 }
18654
18655 default:
18656 // Do nothing and ignore the unexpected tag element
18657 err = decoder.Decoder.Skip()
18658 if err != nil {
18659 return err
18660 }
18661
18662 }
18663 decoder = originalDecoder
18664 }
18665 *v = sv
18666 return nil
18667 }
18668
18669 func awsRestxml_deserializeDocumentInvalidDomainName(v **types.InvalidDomainName, decoder smithyxml.NodeDecoder) error {
18670 if v == nil {
18671 return fmt.Errorf("unexpected nil of type %T", v)
18672 }
18673 var sv *types.InvalidDomainName
18674 if *v == nil {
18675 sv = &types.InvalidDomainName{}
18676 } else {
18677 sv = *v
18678 }
18679
18680 for {
18681 t, done, err := decoder.Token()
18682 if err != nil {
18683 return err
18684 }
18685 if done {
18686 break
18687 }
18688 originalDecoder := decoder
18689 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18690 switch {
18691 case strings.EqualFold("message", t.Name.Local):
18692 val, err := decoder.Value()
18693 if err != nil {
18694 return err
18695 }
18696 if val == nil {
18697 break
18698 }
18699 {
18700 xtv := string(val)
18701 sv.Message = ptr.String(xtv)
18702 }
18703
18704 default:
18705 // Do nothing and ignore the unexpected tag element
18706 err = decoder.Decoder.Skip()
18707 if err != nil {
18708 return err
18709 }
18710
18711 }
18712 decoder = originalDecoder
18713 }
18714 *v = sv
18715 return nil
18716 }
18717
18718 func awsRestxml_deserializeDocumentInvalidInput(v **types.InvalidInput, decoder smithyxml.NodeDecoder) error {
18719 if v == nil {
18720 return fmt.Errorf("unexpected nil of type %T", v)
18721 }
18722 var sv *types.InvalidInput
18723 if *v == nil {
18724 sv = &types.InvalidInput{}
18725 } else {
18726 sv = *v
18727 }
18728
18729 for {
18730 t, done, err := decoder.Token()
18731 if err != nil {
18732 return err
18733 }
18734 if done {
18735 break
18736 }
18737 originalDecoder := decoder
18738 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18739 switch {
18740 case strings.EqualFold("message", t.Name.Local):
18741 val, err := decoder.Value()
18742 if err != nil {
18743 return err
18744 }
18745 if val == nil {
18746 break
18747 }
18748 {
18749 xtv := string(val)
18750 sv.Message = ptr.String(xtv)
18751 }
18752
18753 default:
18754 // Do nothing and ignore the unexpected tag element
18755 err = decoder.Decoder.Skip()
18756 if err != nil {
18757 return err
18758 }
18759
18760 }
18761 decoder = originalDecoder
18762 }
18763 *v = sv
18764 return nil
18765 }
18766
18767 func awsRestxml_deserializeDocumentInvalidKeySigningKeyName(v **types.InvalidKeySigningKeyName, decoder smithyxml.NodeDecoder) error {
18768 if v == nil {
18769 return fmt.Errorf("unexpected nil of type %T", v)
18770 }
18771 var sv *types.InvalidKeySigningKeyName
18772 if *v == nil {
18773 sv = &types.InvalidKeySigningKeyName{}
18774 } else {
18775 sv = *v
18776 }
18777
18778 for {
18779 t, done, err := decoder.Token()
18780 if err != nil {
18781 return err
18782 }
18783 if done {
18784 break
18785 }
18786 originalDecoder := decoder
18787 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18788 switch {
18789 case strings.EqualFold("message", t.Name.Local):
18790 val, err := decoder.Value()
18791 if err != nil {
18792 return err
18793 }
18794 if val == nil {
18795 break
18796 }
18797 {
18798 xtv := string(val)
18799 sv.Message = ptr.String(xtv)
18800 }
18801
18802 default:
18803 // Do nothing and ignore the unexpected tag element
18804 err = decoder.Decoder.Skip()
18805 if err != nil {
18806 return err
18807 }
18808
18809 }
18810 decoder = originalDecoder
18811 }
18812 *v = sv
18813 return nil
18814 }
18815
18816 func awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(v **types.InvalidKeySigningKeyStatus, decoder smithyxml.NodeDecoder) error {
18817 if v == nil {
18818 return fmt.Errorf("unexpected nil of type %T", v)
18819 }
18820 var sv *types.InvalidKeySigningKeyStatus
18821 if *v == nil {
18822 sv = &types.InvalidKeySigningKeyStatus{}
18823 } else {
18824 sv = *v
18825 }
18826
18827 for {
18828 t, done, err := decoder.Token()
18829 if err != nil {
18830 return err
18831 }
18832 if done {
18833 break
18834 }
18835 originalDecoder := decoder
18836 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18837 switch {
18838 case strings.EqualFold("message", t.Name.Local):
18839 val, err := decoder.Value()
18840 if err != nil {
18841 return err
18842 }
18843 if val == nil {
18844 break
18845 }
18846 {
18847 xtv := string(val)
18848 sv.Message = ptr.String(xtv)
18849 }
18850
18851 default:
18852 // Do nothing and ignore the unexpected tag element
18853 err = decoder.Decoder.Skip()
18854 if err != nil {
18855 return err
18856 }
18857
18858 }
18859 decoder = originalDecoder
18860 }
18861 *v = sv
18862 return nil
18863 }
18864
18865 func awsRestxml_deserializeDocumentInvalidKMSArn(v **types.InvalidKMSArn, decoder smithyxml.NodeDecoder) error {
18866 if v == nil {
18867 return fmt.Errorf("unexpected nil of type %T", v)
18868 }
18869 var sv *types.InvalidKMSArn
18870 if *v == nil {
18871 sv = &types.InvalidKMSArn{}
18872 } else {
18873 sv = *v
18874 }
18875
18876 for {
18877 t, done, err := decoder.Token()
18878 if err != nil {
18879 return err
18880 }
18881 if done {
18882 break
18883 }
18884 originalDecoder := decoder
18885 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18886 switch {
18887 case strings.EqualFold("message", t.Name.Local):
18888 val, err := decoder.Value()
18889 if err != nil {
18890 return err
18891 }
18892 if val == nil {
18893 break
18894 }
18895 {
18896 xtv := string(val)
18897 sv.Message = ptr.String(xtv)
18898 }
18899
18900 default:
18901 // Do nothing and ignore the unexpected tag element
18902 err = decoder.Decoder.Skip()
18903 if err != nil {
18904 return err
18905 }
18906
18907 }
18908 decoder = originalDecoder
18909 }
18910 *v = sv
18911 return nil
18912 }
18913
18914 func awsRestxml_deserializeDocumentInvalidPaginationToken(v **types.InvalidPaginationToken, decoder smithyxml.NodeDecoder) error {
18915 if v == nil {
18916 return fmt.Errorf("unexpected nil of type %T", v)
18917 }
18918 var sv *types.InvalidPaginationToken
18919 if *v == nil {
18920 sv = &types.InvalidPaginationToken{}
18921 } else {
18922 sv = *v
18923 }
18924
18925 for {
18926 t, done, err := decoder.Token()
18927 if err != nil {
18928 return err
18929 }
18930 if done {
18931 break
18932 }
18933 originalDecoder := decoder
18934 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18935 switch {
18936 case strings.EqualFold("message", t.Name.Local):
18937 val, err := decoder.Value()
18938 if err != nil {
18939 return err
18940 }
18941 if val == nil {
18942 break
18943 }
18944 {
18945 xtv := string(val)
18946 sv.Message = ptr.String(xtv)
18947 }
18948
18949 default:
18950 // Do nothing and ignore the unexpected tag element
18951 err = decoder.Decoder.Skip()
18952 if err != nil {
18953 return err
18954 }
18955
18956 }
18957 decoder = originalDecoder
18958 }
18959 *v = sv
18960 return nil
18961 }
18962
18963 func awsRestxml_deserializeDocumentInvalidSigningStatus(v **types.InvalidSigningStatus, decoder smithyxml.NodeDecoder) error {
18964 if v == nil {
18965 return fmt.Errorf("unexpected nil of type %T", v)
18966 }
18967 var sv *types.InvalidSigningStatus
18968 if *v == nil {
18969 sv = &types.InvalidSigningStatus{}
18970 } else {
18971 sv = *v
18972 }
18973
18974 for {
18975 t, done, err := decoder.Token()
18976 if err != nil {
18977 return err
18978 }
18979 if done {
18980 break
18981 }
18982 originalDecoder := decoder
18983 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18984 switch {
18985 case strings.EqualFold("message", t.Name.Local):
18986 val, err := decoder.Value()
18987 if err != nil {
18988 return err
18989 }
18990 if val == nil {
18991 break
18992 }
18993 {
18994 xtv := string(val)
18995 sv.Message = ptr.String(xtv)
18996 }
18997
18998 default:
18999 // Do nothing and ignore the unexpected tag element
19000 err = decoder.Decoder.Skip()
19001 if err != nil {
19002 return err
19003 }
19004
19005 }
19006 decoder = originalDecoder
19007 }
19008 *v = sv
19009 return nil
19010 }
19011
19012 func awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(v **types.InvalidTrafficPolicyDocument, decoder smithyxml.NodeDecoder) error {
19013 if v == nil {
19014 return fmt.Errorf("unexpected nil of type %T", v)
19015 }
19016 var sv *types.InvalidTrafficPolicyDocument
19017 if *v == nil {
19018 sv = &types.InvalidTrafficPolicyDocument{}
19019 } else {
19020 sv = *v
19021 }
19022
19023 for {
19024 t, done, err := decoder.Token()
19025 if err != nil {
19026 return err
19027 }
19028 if done {
19029 break
19030 }
19031 originalDecoder := decoder
19032 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19033 switch {
19034 case strings.EqualFold("message", t.Name.Local):
19035 val, err := decoder.Value()
19036 if err != nil {
19037 return err
19038 }
19039 if val == nil {
19040 break
19041 }
19042 {
19043 xtv := string(val)
19044 sv.Message = ptr.String(xtv)
19045 }
19046
19047 default:
19048 // Do nothing and ignore the unexpected tag element
19049 err = decoder.Decoder.Skip()
19050 if err != nil {
19051 return err
19052 }
19053
19054 }
19055 decoder = originalDecoder
19056 }
19057 *v = sv
19058 return nil
19059 }
19060
19061 func awsRestxml_deserializeDocumentInvalidVPCId(v **types.InvalidVPCId, decoder smithyxml.NodeDecoder) error {
19062 if v == nil {
19063 return fmt.Errorf("unexpected nil of type %T", v)
19064 }
19065 var sv *types.InvalidVPCId
19066 if *v == nil {
19067 sv = &types.InvalidVPCId{}
19068 } else {
19069 sv = *v
19070 }
19071
19072 for {
19073 t, done, err := decoder.Token()
19074 if err != nil {
19075 return err
19076 }
19077 if done {
19078 break
19079 }
19080 originalDecoder := decoder
19081 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19082 switch {
19083 case strings.EqualFold("message", t.Name.Local):
19084 val, err := decoder.Value()
19085 if err != nil {
19086 return err
19087 }
19088 if val == nil {
19089 break
19090 }
19091 {
19092 xtv := string(val)
19093 sv.Message = ptr.String(xtv)
19094 }
19095
19096 default:
19097 // Do nothing and ignore the unexpected tag element
19098 err = decoder.Decoder.Skip()
19099 if err != nil {
19100 return err
19101 }
19102
19103 }
19104 decoder = originalDecoder
19105 }
19106 *v = sv
19107 return nil
19108 }
19109
19110 func awsRestxml_deserializeDocumentKeySigningKey(v **types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
19111 if v == nil {
19112 return fmt.Errorf("unexpected nil of type %T", v)
19113 }
19114 var sv *types.KeySigningKey
19115 if *v == nil {
19116 sv = &types.KeySigningKey{}
19117 } else {
19118 sv = *v
19119 }
19120
19121 for {
19122 t, done, err := decoder.Token()
19123 if err != nil {
19124 return err
19125 }
19126 if done {
19127 break
19128 }
19129 originalDecoder := decoder
19130 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19131 switch {
19132 case strings.EqualFold("CreatedDate", t.Name.Local):
19133 val, err := decoder.Value()
19134 if err != nil {
19135 return err
19136 }
19137 if val == nil {
19138 break
19139 }
19140 {
19141 xtv := string(val)
19142 t, err := smithytime.ParseDateTime(xtv)
19143 if err != nil {
19144 return err
19145 }
19146 sv.CreatedDate = ptr.Time(t)
19147 }
19148
19149 case strings.EqualFold("DigestAlgorithmMnemonic", t.Name.Local):
19150 val, err := decoder.Value()
19151 if err != nil {
19152 return err
19153 }
19154 if val == nil {
19155 break
19156 }
19157 {
19158 xtv := string(val)
19159 sv.DigestAlgorithmMnemonic = ptr.String(xtv)
19160 }
19161
19162 case strings.EqualFold("DigestAlgorithmType", t.Name.Local):
19163 val, err := decoder.Value()
19164 if err != nil {
19165 return err
19166 }
19167 if val == nil {
19168 break
19169 }
19170 {
19171 xtv := string(val)
19172 i64, err := strconv.ParseInt(xtv, 10, 64)
19173 if err != nil {
19174 return err
19175 }
19176 sv.DigestAlgorithmType = int32(i64)
19177 }
19178
19179 case strings.EqualFold("DigestValue", t.Name.Local):
19180 val, err := decoder.Value()
19181 if err != nil {
19182 return err
19183 }
19184 if val == nil {
19185 break
19186 }
19187 {
19188 xtv := string(val)
19189 sv.DigestValue = ptr.String(xtv)
19190 }
19191
19192 case strings.EqualFold("DNSKEYRecord", t.Name.Local):
19193 val, err := decoder.Value()
19194 if err != nil {
19195 return err
19196 }
19197 if val == nil {
19198 break
19199 }
19200 {
19201 xtv := string(val)
19202 sv.DNSKEYRecord = ptr.String(xtv)
19203 }
19204
19205 case strings.EqualFold("DSRecord", t.Name.Local):
19206 val, err := decoder.Value()
19207 if err != nil {
19208 return err
19209 }
19210 if val == nil {
19211 break
19212 }
19213 {
19214 xtv := string(val)
19215 sv.DSRecord = ptr.String(xtv)
19216 }
19217
19218 case strings.EqualFold("Flag", t.Name.Local):
19219 val, err := decoder.Value()
19220 if err != nil {
19221 return err
19222 }
19223 if val == nil {
19224 break
19225 }
19226 {
19227 xtv := string(val)
19228 i64, err := strconv.ParseInt(xtv, 10, 64)
19229 if err != nil {
19230 return err
19231 }
19232 sv.Flag = int32(i64)
19233 }
19234
19235 case strings.EqualFold("KeyTag", t.Name.Local):
19236 val, err := decoder.Value()
19237 if err != nil {
19238 return err
19239 }
19240 if val == nil {
19241 break
19242 }
19243 {
19244 xtv := string(val)
19245 i64, err := strconv.ParseInt(xtv, 10, 64)
19246 if err != nil {
19247 return err
19248 }
19249 sv.KeyTag = int32(i64)
19250 }
19251
19252 case strings.EqualFold("KmsArn", t.Name.Local):
19253 val, err := decoder.Value()
19254 if err != nil {
19255 return err
19256 }
19257 if val == nil {
19258 break
19259 }
19260 {
19261 xtv := string(val)
19262 sv.KmsArn = ptr.String(xtv)
19263 }
19264
19265 case strings.EqualFold("LastModifiedDate", t.Name.Local):
19266 val, err := decoder.Value()
19267 if err != nil {
19268 return err
19269 }
19270 if val == nil {
19271 break
19272 }
19273 {
19274 xtv := string(val)
19275 t, err := smithytime.ParseDateTime(xtv)
19276 if err != nil {
19277 return err
19278 }
19279 sv.LastModifiedDate = ptr.Time(t)
19280 }
19281
19282 case strings.EqualFold("Name", t.Name.Local):
19283 val, err := decoder.Value()
19284 if err != nil {
19285 return err
19286 }
19287 if val == nil {
19288 break
19289 }
19290 {
19291 xtv := string(val)
19292 sv.Name = ptr.String(xtv)
19293 }
19294
19295 case strings.EqualFold("PublicKey", t.Name.Local):
19296 val, err := decoder.Value()
19297 if err != nil {
19298 return err
19299 }
19300 if val == nil {
19301 break
19302 }
19303 {
19304 xtv := string(val)
19305 sv.PublicKey = ptr.String(xtv)
19306 }
19307
19308 case strings.EqualFold("SigningAlgorithmMnemonic", t.Name.Local):
19309 val, err := decoder.Value()
19310 if err != nil {
19311 return err
19312 }
19313 if val == nil {
19314 break
19315 }
19316 {
19317 xtv := string(val)
19318 sv.SigningAlgorithmMnemonic = ptr.String(xtv)
19319 }
19320
19321 case strings.EqualFold("SigningAlgorithmType", t.Name.Local):
19322 val, err := decoder.Value()
19323 if err != nil {
19324 return err
19325 }
19326 if val == nil {
19327 break
19328 }
19329 {
19330 xtv := string(val)
19331 i64, err := strconv.ParseInt(xtv, 10, 64)
19332 if err != nil {
19333 return err
19334 }
19335 sv.SigningAlgorithmType = int32(i64)
19336 }
19337
19338 case strings.EqualFold("Status", t.Name.Local):
19339 val, err := decoder.Value()
19340 if err != nil {
19341 return err
19342 }
19343 if val == nil {
19344 break
19345 }
19346 {
19347 xtv := string(val)
19348 sv.Status = ptr.String(xtv)
19349 }
19350
19351 case strings.EqualFold("StatusMessage", t.Name.Local):
19352 val, err := decoder.Value()
19353 if err != nil {
19354 return err
19355 }
19356 if val == nil {
19357 break
19358 }
19359 {
19360 xtv := string(val)
19361 sv.StatusMessage = ptr.String(xtv)
19362 }
19363
19364 default:
19365 // Do nothing and ignore the unexpected tag element
19366 err = decoder.Decoder.Skip()
19367 if err != nil {
19368 return err
19369 }
19370
19371 }
19372 decoder = originalDecoder
19373 }
19374 *v = sv
19375 return nil
19376 }
19377
19378 func awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(v **types.KeySigningKeyAlreadyExists, decoder smithyxml.NodeDecoder) error {
19379 if v == nil {
19380 return fmt.Errorf("unexpected nil of type %T", v)
19381 }
19382 var sv *types.KeySigningKeyAlreadyExists
19383 if *v == nil {
19384 sv = &types.KeySigningKeyAlreadyExists{}
19385 } else {
19386 sv = *v
19387 }
19388
19389 for {
19390 t, done, err := decoder.Token()
19391 if err != nil {
19392 return err
19393 }
19394 if done {
19395 break
19396 }
19397 originalDecoder := decoder
19398 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19399 switch {
19400 case strings.EqualFold("message", t.Name.Local):
19401 val, err := decoder.Value()
19402 if err != nil {
19403 return err
19404 }
19405 if val == nil {
19406 break
19407 }
19408 {
19409 xtv := string(val)
19410 sv.Message = ptr.String(xtv)
19411 }
19412
19413 default:
19414 // Do nothing and ignore the unexpected tag element
19415 err = decoder.Decoder.Skip()
19416 if err != nil {
19417 return err
19418 }
19419
19420 }
19421 decoder = originalDecoder
19422 }
19423 *v = sv
19424 return nil
19425 }
19426
19427 func awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(v **types.KeySigningKeyInParentDSRecord, decoder smithyxml.NodeDecoder) error {
19428 if v == nil {
19429 return fmt.Errorf("unexpected nil of type %T", v)
19430 }
19431 var sv *types.KeySigningKeyInParentDSRecord
19432 if *v == nil {
19433 sv = &types.KeySigningKeyInParentDSRecord{}
19434 } else {
19435 sv = *v
19436 }
19437
19438 for {
19439 t, done, err := decoder.Token()
19440 if err != nil {
19441 return err
19442 }
19443 if done {
19444 break
19445 }
19446 originalDecoder := decoder
19447 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19448 switch {
19449 case strings.EqualFold("message", t.Name.Local):
19450 val, err := decoder.Value()
19451 if err != nil {
19452 return err
19453 }
19454 if val == nil {
19455 break
19456 }
19457 {
19458 xtv := string(val)
19459 sv.Message = ptr.String(xtv)
19460 }
19461
19462 default:
19463 // Do nothing and ignore the unexpected tag element
19464 err = decoder.Decoder.Skip()
19465 if err != nil {
19466 return err
19467 }
19468
19469 }
19470 decoder = originalDecoder
19471 }
19472 *v = sv
19473 return nil
19474 }
19475
19476 func awsRestxml_deserializeDocumentKeySigningKeyInUse(v **types.KeySigningKeyInUse, decoder smithyxml.NodeDecoder) error {
19477 if v == nil {
19478 return fmt.Errorf("unexpected nil of type %T", v)
19479 }
19480 var sv *types.KeySigningKeyInUse
19481 if *v == nil {
19482 sv = &types.KeySigningKeyInUse{}
19483 } else {
19484 sv = *v
19485 }
19486
19487 for {
19488 t, done, err := decoder.Token()
19489 if err != nil {
19490 return err
19491 }
19492 if done {
19493 break
19494 }
19495 originalDecoder := decoder
19496 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19497 switch {
19498 case strings.EqualFold("message", t.Name.Local):
19499 val, err := decoder.Value()
19500 if err != nil {
19501 return err
19502 }
19503 if val == nil {
19504 break
19505 }
19506 {
19507 xtv := string(val)
19508 sv.Message = ptr.String(xtv)
19509 }
19510
19511 default:
19512 // Do nothing and ignore the unexpected tag element
19513 err = decoder.Decoder.Skip()
19514 if err != nil {
19515 return err
19516 }
19517
19518 }
19519 decoder = originalDecoder
19520 }
19521 *v = sv
19522 return nil
19523 }
19524
19525 func awsRestxml_deserializeDocumentKeySigningKeys(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
19526 if v == nil {
19527 return fmt.Errorf("unexpected nil of type %T", v)
19528 }
19529 var sv []types.KeySigningKey
19530 if *v == nil {
19531 sv = make([]types.KeySigningKey, 0)
19532 } else {
19533 sv = *v
19534 }
19535
19536 originalDecoder := decoder
19537 for {
19538 t, done, err := decoder.Token()
19539 if err != nil {
19540 return err
19541 }
19542 if done {
19543 break
19544 }
19545 switch {
19546 case strings.EqualFold("member", t.Name.Local):
19547 var col types.KeySigningKey
19548 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19549 destAddr := &col
19550 if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil {
19551 return err
19552 }
19553 col = *destAddr
19554 sv = append(sv, col)
19555
19556 default:
19557 err = decoder.Decoder.Skip()
19558 if err != nil {
19559 return err
19560 }
19561
19562 }
19563 decoder = originalDecoder
19564 }
19565 *v = sv
19566 return nil
19567 }
19568
19569 func awsRestxml_deserializeDocumentKeySigningKeysUnwrapped(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
19570 var sv []types.KeySigningKey
19571 if *v == nil {
19572 sv = make([]types.KeySigningKey, 0)
19573 } else {
19574 sv = *v
19575 }
19576
19577 switch {
19578 default:
19579 var mv types.KeySigningKey
19580 t := decoder.StartEl
19581 _ = t
19582 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19583 destAddr := &mv
19584 if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil {
19585 return err
19586 }
19587 mv = *destAddr
19588 sv = append(sv, mv)
19589 }
19590 *v = sv
19591 return nil
19592 }
19593 func awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(v **types.KeySigningKeyWithActiveStatusNotFound, decoder smithyxml.NodeDecoder) error {
19594 if v == nil {
19595 return fmt.Errorf("unexpected nil of type %T", v)
19596 }
19597 var sv *types.KeySigningKeyWithActiveStatusNotFound
19598 if *v == nil {
19599 sv = &types.KeySigningKeyWithActiveStatusNotFound{}
19600 } else {
19601 sv = *v
19602 }
19603
19604 for {
19605 t, done, err := decoder.Token()
19606 if err != nil {
19607 return err
19608 }
19609 if done {
19610 break
19611 }
19612 originalDecoder := decoder
19613 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19614 switch {
19615 case strings.EqualFold("message", t.Name.Local):
19616 val, err := decoder.Value()
19617 if err != nil {
19618 return err
19619 }
19620 if val == nil {
19621 break
19622 }
19623 {
19624 xtv := string(val)
19625 sv.Message = ptr.String(xtv)
19626 }
19627
19628 default:
19629 // Do nothing and ignore the unexpected tag element
19630 err = decoder.Decoder.Skip()
19631 if err != nil {
19632 return err
19633 }
19634
19635 }
19636 decoder = originalDecoder
19637 }
19638 *v = sv
19639 return nil
19640 }
19641
19642 func awsRestxml_deserializeDocumentLastVPCAssociation(v **types.LastVPCAssociation, decoder smithyxml.NodeDecoder) error {
19643 if v == nil {
19644 return fmt.Errorf("unexpected nil of type %T", v)
19645 }
19646 var sv *types.LastVPCAssociation
19647 if *v == nil {
19648 sv = &types.LastVPCAssociation{}
19649 } else {
19650 sv = *v
19651 }
19652
19653 for {
19654 t, done, err := decoder.Token()
19655 if err != nil {
19656 return err
19657 }
19658 if done {
19659 break
19660 }
19661 originalDecoder := decoder
19662 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19663 switch {
19664 case strings.EqualFold("message", t.Name.Local):
19665 val, err := decoder.Value()
19666 if err != nil {
19667 return err
19668 }
19669 if val == nil {
19670 break
19671 }
19672 {
19673 xtv := string(val)
19674 sv.Message = ptr.String(xtv)
19675 }
19676
19677 default:
19678 // Do nothing and ignore the unexpected tag element
19679 err = decoder.Decoder.Skip()
19680 if err != nil {
19681 return err
19682 }
19683
19684 }
19685 decoder = originalDecoder
19686 }
19687 *v = sv
19688 return nil
19689 }
19690
19691 func awsRestxml_deserializeDocumentLimitsExceeded(v **types.LimitsExceeded, decoder smithyxml.NodeDecoder) error {
19692 if v == nil {
19693 return fmt.Errorf("unexpected nil of type %T", v)
19694 }
19695 var sv *types.LimitsExceeded
19696 if *v == nil {
19697 sv = &types.LimitsExceeded{}
19698 } else {
19699 sv = *v
19700 }
19701
19702 for {
19703 t, done, err := decoder.Token()
19704 if err != nil {
19705 return err
19706 }
19707 if done {
19708 break
19709 }
19710 originalDecoder := decoder
19711 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19712 switch {
19713 case strings.EqualFold("message", t.Name.Local):
19714 val, err := decoder.Value()
19715 if err != nil {
19716 return err
19717 }
19718 if val == nil {
19719 break
19720 }
19721 {
19722 xtv := string(val)
19723 sv.Message = ptr.String(xtv)
19724 }
19725
19726 default:
19727 // Do nothing and ignore the unexpected tag element
19728 err = decoder.Decoder.Skip()
19729 if err != nil {
19730 return err
19731 }
19732
19733 }
19734 decoder = originalDecoder
19735 }
19736 *v = sv
19737 return nil
19738 }
19739
19740 func awsRestxml_deserializeDocumentLinkedService(v **types.LinkedService, decoder smithyxml.NodeDecoder) error {
19741 if v == nil {
19742 return fmt.Errorf("unexpected nil of type %T", v)
19743 }
19744 var sv *types.LinkedService
19745 if *v == nil {
19746 sv = &types.LinkedService{}
19747 } else {
19748 sv = *v
19749 }
19750
19751 for {
19752 t, done, err := decoder.Token()
19753 if err != nil {
19754 return err
19755 }
19756 if done {
19757 break
19758 }
19759 originalDecoder := decoder
19760 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19761 switch {
19762 case strings.EqualFold("Description", t.Name.Local):
19763 val, err := decoder.Value()
19764 if err != nil {
19765 return err
19766 }
19767 if val == nil {
19768 break
19769 }
19770 {
19771 xtv := string(val)
19772 sv.Description = ptr.String(xtv)
19773 }
19774
19775 case strings.EqualFold("ServicePrincipal", t.Name.Local):
19776 val, err := decoder.Value()
19777 if err != nil {
19778 return err
19779 }
19780 if val == nil {
19781 break
19782 }
19783 {
19784 xtv := string(val)
19785 sv.ServicePrincipal = ptr.String(xtv)
19786 }
19787
19788 default:
19789 // Do nothing and ignore the unexpected tag element
19790 err = decoder.Decoder.Skip()
19791 if err != nil {
19792 return err
19793 }
19794
19795 }
19796 decoder = originalDecoder
19797 }
19798 *v = sv
19799 return nil
19800 }
19801
19802 func awsRestxml_deserializeDocumentLocationSummaries(v *[]types.LocationSummary, decoder smithyxml.NodeDecoder) error {
19803 if v == nil {
19804 return fmt.Errorf("unexpected nil of type %T", v)
19805 }
19806 var sv []types.LocationSummary
19807 if *v == nil {
19808 sv = make([]types.LocationSummary, 0)
19809 } else {
19810 sv = *v
19811 }
19812
19813 originalDecoder := decoder
19814 for {
19815 t, done, err := decoder.Token()
19816 if err != nil {
19817 return err
19818 }
19819 if done {
19820 break
19821 }
19822 switch {
19823 case strings.EqualFold("member", t.Name.Local):
19824 var col types.LocationSummary
19825 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19826 destAddr := &col
19827 if err := awsRestxml_deserializeDocumentLocationSummary(&destAddr, nodeDecoder); err != nil {
19828 return err
19829 }
19830 col = *destAddr
19831 sv = append(sv, col)
19832
19833 default:
19834 err = decoder.Decoder.Skip()
19835 if err != nil {
19836 return err
19837 }
19838
19839 }
19840 decoder = originalDecoder
19841 }
19842 *v = sv
19843 return nil
19844 }
19845
19846 func awsRestxml_deserializeDocumentLocationSummariesUnwrapped(v *[]types.LocationSummary, decoder smithyxml.NodeDecoder) error {
19847 var sv []types.LocationSummary
19848 if *v == nil {
19849 sv = make([]types.LocationSummary, 0)
19850 } else {
19851 sv = *v
19852 }
19853
19854 switch {
19855 default:
19856 var mv types.LocationSummary
19857 t := decoder.StartEl
19858 _ = t
19859 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19860 destAddr := &mv
19861 if err := awsRestxml_deserializeDocumentLocationSummary(&destAddr, nodeDecoder); err != nil {
19862 return err
19863 }
19864 mv = *destAddr
19865 sv = append(sv, mv)
19866 }
19867 *v = sv
19868 return nil
19869 }
19870 func awsRestxml_deserializeDocumentLocationSummary(v **types.LocationSummary, decoder smithyxml.NodeDecoder) error {
19871 if v == nil {
19872 return fmt.Errorf("unexpected nil of type %T", v)
19873 }
19874 var sv *types.LocationSummary
19875 if *v == nil {
19876 sv = &types.LocationSummary{}
19877 } else {
19878 sv = *v
19879 }
19880
19881 for {
19882 t, done, err := decoder.Token()
19883 if err != nil {
19884 return err
19885 }
19886 if done {
19887 break
19888 }
19889 originalDecoder := decoder
19890 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19891 switch {
19892 case strings.EqualFold("LocationName", t.Name.Local):
19893 val, err := decoder.Value()
19894 if err != nil {
19895 return err
19896 }
19897 if val == nil {
19898 break
19899 }
19900 {
19901 xtv := string(val)
19902 sv.LocationName = ptr.String(xtv)
19903 }
19904
19905 default:
19906 // Do nothing and ignore the unexpected tag element
19907 err = decoder.Decoder.Skip()
19908 if err != nil {
19909 return err
19910 }
19911
19912 }
19913 decoder = originalDecoder
19914 }
19915 *v = sv
19916 return nil
19917 }
19918
19919 func awsRestxml_deserializeDocumentNoSuchChange(v **types.NoSuchChange, decoder smithyxml.NodeDecoder) error {
19920 if v == nil {
19921 return fmt.Errorf("unexpected nil of type %T", v)
19922 }
19923 var sv *types.NoSuchChange
19924 if *v == nil {
19925 sv = &types.NoSuchChange{}
19926 } else {
19927 sv = *v
19928 }
19929
19930 for {
19931 t, done, err := decoder.Token()
19932 if err != nil {
19933 return err
19934 }
19935 if done {
19936 break
19937 }
19938 originalDecoder := decoder
19939 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19940 switch {
19941 case strings.EqualFold("message", t.Name.Local):
19942 val, err := decoder.Value()
19943 if err != nil {
19944 return err
19945 }
19946 if val == nil {
19947 break
19948 }
19949 {
19950 xtv := string(val)
19951 sv.Message = ptr.String(xtv)
19952 }
19953
19954 default:
19955 // Do nothing and ignore the unexpected tag element
19956 err = decoder.Decoder.Skip()
19957 if err != nil {
19958 return err
19959 }
19960
19961 }
19962 decoder = originalDecoder
19963 }
19964 *v = sv
19965 return nil
19966 }
19967
19968 func awsRestxml_deserializeDocumentNoSuchCidrCollectionException(v **types.NoSuchCidrCollectionException, decoder smithyxml.NodeDecoder) error {
19969 if v == nil {
19970 return fmt.Errorf("unexpected nil of type %T", v)
19971 }
19972 var sv *types.NoSuchCidrCollectionException
19973 if *v == nil {
19974 sv = &types.NoSuchCidrCollectionException{}
19975 } else {
19976 sv = *v
19977 }
19978
19979 for {
19980 t, done, err := decoder.Token()
19981 if err != nil {
19982 return err
19983 }
19984 if done {
19985 break
19986 }
19987 originalDecoder := decoder
19988 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19989 switch {
19990 case strings.EqualFold("Message", t.Name.Local):
19991 val, err := decoder.Value()
19992 if err != nil {
19993 return err
19994 }
19995 if val == nil {
19996 break
19997 }
19998 {
19999 xtv := string(val)
20000 sv.Message = ptr.String(xtv)
20001 }
20002
20003 default:
20004 // Do nothing and ignore the unexpected tag element
20005 err = decoder.Decoder.Skip()
20006 if err != nil {
20007 return err
20008 }
20009
20010 }
20011 decoder = originalDecoder
20012 }
20013 *v = sv
20014 return nil
20015 }
20016
20017 func awsRestxml_deserializeDocumentNoSuchCidrLocationException(v **types.NoSuchCidrLocationException, decoder smithyxml.NodeDecoder) error {
20018 if v == nil {
20019 return fmt.Errorf("unexpected nil of type %T", v)
20020 }
20021 var sv *types.NoSuchCidrLocationException
20022 if *v == nil {
20023 sv = &types.NoSuchCidrLocationException{}
20024 } else {
20025 sv = *v
20026 }
20027
20028 for {
20029 t, done, err := decoder.Token()
20030 if err != nil {
20031 return err
20032 }
20033 if done {
20034 break
20035 }
20036 originalDecoder := decoder
20037 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20038 switch {
20039 case strings.EqualFold("Message", t.Name.Local):
20040 val, err := decoder.Value()
20041 if err != nil {
20042 return err
20043 }
20044 if val == nil {
20045 break
20046 }
20047 {
20048 xtv := string(val)
20049 sv.Message = ptr.String(xtv)
20050 }
20051
20052 default:
20053 // Do nothing and ignore the unexpected tag element
20054 err = decoder.Decoder.Skip()
20055 if err != nil {
20056 return err
20057 }
20058
20059 }
20060 decoder = originalDecoder
20061 }
20062 *v = sv
20063 return nil
20064 }
20065
20066 func awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(v **types.NoSuchCloudWatchLogsLogGroup, decoder smithyxml.NodeDecoder) error {
20067 if v == nil {
20068 return fmt.Errorf("unexpected nil of type %T", v)
20069 }
20070 var sv *types.NoSuchCloudWatchLogsLogGroup
20071 if *v == nil {
20072 sv = &types.NoSuchCloudWatchLogsLogGroup{}
20073 } else {
20074 sv = *v
20075 }
20076
20077 for {
20078 t, done, err := decoder.Token()
20079 if err != nil {
20080 return err
20081 }
20082 if done {
20083 break
20084 }
20085 originalDecoder := decoder
20086 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20087 switch {
20088 case strings.EqualFold("message", t.Name.Local):
20089 val, err := decoder.Value()
20090 if err != nil {
20091 return err
20092 }
20093 if val == nil {
20094 break
20095 }
20096 {
20097 xtv := string(val)
20098 sv.Message = ptr.String(xtv)
20099 }
20100
20101 default:
20102 // Do nothing and ignore the unexpected tag element
20103 err = decoder.Decoder.Skip()
20104 if err != nil {
20105 return err
20106 }
20107
20108 }
20109 decoder = originalDecoder
20110 }
20111 *v = sv
20112 return nil
20113 }
20114
20115 func awsRestxml_deserializeDocumentNoSuchDelegationSet(v **types.NoSuchDelegationSet, decoder smithyxml.NodeDecoder) error {
20116 if v == nil {
20117 return fmt.Errorf("unexpected nil of type %T", v)
20118 }
20119 var sv *types.NoSuchDelegationSet
20120 if *v == nil {
20121 sv = &types.NoSuchDelegationSet{}
20122 } else {
20123 sv = *v
20124 }
20125
20126 for {
20127 t, done, err := decoder.Token()
20128 if err != nil {
20129 return err
20130 }
20131 if done {
20132 break
20133 }
20134 originalDecoder := decoder
20135 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20136 switch {
20137 case strings.EqualFold("message", t.Name.Local):
20138 val, err := decoder.Value()
20139 if err != nil {
20140 return err
20141 }
20142 if val == nil {
20143 break
20144 }
20145 {
20146 xtv := string(val)
20147 sv.Message = ptr.String(xtv)
20148 }
20149
20150 default:
20151 // Do nothing and ignore the unexpected tag element
20152 err = decoder.Decoder.Skip()
20153 if err != nil {
20154 return err
20155 }
20156
20157 }
20158 decoder = originalDecoder
20159 }
20160 *v = sv
20161 return nil
20162 }
20163
20164 func awsRestxml_deserializeDocumentNoSuchGeoLocation(v **types.NoSuchGeoLocation, decoder smithyxml.NodeDecoder) error {
20165 if v == nil {
20166 return fmt.Errorf("unexpected nil of type %T", v)
20167 }
20168 var sv *types.NoSuchGeoLocation
20169 if *v == nil {
20170 sv = &types.NoSuchGeoLocation{}
20171 } else {
20172 sv = *v
20173 }
20174
20175 for {
20176 t, done, err := decoder.Token()
20177 if err != nil {
20178 return err
20179 }
20180 if done {
20181 break
20182 }
20183 originalDecoder := decoder
20184 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20185 switch {
20186 case strings.EqualFold("message", t.Name.Local):
20187 val, err := decoder.Value()
20188 if err != nil {
20189 return err
20190 }
20191 if val == nil {
20192 break
20193 }
20194 {
20195 xtv := string(val)
20196 sv.Message = ptr.String(xtv)
20197 }
20198
20199 default:
20200 // Do nothing and ignore the unexpected tag element
20201 err = decoder.Decoder.Skip()
20202 if err != nil {
20203 return err
20204 }
20205
20206 }
20207 decoder = originalDecoder
20208 }
20209 *v = sv
20210 return nil
20211 }
20212
20213 func awsRestxml_deserializeDocumentNoSuchHealthCheck(v **types.NoSuchHealthCheck, decoder smithyxml.NodeDecoder) error {
20214 if v == nil {
20215 return fmt.Errorf("unexpected nil of type %T", v)
20216 }
20217 var sv *types.NoSuchHealthCheck
20218 if *v == nil {
20219 sv = &types.NoSuchHealthCheck{}
20220 } else {
20221 sv = *v
20222 }
20223
20224 for {
20225 t, done, err := decoder.Token()
20226 if err != nil {
20227 return err
20228 }
20229 if done {
20230 break
20231 }
20232 originalDecoder := decoder
20233 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20234 switch {
20235 case strings.EqualFold("message", t.Name.Local):
20236 val, err := decoder.Value()
20237 if err != nil {
20238 return err
20239 }
20240 if val == nil {
20241 break
20242 }
20243 {
20244 xtv := string(val)
20245 sv.Message = ptr.String(xtv)
20246 }
20247
20248 default:
20249 // Do nothing and ignore the unexpected tag element
20250 err = decoder.Decoder.Skip()
20251 if err != nil {
20252 return err
20253 }
20254
20255 }
20256 decoder = originalDecoder
20257 }
20258 *v = sv
20259 return nil
20260 }
20261
20262 func awsRestxml_deserializeDocumentNoSuchHostedZone(v **types.NoSuchHostedZone, decoder smithyxml.NodeDecoder) error {
20263 if v == nil {
20264 return fmt.Errorf("unexpected nil of type %T", v)
20265 }
20266 var sv *types.NoSuchHostedZone
20267 if *v == nil {
20268 sv = &types.NoSuchHostedZone{}
20269 } else {
20270 sv = *v
20271 }
20272
20273 for {
20274 t, done, err := decoder.Token()
20275 if err != nil {
20276 return err
20277 }
20278 if done {
20279 break
20280 }
20281 originalDecoder := decoder
20282 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20283 switch {
20284 case strings.EqualFold("message", t.Name.Local):
20285 val, err := decoder.Value()
20286 if err != nil {
20287 return err
20288 }
20289 if val == nil {
20290 break
20291 }
20292 {
20293 xtv := string(val)
20294 sv.Message = ptr.String(xtv)
20295 }
20296
20297 default:
20298 // Do nothing and ignore the unexpected tag element
20299 err = decoder.Decoder.Skip()
20300 if err != nil {
20301 return err
20302 }
20303
20304 }
20305 decoder = originalDecoder
20306 }
20307 *v = sv
20308 return nil
20309 }
20310
20311 func awsRestxml_deserializeDocumentNoSuchKeySigningKey(v **types.NoSuchKeySigningKey, decoder smithyxml.NodeDecoder) error {
20312 if v == nil {
20313 return fmt.Errorf("unexpected nil of type %T", v)
20314 }
20315 var sv *types.NoSuchKeySigningKey
20316 if *v == nil {
20317 sv = &types.NoSuchKeySigningKey{}
20318 } else {
20319 sv = *v
20320 }
20321
20322 for {
20323 t, done, err := decoder.Token()
20324 if err != nil {
20325 return err
20326 }
20327 if done {
20328 break
20329 }
20330 originalDecoder := decoder
20331 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20332 switch {
20333 case strings.EqualFold("message", 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.Message = 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
20360 func awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(v **types.NoSuchQueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
20361 if v == nil {
20362 return fmt.Errorf("unexpected nil of type %T", v)
20363 }
20364 var sv *types.NoSuchQueryLoggingConfig
20365 if *v == nil {
20366 sv = &types.NoSuchQueryLoggingConfig{}
20367 } else {
20368 sv = *v
20369 }
20370
20371 for {
20372 t, done, err := decoder.Token()
20373 if err != nil {
20374 return err
20375 }
20376 if done {
20377 break
20378 }
20379 originalDecoder := decoder
20380 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20381 switch {
20382 case strings.EqualFold("message", t.Name.Local):
20383 val, err := decoder.Value()
20384 if err != nil {
20385 return err
20386 }
20387 if val == nil {
20388 break
20389 }
20390 {
20391 xtv := string(val)
20392 sv.Message = ptr.String(xtv)
20393 }
20394
20395 default:
20396 // Do nothing and ignore the unexpected tag element
20397 err = decoder.Decoder.Skip()
20398 if err != nil {
20399 return err
20400 }
20401
20402 }
20403 decoder = originalDecoder
20404 }
20405 *v = sv
20406 return nil
20407 }
20408
20409 func awsRestxml_deserializeDocumentNoSuchTrafficPolicy(v **types.NoSuchTrafficPolicy, decoder smithyxml.NodeDecoder) error {
20410 if v == nil {
20411 return fmt.Errorf("unexpected nil of type %T", v)
20412 }
20413 var sv *types.NoSuchTrafficPolicy
20414 if *v == nil {
20415 sv = &types.NoSuchTrafficPolicy{}
20416 } else {
20417 sv = *v
20418 }
20419
20420 for {
20421 t, done, err := decoder.Token()
20422 if err != nil {
20423 return err
20424 }
20425 if done {
20426 break
20427 }
20428 originalDecoder := decoder
20429 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20430 switch {
20431 case strings.EqualFold("message", t.Name.Local):
20432 val, err := decoder.Value()
20433 if err != nil {
20434 return err
20435 }
20436 if val == nil {
20437 break
20438 }
20439 {
20440 xtv := string(val)
20441 sv.Message = ptr.String(xtv)
20442 }
20443
20444 default:
20445 // Do nothing and ignore the unexpected tag element
20446 err = decoder.Decoder.Skip()
20447 if err != nil {
20448 return err
20449 }
20450
20451 }
20452 decoder = originalDecoder
20453 }
20454 *v = sv
20455 return nil
20456 }
20457
20458 func awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(v **types.NoSuchTrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
20459 if v == nil {
20460 return fmt.Errorf("unexpected nil of type %T", v)
20461 }
20462 var sv *types.NoSuchTrafficPolicyInstance
20463 if *v == nil {
20464 sv = &types.NoSuchTrafficPolicyInstance{}
20465 } else {
20466 sv = *v
20467 }
20468
20469 for {
20470 t, done, err := decoder.Token()
20471 if err != nil {
20472 return err
20473 }
20474 if done {
20475 break
20476 }
20477 originalDecoder := decoder
20478 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20479 switch {
20480 case strings.EqualFold("message", t.Name.Local):
20481 val, err := decoder.Value()
20482 if err != nil {
20483 return err
20484 }
20485 if val == nil {
20486 break
20487 }
20488 {
20489 xtv := string(val)
20490 sv.Message = ptr.String(xtv)
20491 }
20492
20493 default:
20494 // Do nothing and ignore the unexpected tag element
20495 err = decoder.Decoder.Skip()
20496 if err != nil {
20497 return err
20498 }
20499
20500 }
20501 decoder = originalDecoder
20502 }
20503 *v = sv
20504 return nil
20505 }
20506
20507 func awsRestxml_deserializeDocumentNotAuthorizedException(v **types.NotAuthorizedException, decoder smithyxml.NodeDecoder) error {
20508 if v == nil {
20509 return fmt.Errorf("unexpected nil of type %T", v)
20510 }
20511 var sv *types.NotAuthorizedException
20512 if *v == nil {
20513 sv = &types.NotAuthorizedException{}
20514 } else {
20515 sv = *v
20516 }
20517
20518 for {
20519 t, done, err := decoder.Token()
20520 if err != nil {
20521 return err
20522 }
20523 if done {
20524 break
20525 }
20526 originalDecoder := decoder
20527 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20528 switch {
20529 case strings.EqualFold("message", t.Name.Local):
20530 val, err := decoder.Value()
20531 if err != nil {
20532 return err
20533 }
20534 if val == nil {
20535 break
20536 }
20537 {
20538 xtv := string(val)
20539 sv.Message = ptr.String(xtv)
20540 }
20541
20542 default:
20543 // Do nothing and ignore the unexpected tag element
20544 err = decoder.Decoder.Skip()
20545 if err != nil {
20546 return err
20547 }
20548
20549 }
20550 decoder = originalDecoder
20551 }
20552 *v = sv
20553 return nil
20554 }
20555
20556 func awsRestxml_deserializeDocumentPriorRequestNotComplete(v **types.PriorRequestNotComplete, decoder smithyxml.NodeDecoder) error {
20557 if v == nil {
20558 return fmt.Errorf("unexpected nil of type %T", v)
20559 }
20560 var sv *types.PriorRequestNotComplete
20561 if *v == nil {
20562 sv = &types.PriorRequestNotComplete{}
20563 } else {
20564 sv = *v
20565 }
20566
20567 for {
20568 t, done, err := decoder.Token()
20569 if err != nil {
20570 return err
20571 }
20572 if done {
20573 break
20574 }
20575 originalDecoder := decoder
20576 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20577 switch {
20578 case strings.EqualFold("message", t.Name.Local):
20579 val, err := decoder.Value()
20580 if err != nil {
20581 return err
20582 }
20583 if val == nil {
20584 break
20585 }
20586 {
20587 xtv := string(val)
20588 sv.Message = ptr.String(xtv)
20589 }
20590
20591 default:
20592 // Do nothing and ignore the unexpected tag element
20593 err = decoder.Decoder.Skip()
20594 if err != nil {
20595 return err
20596 }
20597
20598 }
20599 decoder = originalDecoder
20600 }
20601 *v = sv
20602 return nil
20603 }
20604
20605 func awsRestxml_deserializeDocumentPublicZoneVPCAssociation(v **types.PublicZoneVPCAssociation, decoder smithyxml.NodeDecoder) error {
20606 if v == nil {
20607 return fmt.Errorf("unexpected nil of type %T", v)
20608 }
20609 var sv *types.PublicZoneVPCAssociation
20610 if *v == nil {
20611 sv = &types.PublicZoneVPCAssociation{}
20612 } else {
20613 sv = *v
20614 }
20615
20616 for {
20617 t, done, err := decoder.Token()
20618 if err != nil {
20619 return err
20620 }
20621 if done {
20622 break
20623 }
20624 originalDecoder := decoder
20625 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20626 switch {
20627 case strings.EqualFold("message", t.Name.Local):
20628 val, err := decoder.Value()
20629 if err != nil {
20630 return err
20631 }
20632 if val == nil {
20633 break
20634 }
20635 {
20636 xtv := string(val)
20637 sv.Message = ptr.String(xtv)
20638 }
20639
20640 default:
20641 // Do nothing and ignore the unexpected tag element
20642 err = decoder.Decoder.Skip()
20643 if err != nil {
20644 return err
20645 }
20646
20647 }
20648 decoder = originalDecoder
20649 }
20650 *v = sv
20651 return nil
20652 }
20653
20654 func awsRestxml_deserializeDocumentQueryLoggingConfig(v **types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
20655 if v == nil {
20656 return fmt.Errorf("unexpected nil of type %T", v)
20657 }
20658 var sv *types.QueryLoggingConfig
20659 if *v == nil {
20660 sv = &types.QueryLoggingConfig{}
20661 } else {
20662 sv = *v
20663 }
20664
20665 for {
20666 t, done, err := decoder.Token()
20667 if err != nil {
20668 return err
20669 }
20670 if done {
20671 break
20672 }
20673 originalDecoder := decoder
20674 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20675 switch {
20676 case strings.EqualFold("CloudWatchLogsLogGroupArn", t.Name.Local):
20677 val, err := decoder.Value()
20678 if err != nil {
20679 return err
20680 }
20681 if val == nil {
20682 break
20683 }
20684 {
20685 xtv := string(val)
20686 sv.CloudWatchLogsLogGroupArn = ptr.String(xtv)
20687 }
20688
20689 case strings.EqualFold("HostedZoneId", t.Name.Local):
20690 val, err := decoder.Value()
20691 if err != nil {
20692 return err
20693 }
20694 if val == nil {
20695 break
20696 }
20697 {
20698 xtv := string(val)
20699 sv.HostedZoneId = ptr.String(xtv)
20700 }
20701
20702 case strings.EqualFold("Id", t.Name.Local):
20703 val, err := decoder.Value()
20704 if err != nil {
20705 return err
20706 }
20707 if val == nil {
20708 break
20709 }
20710 {
20711 xtv := string(val)
20712 sv.Id = ptr.String(xtv)
20713 }
20714
20715 default:
20716 // Do nothing and ignore the unexpected tag element
20717 err = decoder.Decoder.Skip()
20718 if err != nil {
20719 return err
20720 }
20721
20722 }
20723 decoder = originalDecoder
20724 }
20725 *v = sv
20726 return nil
20727 }
20728
20729 func awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(v **types.QueryLoggingConfigAlreadyExists, decoder smithyxml.NodeDecoder) error {
20730 if v == nil {
20731 return fmt.Errorf("unexpected nil of type %T", v)
20732 }
20733 var sv *types.QueryLoggingConfigAlreadyExists
20734 if *v == nil {
20735 sv = &types.QueryLoggingConfigAlreadyExists{}
20736 } else {
20737 sv = *v
20738 }
20739
20740 for {
20741 t, done, err := decoder.Token()
20742 if err != nil {
20743 return err
20744 }
20745 if done {
20746 break
20747 }
20748 originalDecoder := decoder
20749 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20750 switch {
20751 case strings.EqualFold("message", t.Name.Local):
20752 val, err := decoder.Value()
20753 if err != nil {
20754 return err
20755 }
20756 if val == nil {
20757 break
20758 }
20759 {
20760 xtv := string(val)
20761 sv.Message = ptr.String(xtv)
20762 }
20763
20764 default:
20765 // Do nothing and ignore the unexpected tag element
20766 err = decoder.Decoder.Skip()
20767 if err != nil {
20768 return err
20769 }
20770
20771 }
20772 decoder = originalDecoder
20773 }
20774 *v = sv
20775 return nil
20776 }
20777
20778 func awsRestxml_deserializeDocumentQueryLoggingConfigs(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
20779 if v == nil {
20780 return fmt.Errorf("unexpected nil of type %T", v)
20781 }
20782 var sv []types.QueryLoggingConfig
20783 if *v == nil {
20784 sv = make([]types.QueryLoggingConfig, 0)
20785 } else {
20786 sv = *v
20787 }
20788
20789 originalDecoder := decoder
20790 for {
20791 t, done, err := decoder.Token()
20792 if err != nil {
20793 return err
20794 }
20795 if done {
20796 break
20797 }
20798 switch {
20799 case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
20800 var col types.QueryLoggingConfig
20801 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20802 destAddr := &col
20803 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil {
20804 return err
20805 }
20806 col = *destAddr
20807 sv = append(sv, col)
20808
20809 default:
20810 err = decoder.Decoder.Skip()
20811 if err != nil {
20812 return err
20813 }
20814
20815 }
20816 decoder = originalDecoder
20817 }
20818 *v = sv
20819 return nil
20820 }
20821
20822 func awsRestxml_deserializeDocumentQueryLoggingConfigsUnwrapped(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
20823 var sv []types.QueryLoggingConfig
20824 if *v == nil {
20825 sv = make([]types.QueryLoggingConfig, 0)
20826 } else {
20827 sv = *v
20828 }
20829
20830 switch {
20831 default:
20832 var mv types.QueryLoggingConfig
20833 t := decoder.StartEl
20834 _ = t
20835 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20836 destAddr := &mv
20837 if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil {
20838 return err
20839 }
20840 mv = *destAddr
20841 sv = append(sv, mv)
20842 }
20843 *v = sv
20844 return nil
20845 }
20846 func awsRestxml_deserializeDocumentRecordData(v *[]string, decoder smithyxml.NodeDecoder) error {
20847 if v == nil {
20848 return fmt.Errorf("unexpected nil of type %T", v)
20849 }
20850 var sv []string
20851 if *v == nil {
20852 sv = make([]string, 0)
20853 } else {
20854 sv = *v
20855 }
20856
20857 originalDecoder := decoder
20858 for {
20859 t, done, err := decoder.Token()
20860 if err != nil {
20861 return err
20862 }
20863 if done {
20864 break
20865 }
20866 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20867 decoder = memberDecoder
20868 switch {
20869 case strings.EqualFold("RecordDataEntry", t.Name.Local):
20870 var col string
20871 val, err := decoder.Value()
20872 if err != nil {
20873 return err
20874 }
20875 if val == nil {
20876 break
20877 }
20878 {
20879 xtv := string(val)
20880 col = xtv
20881 }
20882 sv = append(sv, col)
20883
20884 default:
20885 err = decoder.Decoder.Skip()
20886 if err != nil {
20887 return err
20888 }
20889
20890 }
20891 decoder = originalDecoder
20892 }
20893 *v = sv
20894 return nil
20895 }
20896
20897 func awsRestxml_deserializeDocumentRecordDataUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
20898 var sv []string
20899 if *v == nil {
20900 sv = make([]string, 0)
20901 } else {
20902 sv = *v
20903 }
20904
20905 switch {
20906 default:
20907 var mv string
20908 t := decoder.StartEl
20909 _ = t
20910 val, err := decoder.Value()
20911 if err != nil {
20912 return err
20913 }
20914 if val == nil {
20915 break
20916 }
20917 {
20918 xtv := string(val)
20919 mv = xtv
20920 }
20921 sv = append(sv, mv)
20922 }
20923 *v = sv
20924 return nil
20925 }
20926 func awsRestxml_deserializeDocumentResourceRecord(v **types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
20927 if v == nil {
20928 return fmt.Errorf("unexpected nil of type %T", v)
20929 }
20930 var sv *types.ResourceRecord
20931 if *v == nil {
20932 sv = &types.ResourceRecord{}
20933 } else {
20934 sv = *v
20935 }
20936
20937 for {
20938 t, done, err := decoder.Token()
20939 if err != nil {
20940 return err
20941 }
20942 if done {
20943 break
20944 }
20945 originalDecoder := decoder
20946 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20947 switch {
20948 case strings.EqualFold("Value", t.Name.Local):
20949 val, err := decoder.Value()
20950 if err != nil {
20951 return err
20952 }
20953 if val == nil {
20954 break
20955 }
20956 {
20957 xtv := string(val)
20958 sv.Value = ptr.String(xtv)
20959 }
20960
20961 default:
20962 // Do nothing and ignore the unexpected tag element
20963 err = decoder.Decoder.Skip()
20964 if err != nil {
20965 return err
20966 }
20967
20968 }
20969 decoder = originalDecoder
20970 }
20971 *v = sv
20972 return nil
20973 }
20974
20975 func awsRestxml_deserializeDocumentResourceRecords(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
20976 if v == nil {
20977 return fmt.Errorf("unexpected nil of type %T", v)
20978 }
20979 var sv []types.ResourceRecord
20980 if *v == nil {
20981 sv = make([]types.ResourceRecord, 0)
20982 } else {
20983 sv = *v
20984 }
20985
20986 originalDecoder := decoder
20987 for {
20988 t, done, err := decoder.Token()
20989 if err != nil {
20990 return err
20991 }
20992 if done {
20993 break
20994 }
20995 switch {
20996 case strings.EqualFold("ResourceRecord", t.Name.Local):
20997 var col types.ResourceRecord
20998 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20999 destAddr := &col
21000 if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil {
21001 return err
21002 }
21003 col = *destAddr
21004 sv = append(sv, col)
21005
21006 default:
21007 err = decoder.Decoder.Skip()
21008 if err != nil {
21009 return err
21010 }
21011
21012 }
21013 decoder = originalDecoder
21014 }
21015 *v = sv
21016 return nil
21017 }
21018
21019 func awsRestxml_deserializeDocumentResourceRecordsUnwrapped(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
21020 var sv []types.ResourceRecord
21021 if *v == nil {
21022 sv = make([]types.ResourceRecord, 0)
21023 } else {
21024 sv = *v
21025 }
21026
21027 switch {
21028 default:
21029 var mv types.ResourceRecord
21030 t := decoder.StartEl
21031 _ = t
21032 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21033 destAddr := &mv
21034 if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil {
21035 return err
21036 }
21037 mv = *destAddr
21038 sv = append(sv, mv)
21039 }
21040 *v = sv
21041 return nil
21042 }
21043 func awsRestxml_deserializeDocumentResourceRecordSet(v **types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
21044 if v == nil {
21045 return fmt.Errorf("unexpected nil of type %T", v)
21046 }
21047 var sv *types.ResourceRecordSet
21048 if *v == nil {
21049 sv = &types.ResourceRecordSet{}
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("AliasTarget", t.Name.Local):
21066 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21067 if err := awsRestxml_deserializeDocumentAliasTarget(&sv.AliasTarget, nodeDecoder); err != nil {
21068 return err
21069 }
21070
21071 case strings.EqualFold("CidrRoutingConfig", t.Name.Local):
21072 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21073 if err := awsRestxml_deserializeDocumentCidrRoutingConfig(&sv.CidrRoutingConfig, nodeDecoder); err != nil {
21074 return err
21075 }
21076
21077 case strings.EqualFold("Failover", t.Name.Local):
21078 val, err := decoder.Value()
21079 if err != nil {
21080 return err
21081 }
21082 if val == nil {
21083 break
21084 }
21085 {
21086 xtv := string(val)
21087 sv.Failover = types.ResourceRecordSetFailover(xtv)
21088 }
21089
21090 case strings.EqualFold("GeoLocation", t.Name.Local):
21091 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21092 if err := awsRestxml_deserializeDocumentGeoLocation(&sv.GeoLocation, nodeDecoder); err != nil {
21093 return err
21094 }
21095
21096 case strings.EqualFold("GeoProximityLocation", t.Name.Local):
21097 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21098 if err := awsRestxml_deserializeDocumentGeoProximityLocation(&sv.GeoProximityLocation, nodeDecoder); err != nil {
21099 return err
21100 }
21101
21102 case strings.EqualFold("HealthCheckId", t.Name.Local):
21103 val, err := decoder.Value()
21104 if err != nil {
21105 return err
21106 }
21107 if val == nil {
21108 break
21109 }
21110 {
21111 xtv := string(val)
21112 sv.HealthCheckId = ptr.String(xtv)
21113 }
21114
21115 case strings.EqualFold("MultiValueAnswer", t.Name.Local):
21116 val, err := decoder.Value()
21117 if err != nil {
21118 return err
21119 }
21120 if val == nil {
21121 break
21122 }
21123 {
21124 xtv, err := strconv.ParseBool(string(val))
21125 if err != nil {
21126 return fmt.Errorf("expected ResourceRecordSetMultiValueAnswer to be of type *bool, got %T instead", val)
21127 }
21128 sv.MultiValueAnswer = ptr.Bool(xtv)
21129 }
21130
21131 case strings.EqualFold("Name", t.Name.Local):
21132 val, err := decoder.Value()
21133 if err != nil {
21134 return err
21135 }
21136 if val == nil {
21137 break
21138 }
21139 {
21140 xtv := string(val)
21141 sv.Name = ptr.String(xtv)
21142 }
21143
21144 case strings.EqualFold("Region", t.Name.Local):
21145 val, err := decoder.Value()
21146 if err != nil {
21147 return err
21148 }
21149 if val == nil {
21150 break
21151 }
21152 {
21153 xtv := string(val)
21154 sv.Region = types.ResourceRecordSetRegion(xtv)
21155 }
21156
21157 case strings.EqualFold("ResourceRecords", t.Name.Local):
21158 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21159 if err := awsRestxml_deserializeDocumentResourceRecords(&sv.ResourceRecords, nodeDecoder); err != nil {
21160 return err
21161 }
21162
21163 case strings.EqualFold("SetIdentifier", t.Name.Local):
21164 val, err := decoder.Value()
21165 if err != nil {
21166 return err
21167 }
21168 if val == nil {
21169 break
21170 }
21171 {
21172 xtv := string(val)
21173 sv.SetIdentifier = ptr.String(xtv)
21174 }
21175
21176 case strings.EqualFold("TrafficPolicyInstanceId", t.Name.Local):
21177 val, err := decoder.Value()
21178 if err != nil {
21179 return err
21180 }
21181 if val == nil {
21182 break
21183 }
21184 {
21185 xtv := string(val)
21186 sv.TrafficPolicyInstanceId = ptr.String(xtv)
21187 }
21188
21189 case strings.EqualFold("TTL", t.Name.Local):
21190 val, err := decoder.Value()
21191 if err != nil {
21192 return err
21193 }
21194 if val == nil {
21195 break
21196 }
21197 {
21198 xtv := string(val)
21199 i64, err := strconv.ParseInt(xtv, 10, 64)
21200 if err != nil {
21201 return err
21202 }
21203 sv.TTL = ptr.Int64(i64)
21204 }
21205
21206 case strings.EqualFold("Type", t.Name.Local):
21207 val, err := decoder.Value()
21208 if err != nil {
21209 return err
21210 }
21211 if val == nil {
21212 break
21213 }
21214 {
21215 xtv := string(val)
21216 sv.Type = types.RRType(xtv)
21217 }
21218
21219 case strings.EqualFold("Weight", t.Name.Local):
21220 val, err := decoder.Value()
21221 if err != nil {
21222 return err
21223 }
21224 if val == nil {
21225 break
21226 }
21227 {
21228 xtv := string(val)
21229 i64, err := strconv.ParseInt(xtv, 10, 64)
21230 if err != nil {
21231 return err
21232 }
21233 sv.Weight = ptr.Int64(i64)
21234 }
21235
21236 default:
21237 // Do nothing and ignore the unexpected tag element
21238 err = decoder.Decoder.Skip()
21239 if err != nil {
21240 return err
21241 }
21242
21243 }
21244 decoder = originalDecoder
21245 }
21246 *v = sv
21247 return nil
21248 }
21249
21250 func awsRestxml_deserializeDocumentResourceRecordSets(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
21251 if v == nil {
21252 return fmt.Errorf("unexpected nil of type %T", v)
21253 }
21254 var sv []types.ResourceRecordSet
21255 if *v == nil {
21256 sv = make([]types.ResourceRecordSet, 0)
21257 } else {
21258 sv = *v
21259 }
21260
21261 originalDecoder := decoder
21262 for {
21263 t, done, err := decoder.Token()
21264 if err != nil {
21265 return err
21266 }
21267 if done {
21268 break
21269 }
21270 switch {
21271 case strings.EqualFold("ResourceRecordSet", t.Name.Local):
21272 var col types.ResourceRecordSet
21273 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21274 destAddr := &col
21275 if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil {
21276 return err
21277 }
21278 col = *destAddr
21279 sv = append(sv, col)
21280
21281 default:
21282 err = decoder.Decoder.Skip()
21283 if err != nil {
21284 return err
21285 }
21286
21287 }
21288 decoder = originalDecoder
21289 }
21290 *v = sv
21291 return nil
21292 }
21293
21294 func awsRestxml_deserializeDocumentResourceRecordSetsUnwrapped(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
21295 var sv []types.ResourceRecordSet
21296 if *v == nil {
21297 sv = make([]types.ResourceRecordSet, 0)
21298 } else {
21299 sv = *v
21300 }
21301
21302 switch {
21303 default:
21304 var mv types.ResourceRecordSet
21305 t := decoder.StartEl
21306 _ = t
21307 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21308 destAddr := &mv
21309 if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil {
21310 return err
21311 }
21312 mv = *destAddr
21313 sv = append(sv, mv)
21314 }
21315 *v = sv
21316 return nil
21317 }
21318 func awsRestxml_deserializeDocumentResourceTagSet(v **types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
21319 if v == nil {
21320 return fmt.Errorf("unexpected nil of type %T", v)
21321 }
21322 var sv *types.ResourceTagSet
21323 if *v == nil {
21324 sv = &types.ResourceTagSet{}
21325 } else {
21326 sv = *v
21327 }
21328
21329 for {
21330 t, done, err := decoder.Token()
21331 if err != nil {
21332 return err
21333 }
21334 if done {
21335 break
21336 }
21337 originalDecoder := decoder
21338 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21339 switch {
21340 case strings.EqualFold("ResourceId", t.Name.Local):
21341 val, err := decoder.Value()
21342 if err != nil {
21343 return err
21344 }
21345 if val == nil {
21346 break
21347 }
21348 {
21349 xtv := string(val)
21350 sv.ResourceId = ptr.String(xtv)
21351 }
21352
21353 case strings.EqualFold("ResourceType", t.Name.Local):
21354 val, err := decoder.Value()
21355 if err != nil {
21356 return err
21357 }
21358 if val == nil {
21359 break
21360 }
21361 {
21362 xtv := string(val)
21363 sv.ResourceType = types.TagResourceType(xtv)
21364 }
21365
21366 case strings.EqualFold("Tags", t.Name.Local):
21367 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21368 if err := awsRestxml_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil {
21369 return err
21370 }
21371
21372 default:
21373 // Do nothing and ignore the unexpected tag element
21374 err = decoder.Decoder.Skip()
21375 if err != nil {
21376 return err
21377 }
21378
21379 }
21380 decoder = originalDecoder
21381 }
21382 *v = sv
21383 return nil
21384 }
21385
21386 func awsRestxml_deserializeDocumentResourceTagSetList(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
21387 if v == nil {
21388 return fmt.Errorf("unexpected nil of type %T", v)
21389 }
21390 var sv []types.ResourceTagSet
21391 if *v == nil {
21392 sv = make([]types.ResourceTagSet, 0)
21393 } else {
21394 sv = *v
21395 }
21396
21397 originalDecoder := decoder
21398 for {
21399 t, done, err := decoder.Token()
21400 if err != nil {
21401 return err
21402 }
21403 if done {
21404 break
21405 }
21406 switch {
21407 case strings.EqualFold("ResourceTagSet", t.Name.Local):
21408 var col types.ResourceTagSet
21409 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21410 destAddr := &col
21411 if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil {
21412 return err
21413 }
21414 col = *destAddr
21415 sv = append(sv, col)
21416
21417 default:
21418 err = decoder.Decoder.Skip()
21419 if err != nil {
21420 return err
21421 }
21422
21423 }
21424 decoder = originalDecoder
21425 }
21426 *v = sv
21427 return nil
21428 }
21429
21430 func awsRestxml_deserializeDocumentResourceTagSetListUnwrapped(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
21431 var sv []types.ResourceTagSet
21432 if *v == nil {
21433 sv = make([]types.ResourceTagSet, 0)
21434 } else {
21435 sv = *v
21436 }
21437
21438 switch {
21439 default:
21440 var mv types.ResourceTagSet
21441 t := decoder.StartEl
21442 _ = t
21443 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21444 destAddr := &mv
21445 if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil {
21446 return err
21447 }
21448 mv = *destAddr
21449 sv = append(sv, mv)
21450 }
21451 *v = sv
21452 return nil
21453 }
21454 func awsRestxml_deserializeDocumentReusableDelegationSetLimit(v **types.ReusableDelegationSetLimit, decoder smithyxml.NodeDecoder) error {
21455 if v == nil {
21456 return fmt.Errorf("unexpected nil of type %T", v)
21457 }
21458 var sv *types.ReusableDelegationSetLimit
21459 if *v == nil {
21460 sv = &types.ReusableDelegationSetLimit{}
21461 } else {
21462 sv = *v
21463 }
21464
21465 for {
21466 t, done, err := decoder.Token()
21467 if err != nil {
21468 return err
21469 }
21470 if done {
21471 break
21472 }
21473 originalDecoder := decoder
21474 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21475 switch {
21476 case strings.EqualFold("Type", t.Name.Local):
21477 val, err := decoder.Value()
21478 if err != nil {
21479 return err
21480 }
21481 if val == nil {
21482 break
21483 }
21484 {
21485 xtv := string(val)
21486 sv.Type = types.ReusableDelegationSetLimitType(xtv)
21487 }
21488
21489 case strings.EqualFold("Value", t.Name.Local):
21490 val, err := decoder.Value()
21491 if err != nil {
21492 return err
21493 }
21494 if val == nil {
21495 break
21496 }
21497 {
21498 xtv := string(val)
21499 i64, err := strconv.ParseInt(xtv, 10, 64)
21500 if err != nil {
21501 return err
21502 }
21503 sv.Value = ptr.Int64(i64)
21504 }
21505
21506 default:
21507 // Do nothing and ignore the unexpected tag element
21508 err = decoder.Decoder.Skip()
21509 if err != nil {
21510 return err
21511 }
21512
21513 }
21514 decoder = originalDecoder
21515 }
21516 *v = sv
21517 return nil
21518 }
21519
21520 func awsRestxml_deserializeDocumentStatusReport(v **types.StatusReport, decoder smithyxml.NodeDecoder) error {
21521 if v == nil {
21522 return fmt.Errorf("unexpected nil of type %T", v)
21523 }
21524 var sv *types.StatusReport
21525 if *v == nil {
21526 sv = &types.StatusReport{}
21527 } else {
21528 sv = *v
21529 }
21530
21531 for {
21532 t, done, err := decoder.Token()
21533 if err != nil {
21534 return err
21535 }
21536 if done {
21537 break
21538 }
21539 originalDecoder := decoder
21540 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21541 switch {
21542 case strings.EqualFold("CheckedTime", t.Name.Local):
21543 val, err := decoder.Value()
21544 if err != nil {
21545 return err
21546 }
21547 if val == nil {
21548 break
21549 }
21550 {
21551 xtv := string(val)
21552 t, err := smithytime.ParseDateTime(xtv)
21553 if err != nil {
21554 return err
21555 }
21556 sv.CheckedTime = ptr.Time(t)
21557 }
21558
21559 case strings.EqualFold("Status", t.Name.Local):
21560 val, err := decoder.Value()
21561 if err != nil {
21562 return err
21563 }
21564 if val == nil {
21565 break
21566 }
21567 {
21568 xtv := string(val)
21569 sv.Status = ptr.String(xtv)
21570 }
21571
21572 default:
21573 // Do nothing and ignore the unexpected tag element
21574 err = decoder.Decoder.Skip()
21575 if err != nil {
21576 return err
21577 }
21578
21579 }
21580 decoder = originalDecoder
21581 }
21582 *v = sv
21583 return nil
21584 }
21585
21586 func awsRestxml_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error {
21587 if v == nil {
21588 return fmt.Errorf("unexpected nil of type %T", v)
21589 }
21590 var sv *types.Tag
21591 if *v == nil {
21592 sv = &types.Tag{}
21593 } else {
21594 sv = *v
21595 }
21596
21597 for {
21598 t, done, err := decoder.Token()
21599 if err != nil {
21600 return err
21601 }
21602 if done {
21603 break
21604 }
21605 originalDecoder := decoder
21606 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21607 switch {
21608 case strings.EqualFold("Key", t.Name.Local):
21609 val, err := decoder.Value()
21610 if err != nil {
21611 return err
21612 }
21613 if val == nil {
21614 break
21615 }
21616 {
21617 xtv := string(val)
21618 sv.Key = ptr.String(xtv)
21619 }
21620
21621 case strings.EqualFold("Value", t.Name.Local):
21622 val, err := decoder.Value()
21623 if err != nil {
21624 return err
21625 }
21626 if val == nil {
21627 break
21628 }
21629 {
21630 xtv := string(val)
21631 sv.Value = ptr.String(xtv)
21632 }
21633
21634 default:
21635 // Do nothing and ignore the unexpected tag element
21636 err = decoder.Decoder.Skip()
21637 if err != nil {
21638 return err
21639 }
21640
21641 }
21642 decoder = originalDecoder
21643 }
21644 *v = sv
21645 return nil
21646 }
21647
21648 func awsRestxml_deserializeDocumentTagList(v *[]types.Tag, decoder smithyxml.NodeDecoder) error {
21649 if v == nil {
21650 return fmt.Errorf("unexpected nil of type %T", v)
21651 }
21652 var sv []types.Tag
21653 if *v == nil {
21654 sv = make([]types.Tag, 0)
21655 } else {
21656 sv = *v
21657 }
21658
21659 originalDecoder := decoder
21660 for {
21661 t, done, err := decoder.Token()
21662 if err != nil {
21663 return err
21664 }
21665 if done {
21666 break
21667 }
21668 switch {
21669 case strings.EqualFold("Tag", t.Name.Local):
21670 var col types.Tag
21671 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21672 destAddr := &col
21673 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil {
21674 return err
21675 }
21676 col = *destAddr
21677 sv = append(sv, col)
21678
21679 default:
21680 err = decoder.Decoder.Skip()
21681 if err != nil {
21682 return err
21683 }
21684
21685 }
21686 decoder = originalDecoder
21687 }
21688 *v = sv
21689 return nil
21690 }
21691
21692 func awsRestxml_deserializeDocumentTagListUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error {
21693 var sv []types.Tag
21694 if *v == nil {
21695 sv = make([]types.Tag, 0)
21696 } else {
21697 sv = *v
21698 }
21699
21700 switch {
21701 default:
21702 var mv types.Tag
21703 t := decoder.StartEl
21704 _ = t
21705 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21706 destAddr := &mv
21707 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil {
21708 return err
21709 }
21710 mv = *destAddr
21711 sv = append(sv, mv)
21712 }
21713 *v = sv
21714 return nil
21715 }
21716 func awsRestxml_deserializeDocumentThrottlingException(v **types.ThrottlingException, decoder smithyxml.NodeDecoder) error {
21717 if v == nil {
21718 return fmt.Errorf("unexpected nil of type %T", v)
21719 }
21720 var sv *types.ThrottlingException
21721 if *v == nil {
21722 sv = &types.ThrottlingException{}
21723 } else {
21724 sv = *v
21725 }
21726
21727 for {
21728 t, done, err := decoder.Token()
21729 if err != nil {
21730 return err
21731 }
21732 if done {
21733 break
21734 }
21735 originalDecoder := decoder
21736 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21737 switch {
21738 case strings.EqualFold("message", t.Name.Local):
21739 val, err := decoder.Value()
21740 if err != nil {
21741 return err
21742 }
21743 if val == nil {
21744 break
21745 }
21746 {
21747 xtv := string(val)
21748 sv.Message = ptr.String(xtv)
21749 }
21750
21751 default:
21752 // Do nothing and ignore the unexpected tag element
21753 err = decoder.Decoder.Skip()
21754 if err != nil {
21755 return err
21756 }
21757
21758 }
21759 decoder = originalDecoder
21760 }
21761 *v = sv
21762 return nil
21763 }
21764
21765 func awsRestxml_deserializeDocumentTooManyHealthChecks(v **types.TooManyHealthChecks, decoder smithyxml.NodeDecoder) error {
21766 if v == nil {
21767 return fmt.Errorf("unexpected nil of type %T", v)
21768 }
21769 var sv *types.TooManyHealthChecks
21770 if *v == nil {
21771 sv = &types.TooManyHealthChecks{}
21772 } else {
21773 sv = *v
21774 }
21775
21776 for {
21777 t, done, err := decoder.Token()
21778 if err != nil {
21779 return err
21780 }
21781 if done {
21782 break
21783 }
21784 originalDecoder := decoder
21785 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21786 switch {
21787 case strings.EqualFold("message", t.Name.Local):
21788 val, err := decoder.Value()
21789 if err != nil {
21790 return err
21791 }
21792 if val == nil {
21793 break
21794 }
21795 {
21796 xtv := string(val)
21797 sv.Message = ptr.String(xtv)
21798 }
21799
21800 default:
21801 // Do nothing and ignore the unexpected tag element
21802 err = decoder.Decoder.Skip()
21803 if err != nil {
21804 return err
21805 }
21806
21807 }
21808 decoder = originalDecoder
21809 }
21810 *v = sv
21811 return nil
21812 }
21813
21814 func awsRestxml_deserializeDocumentTooManyHostedZones(v **types.TooManyHostedZones, decoder smithyxml.NodeDecoder) error {
21815 if v == nil {
21816 return fmt.Errorf("unexpected nil of type %T", v)
21817 }
21818 var sv *types.TooManyHostedZones
21819 if *v == nil {
21820 sv = &types.TooManyHostedZones{}
21821 } else {
21822 sv = *v
21823 }
21824
21825 for {
21826 t, done, err := decoder.Token()
21827 if err != nil {
21828 return err
21829 }
21830 if done {
21831 break
21832 }
21833 originalDecoder := decoder
21834 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21835 switch {
21836 case strings.EqualFold("message", t.Name.Local):
21837 val, err := decoder.Value()
21838 if err != nil {
21839 return err
21840 }
21841 if val == nil {
21842 break
21843 }
21844 {
21845 xtv := string(val)
21846 sv.Message = ptr.String(xtv)
21847 }
21848
21849 default:
21850 // Do nothing and ignore the unexpected tag element
21851 err = decoder.Decoder.Skip()
21852 if err != nil {
21853 return err
21854 }
21855
21856 }
21857 decoder = originalDecoder
21858 }
21859 *v = sv
21860 return nil
21861 }
21862
21863 func awsRestxml_deserializeDocumentTooManyKeySigningKeys(v **types.TooManyKeySigningKeys, decoder smithyxml.NodeDecoder) error {
21864 if v == nil {
21865 return fmt.Errorf("unexpected nil of type %T", v)
21866 }
21867 var sv *types.TooManyKeySigningKeys
21868 if *v == nil {
21869 sv = &types.TooManyKeySigningKeys{}
21870 } else {
21871 sv = *v
21872 }
21873
21874 for {
21875 t, done, err := decoder.Token()
21876 if err != nil {
21877 return err
21878 }
21879 if done {
21880 break
21881 }
21882 originalDecoder := decoder
21883 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21884 switch {
21885 case strings.EqualFold("message", t.Name.Local):
21886 val, err := decoder.Value()
21887 if err != nil {
21888 return err
21889 }
21890 if val == nil {
21891 break
21892 }
21893 {
21894 xtv := string(val)
21895 sv.Message = ptr.String(xtv)
21896 }
21897
21898 default:
21899 // Do nothing and ignore the unexpected tag element
21900 err = decoder.Decoder.Skip()
21901 if err != nil {
21902 return err
21903 }
21904
21905 }
21906 decoder = originalDecoder
21907 }
21908 *v = sv
21909 return nil
21910 }
21911
21912 func awsRestxml_deserializeDocumentTooManyTrafficPolicies(v **types.TooManyTrafficPolicies, decoder smithyxml.NodeDecoder) error {
21913 if v == nil {
21914 return fmt.Errorf("unexpected nil of type %T", v)
21915 }
21916 var sv *types.TooManyTrafficPolicies
21917 if *v == nil {
21918 sv = &types.TooManyTrafficPolicies{}
21919 } else {
21920 sv = *v
21921 }
21922
21923 for {
21924 t, done, err := decoder.Token()
21925 if err != nil {
21926 return err
21927 }
21928 if done {
21929 break
21930 }
21931 originalDecoder := decoder
21932 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21933 switch {
21934 case strings.EqualFold("message", t.Name.Local):
21935 val, err := decoder.Value()
21936 if err != nil {
21937 return err
21938 }
21939 if val == nil {
21940 break
21941 }
21942 {
21943 xtv := string(val)
21944 sv.Message = ptr.String(xtv)
21945 }
21946
21947 default:
21948 // Do nothing and ignore the unexpected tag element
21949 err = decoder.Decoder.Skip()
21950 if err != nil {
21951 return err
21952 }
21953
21954 }
21955 decoder = originalDecoder
21956 }
21957 *v = sv
21958 return nil
21959 }
21960
21961 func awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(v **types.TooManyTrafficPolicyInstances, decoder smithyxml.NodeDecoder) error {
21962 if v == nil {
21963 return fmt.Errorf("unexpected nil of type %T", v)
21964 }
21965 var sv *types.TooManyTrafficPolicyInstances
21966 if *v == nil {
21967 sv = &types.TooManyTrafficPolicyInstances{}
21968 } else {
21969 sv = *v
21970 }
21971
21972 for {
21973 t, done, err := decoder.Token()
21974 if err != nil {
21975 return err
21976 }
21977 if done {
21978 break
21979 }
21980 originalDecoder := decoder
21981 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21982 switch {
21983 case strings.EqualFold("message", t.Name.Local):
21984 val, err := decoder.Value()
21985 if err != nil {
21986 return err
21987 }
21988 if val == nil {
21989 break
21990 }
21991 {
21992 xtv := string(val)
21993 sv.Message = ptr.String(xtv)
21994 }
21995
21996 default:
21997 // Do nothing and ignore the unexpected tag element
21998 err = decoder.Decoder.Skip()
21999 if err != nil {
22000 return err
22001 }
22002
22003 }
22004 decoder = originalDecoder
22005 }
22006 *v = sv
22007 return nil
22008 }
22009
22010 func awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(v **types.TooManyTrafficPolicyVersionsForCurrentPolicy, decoder smithyxml.NodeDecoder) error {
22011 if v == nil {
22012 return fmt.Errorf("unexpected nil of type %T", v)
22013 }
22014 var sv *types.TooManyTrafficPolicyVersionsForCurrentPolicy
22015 if *v == nil {
22016 sv = &types.TooManyTrafficPolicyVersionsForCurrentPolicy{}
22017 } else {
22018 sv = *v
22019 }
22020
22021 for {
22022 t, done, err := decoder.Token()
22023 if err != nil {
22024 return err
22025 }
22026 if done {
22027 break
22028 }
22029 originalDecoder := decoder
22030 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22031 switch {
22032 case strings.EqualFold("message", t.Name.Local):
22033 val, err := decoder.Value()
22034 if err != nil {
22035 return err
22036 }
22037 if val == nil {
22038 break
22039 }
22040 {
22041 xtv := string(val)
22042 sv.Message = ptr.String(xtv)
22043 }
22044
22045 default:
22046 // Do nothing and ignore the unexpected tag element
22047 err = decoder.Decoder.Skip()
22048 if err != nil {
22049 return err
22050 }
22051
22052 }
22053 decoder = originalDecoder
22054 }
22055 *v = sv
22056 return nil
22057 }
22058
22059 func awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(v **types.TooManyVPCAssociationAuthorizations, decoder smithyxml.NodeDecoder) error {
22060 if v == nil {
22061 return fmt.Errorf("unexpected nil of type %T", v)
22062 }
22063 var sv *types.TooManyVPCAssociationAuthorizations
22064 if *v == nil {
22065 sv = &types.TooManyVPCAssociationAuthorizations{}
22066 } else {
22067 sv = *v
22068 }
22069
22070 for {
22071 t, done, err := decoder.Token()
22072 if err != nil {
22073 return err
22074 }
22075 if done {
22076 break
22077 }
22078 originalDecoder := decoder
22079 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22080 switch {
22081 case strings.EqualFold("message", t.Name.Local):
22082 val, err := decoder.Value()
22083 if err != nil {
22084 return err
22085 }
22086 if val == nil {
22087 break
22088 }
22089 {
22090 xtv := string(val)
22091 sv.Message = ptr.String(xtv)
22092 }
22093
22094 default:
22095 // Do nothing and ignore the unexpected tag element
22096 err = decoder.Decoder.Skip()
22097 if err != nil {
22098 return err
22099 }
22100
22101 }
22102 decoder = originalDecoder
22103 }
22104 *v = sv
22105 return nil
22106 }
22107
22108 func awsRestxml_deserializeDocumentTrafficPolicies(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
22109 if v == nil {
22110 return fmt.Errorf("unexpected nil of type %T", v)
22111 }
22112 var sv []types.TrafficPolicy
22113 if *v == nil {
22114 sv = make([]types.TrafficPolicy, 0)
22115 } else {
22116 sv = *v
22117 }
22118
22119 originalDecoder := decoder
22120 for {
22121 t, done, err := decoder.Token()
22122 if err != nil {
22123 return err
22124 }
22125 if done {
22126 break
22127 }
22128 switch {
22129 case strings.EqualFold("TrafficPolicy", t.Name.Local):
22130 var col types.TrafficPolicy
22131 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22132 destAddr := &col
22133 if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil {
22134 return err
22135 }
22136 col = *destAddr
22137 sv = append(sv, col)
22138
22139 default:
22140 err = decoder.Decoder.Skip()
22141 if err != nil {
22142 return err
22143 }
22144
22145 }
22146 decoder = originalDecoder
22147 }
22148 *v = sv
22149 return nil
22150 }
22151
22152 func awsRestxml_deserializeDocumentTrafficPoliciesUnwrapped(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
22153 var sv []types.TrafficPolicy
22154 if *v == nil {
22155 sv = make([]types.TrafficPolicy, 0)
22156 } else {
22157 sv = *v
22158 }
22159
22160 switch {
22161 default:
22162 var mv types.TrafficPolicy
22163 t := decoder.StartEl
22164 _ = t
22165 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22166 destAddr := &mv
22167 if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil {
22168 return err
22169 }
22170 mv = *destAddr
22171 sv = append(sv, mv)
22172 }
22173 *v = sv
22174 return nil
22175 }
22176 func awsRestxml_deserializeDocumentTrafficPolicy(v **types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
22177 if v == nil {
22178 return fmt.Errorf("unexpected nil of type %T", v)
22179 }
22180 var sv *types.TrafficPolicy
22181 if *v == nil {
22182 sv = &types.TrafficPolicy{}
22183 } else {
22184 sv = *v
22185 }
22186
22187 for {
22188 t, done, err := decoder.Token()
22189 if err != nil {
22190 return err
22191 }
22192 if done {
22193 break
22194 }
22195 originalDecoder := decoder
22196 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22197 switch {
22198 case strings.EqualFold("Comment", t.Name.Local):
22199 val, err := decoder.Value()
22200 if err != nil {
22201 return err
22202 }
22203 if val == nil {
22204 break
22205 }
22206 {
22207 xtv := string(val)
22208 sv.Comment = ptr.String(xtv)
22209 }
22210
22211 case strings.EqualFold("Document", t.Name.Local):
22212 val, err := decoder.Value()
22213 if err != nil {
22214 return err
22215 }
22216 if val == nil {
22217 break
22218 }
22219 {
22220 xtv := string(val)
22221 sv.Document = ptr.String(xtv)
22222 }
22223
22224 case strings.EqualFold("Id", t.Name.Local):
22225 val, err := decoder.Value()
22226 if err != nil {
22227 return err
22228 }
22229 if val == nil {
22230 break
22231 }
22232 {
22233 xtv := string(val)
22234 sv.Id = ptr.String(xtv)
22235 }
22236
22237 case strings.EqualFold("Name", t.Name.Local):
22238 val, err := decoder.Value()
22239 if err != nil {
22240 return err
22241 }
22242 if val == nil {
22243 break
22244 }
22245 {
22246 xtv := string(val)
22247 sv.Name = ptr.String(xtv)
22248 }
22249
22250 case strings.EqualFold("Type", t.Name.Local):
22251 val, err := decoder.Value()
22252 if err != nil {
22253 return err
22254 }
22255 if val == nil {
22256 break
22257 }
22258 {
22259 xtv := string(val)
22260 sv.Type = types.RRType(xtv)
22261 }
22262
22263 case strings.EqualFold("Version", t.Name.Local):
22264 val, err := decoder.Value()
22265 if err != nil {
22266 return err
22267 }
22268 if val == nil {
22269 break
22270 }
22271 {
22272 xtv := string(val)
22273 i64, err := strconv.ParseInt(xtv, 10, 64)
22274 if err != nil {
22275 return err
22276 }
22277 sv.Version = ptr.Int32(int32(i64))
22278 }
22279
22280 default:
22281 // Do nothing and ignore the unexpected tag element
22282 err = decoder.Decoder.Skip()
22283 if err != nil {
22284 return err
22285 }
22286
22287 }
22288 decoder = originalDecoder
22289 }
22290 *v = sv
22291 return nil
22292 }
22293
22294 func awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(v **types.TrafficPolicyAlreadyExists, decoder smithyxml.NodeDecoder) error {
22295 if v == nil {
22296 return fmt.Errorf("unexpected nil of type %T", v)
22297 }
22298 var sv *types.TrafficPolicyAlreadyExists
22299 if *v == nil {
22300 sv = &types.TrafficPolicyAlreadyExists{}
22301 } else {
22302 sv = *v
22303 }
22304
22305 for {
22306 t, done, err := decoder.Token()
22307 if err != nil {
22308 return err
22309 }
22310 if done {
22311 break
22312 }
22313 originalDecoder := decoder
22314 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22315 switch {
22316 case strings.EqualFold("message", t.Name.Local):
22317 val, err := decoder.Value()
22318 if err != nil {
22319 return err
22320 }
22321 if val == nil {
22322 break
22323 }
22324 {
22325 xtv := string(val)
22326 sv.Message = ptr.String(xtv)
22327 }
22328
22329 default:
22330 // Do nothing and ignore the unexpected tag element
22331 err = decoder.Decoder.Skip()
22332 if err != nil {
22333 return err
22334 }
22335
22336 }
22337 decoder = originalDecoder
22338 }
22339 *v = sv
22340 return nil
22341 }
22342
22343 func awsRestxml_deserializeDocumentTrafficPolicyInstance(v **types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
22344 if v == nil {
22345 return fmt.Errorf("unexpected nil of type %T", v)
22346 }
22347 var sv *types.TrafficPolicyInstance
22348 if *v == nil {
22349 sv = &types.TrafficPolicyInstance{}
22350 } else {
22351 sv = *v
22352 }
22353
22354 for {
22355 t, done, err := decoder.Token()
22356 if err != nil {
22357 return err
22358 }
22359 if done {
22360 break
22361 }
22362 originalDecoder := decoder
22363 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22364 switch {
22365 case strings.EqualFold("HostedZoneId", t.Name.Local):
22366 val, err := decoder.Value()
22367 if err != nil {
22368 return err
22369 }
22370 if val == nil {
22371 break
22372 }
22373 {
22374 xtv := string(val)
22375 sv.HostedZoneId = ptr.String(xtv)
22376 }
22377
22378 case strings.EqualFold("Id", t.Name.Local):
22379 val, err := decoder.Value()
22380 if err != nil {
22381 return err
22382 }
22383 if val == nil {
22384 break
22385 }
22386 {
22387 xtv := string(val)
22388 sv.Id = ptr.String(xtv)
22389 }
22390
22391 case strings.EqualFold("Message", t.Name.Local):
22392 val, err := decoder.Value()
22393 if err != nil {
22394 return err
22395 }
22396 if val == nil {
22397 break
22398 }
22399 {
22400 xtv := string(val)
22401 sv.Message = ptr.String(xtv)
22402 }
22403
22404 case strings.EqualFold("Name", t.Name.Local):
22405 val, err := decoder.Value()
22406 if err != nil {
22407 return err
22408 }
22409 if val == nil {
22410 break
22411 }
22412 {
22413 xtv := string(val)
22414 sv.Name = ptr.String(xtv)
22415 }
22416
22417 case strings.EqualFold("State", t.Name.Local):
22418 val, err := decoder.Value()
22419 if err != nil {
22420 return err
22421 }
22422 if val == nil {
22423 break
22424 }
22425 {
22426 xtv := string(val)
22427 sv.State = ptr.String(xtv)
22428 }
22429
22430 case strings.EqualFold("TrafficPolicyId", t.Name.Local):
22431 val, err := decoder.Value()
22432 if err != nil {
22433 return err
22434 }
22435 if val == nil {
22436 break
22437 }
22438 {
22439 xtv := string(val)
22440 sv.TrafficPolicyId = ptr.String(xtv)
22441 }
22442
22443 case strings.EqualFold("TrafficPolicyType", t.Name.Local):
22444 val, err := decoder.Value()
22445 if err != nil {
22446 return err
22447 }
22448 if val == nil {
22449 break
22450 }
22451 {
22452 xtv := string(val)
22453 sv.TrafficPolicyType = types.RRType(xtv)
22454 }
22455
22456 case strings.EqualFold("TrafficPolicyVersion", t.Name.Local):
22457 val, err := decoder.Value()
22458 if err != nil {
22459 return err
22460 }
22461 if val == nil {
22462 break
22463 }
22464 {
22465 xtv := string(val)
22466 i64, err := strconv.ParseInt(xtv, 10, 64)
22467 if err != nil {
22468 return err
22469 }
22470 sv.TrafficPolicyVersion = ptr.Int32(int32(i64))
22471 }
22472
22473 case strings.EqualFold("TTL", t.Name.Local):
22474 val, err := decoder.Value()
22475 if err != nil {
22476 return err
22477 }
22478 if val == nil {
22479 break
22480 }
22481 {
22482 xtv := string(val)
22483 i64, err := strconv.ParseInt(xtv, 10, 64)
22484 if err != nil {
22485 return err
22486 }
22487 sv.TTL = ptr.Int64(i64)
22488 }
22489
22490 default:
22491 // Do nothing and ignore the unexpected tag element
22492 err = decoder.Decoder.Skip()
22493 if err != nil {
22494 return err
22495 }
22496
22497 }
22498 decoder = originalDecoder
22499 }
22500 *v = sv
22501 return nil
22502 }
22503
22504 func awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(v **types.TrafficPolicyInstanceAlreadyExists, decoder smithyxml.NodeDecoder) error {
22505 if v == nil {
22506 return fmt.Errorf("unexpected nil of type %T", v)
22507 }
22508 var sv *types.TrafficPolicyInstanceAlreadyExists
22509 if *v == nil {
22510 sv = &types.TrafficPolicyInstanceAlreadyExists{}
22511 } else {
22512 sv = *v
22513 }
22514
22515 for {
22516 t, done, err := decoder.Token()
22517 if err != nil {
22518 return err
22519 }
22520 if done {
22521 break
22522 }
22523 originalDecoder := decoder
22524 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22525 switch {
22526 case strings.EqualFold("message", t.Name.Local):
22527 val, err := decoder.Value()
22528 if err != nil {
22529 return err
22530 }
22531 if val == nil {
22532 break
22533 }
22534 {
22535 xtv := string(val)
22536 sv.Message = ptr.String(xtv)
22537 }
22538
22539 default:
22540 // Do nothing and ignore the unexpected tag element
22541 err = decoder.Decoder.Skip()
22542 if err != nil {
22543 return err
22544 }
22545
22546 }
22547 decoder = originalDecoder
22548 }
22549 *v = sv
22550 return nil
22551 }
22552
22553 func awsRestxml_deserializeDocumentTrafficPolicyInstances(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
22554 if v == nil {
22555 return fmt.Errorf("unexpected nil of type %T", v)
22556 }
22557 var sv []types.TrafficPolicyInstance
22558 if *v == nil {
22559 sv = make([]types.TrafficPolicyInstance, 0)
22560 } else {
22561 sv = *v
22562 }
22563
22564 originalDecoder := decoder
22565 for {
22566 t, done, err := decoder.Token()
22567 if err != nil {
22568 return err
22569 }
22570 if done {
22571 break
22572 }
22573 switch {
22574 case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
22575 var col types.TrafficPolicyInstance
22576 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22577 destAddr := &col
22578 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil {
22579 return err
22580 }
22581 col = *destAddr
22582 sv = append(sv, col)
22583
22584 default:
22585 err = decoder.Decoder.Skip()
22586 if err != nil {
22587 return err
22588 }
22589
22590 }
22591 decoder = originalDecoder
22592 }
22593 *v = sv
22594 return nil
22595 }
22596
22597 func awsRestxml_deserializeDocumentTrafficPolicyInstancesUnwrapped(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
22598 var sv []types.TrafficPolicyInstance
22599 if *v == nil {
22600 sv = make([]types.TrafficPolicyInstance, 0)
22601 } else {
22602 sv = *v
22603 }
22604
22605 switch {
22606 default:
22607 var mv types.TrafficPolicyInstance
22608 t := decoder.StartEl
22609 _ = t
22610 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22611 destAddr := &mv
22612 if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil {
22613 return err
22614 }
22615 mv = *destAddr
22616 sv = append(sv, mv)
22617 }
22618 *v = sv
22619 return nil
22620 }
22621 func awsRestxml_deserializeDocumentTrafficPolicyInUse(v **types.TrafficPolicyInUse, decoder smithyxml.NodeDecoder) error {
22622 if v == nil {
22623 return fmt.Errorf("unexpected nil of type %T", v)
22624 }
22625 var sv *types.TrafficPolicyInUse
22626 if *v == nil {
22627 sv = &types.TrafficPolicyInUse{}
22628 } else {
22629 sv = *v
22630 }
22631
22632 for {
22633 t, done, err := decoder.Token()
22634 if err != nil {
22635 return err
22636 }
22637 if done {
22638 break
22639 }
22640 originalDecoder := decoder
22641 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22642 switch {
22643 case strings.EqualFold("message", t.Name.Local):
22644 val, err := decoder.Value()
22645 if err != nil {
22646 return err
22647 }
22648 if val == nil {
22649 break
22650 }
22651 {
22652 xtv := string(val)
22653 sv.Message = ptr.String(xtv)
22654 }
22655
22656 default:
22657 // Do nothing and ignore the unexpected tag element
22658 err = decoder.Decoder.Skip()
22659 if err != nil {
22660 return err
22661 }
22662
22663 }
22664 decoder = originalDecoder
22665 }
22666 *v = sv
22667 return nil
22668 }
22669
22670 func awsRestxml_deserializeDocumentTrafficPolicySummaries(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
22671 if v == nil {
22672 return fmt.Errorf("unexpected nil of type %T", v)
22673 }
22674 var sv []types.TrafficPolicySummary
22675 if *v == nil {
22676 sv = make([]types.TrafficPolicySummary, 0)
22677 } else {
22678 sv = *v
22679 }
22680
22681 originalDecoder := decoder
22682 for {
22683 t, done, err := decoder.Token()
22684 if err != nil {
22685 return err
22686 }
22687 if done {
22688 break
22689 }
22690 switch {
22691 case strings.EqualFold("TrafficPolicySummary", t.Name.Local):
22692 var col types.TrafficPolicySummary
22693 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22694 destAddr := &col
22695 if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil {
22696 return err
22697 }
22698 col = *destAddr
22699 sv = append(sv, col)
22700
22701 default:
22702 err = decoder.Decoder.Skip()
22703 if err != nil {
22704 return err
22705 }
22706
22707 }
22708 decoder = originalDecoder
22709 }
22710 *v = sv
22711 return nil
22712 }
22713
22714 func awsRestxml_deserializeDocumentTrafficPolicySummariesUnwrapped(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
22715 var sv []types.TrafficPolicySummary
22716 if *v == nil {
22717 sv = make([]types.TrafficPolicySummary, 0)
22718 } else {
22719 sv = *v
22720 }
22721
22722 switch {
22723 default:
22724 var mv types.TrafficPolicySummary
22725 t := decoder.StartEl
22726 _ = t
22727 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22728 destAddr := &mv
22729 if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil {
22730 return err
22731 }
22732 mv = *destAddr
22733 sv = append(sv, mv)
22734 }
22735 *v = sv
22736 return nil
22737 }
22738 func awsRestxml_deserializeDocumentTrafficPolicySummary(v **types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
22739 if v == nil {
22740 return fmt.Errorf("unexpected nil of type %T", v)
22741 }
22742 var sv *types.TrafficPolicySummary
22743 if *v == nil {
22744 sv = &types.TrafficPolicySummary{}
22745 } else {
22746 sv = *v
22747 }
22748
22749 for {
22750 t, done, err := decoder.Token()
22751 if err != nil {
22752 return err
22753 }
22754 if done {
22755 break
22756 }
22757 originalDecoder := decoder
22758 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22759 switch {
22760 case strings.EqualFold("Id", t.Name.Local):
22761 val, err := decoder.Value()
22762 if err != nil {
22763 return err
22764 }
22765 if val == nil {
22766 break
22767 }
22768 {
22769 xtv := string(val)
22770 sv.Id = ptr.String(xtv)
22771 }
22772
22773 case strings.EqualFold("LatestVersion", t.Name.Local):
22774 val, err := decoder.Value()
22775 if err != nil {
22776 return err
22777 }
22778 if val == nil {
22779 break
22780 }
22781 {
22782 xtv := string(val)
22783 i64, err := strconv.ParseInt(xtv, 10, 64)
22784 if err != nil {
22785 return err
22786 }
22787 sv.LatestVersion = ptr.Int32(int32(i64))
22788 }
22789
22790 case strings.EqualFold("Name", t.Name.Local):
22791 val, err := decoder.Value()
22792 if err != nil {
22793 return err
22794 }
22795 if val == nil {
22796 break
22797 }
22798 {
22799 xtv := string(val)
22800 sv.Name = ptr.String(xtv)
22801 }
22802
22803 case strings.EqualFold("TrafficPolicyCount", t.Name.Local):
22804 val, err := decoder.Value()
22805 if err != nil {
22806 return err
22807 }
22808 if val == nil {
22809 break
22810 }
22811 {
22812 xtv := string(val)
22813 i64, err := strconv.ParseInt(xtv, 10, 64)
22814 if err != nil {
22815 return err
22816 }
22817 sv.TrafficPolicyCount = ptr.Int32(int32(i64))
22818 }
22819
22820 case strings.EqualFold("Type", t.Name.Local):
22821 val, err := decoder.Value()
22822 if err != nil {
22823 return err
22824 }
22825 if val == nil {
22826 break
22827 }
22828 {
22829 xtv := string(val)
22830 sv.Type = types.RRType(xtv)
22831 }
22832
22833 default:
22834 // Do nothing and ignore the unexpected tag element
22835 err = decoder.Decoder.Skip()
22836 if err != nil {
22837 return err
22838 }
22839
22840 }
22841 decoder = originalDecoder
22842 }
22843 *v = sv
22844 return nil
22845 }
22846
22847 func awsRestxml_deserializeDocumentVPC(v **types.VPC, decoder smithyxml.NodeDecoder) error {
22848 if v == nil {
22849 return fmt.Errorf("unexpected nil of type %T", v)
22850 }
22851 var sv *types.VPC
22852 if *v == nil {
22853 sv = &types.VPC{}
22854 } else {
22855 sv = *v
22856 }
22857
22858 for {
22859 t, done, err := decoder.Token()
22860 if err != nil {
22861 return err
22862 }
22863 if done {
22864 break
22865 }
22866 originalDecoder := decoder
22867 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22868 switch {
22869 case strings.EqualFold("VPCId", t.Name.Local):
22870 val, err := decoder.Value()
22871 if err != nil {
22872 return err
22873 }
22874 if val == nil {
22875 break
22876 }
22877 {
22878 xtv := string(val)
22879 sv.VPCId = ptr.String(xtv)
22880 }
22881
22882 case strings.EqualFold("VPCRegion", t.Name.Local):
22883 val, err := decoder.Value()
22884 if err != nil {
22885 return err
22886 }
22887 if val == nil {
22888 break
22889 }
22890 {
22891 xtv := string(val)
22892 sv.VPCRegion = types.VPCRegion(xtv)
22893 }
22894
22895 default:
22896 // Do nothing and ignore the unexpected tag element
22897 err = decoder.Decoder.Skip()
22898 if err != nil {
22899 return err
22900 }
22901
22902 }
22903 decoder = originalDecoder
22904 }
22905 *v = sv
22906 return nil
22907 }
22908
22909 func awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(v **types.VPCAssociationAuthorizationNotFound, decoder smithyxml.NodeDecoder) error {
22910 if v == nil {
22911 return fmt.Errorf("unexpected nil of type %T", v)
22912 }
22913 var sv *types.VPCAssociationAuthorizationNotFound
22914 if *v == nil {
22915 sv = &types.VPCAssociationAuthorizationNotFound{}
22916 } else {
22917 sv = *v
22918 }
22919
22920 for {
22921 t, done, err := decoder.Token()
22922 if err != nil {
22923 return err
22924 }
22925 if done {
22926 break
22927 }
22928 originalDecoder := decoder
22929 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22930 switch {
22931 case strings.EqualFold("message", t.Name.Local):
22932 val, err := decoder.Value()
22933 if err != nil {
22934 return err
22935 }
22936 if val == nil {
22937 break
22938 }
22939 {
22940 xtv := string(val)
22941 sv.Message = ptr.String(xtv)
22942 }
22943
22944 default:
22945 // Do nothing and ignore the unexpected tag element
22946 err = decoder.Decoder.Skip()
22947 if err != nil {
22948 return err
22949 }
22950
22951 }
22952 decoder = originalDecoder
22953 }
22954 *v = sv
22955 return nil
22956 }
22957
22958 func awsRestxml_deserializeDocumentVPCAssociationNotFound(v **types.VPCAssociationNotFound, decoder smithyxml.NodeDecoder) error {
22959 if v == nil {
22960 return fmt.Errorf("unexpected nil of type %T", v)
22961 }
22962 var sv *types.VPCAssociationNotFound
22963 if *v == nil {
22964 sv = &types.VPCAssociationNotFound{}
22965 } else {
22966 sv = *v
22967 }
22968
22969 for {
22970 t, done, err := decoder.Token()
22971 if err != nil {
22972 return err
22973 }
22974 if done {
22975 break
22976 }
22977 originalDecoder := decoder
22978 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22979 switch {
22980 case strings.EqualFold("message", t.Name.Local):
22981 val, err := decoder.Value()
22982 if err != nil {
22983 return err
22984 }
22985 if val == nil {
22986 break
22987 }
22988 {
22989 xtv := string(val)
22990 sv.Message = ptr.String(xtv)
22991 }
22992
22993 default:
22994 // Do nothing and ignore the unexpected tag element
22995 err = decoder.Decoder.Skip()
22996 if err != nil {
22997 return err
22998 }
22999
23000 }
23001 decoder = originalDecoder
23002 }
23003 *v = sv
23004 return nil
23005 }
23006
23007 func awsRestxml_deserializeDocumentVPCs(v *[]types.VPC, decoder smithyxml.NodeDecoder) error {
23008 if v == nil {
23009 return fmt.Errorf("unexpected nil of type %T", v)
23010 }
23011 var sv []types.VPC
23012 if *v == nil {
23013 sv = make([]types.VPC, 0)
23014 } else {
23015 sv = *v
23016 }
23017
23018 originalDecoder := decoder
23019 for {
23020 t, done, err := decoder.Token()
23021 if err != nil {
23022 return err
23023 }
23024 if done {
23025 break
23026 }
23027 switch {
23028 case strings.EqualFold("VPC", t.Name.Local):
23029 var col types.VPC
23030 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23031 destAddr := &col
23032 if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil {
23033 return err
23034 }
23035 col = *destAddr
23036 sv = append(sv, col)
23037
23038 default:
23039 err = decoder.Decoder.Skip()
23040 if err != nil {
23041 return err
23042 }
23043
23044 }
23045 decoder = originalDecoder
23046 }
23047 *v = sv
23048 return nil
23049 }
23050
23051 func awsRestxml_deserializeDocumentVPCsUnwrapped(v *[]types.VPC, decoder smithyxml.NodeDecoder) error {
23052 var sv []types.VPC
23053 if *v == nil {
23054 sv = make([]types.VPC, 0)
23055 } else {
23056 sv = *v
23057 }
23058
23059 switch {
23060 default:
23061 var mv types.VPC
23062 t := decoder.StartEl
23063 _ = t
23064 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23065 destAddr := &mv
23066 if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil {
23067 return err
23068 }
23069 mv = *destAddr
23070 sv = append(sv, mv)
23071 }
23072 *v = sv
23073 return nil
23074 }
23075