src

Go monorepo.
git clone git://code.dwrz.net/src
Log | Files | Refs

deserializers.go (598103B)

      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 	"io"
     11 	"strconv"
     12 	"strings"
     13 
     14 	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
     15 	awsxml "github.com/aws/aws-sdk-go-v2/aws/protocol/xml"
     16 	"github.com/aws/aws-sdk-go-v2/service/route53/types"
     17 	smithy "github.com/aws/smithy-go"
     18 	smithyxml "github.com/aws/smithy-go/encoding/xml"
     19 	smithyio "github.com/aws/smithy-go/io"
     20 	"github.com/aws/smithy-go/middleware"
     21 	"github.com/aws/smithy-go/ptr"
     22 	smithytime "github.com/aws/smithy-go/time"
     23 	"github.com/aws/smithy-go/tracing"
     24 	smithyhttp "github.com/aws/smithy-go/transport/http"
     25 )
     26 
     27 type awsRestxml_deserializeOpActivateKeySigningKey struct {
     28 }
     29 
     30 func (*awsRestxml_deserializeOpActivateKeySigningKey) ID() string {
     31 	return "OperationDeserializer"
     32 }
     33 
     34 func (m *awsRestxml_deserializeOpActivateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
     35 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
     36 ) {
     37 	out, metadata, err = next.HandleDeserialize(ctx, in)
     38 	if err != nil {
     39 		return out, metadata, err
     40 	}
     41 
     42 	response, ok := out.RawResponse.(*smithyhttp.Response)
     43 	if !ok {
     44 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
     45 	}
     46 
     47 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
     48 
     49 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
     50 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
     51 	defer endTimer()
     52 	defer span.End()
     53 
     54 	if response.StatusCode < 200 || response.StatusCode >= 300 {
     55 		return out, metadata, awsRestxml_deserializeOpErrorActivateKeySigningKey(response, &metadata)
     56 	}
     57 	output := &ActivateKeySigningKeyOutput{}
     58 	out.Result = output
     59 
     60 	var buff [1024]byte
     61 	ringBuffer := smithyio.NewRingBuffer(buff[:])
     62 	body := io.TeeReader(response.Body, ringBuffer)
     63 	rootDecoder := xml.NewDecoder(body)
     64 	t, err := smithyxml.FetchRootElement(rootDecoder)
     65 	if err == io.EOF {
     66 		return out, metadata, nil
     67 	}
     68 	if err != nil {
     69 		var snapshot bytes.Buffer
     70 		io.Copy(&snapshot, ringBuffer)
     71 		return out, metadata, &smithy.DeserializationError{
     72 			Err:      fmt.Errorf("failed to decode response body, %w", err),
     73 			Snapshot: snapshot.Bytes(),
     74 		}
     75 	}
     76 
     77 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
     78 	err = awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(&output, decoder)
     79 	if err != nil {
     80 		var snapshot bytes.Buffer
     81 		io.Copy(&snapshot, ringBuffer)
     82 		return out, metadata, &smithy.DeserializationError{
     83 			Err:      fmt.Errorf("failed to decode response body, %w", err),
     84 			Snapshot: snapshot.Bytes(),
     85 		}
     86 	}
     87 
     88 	span.End()
     89 	return out, metadata, err
     90 }
     91 
     92 func awsRestxml_deserializeOpErrorActivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
     93 	var errorBuffer bytes.Buffer
     94 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
     95 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
     96 	}
     97 	errorBody := bytes.NewReader(errorBuffer.Bytes())
     98 
     99 	errorCode := "UnknownError"
    100 	errorMessage := errorCode
    101 
    102 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    103 	if err != nil {
    104 		return err
    105 	}
    106 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    107 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    108 	}
    109 	if len(errorComponents.Code) != 0 {
    110 		errorCode = errorComponents.Code
    111 	}
    112 	if len(errorComponents.Message) != 0 {
    113 		errorMessage = errorComponents.Message
    114 	}
    115 	errorBody.Seek(0, io.SeekStart)
    116 	switch {
    117 	case strings.EqualFold("ConcurrentModification", errorCode):
    118 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
    119 
    120 	case strings.EqualFold("InvalidInput", errorCode):
    121 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    122 
    123 	case strings.EqualFold("InvalidKMSArn", errorCode):
    124 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
    125 
    126 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
    127 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
    128 
    129 	case strings.EqualFold("InvalidSigningStatus", errorCode):
    130 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
    131 
    132 	case strings.EqualFold("NoSuchKeySigningKey", errorCode):
    133 		return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
    134 
    135 	default:
    136 		genericError := &smithy.GenericAPIError{
    137 			Code:    errorCode,
    138 			Message: errorMessage,
    139 		}
    140 		return genericError
    141 
    142 	}
    143 }
    144 
    145 func awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(v **ActivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
    146 	if v == nil {
    147 		return fmt.Errorf("unexpected nil of type %T", v)
    148 	}
    149 	var sv *ActivateKeySigningKeyOutput
    150 	if *v == nil {
    151 		sv = &ActivateKeySigningKeyOutput{}
    152 	} else {
    153 		sv = *v
    154 	}
    155 
    156 	for {
    157 		t, done, err := decoder.Token()
    158 		if err != nil {
    159 			return err
    160 		}
    161 		if done {
    162 			break
    163 		}
    164 		originalDecoder := decoder
    165 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    166 		switch {
    167 		case strings.EqualFold("ChangeInfo", t.Name.Local):
    168 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    169 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
    170 				return err
    171 			}
    172 
    173 		default:
    174 			// Do nothing and ignore the unexpected tag element
    175 			err = decoder.Decoder.Skip()
    176 			if err != nil {
    177 				return err
    178 			}
    179 
    180 		}
    181 		decoder = originalDecoder
    182 	}
    183 	*v = sv
    184 	return nil
    185 }
    186 
    187 type awsRestxml_deserializeOpAssociateVPCWithHostedZone struct {
    188 }
    189 
    190 func (*awsRestxml_deserializeOpAssociateVPCWithHostedZone) ID() string {
    191 	return "OperationDeserializer"
    192 }
    193 
    194 func (m *awsRestxml_deserializeOpAssociateVPCWithHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    195 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    196 ) {
    197 	out, metadata, err = next.HandleDeserialize(ctx, in)
    198 	if err != nil {
    199 		return out, metadata, err
    200 	}
    201 
    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 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    208 
    209 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    210 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    211 	defer endTimer()
    212 	defer span.End()
    213 
    214 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    215 		return out, metadata, awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response, &metadata)
    216 	}
    217 	output := &AssociateVPCWithHostedZoneOutput{}
    218 	out.Result = output
    219 
    220 	var buff [1024]byte
    221 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    222 	body := io.TeeReader(response.Body, ringBuffer)
    223 	rootDecoder := xml.NewDecoder(body)
    224 	t, err := smithyxml.FetchRootElement(rootDecoder)
    225 	if err == io.EOF {
    226 		return out, metadata, nil
    227 	}
    228 	if err != nil {
    229 		var snapshot bytes.Buffer
    230 		io.Copy(&snapshot, ringBuffer)
    231 		return out, metadata, &smithy.DeserializationError{
    232 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    233 			Snapshot: snapshot.Bytes(),
    234 		}
    235 	}
    236 
    237 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    238 	err = awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(&output, decoder)
    239 	if err != nil {
    240 		var snapshot bytes.Buffer
    241 		io.Copy(&snapshot, ringBuffer)
    242 		return out, metadata, &smithy.DeserializationError{
    243 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    244 			Snapshot: snapshot.Bytes(),
    245 		}
    246 	}
    247 
    248 	span.End()
    249 	return out, metadata, err
    250 }
    251 
    252 func awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    253 	var errorBuffer bytes.Buffer
    254 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    255 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    256 	}
    257 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    258 
    259 	errorCode := "UnknownError"
    260 	errorMessage := errorCode
    261 
    262 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    263 	if err != nil {
    264 		return err
    265 	}
    266 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    267 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    268 	}
    269 	if len(errorComponents.Code) != 0 {
    270 		errorCode = errorComponents.Code
    271 	}
    272 	if len(errorComponents.Message) != 0 {
    273 		errorMessage = errorComponents.Message
    274 	}
    275 	errorBody.Seek(0, io.SeekStart)
    276 	switch {
    277 	case strings.EqualFold("ConflictingDomainExists", errorCode):
    278 		return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody)
    279 
    280 	case strings.EqualFold("InvalidInput", errorCode):
    281 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    282 
    283 	case strings.EqualFold("InvalidVPCId", errorCode):
    284 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
    285 
    286 	case strings.EqualFold("LimitsExceeded", errorCode):
    287 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
    288 
    289 	case strings.EqualFold("NoSuchHostedZone", errorCode):
    290 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
    291 
    292 	case strings.EqualFold("NotAuthorizedException", errorCode):
    293 		return awsRestxml_deserializeErrorNotAuthorizedException(response, errorBody)
    294 
    295 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
    296 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
    297 
    298 	case strings.EqualFold("PublicZoneVPCAssociation", errorCode):
    299 		return awsRestxml_deserializeErrorPublicZoneVPCAssociation(response, errorBody)
    300 
    301 	default:
    302 		genericError := &smithy.GenericAPIError{
    303 			Code:    errorCode,
    304 			Message: errorMessage,
    305 		}
    306 		return genericError
    307 
    308 	}
    309 }
    310 
    311 func awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(v **AssociateVPCWithHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
    312 	if v == nil {
    313 		return fmt.Errorf("unexpected nil of type %T", v)
    314 	}
    315 	var sv *AssociateVPCWithHostedZoneOutput
    316 	if *v == nil {
    317 		sv = &AssociateVPCWithHostedZoneOutput{}
    318 	} else {
    319 		sv = *v
    320 	}
    321 
    322 	for {
    323 		t, done, err := decoder.Token()
    324 		if err != nil {
    325 			return err
    326 		}
    327 		if done {
    328 			break
    329 		}
    330 		originalDecoder := decoder
    331 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    332 		switch {
    333 		case strings.EqualFold("ChangeInfo", t.Name.Local):
    334 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    335 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
    336 				return err
    337 			}
    338 
    339 		default:
    340 			// Do nothing and ignore the unexpected tag element
    341 			err = decoder.Decoder.Skip()
    342 			if err != nil {
    343 				return err
    344 			}
    345 
    346 		}
    347 		decoder = originalDecoder
    348 	}
    349 	*v = sv
    350 	return nil
    351 }
    352 
    353 type awsRestxml_deserializeOpChangeCidrCollection struct {
    354 }
    355 
    356 func (*awsRestxml_deserializeOpChangeCidrCollection) ID() string {
    357 	return "OperationDeserializer"
    358 }
    359 
    360 func (m *awsRestxml_deserializeOpChangeCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    361 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    362 ) {
    363 	out, metadata, err = next.HandleDeserialize(ctx, in)
    364 	if err != nil {
    365 		return out, metadata, err
    366 	}
    367 
    368 	response, ok := out.RawResponse.(*smithyhttp.Response)
    369 	if !ok {
    370 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    371 	}
    372 
    373 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    374 
    375 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    376 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    377 	defer endTimer()
    378 	defer span.End()
    379 
    380 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    381 		return out, metadata, awsRestxml_deserializeOpErrorChangeCidrCollection(response, &metadata)
    382 	}
    383 	output := &ChangeCidrCollectionOutput{}
    384 	out.Result = output
    385 
    386 	var buff [1024]byte
    387 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    388 	body := io.TeeReader(response.Body, ringBuffer)
    389 	rootDecoder := xml.NewDecoder(body)
    390 	t, err := smithyxml.FetchRootElement(rootDecoder)
    391 	if err == io.EOF {
    392 		return out, metadata, nil
    393 	}
    394 	if err != nil {
    395 		var snapshot bytes.Buffer
    396 		io.Copy(&snapshot, ringBuffer)
    397 		return out, metadata, &smithy.DeserializationError{
    398 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    399 			Snapshot: snapshot.Bytes(),
    400 		}
    401 	}
    402 
    403 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    404 	err = awsRestxml_deserializeOpDocumentChangeCidrCollectionOutput(&output, decoder)
    405 	if err != nil {
    406 		var snapshot bytes.Buffer
    407 		io.Copy(&snapshot, ringBuffer)
    408 		return out, metadata, &smithy.DeserializationError{
    409 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    410 			Snapshot: snapshot.Bytes(),
    411 		}
    412 	}
    413 
    414 	span.End()
    415 	return out, metadata, err
    416 }
    417 
    418 func awsRestxml_deserializeOpErrorChangeCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    419 	var errorBuffer bytes.Buffer
    420 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    421 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    422 	}
    423 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    424 
    425 	errorCode := "UnknownError"
    426 	errorMessage := errorCode
    427 
    428 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    429 	if err != nil {
    430 		return err
    431 	}
    432 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    433 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    434 	}
    435 	if len(errorComponents.Code) != 0 {
    436 		errorCode = errorComponents.Code
    437 	}
    438 	if len(errorComponents.Message) != 0 {
    439 		errorMessage = errorComponents.Message
    440 	}
    441 	errorBody.Seek(0, io.SeekStart)
    442 	switch {
    443 	case strings.EqualFold("CidrBlockInUseException", errorCode):
    444 		return awsRestxml_deserializeErrorCidrBlockInUseException(response, errorBody)
    445 
    446 	case strings.EqualFold("CidrCollectionVersionMismatchException", errorCode):
    447 		return awsRestxml_deserializeErrorCidrCollectionVersionMismatchException(response, errorBody)
    448 
    449 	case strings.EqualFold("ConcurrentModification", errorCode):
    450 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
    451 
    452 	case strings.EqualFold("InvalidInput", errorCode):
    453 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    454 
    455 	case strings.EqualFold("LimitsExceeded", errorCode):
    456 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
    457 
    458 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
    459 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
    460 
    461 	default:
    462 		genericError := &smithy.GenericAPIError{
    463 			Code:    errorCode,
    464 			Message: errorMessage,
    465 		}
    466 		return genericError
    467 
    468 	}
    469 }
    470 
    471 func awsRestxml_deserializeOpDocumentChangeCidrCollectionOutput(v **ChangeCidrCollectionOutput, decoder smithyxml.NodeDecoder) error {
    472 	if v == nil {
    473 		return fmt.Errorf("unexpected nil of type %T", v)
    474 	}
    475 	var sv *ChangeCidrCollectionOutput
    476 	if *v == nil {
    477 		sv = &ChangeCidrCollectionOutput{}
    478 	} else {
    479 		sv = *v
    480 	}
    481 
    482 	for {
    483 		t, done, err := decoder.Token()
    484 		if err != nil {
    485 			return err
    486 		}
    487 		if done {
    488 			break
    489 		}
    490 		originalDecoder := decoder
    491 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    492 		switch {
    493 		case strings.EqualFold("Id", t.Name.Local):
    494 			val, err := decoder.Value()
    495 			if err != nil {
    496 				return err
    497 			}
    498 			if val == nil {
    499 				break
    500 			}
    501 			{
    502 				xtv := string(val)
    503 				sv.Id = ptr.String(xtv)
    504 			}
    505 
    506 		default:
    507 			// Do nothing and ignore the unexpected tag element
    508 			err = decoder.Decoder.Skip()
    509 			if err != nil {
    510 				return err
    511 			}
    512 
    513 		}
    514 		decoder = originalDecoder
    515 	}
    516 	*v = sv
    517 	return nil
    518 }
    519 
    520 type awsRestxml_deserializeOpChangeResourceRecordSets struct {
    521 }
    522 
    523 func (*awsRestxml_deserializeOpChangeResourceRecordSets) ID() string {
    524 	return "OperationDeserializer"
    525 }
    526 
    527 func (m *awsRestxml_deserializeOpChangeResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    528 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    529 ) {
    530 	out, metadata, err = next.HandleDeserialize(ctx, in)
    531 	if err != nil {
    532 		return out, metadata, err
    533 	}
    534 
    535 	response, ok := out.RawResponse.(*smithyhttp.Response)
    536 	if !ok {
    537 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    538 	}
    539 
    540 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    541 
    542 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    543 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    544 	defer endTimer()
    545 	defer span.End()
    546 
    547 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    548 		return out, metadata, awsRestxml_deserializeOpErrorChangeResourceRecordSets(response, &metadata)
    549 	}
    550 	output := &ChangeResourceRecordSetsOutput{}
    551 	out.Result = output
    552 
    553 	var buff [1024]byte
    554 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    555 	body := io.TeeReader(response.Body, ringBuffer)
    556 	rootDecoder := xml.NewDecoder(body)
    557 	t, err := smithyxml.FetchRootElement(rootDecoder)
    558 	if err == io.EOF {
    559 		return out, metadata, nil
    560 	}
    561 	if err != nil {
    562 		var snapshot bytes.Buffer
    563 		io.Copy(&snapshot, ringBuffer)
    564 		return out, metadata, &smithy.DeserializationError{
    565 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    566 			Snapshot: snapshot.Bytes(),
    567 		}
    568 	}
    569 
    570 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    571 	err = awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(&output, decoder)
    572 	if err != nil {
    573 		var snapshot bytes.Buffer
    574 		io.Copy(&snapshot, ringBuffer)
    575 		return out, metadata, &smithy.DeserializationError{
    576 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    577 			Snapshot: snapshot.Bytes(),
    578 		}
    579 	}
    580 
    581 	span.End()
    582 	return out, metadata, err
    583 }
    584 
    585 func awsRestxml_deserializeOpErrorChangeResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    586 	var errorBuffer bytes.Buffer
    587 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    588 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    589 	}
    590 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    591 
    592 	errorCode := "UnknownError"
    593 	errorMessage := errorCode
    594 
    595 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    596 	if err != nil {
    597 		return err
    598 	}
    599 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    600 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    601 	}
    602 	if len(errorComponents.Code) != 0 {
    603 		errorCode = errorComponents.Code
    604 	}
    605 	if len(errorComponents.Message) != 0 {
    606 		errorMessage = errorComponents.Message
    607 	}
    608 	errorBody.Seek(0, io.SeekStart)
    609 	switch {
    610 	case strings.EqualFold("InvalidChangeBatch", errorCode):
    611 		return awsRestxml_deserializeErrorInvalidChangeBatch(response, errorBody)
    612 
    613 	case strings.EqualFold("InvalidInput", errorCode):
    614 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    615 
    616 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
    617 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
    618 
    619 	case strings.EqualFold("NoSuchHostedZone", errorCode):
    620 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
    621 
    622 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
    623 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
    624 
    625 	default:
    626 		genericError := &smithy.GenericAPIError{
    627 			Code:    errorCode,
    628 			Message: errorMessage,
    629 		}
    630 		return genericError
    631 
    632 	}
    633 }
    634 
    635 func awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(v **ChangeResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error {
    636 	if v == nil {
    637 		return fmt.Errorf("unexpected nil of type %T", v)
    638 	}
    639 	var sv *ChangeResourceRecordSetsOutput
    640 	if *v == nil {
    641 		sv = &ChangeResourceRecordSetsOutput{}
    642 	} else {
    643 		sv = *v
    644 	}
    645 
    646 	for {
    647 		t, done, err := decoder.Token()
    648 		if err != nil {
    649 			return err
    650 		}
    651 		if done {
    652 			break
    653 		}
    654 		originalDecoder := decoder
    655 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    656 		switch {
    657 		case strings.EqualFold("ChangeInfo", t.Name.Local):
    658 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    659 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
    660 				return err
    661 			}
    662 
    663 		default:
    664 			// Do nothing and ignore the unexpected tag element
    665 			err = decoder.Decoder.Skip()
    666 			if err != nil {
    667 				return err
    668 			}
    669 
    670 		}
    671 		decoder = originalDecoder
    672 	}
    673 	*v = sv
    674 	return nil
    675 }
    676 
    677 type awsRestxml_deserializeOpChangeTagsForResource struct {
    678 }
    679 
    680 func (*awsRestxml_deserializeOpChangeTagsForResource) ID() string {
    681 	return "OperationDeserializer"
    682 }
    683 
    684 func (m *awsRestxml_deserializeOpChangeTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    685 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    686 ) {
    687 	out, metadata, err = next.HandleDeserialize(ctx, in)
    688 	if err != nil {
    689 		return out, metadata, err
    690 	}
    691 
    692 	response, ok := out.RawResponse.(*smithyhttp.Response)
    693 	if !ok {
    694 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    695 	}
    696 
    697 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    698 
    699 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    700 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    701 	defer endTimer()
    702 	defer span.End()
    703 
    704 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    705 		return out, metadata, awsRestxml_deserializeOpErrorChangeTagsForResource(response, &metadata)
    706 	}
    707 	output := &ChangeTagsForResourceOutput{}
    708 	out.Result = output
    709 
    710 	span.End()
    711 	return out, metadata, err
    712 }
    713 
    714 func awsRestxml_deserializeOpErrorChangeTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    715 	var errorBuffer bytes.Buffer
    716 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    717 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    718 	}
    719 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    720 
    721 	errorCode := "UnknownError"
    722 	errorMessage := errorCode
    723 
    724 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    725 	if err != nil {
    726 		return err
    727 	}
    728 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    729 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    730 	}
    731 	if len(errorComponents.Code) != 0 {
    732 		errorCode = errorComponents.Code
    733 	}
    734 	if len(errorComponents.Message) != 0 {
    735 		errorMessage = errorComponents.Message
    736 	}
    737 	errorBody.Seek(0, io.SeekStart)
    738 	switch {
    739 	case strings.EqualFold("InvalidInput", errorCode):
    740 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    741 
    742 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
    743 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
    744 
    745 	case strings.EqualFold("NoSuchHostedZone", errorCode):
    746 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
    747 
    748 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
    749 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
    750 
    751 	case strings.EqualFold("ThrottlingException", errorCode):
    752 		return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
    753 
    754 	default:
    755 		genericError := &smithy.GenericAPIError{
    756 			Code:    errorCode,
    757 			Message: errorMessage,
    758 		}
    759 		return genericError
    760 
    761 	}
    762 }
    763 
    764 type awsRestxml_deserializeOpCreateCidrCollection struct {
    765 }
    766 
    767 func (*awsRestxml_deserializeOpCreateCidrCollection) ID() string {
    768 	return "OperationDeserializer"
    769 }
    770 
    771 func (m *awsRestxml_deserializeOpCreateCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    772 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    773 ) {
    774 	out, metadata, err = next.HandleDeserialize(ctx, in)
    775 	if err != nil {
    776 		return out, metadata, err
    777 	}
    778 
    779 	response, ok := out.RawResponse.(*smithyhttp.Response)
    780 	if !ok {
    781 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    782 	}
    783 
    784 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    785 
    786 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    787 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    788 	defer endTimer()
    789 	defer span.End()
    790 
    791 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    792 		return out, metadata, awsRestxml_deserializeOpErrorCreateCidrCollection(response, &metadata)
    793 	}
    794 	output := &CreateCidrCollectionOutput{}
    795 	out.Result = output
    796 
    797 	err = awsRestxml_deserializeOpHttpBindingsCreateCidrCollectionOutput(output, response)
    798 	if err != nil {
    799 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
    800 	}
    801 
    802 	var buff [1024]byte
    803 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    804 	body := io.TeeReader(response.Body, ringBuffer)
    805 	rootDecoder := xml.NewDecoder(body)
    806 	t, err := smithyxml.FetchRootElement(rootDecoder)
    807 	if err == io.EOF {
    808 		return out, metadata, nil
    809 	}
    810 	if err != nil {
    811 		var snapshot bytes.Buffer
    812 		io.Copy(&snapshot, ringBuffer)
    813 		return out, metadata, &smithy.DeserializationError{
    814 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    815 			Snapshot: snapshot.Bytes(),
    816 		}
    817 	}
    818 
    819 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    820 	err = awsRestxml_deserializeOpDocumentCreateCidrCollectionOutput(&output, decoder)
    821 	if err != nil {
    822 		var snapshot bytes.Buffer
    823 		io.Copy(&snapshot, ringBuffer)
    824 		return out, metadata, &smithy.DeserializationError{
    825 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    826 			Snapshot: snapshot.Bytes(),
    827 		}
    828 	}
    829 
    830 	span.End()
    831 	return out, metadata, err
    832 }
    833 
    834 func awsRestxml_deserializeOpErrorCreateCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    835 	var errorBuffer bytes.Buffer
    836 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    837 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    838 	}
    839 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    840 
    841 	errorCode := "UnknownError"
    842 	errorMessage := errorCode
    843 
    844 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    845 	if err != nil {
    846 		return err
    847 	}
    848 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    849 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    850 	}
    851 	if len(errorComponents.Code) != 0 {
    852 		errorCode = errorComponents.Code
    853 	}
    854 	if len(errorComponents.Message) != 0 {
    855 		errorMessage = errorComponents.Message
    856 	}
    857 	errorBody.Seek(0, io.SeekStart)
    858 	switch {
    859 	case strings.EqualFold("CidrCollectionAlreadyExistsException", errorCode):
    860 		return awsRestxml_deserializeErrorCidrCollectionAlreadyExistsException(response, errorBody)
    861 
    862 	case strings.EqualFold("ConcurrentModification", errorCode):
    863 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
    864 
    865 	case strings.EqualFold("InvalidInput", errorCode):
    866 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    867 
    868 	case strings.EqualFold("LimitsExceeded", errorCode):
    869 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
    870 
    871 	default:
    872 		genericError := &smithy.GenericAPIError{
    873 			Code:    errorCode,
    874 			Message: errorMessage,
    875 		}
    876 		return genericError
    877 
    878 	}
    879 }
    880 
    881 func awsRestxml_deserializeOpHttpBindingsCreateCidrCollectionOutput(v *CreateCidrCollectionOutput, response *smithyhttp.Response) error {
    882 	if v == nil {
    883 		return fmt.Errorf("unsupported deserialization for nil %T", v)
    884 	}
    885 
    886 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
    887 		headerValues[0] = strings.TrimSpace(headerValues[0])
    888 		v.Location = ptr.String(headerValues[0])
    889 	}
    890 
    891 	return nil
    892 }
    893 func awsRestxml_deserializeOpDocumentCreateCidrCollectionOutput(v **CreateCidrCollectionOutput, decoder smithyxml.NodeDecoder) error {
    894 	if v == nil {
    895 		return fmt.Errorf("unexpected nil of type %T", v)
    896 	}
    897 	var sv *CreateCidrCollectionOutput
    898 	if *v == nil {
    899 		sv = &CreateCidrCollectionOutput{}
    900 	} else {
    901 		sv = *v
    902 	}
    903 
    904 	for {
    905 		t, done, err := decoder.Token()
    906 		if err != nil {
    907 			return err
    908 		}
    909 		if done {
    910 			break
    911 		}
    912 		originalDecoder := decoder
    913 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    914 		switch {
    915 		case strings.EqualFold("Collection", t.Name.Local):
    916 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    917 			if err := awsRestxml_deserializeDocumentCidrCollection(&sv.Collection, nodeDecoder); err != nil {
    918 				return err
    919 			}
    920 
    921 		default:
    922 			// Do nothing and ignore the unexpected tag element
    923 			err = decoder.Decoder.Skip()
    924 			if err != nil {
    925 				return err
    926 			}
    927 
    928 		}
    929 		decoder = originalDecoder
    930 	}
    931 	*v = sv
    932 	return nil
    933 }
    934 
    935 type awsRestxml_deserializeOpCreateHealthCheck struct {
    936 }
    937 
    938 func (*awsRestxml_deserializeOpCreateHealthCheck) ID() string {
    939 	return "OperationDeserializer"
    940 }
    941 
    942 func (m *awsRestxml_deserializeOpCreateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    943 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    944 ) {
    945 	out, metadata, err = next.HandleDeserialize(ctx, in)
    946 	if err != nil {
    947 		return out, metadata, err
    948 	}
    949 
    950 	response, ok := out.RawResponse.(*smithyhttp.Response)
    951 	if !ok {
    952 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    953 	}
    954 
    955 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    956 
    957 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    958 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    959 	defer endTimer()
    960 	defer span.End()
    961 
    962 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    963 		return out, metadata, awsRestxml_deserializeOpErrorCreateHealthCheck(response, &metadata)
    964 	}
    965 	output := &CreateHealthCheckOutput{}
    966 	out.Result = output
    967 
    968 	err = awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(output, response)
    969 	if err != nil {
    970 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
    971 	}
    972 
    973 	var buff [1024]byte
    974 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    975 	body := io.TeeReader(response.Body, ringBuffer)
    976 	rootDecoder := xml.NewDecoder(body)
    977 	t, err := smithyxml.FetchRootElement(rootDecoder)
    978 	if err == io.EOF {
    979 		return out, metadata, nil
    980 	}
    981 	if err != nil {
    982 		var snapshot bytes.Buffer
    983 		io.Copy(&snapshot, ringBuffer)
    984 		return out, metadata, &smithy.DeserializationError{
    985 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    986 			Snapshot: snapshot.Bytes(),
    987 		}
    988 	}
    989 
    990 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    991 	err = awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(&output, decoder)
    992 	if err != nil {
    993 		var snapshot bytes.Buffer
    994 		io.Copy(&snapshot, ringBuffer)
    995 		return out, metadata, &smithy.DeserializationError{
    996 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    997 			Snapshot: snapshot.Bytes(),
    998 		}
    999 	}
   1000 
   1001 	span.End()
   1002 	return out, metadata, err
   1003 }
   1004 
   1005 func awsRestxml_deserializeOpErrorCreateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1006 	var errorBuffer bytes.Buffer
   1007 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1008 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1009 	}
   1010 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1011 
   1012 	errorCode := "UnknownError"
   1013 	errorMessage := errorCode
   1014 
   1015 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1016 	if err != nil {
   1017 		return err
   1018 	}
   1019 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1020 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1021 	}
   1022 	if len(errorComponents.Code) != 0 {
   1023 		errorCode = errorComponents.Code
   1024 	}
   1025 	if len(errorComponents.Message) != 0 {
   1026 		errorMessage = errorComponents.Message
   1027 	}
   1028 	errorBody.Seek(0, io.SeekStart)
   1029 	switch {
   1030 	case strings.EqualFold("HealthCheckAlreadyExists", errorCode):
   1031 		return awsRestxml_deserializeErrorHealthCheckAlreadyExists(response, errorBody)
   1032 
   1033 	case strings.EqualFold("InvalidInput", errorCode):
   1034 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1035 
   1036 	case strings.EqualFold("TooManyHealthChecks", errorCode):
   1037 		return awsRestxml_deserializeErrorTooManyHealthChecks(response, errorBody)
   1038 
   1039 	default:
   1040 		genericError := &smithy.GenericAPIError{
   1041 			Code:    errorCode,
   1042 			Message: errorMessage,
   1043 		}
   1044 		return genericError
   1045 
   1046 	}
   1047 }
   1048 
   1049 func awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(v *CreateHealthCheckOutput, response *smithyhttp.Response) error {
   1050 	if v == nil {
   1051 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1052 	}
   1053 
   1054 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1055 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1056 		v.Location = ptr.String(headerValues[0])
   1057 	}
   1058 
   1059 	return nil
   1060 }
   1061 func awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(v **CreateHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
   1062 	if v == nil {
   1063 		return fmt.Errorf("unexpected nil of type %T", v)
   1064 	}
   1065 	var sv *CreateHealthCheckOutput
   1066 	if *v == nil {
   1067 		sv = &CreateHealthCheckOutput{}
   1068 	} else {
   1069 		sv = *v
   1070 	}
   1071 
   1072 	for {
   1073 		t, done, err := decoder.Token()
   1074 		if err != nil {
   1075 			return err
   1076 		}
   1077 		if done {
   1078 			break
   1079 		}
   1080 		originalDecoder := decoder
   1081 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1082 		switch {
   1083 		case strings.EqualFold("HealthCheck", t.Name.Local):
   1084 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1085 			if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
   1086 				return err
   1087 			}
   1088 
   1089 		default:
   1090 			// Do nothing and ignore the unexpected tag element
   1091 			err = decoder.Decoder.Skip()
   1092 			if err != nil {
   1093 				return err
   1094 			}
   1095 
   1096 		}
   1097 		decoder = originalDecoder
   1098 	}
   1099 	*v = sv
   1100 	return nil
   1101 }
   1102 
   1103 type awsRestxml_deserializeOpCreateHostedZone struct {
   1104 }
   1105 
   1106 func (*awsRestxml_deserializeOpCreateHostedZone) ID() string {
   1107 	return "OperationDeserializer"
   1108 }
   1109 
   1110 func (m *awsRestxml_deserializeOpCreateHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1111 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1112 ) {
   1113 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1114 	if err != nil {
   1115 		return out, metadata, err
   1116 	}
   1117 
   1118 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1119 	if !ok {
   1120 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1121 	}
   1122 
   1123 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   1124 
   1125 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1126 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1127 	defer endTimer()
   1128 	defer span.End()
   1129 
   1130 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1131 		return out, metadata, awsRestxml_deserializeOpErrorCreateHostedZone(response, &metadata)
   1132 	}
   1133 	output := &CreateHostedZoneOutput{}
   1134 	out.Result = output
   1135 
   1136 	err = awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(output, response)
   1137 	if err != nil {
   1138 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1139 	}
   1140 
   1141 	var buff [1024]byte
   1142 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1143 	body := io.TeeReader(response.Body, ringBuffer)
   1144 	rootDecoder := xml.NewDecoder(body)
   1145 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1146 	if err == io.EOF {
   1147 		return out, metadata, nil
   1148 	}
   1149 	if err != nil {
   1150 		var snapshot bytes.Buffer
   1151 		io.Copy(&snapshot, ringBuffer)
   1152 		return out, metadata, &smithy.DeserializationError{
   1153 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1154 			Snapshot: snapshot.Bytes(),
   1155 		}
   1156 	}
   1157 
   1158 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1159 	err = awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(&output, decoder)
   1160 	if err != nil {
   1161 		var snapshot bytes.Buffer
   1162 		io.Copy(&snapshot, ringBuffer)
   1163 		return out, metadata, &smithy.DeserializationError{
   1164 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1165 			Snapshot: snapshot.Bytes(),
   1166 		}
   1167 	}
   1168 
   1169 	span.End()
   1170 	return out, metadata, err
   1171 }
   1172 
   1173 func awsRestxml_deserializeOpErrorCreateHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1174 	var errorBuffer bytes.Buffer
   1175 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1176 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1177 	}
   1178 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1179 
   1180 	errorCode := "UnknownError"
   1181 	errorMessage := errorCode
   1182 
   1183 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1184 	if err != nil {
   1185 		return err
   1186 	}
   1187 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1188 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1189 	}
   1190 	if len(errorComponents.Code) != 0 {
   1191 		errorCode = errorComponents.Code
   1192 	}
   1193 	if len(errorComponents.Message) != 0 {
   1194 		errorMessage = errorComponents.Message
   1195 	}
   1196 	errorBody.Seek(0, io.SeekStart)
   1197 	switch {
   1198 	case strings.EqualFold("ConflictingDomainExists", errorCode):
   1199 		return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody)
   1200 
   1201 	case strings.EqualFold("DelegationSetNotAvailable", errorCode):
   1202 		return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody)
   1203 
   1204 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   1205 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   1206 
   1207 	case strings.EqualFold("HostedZoneAlreadyExists", errorCode):
   1208 		return awsRestxml_deserializeErrorHostedZoneAlreadyExists(response, errorBody)
   1209 
   1210 	case strings.EqualFold("InvalidDomainName", errorCode):
   1211 		return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
   1212 
   1213 	case strings.EqualFold("InvalidInput", errorCode):
   1214 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1215 
   1216 	case strings.EqualFold("InvalidVPCId", errorCode):
   1217 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   1218 
   1219 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   1220 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   1221 
   1222 	case strings.EqualFold("TooManyHostedZones", errorCode):
   1223 		return awsRestxml_deserializeErrorTooManyHostedZones(response, errorBody)
   1224 
   1225 	default:
   1226 		genericError := &smithy.GenericAPIError{
   1227 			Code:    errorCode,
   1228 			Message: errorMessage,
   1229 		}
   1230 		return genericError
   1231 
   1232 	}
   1233 }
   1234 
   1235 func awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(v *CreateHostedZoneOutput, response *smithyhttp.Response) error {
   1236 	if v == nil {
   1237 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1238 	}
   1239 
   1240 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1241 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1242 		v.Location = ptr.String(headerValues[0])
   1243 	}
   1244 
   1245 	return nil
   1246 }
   1247 func awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(v **CreateHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   1248 	if v == nil {
   1249 		return fmt.Errorf("unexpected nil of type %T", v)
   1250 	}
   1251 	var sv *CreateHostedZoneOutput
   1252 	if *v == nil {
   1253 		sv = &CreateHostedZoneOutput{}
   1254 	} else {
   1255 		sv = *v
   1256 	}
   1257 
   1258 	for {
   1259 		t, done, err := decoder.Token()
   1260 		if err != nil {
   1261 			return err
   1262 		}
   1263 		if done {
   1264 			break
   1265 		}
   1266 		originalDecoder := decoder
   1267 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1268 		switch {
   1269 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   1270 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1271 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   1272 				return err
   1273 			}
   1274 
   1275 		case strings.EqualFold("DelegationSet", t.Name.Local):
   1276 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1277 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   1278 				return err
   1279 			}
   1280 
   1281 		case strings.EqualFold("HostedZone", t.Name.Local):
   1282 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1283 			if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
   1284 				return err
   1285 			}
   1286 
   1287 		case strings.EqualFold("VPC", t.Name.Local):
   1288 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1289 			if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil {
   1290 				return err
   1291 			}
   1292 
   1293 		default:
   1294 			// Do nothing and ignore the unexpected tag element
   1295 			err = decoder.Decoder.Skip()
   1296 			if err != nil {
   1297 				return err
   1298 			}
   1299 
   1300 		}
   1301 		decoder = originalDecoder
   1302 	}
   1303 	*v = sv
   1304 	return nil
   1305 }
   1306 
   1307 type awsRestxml_deserializeOpCreateKeySigningKey struct {
   1308 }
   1309 
   1310 func (*awsRestxml_deserializeOpCreateKeySigningKey) ID() string {
   1311 	return "OperationDeserializer"
   1312 }
   1313 
   1314 func (m *awsRestxml_deserializeOpCreateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1315 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1316 ) {
   1317 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1318 	if err != nil {
   1319 		return out, metadata, err
   1320 	}
   1321 
   1322 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1323 	if !ok {
   1324 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1325 	}
   1326 
   1327 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   1328 
   1329 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1330 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1331 	defer endTimer()
   1332 	defer span.End()
   1333 
   1334 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1335 		return out, metadata, awsRestxml_deserializeOpErrorCreateKeySigningKey(response, &metadata)
   1336 	}
   1337 	output := &CreateKeySigningKeyOutput{}
   1338 	out.Result = output
   1339 
   1340 	err = awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(output, response)
   1341 	if err != nil {
   1342 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1343 	}
   1344 
   1345 	var buff [1024]byte
   1346 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1347 	body := io.TeeReader(response.Body, ringBuffer)
   1348 	rootDecoder := xml.NewDecoder(body)
   1349 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1350 	if err == io.EOF {
   1351 		return out, metadata, nil
   1352 	}
   1353 	if err != nil {
   1354 		var snapshot bytes.Buffer
   1355 		io.Copy(&snapshot, ringBuffer)
   1356 		return out, metadata, &smithy.DeserializationError{
   1357 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1358 			Snapshot: snapshot.Bytes(),
   1359 		}
   1360 	}
   1361 
   1362 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1363 	err = awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(&output, decoder)
   1364 	if err != nil {
   1365 		var snapshot bytes.Buffer
   1366 		io.Copy(&snapshot, ringBuffer)
   1367 		return out, metadata, &smithy.DeserializationError{
   1368 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1369 			Snapshot: snapshot.Bytes(),
   1370 		}
   1371 	}
   1372 
   1373 	span.End()
   1374 	return out, metadata, err
   1375 }
   1376 
   1377 func awsRestxml_deserializeOpErrorCreateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1378 	var errorBuffer bytes.Buffer
   1379 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1380 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1381 	}
   1382 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1383 
   1384 	errorCode := "UnknownError"
   1385 	errorMessage := errorCode
   1386 
   1387 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1388 	if err != nil {
   1389 		return err
   1390 	}
   1391 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1392 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1393 	}
   1394 	if len(errorComponents.Code) != 0 {
   1395 		errorCode = errorComponents.Code
   1396 	}
   1397 	if len(errorComponents.Message) != 0 {
   1398 		errorMessage = errorComponents.Message
   1399 	}
   1400 	errorBody.Seek(0, io.SeekStart)
   1401 	switch {
   1402 	case strings.EqualFold("ConcurrentModification", errorCode):
   1403 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   1404 
   1405 	case strings.EqualFold("InvalidArgument", errorCode):
   1406 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   1407 
   1408 	case strings.EqualFold("InvalidInput", errorCode):
   1409 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1410 
   1411 	case strings.EqualFold("InvalidKMSArn", errorCode):
   1412 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   1413 
   1414 	case strings.EqualFold("InvalidKeySigningKeyName", errorCode):
   1415 		return awsRestxml_deserializeErrorInvalidKeySigningKeyName(response, errorBody)
   1416 
   1417 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   1418 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   1419 
   1420 	case strings.EqualFold("InvalidSigningStatus", errorCode):
   1421 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
   1422 
   1423 	case strings.EqualFold("KeySigningKeyAlreadyExists", errorCode):
   1424 		return awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response, errorBody)
   1425 
   1426 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   1427 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   1428 
   1429 	case strings.EqualFold("TooManyKeySigningKeys", errorCode):
   1430 		return awsRestxml_deserializeErrorTooManyKeySigningKeys(response, errorBody)
   1431 
   1432 	default:
   1433 		genericError := &smithy.GenericAPIError{
   1434 			Code:    errorCode,
   1435 			Message: errorMessage,
   1436 		}
   1437 		return genericError
   1438 
   1439 	}
   1440 }
   1441 
   1442 func awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(v *CreateKeySigningKeyOutput, response *smithyhttp.Response) error {
   1443 	if v == nil {
   1444 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1445 	}
   1446 
   1447 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1448 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1449 		v.Location = ptr.String(headerValues[0])
   1450 	}
   1451 
   1452 	return nil
   1453 }
   1454 func awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(v **CreateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
   1455 	if v == nil {
   1456 		return fmt.Errorf("unexpected nil of type %T", v)
   1457 	}
   1458 	var sv *CreateKeySigningKeyOutput
   1459 	if *v == nil {
   1460 		sv = &CreateKeySigningKeyOutput{}
   1461 	} else {
   1462 		sv = *v
   1463 	}
   1464 
   1465 	for {
   1466 		t, done, err := decoder.Token()
   1467 		if err != nil {
   1468 			return err
   1469 		}
   1470 		if done {
   1471 			break
   1472 		}
   1473 		originalDecoder := decoder
   1474 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1475 		switch {
   1476 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   1477 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1478 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   1479 				return err
   1480 			}
   1481 
   1482 		case strings.EqualFold("KeySigningKey", t.Name.Local):
   1483 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1484 			if err := awsRestxml_deserializeDocumentKeySigningKey(&sv.KeySigningKey, nodeDecoder); err != nil {
   1485 				return err
   1486 			}
   1487 
   1488 		default:
   1489 			// Do nothing and ignore the unexpected tag element
   1490 			err = decoder.Decoder.Skip()
   1491 			if err != nil {
   1492 				return err
   1493 			}
   1494 
   1495 		}
   1496 		decoder = originalDecoder
   1497 	}
   1498 	*v = sv
   1499 	return nil
   1500 }
   1501 
   1502 type awsRestxml_deserializeOpCreateQueryLoggingConfig struct {
   1503 }
   1504 
   1505 func (*awsRestxml_deserializeOpCreateQueryLoggingConfig) ID() string {
   1506 	return "OperationDeserializer"
   1507 }
   1508 
   1509 func (m *awsRestxml_deserializeOpCreateQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1510 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1511 ) {
   1512 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1513 	if err != nil {
   1514 		return out, metadata, err
   1515 	}
   1516 
   1517 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1518 	if !ok {
   1519 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1520 	}
   1521 
   1522 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   1523 
   1524 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1525 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1526 	defer endTimer()
   1527 	defer span.End()
   1528 
   1529 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1530 		return out, metadata, awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response, &metadata)
   1531 	}
   1532 	output := &CreateQueryLoggingConfigOutput{}
   1533 	out.Result = output
   1534 
   1535 	err = awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(output, response)
   1536 	if err != nil {
   1537 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1538 	}
   1539 
   1540 	var buff [1024]byte
   1541 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1542 	body := io.TeeReader(response.Body, ringBuffer)
   1543 	rootDecoder := xml.NewDecoder(body)
   1544 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1545 	if err == io.EOF {
   1546 		return out, metadata, nil
   1547 	}
   1548 	if err != nil {
   1549 		var snapshot bytes.Buffer
   1550 		io.Copy(&snapshot, ringBuffer)
   1551 		return out, metadata, &smithy.DeserializationError{
   1552 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1553 			Snapshot: snapshot.Bytes(),
   1554 		}
   1555 	}
   1556 
   1557 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1558 	err = awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(&output, decoder)
   1559 	if err != nil {
   1560 		var snapshot bytes.Buffer
   1561 		io.Copy(&snapshot, ringBuffer)
   1562 		return out, metadata, &smithy.DeserializationError{
   1563 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1564 			Snapshot: snapshot.Bytes(),
   1565 		}
   1566 	}
   1567 
   1568 	span.End()
   1569 	return out, metadata, err
   1570 }
   1571 
   1572 func awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1573 	var errorBuffer bytes.Buffer
   1574 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1575 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1576 	}
   1577 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1578 
   1579 	errorCode := "UnknownError"
   1580 	errorMessage := errorCode
   1581 
   1582 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1583 	if err != nil {
   1584 		return err
   1585 	}
   1586 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1587 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1588 	}
   1589 	if len(errorComponents.Code) != 0 {
   1590 		errorCode = errorComponents.Code
   1591 	}
   1592 	if len(errorComponents.Message) != 0 {
   1593 		errorMessage = errorComponents.Message
   1594 	}
   1595 	errorBody.Seek(0, io.SeekStart)
   1596 	switch {
   1597 	case strings.EqualFold("ConcurrentModification", errorCode):
   1598 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   1599 
   1600 	case strings.EqualFold("InsufficientCloudWatchLogsResourcePolicy", errorCode):
   1601 		return awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response, errorBody)
   1602 
   1603 	case strings.EqualFold("InvalidInput", errorCode):
   1604 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1605 
   1606 	case strings.EqualFold("NoSuchCloudWatchLogsLogGroup", errorCode):
   1607 		return awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response, errorBody)
   1608 
   1609 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   1610 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   1611 
   1612 	case strings.EqualFold("QueryLoggingConfigAlreadyExists", errorCode):
   1613 		return awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response, errorBody)
   1614 
   1615 	default:
   1616 		genericError := &smithy.GenericAPIError{
   1617 			Code:    errorCode,
   1618 			Message: errorMessage,
   1619 		}
   1620 		return genericError
   1621 
   1622 	}
   1623 }
   1624 
   1625 func awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(v *CreateQueryLoggingConfigOutput, response *smithyhttp.Response) error {
   1626 	if v == nil {
   1627 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1628 	}
   1629 
   1630 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1631 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1632 		v.Location = ptr.String(headerValues[0])
   1633 	}
   1634 
   1635 	return nil
   1636 }
   1637 func awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(v **CreateQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error {
   1638 	if v == nil {
   1639 		return fmt.Errorf("unexpected nil of type %T", v)
   1640 	}
   1641 	var sv *CreateQueryLoggingConfigOutput
   1642 	if *v == nil {
   1643 		sv = &CreateQueryLoggingConfigOutput{}
   1644 	} else {
   1645 		sv = *v
   1646 	}
   1647 
   1648 	for {
   1649 		t, done, err := decoder.Token()
   1650 		if err != nil {
   1651 			return err
   1652 		}
   1653 		if done {
   1654 			break
   1655 		}
   1656 		originalDecoder := decoder
   1657 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1658 		switch {
   1659 		case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
   1660 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1661 			if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil {
   1662 				return err
   1663 			}
   1664 
   1665 		default:
   1666 			// Do nothing and ignore the unexpected tag element
   1667 			err = decoder.Decoder.Skip()
   1668 			if err != nil {
   1669 				return err
   1670 			}
   1671 
   1672 		}
   1673 		decoder = originalDecoder
   1674 	}
   1675 	*v = sv
   1676 	return nil
   1677 }
   1678 
   1679 type awsRestxml_deserializeOpCreateReusableDelegationSet struct {
   1680 }
   1681 
   1682 func (*awsRestxml_deserializeOpCreateReusableDelegationSet) ID() string {
   1683 	return "OperationDeserializer"
   1684 }
   1685 
   1686 func (m *awsRestxml_deserializeOpCreateReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1687 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1688 ) {
   1689 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1690 	if err != nil {
   1691 		return out, metadata, err
   1692 	}
   1693 
   1694 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1695 	if !ok {
   1696 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1697 	}
   1698 
   1699 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   1700 
   1701 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1702 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1703 	defer endTimer()
   1704 	defer span.End()
   1705 
   1706 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1707 		return out, metadata, awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response, &metadata)
   1708 	}
   1709 	output := &CreateReusableDelegationSetOutput{}
   1710 	out.Result = output
   1711 
   1712 	err = awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(output, response)
   1713 	if err != nil {
   1714 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1715 	}
   1716 
   1717 	var buff [1024]byte
   1718 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1719 	body := io.TeeReader(response.Body, ringBuffer)
   1720 	rootDecoder := xml.NewDecoder(body)
   1721 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1722 	if err == io.EOF {
   1723 		return out, metadata, nil
   1724 	}
   1725 	if err != nil {
   1726 		var snapshot bytes.Buffer
   1727 		io.Copy(&snapshot, ringBuffer)
   1728 		return out, metadata, &smithy.DeserializationError{
   1729 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1730 			Snapshot: snapshot.Bytes(),
   1731 		}
   1732 	}
   1733 
   1734 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1735 	err = awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(&output, decoder)
   1736 	if err != nil {
   1737 		var snapshot bytes.Buffer
   1738 		io.Copy(&snapshot, ringBuffer)
   1739 		return out, metadata, &smithy.DeserializationError{
   1740 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1741 			Snapshot: snapshot.Bytes(),
   1742 		}
   1743 	}
   1744 
   1745 	span.End()
   1746 	return out, metadata, err
   1747 }
   1748 
   1749 func awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1750 	var errorBuffer bytes.Buffer
   1751 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1752 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1753 	}
   1754 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1755 
   1756 	errorCode := "UnknownError"
   1757 	errorMessage := errorCode
   1758 
   1759 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1760 	if err != nil {
   1761 		return err
   1762 	}
   1763 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1764 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1765 	}
   1766 	if len(errorComponents.Code) != 0 {
   1767 		errorCode = errorComponents.Code
   1768 	}
   1769 	if len(errorComponents.Message) != 0 {
   1770 		errorMessage = errorComponents.Message
   1771 	}
   1772 	errorBody.Seek(0, io.SeekStart)
   1773 	switch {
   1774 	case strings.EqualFold("DelegationSetAlreadyCreated", errorCode):
   1775 		return awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response, errorBody)
   1776 
   1777 	case strings.EqualFold("DelegationSetAlreadyReusable", errorCode):
   1778 		return awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response, errorBody)
   1779 
   1780 	case strings.EqualFold("DelegationSetNotAvailable", errorCode):
   1781 		return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody)
   1782 
   1783 	case strings.EqualFold("HostedZoneNotFound", errorCode):
   1784 		return awsRestxml_deserializeErrorHostedZoneNotFound(response, errorBody)
   1785 
   1786 	case strings.EqualFold("InvalidArgument", errorCode):
   1787 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   1788 
   1789 	case strings.EqualFold("InvalidInput", errorCode):
   1790 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1791 
   1792 	case strings.EqualFold("LimitsExceeded", errorCode):
   1793 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
   1794 
   1795 	default:
   1796 		genericError := &smithy.GenericAPIError{
   1797 			Code:    errorCode,
   1798 			Message: errorMessage,
   1799 		}
   1800 		return genericError
   1801 
   1802 	}
   1803 }
   1804 
   1805 func awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(v *CreateReusableDelegationSetOutput, response *smithyhttp.Response) error {
   1806 	if v == nil {
   1807 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1808 	}
   1809 
   1810 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1811 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1812 		v.Location = ptr.String(headerValues[0])
   1813 	}
   1814 
   1815 	return nil
   1816 }
   1817 func awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(v **CreateReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error {
   1818 	if v == nil {
   1819 		return fmt.Errorf("unexpected nil of type %T", v)
   1820 	}
   1821 	var sv *CreateReusableDelegationSetOutput
   1822 	if *v == nil {
   1823 		sv = &CreateReusableDelegationSetOutput{}
   1824 	} else {
   1825 		sv = *v
   1826 	}
   1827 
   1828 	for {
   1829 		t, done, err := decoder.Token()
   1830 		if err != nil {
   1831 			return err
   1832 		}
   1833 		if done {
   1834 			break
   1835 		}
   1836 		originalDecoder := decoder
   1837 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1838 		switch {
   1839 		case strings.EqualFold("DelegationSet", t.Name.Local):
   1840 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1841 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   1842 				return err
   1843 			}
   1844 
   1845 		default:
   1846 			// Do nothing and ignore the unexpected tag element
   1847 			err = decoder.Decoder.Skip()
   1848 			if err != nil {
   1849 				return err
   1850 			}
   1851 
   1852 		}
   1853 		decoder = originalDecoder
   1854 	}
   1855 	*v = sv
   1856 	return nil
   1857 }
   1858 
   1859 type awsRestxml_deserializeOpCreateTrafficPolicy struct {
   1860 }
   1861 
   1862 func (*awsRestxml_deserializeOpCreateTrafficPolicy) ID() string {
   1863 	return "OperationDeserializer"
   1864 }
   1865 
   1866 func (m *awsRestxml_deserializeOpCreateTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1867 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1868 ) {
   1869 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1870 	if err != nil {
   1871 		return out, metadata, err
   1872 	}
   1873 
   1874 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1875 	if !ok {
   1876 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1877 	}
   1878 
   1879 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   1880 
   1881 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1882 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1883 	defer endTimer()
   1884 	defer span.End()
   1885 
   1886 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1887 		return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicy(response, &metadata)
   1888 	}
   1889 	output := &CreateTrafficPolicyOutput{}
   1890 	out.Result = output
   1891 
   1892 	err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(output, response)
   1893 	if err != nil {
   1894 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1895 	}
   1896 
   1897 	var buff [1024]byte
   1898 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1899 	body := io.TeeReader(response.Body, ringBuffer)
   1900 	rootDecoder := xml.NewDecoder(body)
   1901 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1902 	if err == io.EOF {
   1903 		return out, metadata, nil
   1904 	}
   1905 	if err != nil {
   1906 		var snapshot bytes.Buffer
   1907 		io.Copy(&snapshot, ringBuffer)
   1908 		return out, metadata, &smithy.DeserializationError{
   1909 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1910 			Snapshot: snapshot.Bytes(),
   1911 		}
   1912 	}
   1913 
   1914 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1915 	err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(&output, decoder)
   1916 	if err != nil {
   1917 		var snapshot bytes.Buffer
   1918 		io.Copy(&snapshot, ringBuffer)
   1919 		return out, metadata, &smithy.DeserializationError{
   1920 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1921 			Snapshot: snapshot.Bytes(),
   1922 		}
   1923 	}
   1924 
   1925 	span.End()
   1926 	return out, metadata, err
   1927 }
   1928 
   1929 func awsRestxml_deserializeOpErrorCreateTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1930 	var errorBuffer bytes.Buffer
   1931 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1932 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1933 	}
   1934 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1935 
   1936 	errorCode := "UnknownError"
   1937 	errorMessage := errorCode
   1938 
   1939 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1940 	if err != nil {
   1941 		return err
   1942 	}
   1943 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1944 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1945 	}
   1946 	if len(errorComponents.Code) != 0 {
   1947 		errorCode = errorComponents.Code
   1948 	}
   1949 	if len(errorComponents.Message) != 0 {
   1950 		errorMessage = errorComponents.Message
   1951 	}
   1952 	errorBody.Seek(0, io.SeekStart)
   1953 	switch {
   1954 	case strings.EqualFold("InvalidInput", errorCode):
   1955 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1956 
   1957 	case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode):
   1958 		return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody)
   1959 
   1960 	case strings.EqualFold("TooManyTrafficPolicies", errorCode):
   1961 		return awsRestxml_deserializeErrorTooManyTrafficPolicies(response, errorBody)
   1962 
   1963 	case strings.EqualFold("TrafficPolicyAlreadyExists", errorCode):
   1964 		return awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response, errorBody)
   1965 
   1966 	default:
   1967 		genericError := &smithy.GenericAPIError{
   1968 			Code:    errorCode,
   1969 			Message: errorMessage,
   1970 		}
   1971 		return genericError
   1972 
   1973 	}
   1974 }
   1975 
   1976 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(v *CreateTrafficPolicyOutput, response *smithyhttp.Response) error {
   1977 	if v == nil {
   1978 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1979 	}
   1980 
   1981 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1982 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1983 		v.Location = ptr.String(headerValues[0])
   1984 	}
   1985 
   1986 	return nil
   1987 }
   1988 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(v **CreateTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error {
   1989 	if v == nil {
   1990 		return fmt.Errorf("unexpected nil of type %T", v)
   1991 	}
   1992 	var sv *CreateTrafficPolicyOutput
   1993 	if *v == nil {
   1994 		sv = &CreateTrafficPolicyOutput{}
   1995 	} else {
   1996 		sv = *v
   1997 	}
   1998 
   1999 	for {
   2000 		t, done, err := decoder.Token()
   2001 		if err != nil {
   2002 			return err
   2003 		}
   2004 		if done {
   2005 			break
   2006 		}
   2007 		originalDecoder := decoder
   2008 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2009 		switch {
   2010 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
   2011 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2012 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
   2013 				return err
   2014 			}
   2015 
   2016 		default:
   2017 			// Do nothing and ignore the unexpected tag element
   2018 			err = decoder.Decoder.Skip()
   2019 			if err != nil {
   2020 				return err
   2021 			}
   2022 
   2023 		}
   2024 		decoder = originalDecoder
   2025 	}
   2026 	*v = sv
   2027 	return nil
   2028 }
   2029 
   2030 type awsRestxml_deserializeOpCreateTrafficPolicyInstance struct {
   2031 }
   2032 
   2033 func (*awsRestxml_deserializeOpCreateTrafficPolicyInstance) ID() string {
   2034 	return "OperationDeserializer"
   2035 }
   2036 
   2037 func (m *awsRestxml_deserializeOpCreateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2038 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2039 ) {
   2040 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2041 	if err != nil {
   2042 		return out, metadata, err
   2043 	}
   2044 
   2045 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2046 	if !ok {
   2047 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2048 	}
   2049 
   2050 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   2051 
   2052 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2053 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2054 	defer endTimer()
   2055 	defer span.End()
   2056 
   2057 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2058 		return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response, &metadata)
   2059 	}
   2060 	output := &CreateTrafficPolicyInstanceOutput{}
   2061 	out.Result = output
   2062 
   2063 	err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(output, response)
   2064 	if err != nil {
   2065 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   2066 	}
   2067 
   2068 	var buff [1024]byte
   2069 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2070 	body := io.TeeReader(response.Body, ringBuffer)
   2071 	rootDecoder := xml.NewDecoder(body)
   2072 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2073 	if err == io.EOF {
   2074 		return out, metadata, nil
   2075 	}
   2076 	if err != nil {
   2077 		var snapshot bytes.Buffer
   2078 		io.Copy(&snapshot, ringBuffer)
   2079 		return out, metadata, &smithy.DeserializationError{
   2080 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2081 			Snapshot: snapshot.Bytes(),
   2082 		}
   2083 	}
   2084 
   2085 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2086 	err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(&output, decoder)
   2087 	if err != nil {
   2088 		var snapshot bytes.Buffer
   2089 		io.Copy(&snapshot, ringBuffer)
   2090 		return out, metadata, &smithy.DeserializationError{
   2091 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2092 			Snapshot: snapshot.Bytes(),
   2093 		}
   2094 	}
   2095 
   2096 	span.End()
   2097 	return out, metadata, err
   2098 }
   2099 
   2100 func awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2101 	var errorBuffer bytes.Buffer
   2102 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2103 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2104 	}
   2105 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2106 
   2107 	errorCode := "UnknownError"
   2108 	errorMessage := errorCode
   2109 
   2110 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2111 	if err != nil {
   2112 		return err
   2113 	}
   2114 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2115 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2116 	}
   2117 	if len(errorComponents.Code) != 0 {
   2118 		errorCode = errorComponents.Code
   2119 	}
   2120 	if len(errorComponents.Message) != 0 {
   2121 		errorMessage = errorComponents.Message
   2122 	}
   2123 	errorBody.Seek(0, io.SeekStart)
   2124 	switch {
   2125 	case strings.EqualFold("InvalidInput", errorCode):
   2126 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2127 
   2128 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   2129 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   2130 
   2131 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   2132 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   2133 
   2134 	case strings.EqualFold("TooManyTrafficPolicyInstances", errorCode):
   2135 		return awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response, errorBody)
   2136 
   2137 	case strings.EqualFold("TrafficPolicyInstanceAlreadyExists", errorCode):
   2138 		return awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response, errorBody)
   2139 
   2140 	default:
   2141 		genericError := &smithy.GenericAPIError{
   2142 			Code:    errorCode,
   2143 			Message: errorMessage,
   2144 		}
   2145 		return genericError
   2146 
   2147 	}
   2148 }
   2149 
   2150 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(v *CreateTrafficPolicyInstanceOutput, response *smithyhttp.Response) error {
   2151 	if v == nil {
   2152 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   2153 	}
   2154 
   2155 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   2156 		headerValues[0] = strings.TrimSpace(headerValues[0])
   2157 		v.Location = ptr.String(headerValues[0])
   2158 	}
   2159 
   2160 	return nil
   2161 }
   2162 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(v **CreateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
   2163 	if v == nil {
   2164 		return fmt.Errorf("unexpected nil of type %T", v)
   2165 	}
   2166 	var sv *CreateTrafficPolicyInstanceOutput
   2167 	if *v == nil {
   2168 		sv = &CreateTrafficPolicyInstanceOutput{}
   2169 	} else {
   2170 		sv = *v
   2171 	}
   2172 
   2173 	for {
   2174 		t, done, err := decoder.Token()
   2175 		if err != nil {
   2176 			return err
   2177 		}
   2178 		if done {
   2179 			break
   2180 		}
   2181 		originalDecoder := decoder
   2182 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2183 		switch {
   2184 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
   2185 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2186 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
   2187 				return err
   2188 			}
   2189 
   2190 		default:
   2191 			// Do nothing and ignore the unexpected tag element
   2192 			err = decoder.Decoder.Skip()
   2193 			if err != nil {
   2194 				return err
   2195 			}
   2196 
   2197 		}
   2198 		decoder = originalDecoder
   2199 	}
   2200 	*v = sv
   2201 	return nil
   2202 }
   2203 
   2204 type awsRestxml_deserializeOpCreateTrafficPolicyVersion struct {
   2205 }
   2206 
   2207 func (*awsRestxml_deserializeOpCreateTrafficPolicyVersion) ID() string {
   2208 	return "OperationDeserializer"
   2209 }
   2210 
   2211 func (m *awsRestxml_deserializeOpCreateTrafficPolicyVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2212 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2213 ) {
   2214 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2215 	if err != nil {
   2216 		return out, metadata, err
   2217 	}
   2218 
   2219 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2220 	if !ok {
   2221 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2222 	}
   2223 
   2224 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   2225 
   2226 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2227 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2228 	defer endTimer()
   2229 	defer span.End()
   2230 
   2231 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2232 		return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response, &metadata)
   2233 	}
   2234 	output := &CreateTrafficPolicyVersionOutput{}
   2235 	out.Result = output
   2236 
   2237 	err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(output, response)
   2238 	if err != nil {
   2239 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   2240 	}
   2241 
   2242 	var buff [1024]byte
   2243 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2244 	body := io.TeeReader(response.Body, ringBuffer)
   2245 	rootDecoder := xml.NewDecoder(body)
   2246 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2247 	if err == io.EOF {
   2248 		return out, metadata, nil
   2249 	}
   2250 	if err != nil {
   2251 		var snapshot bytes.Buffer
   2252 		io.Copy(&snapshot, ringBuffer)
   2253 		return out, metadata, &smithy.DeserializationError{
   2254 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2255 			Snapshot: snapshot.Bytes(),
   2256 		}
   2257 	}
   2258 
   2259 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2260 	err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(&output, decoder)
   2261 	if err != nil {
   2262 		var snapshot bytes.Buffer
   2263 		io.Copy(&snapshot, ringBuffer)
   2264 		return out, metadata, &smithy.DeserializationError{
   2265 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2266 			Snapshot: snapshot.Bytes(),
   2267 		}
   2268 	}
   2269 
   2270 	span.End()
   2271 	return out, metadata, err
   2272 }
   2273 
   2274 func awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2275 	var errorBuffer bytes.Buffer
   2276 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2277 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2278 	}
   2279 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2280 
   2281 	errorCode := "UnknownError"
   2282 	errorMessage := errorCode
   2283 
   2284 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2285 	if err != nil {
   2286 		return err
   2287 	}
   2288 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2289 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2290 	}
   2291 	if len(errorComponents.Code) != 0 {
   2292 		errorCode = errorComponents.Code
   2293 	}
   2294 	if len(errorComponents.Message) != 0 {
   2295 		errorMessage = errorComponents.Message
   2296 	}
   2297 	errorBody.Seek(0, io.SeekStart)
   2298 	switch {
   2299 	case strings.EqualFold("ConcurrentModification", errorCode):
   2300 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2301 
   2302 	case strings.EqualFold("InvalidInput", errorCode):
   2303 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2304 
   2305 	case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode):
   2306 		return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody)
   2307 
   2308 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   2309 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   2310 
   2311 	case strings.EqualFold("TooManyTrafficPolicyVersionsForCurrentPolicy", errorCode):
   2312 		return awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response, errorBody)
   2313 
   2314 	default:
   2315 		genericError := &smithy.GenericAPIError{
   2316 			Code:    errorCode,
   2317 			Message: errorMessage,
   2318 		}
   2319 		return genericError
   2320 
   2321 	}
   2322 }
   2323 
   2324 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(v *CreateTrafficPolicyVersionOutput, response *smithyhttp.Response) error {
   2325 	if v == nil {
   2326 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   2327 	}
   2328 
   2329 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   2330 		headerValues[0] = strings.TrimSpace(headerValues[0])
   2331 		v.Location = ptr.String(headerValues[0])
   2332 	}
   2333 
   2334 	return nil
   2335 }
   2336 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(v **CreateTrafficPolicyVersionOutput, decoder smithyxml.NodeDecoder) error {
   2337 	if v == nil {
   2338 		return fmt.Errorf("unexpected nil of type %T", v)
   2339 	}
   2340 	var sv *CreateTrafficPolicyVersionOutput
   2341 	if *v == nil {
   2342 		sv = &CreateTrafficPolicyVersionOutput{}
   2343 	} else {
   2344 		sv = *v
   2345 	}
   2346 
   2347 	for {
   2348 		t, done, err := decoder.Token()
   2349 		if err != nil {
   2350 			return err
   2351 		}
   2352 		if done {
   2353 			break
   2354 		}
   2355 		originalDecoder := decoder
   2356 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2357 		switch {
   2358 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
   2359 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2360 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
   2361 				return err
   2362 			}
   2363 
   2364 		default:
   2365 			// Do nothing and ignore the unexpected tag element
   2366 			err = decoder.Decoder.Skip()
   2367 			if err != nil {
   2368 				return err
   2369 			}
   2370 
   2371 		}
   2372 		decoder = originalDecoder
   2373 	}
   2374 	*v = sv
   2375 	return nil
   2376 }
   2377 
   2378 type awsRestxml_deserializeOpCreateVPCAssociationAuthorization struct {
   2379 }
   2380 
   2381 func (*awsRestxml_deserializeOpCreateVPCAssociationAuthorization) ID() string {
   2382 	return "OperationDeserializer"
   2383 }
   2384 
   2385 func (m *awsRestxml_deserializeOpCreateVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2386 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2387 ) {
   2388 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2389 	if err != nil {
   2390 		return out, metadata, err
   2391 	}
   2392 
   2393 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2394 	if !ok {
   2395 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2396 	}
   2397 
   2398 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   2399 
   2400 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2401 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2402 	defer endTimer()
   2403 	defer span.End()
   2404 
   2405 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2406 		return out, metadata, awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response, &metadata)
   2407 	}
   2408 	output := &CreateVPCAssociationAuthorizationOutput{}
   2409 	out.Result = output
   2410 
   2411 	var buff [1024]byte
   2412 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2413 	body := io.TeeReader(response.Body, ringBuffer)
   2414 	rootDecoder := xml.NewDecoder(body)
   2415 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2416 	if err == io.EOF {
   2417 		return out, metadata, nil
   2418 	}
   2419 	if err != nil {
   2420 		var snapshot bytes.Buffer
   2421 		io.Copy(&snapshot, ringBuffer)
   2422 		return out, metadata, &smithy.DeserializationError{
   2423 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2424 			Snapshot: snapshot.Bytes(),
   2425 		}
   2426 	}
   2427 
   2428 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2429 	err = awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(&output, decoder)
   2430 	if err != nil {
   2431 		var snapshot bytes.Buffer
   2432 		io.Copy(&snapshot, ringBuffer)
   2433 		return out, metadata, &smithy.DeserializationError{
   2434 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2435 			Snapshot: snapshot.Bytes(),
   2436 		}
   2437 	}
   2438 
   2439 	span.End()
   2440 	return out, metadata, err
   2441 }
   2442 
   2443 func awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2444 	var errorBuffer bytes.Buffer
   2445 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2446 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2447 	}
   2448 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2449 
   2450 	errorCode := "UnknownError"
   2451 	errorMessage := errorCode
   2452 
   2453 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2454 	if err != nil {
   2455 		return err
   2456 	}
   2457 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2458 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2459 	}
   2460 	if len(errorComponents.Code) != 0 {
   2461 		errorCode = errorComponents.Code
   2462 	}
   2463 	if len(errorComponents.Message) != 0 {
   2464 		errorMessage = errorComponents.Message
   2465 	}
   2466 	errorBody.Seek(0, io.SeekStart)
   2467 	switch {
   2468 	case strings.EqualFold("ConcurrentModification", errorCode):
   2469 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2470 
   2471 	case strings.EqualFold("InvalidInput", errorCode):
   2472 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2473 
   2474 	case strings.EqualFold("InvalidVPCId", errorCode):
   2475 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   2476 
   2477 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   2478 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   2479 
   2480 	case strings.EqualFold("TooManyVPCAssociationAuthorizations", errorCode):
   2481 		return awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response, errorBody)
   2482 
   2483 	default:
   2484 		genericError := &smithy.GenericAPIError{
   2485 			Code:    errorCode,
   2486 			Message: errorMessage,
   2487 		}
   2488 		return genericError
   2489 
   2490 	}
   2491 }
   2492 
   2493 func awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(v **CreateVPCAssociationAuthorizationOutput, decoder smithyxml.NodeDecoder) error {
   2494 	if v == nil {
   2495 		return fmt.Errorf("unexpected nil of type %T", v)
   2496 	}
   2497 	var sv *CreateVPCAssociationAuthorizationOutput
   2498 	if *v == nil {
   2499 		sv = &CreateVPCAssociationAuthorizationOutput{}
   2500 	} else {
   2501 		sv = *v
   2502 	}
   2503 
   2504 	for {
   2505 		t, done, err := decoder.Token()
   2506 		if err != nil {
   2507 			return err
   2508 		}
   2509 		if done {
   2510 			break
   2511 		}
   2512 		originalDecoder := decoder
   2513 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2514 		switch {
   2515 		case strings.EqualFold("HostedZoneId", t.Name.Local):
   2516 			val, err := decoder.Value()
   2517 			if err != nil {
   2518 				return err
   2519 			}
   2520 			if val == nil {
   2521 				break
   2522 			}
   2523 			{
   2524 				xtv := string(val)
   2525 				sv.HostedZoneId = ptr.String(xtv)
   2526 			}
   2527 
   2528 		case strings.EqualFold("VPC", t.Name.Local):
   2529 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2530 			if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil {
   2531 				return err
   2532 			}
   2533 
   2534 		default:
   2535 			// Do nothing and ignore the unexpected tag element
   2536 			err = decoder.Decoder.Skip()
   2537 			if err != nil {
   2538 				return err
   2539 			}
   2540 
   2541 		}
   2542 		decoder = originalDecoder
   2543 	}
   2544 	*v = sv
   2545 	return nil
   2546 }
   2547 
   2548 type awsRestxml_deserializeOpDeactivateKeySigningKey struct {
   2549 }
   2550 
   2551 func (*awsRestxml_deserializeOpDeactivateKeySigningKey) ID() string {
   2552 	return "OperationDeserializer"
   2553 }
   2554 
   2555 func (m *awsRestxml_deserializeOpDeactivateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2556 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2557 ) {
   2558 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2559 	if err != nil {
   2560 		return out, metadata, err
   2561 	}
   2562 
   2563 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2564 	if !ok {
   2565 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2566 	}
   2567 
   2568 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   2569 
   2570 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2571 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2572 	defer endTimer()
   2573 	defer span.End()
   2574 
   2575 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2576 		return out, metadata, awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response, &metadata)
   2577 	}
   2578 	output := &DeactivateKeySigningKeyOutput{}
   2579 	out.Result = output
   2580 
   2581 	var buff [1024]byte
   2582 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2583 	body := io.TeeReader(response.Body, ringBuffer)
   2584 	rootDecoder := xml.NewDecoder(body)
   2585 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2586 	if err == io.EOF {
   2587 		return out, metadata, nil
   2588 	}
   2589 	if err != nil {
   2590 		var snapshot bytes.Buffer
   2591 		io.Copy(&snapshot, ringBuffer)
   2592 		return out, metadata, &smithy.DeserializationError{
   2593 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2594 			Snapshot: snapshot.Bytes(),
   2595 		}
   2596 	}
   2597 
   2598 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2599 	err = awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(&output, decoder)
   2600 	if err != nil {
   2601 		var snapshot bytes.Buffer
   2602 		io.Copy(&snapshot, ringBuffer)
   2603 		return out, metadata, &smithy.DeserializationError{
   2604 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2605 			Snapshot: snapshot.Bytes(),
   2606 		}
   2607 	}
   2608 
   2609 	span.End()
   2610 	return out, metadata, err
   2611 }
   2612 
   2613 func awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2614 	var errorBuffer bytes.Buffer
   2615 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2616 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2617 	}
   2618 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2619 
   2620 	errorCode := "UnknownError"
   2621 	errorMessage := errorCode
   2622 
   2623 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2624 	if err != nil {
   2625 		return err
   2626 	}
   2627 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2628 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2629 	}
   2630 	if len(errorComponents.Code) != 0 {
   2631 		errorCode = errorComponents.Code
   2632 	}
   2633 	if len(errorComponents.Message) != 0 {
   2634 		errorMessage = errorComponents.Message
   2635 	}
   2636 	errorBody.Seek(0, io.SeekStart)
   2637 	switch {
   2638 	case strings.EqualFold("ConcurrentModification", errorCode):
   2639 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2640 
   2641 	case strings.EqualFold("InvalidInput", errorCode):
   2642 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2643 
   2644 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   2645 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   2646 
   2647 	case strings.EqualFold("InvalidSigningStatus", errorCode):
   2648 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
   2649 
   2650 	case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode):
   2651 		return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody)
   2652 
   2653 	case strings.EqualFold("KeySigningKeyInUse", errorCode):
   2654 		return awsRestxml_deserializeErrorKeySigningKeyInUse(response, errorBody)
   2655 
   2656 	case strings.EqualFold("NoSuchKeySigningKey", errorCode):
   2657 		return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
   2658 
   2659 	default:
   2660 		genericError := &smithy.GenericAPIError{
   2661 			Code:    errorCode,
   2662 			Message: errorMessage,
   2663 		}
   2664 		return genericError
   2665 
   2666 	}
   2667 }
   2668 
   2669 func awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(v **DeactivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
   2670 	if v == nil {
   2671 		return fmt.Errorf("unexpected nil of type %T", v)
   2672 	}
   2673 	var sv *DeactivateKeySigningKeyOutput
   2674 	if *v == nil {
   2675 		sv = &DeactivateKeySigningKeyOutput{}
   2676 	} else {
   2677 		sv = *v
   2678 	}
   2679 
   2680 	for {
   2681 		t, done, err := decoder.Token()
   2682 		if err != nil {
   2683 			return err
   2684 		}
   2685 		if done {
   2686 			break
   2687 		}
   2688 		originalDecoder := decoder
   2689 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2690 		switch {
   2691 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   2692 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2693 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   2694 				return err
   2695 			}
   2696 
   2697 		default:
   2698 			// Do nothing and ignore the unexpected tag element
   2699 			err = decoder.Decoder.Skip()
   2700 			if err != nil {
   2701 				return err
   2702 			}
   2703 
   2704 		}
   2705 		decoder = originalDecoder
   2706 	}
   2707 	*v = sv
   2708 	return nil
   2709 }
   2710 
   2711 type awsRestxml_deserializeOpDeleteCidrCollection struct {
   2712 }
   2713 
   2714 func (*awsRestxml_deserializeOpDeleteCidrCollection) ID() string {
   2715 	return "OperationDeserializer"
   2716 }
   2717 
   2718 func (m *awsRestxml_deserializeOpDeleteCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2719 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2720 ) {
   2721 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2722 	if err != nil {
   2723 		return out, metadata, err
   2724 	}
   2725 
   2726 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2727 	if !ok {
   2728 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2729 	}
   2730 
   2731 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   2732 
   2733 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2734 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2735 	defer endTimer()
   2736 	defer span.End()
   2737 
   2738 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2739 		return out, metadata, awsRestxml_deserializeOpErrorDeleteCidrCollection(response, &metadata)
   2740 	}
   2741 	output := &DeleteCidrCollectionOutput{}
   2742 	out.Result = output
   2743 
   2744 	span.End()
   2745 	return out, metadata, err
   2746 }
   2747 
   2748 func awsRestxml_deserializeOpErrorDeleteCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2749 	var errorBuffer bytes.Buffer
   2750 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2751 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2752 	}
   2753 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2754 
   2755 	errorCode := "UnknownError"
   2756 	errorMessage := errorCode
   2757 
   2758 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2759 	if err != nil {
   2760 		return err
   2761 	}
   2762 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2763 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2764 	}
   2765 	if len(errorComponents.Code) != 0 {
   2766 		errorCode = errorComponents.Code
   2767 	}
   2768 	if len(errorComponents.Message) != 0 {
   2769 		errorMessage = errorComponents.Message
   2770 	}
   2771 	errorBody.Seek(0, io.SeekStart)
   2772 	switch {
   2773 	case strings.EqualFold("CidrCollectionInUseException", errorCode):
   2774 		return awsRestxml_deserializeErrorCidrCollectionInUseException(response, errorBody)
   2775 
   2776 	case strings.EqualFold("ConcurrentModification", errorCode):
   2777 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2778 
   2779 	case strings.EqualFold("InvalidInput", errorCode):
   2780 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2781 
   2782 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
   2783 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
   2784 
   2785 	default:
   2786 		genericError := &smithy.GenericAPIError{
   2787 			Code:    errorCode,
   2788 			Message: errorMessage,
   2789 		}
   2790 		return genericError
   2791 
   2792 	}
   2793 }
   2794 
   2795 type awsRestxml_deserializeOpDeleteHealthCheck struct {
   2796 }
   2797 
   2798 func (*awsRestxml_deserializeOpDeleteHealthCheck) ID() string {
   2799 	return "OperationDeserializer"
   2800 }
   2801 
   2802 func (m *awsRestxml_deserializeOpDeleteHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2803 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2804 ) {
   2805 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2806 	if err != nil {
   2807 		return out, metadata, err
   2808 	}
   2809 
   2810 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2811 	if !ok {
   2812 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2813 	}
   2814 
   2815 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   2816 
   2817 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2818 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2819 	defer endTimer()
   2820 	defer span.End()
   2821 
   2822 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2823 		return out, metadata, awsRestxml_deserializeOpErrorDeleteHealthCheck(response, &metadata)
   2824 	}
   2825 	output := &DeleteHealthCheckOutput{}
   2826 	out.Result = output
   2827 
   2828 	span.End()
   2829 	return out, metadata, err
   2830 }
   2831 
   2832 func awsRestxml_deserializeOpErrorDeleteHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2833 	var errorBuffer bytes.Buffer
   2834 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2835 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2836 	}
   2837 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2838 
   2839 	errorCode := "UnknownError"
   2840 	errorMessage := errorCode
   2841 
   2842 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2843 	if err != nil {
   2844 		return err
   2845 	}
   2846 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2847 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2848 	}
   2849 	if len(errorComponents.Code) != 0 {
   2850 		errorCode = errorComponents.Code
   2851 	}
   2852 	if len(errorComponents.Message) != 0 {
   2853 		errorMessage = errorComponents.Message
   2854 	}
   2855 	errorBody.Seek(0, io.SeekStart)
   2856 	switch {
   2857 	case strings.EqualFold("HealthCheckInUse", errorCode):
   2858 		return awsRestxml_deserializeErrorHealthCheckInUse(response, errorBody)
   2859 
   2860 	case strings.EqualFold("InvalidInput", errorCode):
   2861 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2862 
   2863 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   2864 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   2865 
   2866 	default:
   2867 		genericError := &smithy.GenericAPIError{
   2868 			Code:    errorCode,
   2869 			Message: errorMessage,
   2870 		}
   2871 		return genericError
   2872 
   2873 	}
   2874 }
   2875 
   2876 type awsRestxml_deserializeOpDeleteHostedZone struct {
   2877 }
   2878 
   2879 func (*awsRestxml_deserializeOpDeleteHostedZone) ID() string {
   2880 	return "OperationDeserializer"
   2881 }
   2882 
   2883 func (m *awsRestxml_deserializeOpDeleteHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2884 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2885 ) {
   2886 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2887 	if err != nil {
   2888 		return out, metadata, err
   2889 	}
   2890 
   2891 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2892 	if !ok {
   2893 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2894 	}
   2895 
   2896 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   2897 
   2898 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2899 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2900 	defer endTimer()
   2901 	defer span.End()
   2902 
   2903 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2904 		return out, metadata, awsRestxml_deserializeOpErrorDeleteHostedZone(response, &metadata)
   2905 	}
   2906 	output := &DeleteHostedZoneOutput{}
   2907 	out.Result = output
   2908 
   2909 	var buff [1024]byte
   2910 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2911 	body := io.TeeReader(response.Body, ringBuffer)
   2912 	rootDecoder := xml.NewDecoder(body)
   2913 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2914 	if err == io.EOF {
   2915 		return out, metadata, nil
   2916 	}
   2917 	if err != nil {
   2918 		var snapshot bytes.Buffer
   2919 		io.Copy(&snapshot, ringBuffer)
   2920 		return out, metadata, &smithy.DeserializationError{
   2921 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2922 			Snapshot: snapshot.Bytes(),
   2923 		}
   2924 	}
   2925 
   2926 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2927 	err = awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(&output, decoder)
   2928 	if err != nil {
   2929 		var snapshot bytes.Buffer
   2930 		io.Copy(&snapshot, ringBuffer)
   2931 		return out, metadata, &smithy.DeserializationError{
   2932 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2933 			Snapshot: snapshot.Bytes(),
   2934 		}
   2935 	}
   2936 
   2937 	span.End()
   2938 	return out, metadata, err
   2939 }
   2940 
   2941 func awsRestxml_deserializeOpErrorDeleteHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2942 	var errorBuffer bytes.Buffer
   2943 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2944 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2945 	}
   2946 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2947 
   2948 	errorCode := "UnknownError"
   2949 	errorMessage := errorCode
   2950 
   2951 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2952 	if err != nil {
   2953 		return err
   2954 	}
   2955 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2956 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2957 	}
   2958 	if len(errorComponents.Code) != 0 {
   2959 		errorCode = errorComponents.Code
   2960 	}
   2961 	if len(errorComponents.Message) != 0 {
   2962 		errorMessage = errorComponents.Message
   2963 	}
   2964 	errorBody.Seek(0, io.SeekStart)
   2965 	switch {
   2966 	case strings.EqualFold("HostedZoneNotEmpty", errorCode):
   2967 		return awsRestxml_deserializeErrorHostedZoneNotEmpty(response, errorBody)
   2968 
   2969 	case strings.EqualFold("InvalidDomainName", errorCode):
   2970 		return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
   2971 
   2972 	case strings.EqualFold("InvalidInput", errorCode):
   2973 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2974 
   2975 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   2976 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   2977 
   2978 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   2979 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   2980 
   2981 	default:
   2982 		genericError := &smithy.GenericAPIError{
   2983 			Code:    errorCode,
   2984 			Message: errorMessage,
   2985 		}
   2986 		return genericError
   2987 
   2988 	}
   2989 }
   2990 
   2991 func awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(v **DeleteHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   2992 	if v == nil {
   2993 		return fmt.Errorf("unexpected nil of type %T", v)
   2994 	}
   2995 	var sv *DeleteHostedZoneOutput
   2996 	if *v == nil {
   2997 		sv = &DeleteHostedZoneOutput{}
   2998 	} else {
   2999 		sv = *v
   3000 	}
   3001 
   3002 	for {
   3003 		t, done, err := decoder.Token()
   3004 		if err != nil {
   3005 			return err
   3006 		}
   3007 		if done {
   3008 			break
   3009 		}
   3010 		originalDecoder := decoder
   3011 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3012 		switch {
   3013 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3014 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3015 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3016 				return err
   3017 			}
   3018 
   3019 		default:
   3020 			// Do nothing and ignore the unexpected tag element
   3021 			err = decoder.Decoder.Skip()
   3022 			if err != nil {
   3023 				return err
   3024 			}
   3025 
   3026 		}
   3027 		decoder = originalDecoder
   3028 	}
   3029 	*v = sv
   3030 	return nil
   3031 }
   3032 
   3033 type awsRestxml_deserializeOpDeleteKeySigningKey struct {
   3034 }
   3035 
   3036 func (*awsRestxml_deserializeOpDeleteKeySigningKey) ID() string {
   3037 	return "OperationDeserializer"
   3038 }
   3039 
   3040 func (m *awsRestxml_deserializeOpDeleteKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3041 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3042 ) {
   3043 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3044 	if err != nil {
   3045 		return out, metadata, err
   3046 	}
   3047 
   3048 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3049 	if !ok {
   3050 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3051 	}
   3052 
   3053 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   3054 
   3055 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3056 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3057 	defer endTimer()
   3058 	defer span.End()
   3059 
   3060 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3061 		return out, metadata, awsRestxml_deserializeOpErrorDeleteKeySigningKey(response, &metadata)
   3062 	}
   3063 	output := &DeleteKeySigningKeyOutput{}
   3064 	out.Result = output
   3065 
   3066 	var buff [1024]byte
   3067 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3068 	body := io.TeeReader(response.Body, ringBuffer)
   3069 	rootDecoder := xml.NewDecoder(body)
   3070 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3071 	if err == io.EOF {
   3072 		return out, metadata, nil
   3073 	}
   3074 	if err != nil {
   3075 		var snapshot bytes.Buffer
   3076 		io.Copy(&snapshot, ringBuffer)
   3077 		return out, metadata, &smithy.DeserializationError{
   3078 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3079 			Snapshot: snapshot.Bytes(),
   3080 		}
   3081 	}
   3082 
   3083 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3084 	err = awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(&output, decoder)
   3085 	if err != nil {
   3086 		var snapshot bytes.Buffer
   3087 		io.Copy(&snapshot, ringBuffer)
   3088 		return out, metadata, &smithy.DeserializationError{
   3089 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3090 			Snapshot: snapshot.Bytes(),
   3091 		}
   3092 	}
   3093 
   3094 	span.End()
   3095 	return out, metadata, err
   3096 }
   3097 
   3098 func awsRestxml_deserializeOpErrorDeleteKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3099 	var errorBuffer bytes.Buffer
   3100 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3101 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3102 	}
   3103 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3104 
   3105 	errorCode := "UnknownError"
   3106 	errorMessage := errorCode
   3107 
   3108 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3109 	if err != nil {
   3110 		return err
   3111 	}
   3112 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3113 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3114 	}
   3115 	if len(errorComponents.Code) != 0 {
   3116 		errorCode = errorComponents.Code
   3117 	}
   3118 	if len(errorComponents.Message) != 0 {
   3119 		errorMessage = errorComponents.Message
   3120 	}
   3121 	errorBody.Seek(0, io.SeekStart)
   3122 	switch {
   3123 	case strings.EqualFold("ConcurrentModification", errorCode):
   3124 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3125 
   3126 	case strings.EqualFold("InvalidInput", errorCode):
   3127 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3128 
   3129 	case strings.EqualFold("InvalidKMSArn", errorCode):
   3130 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   3131 
   3132 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   3133 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   3134 
   3135 	case strings.EqualFold("InvalidSigningStatus", errorCode):
   3136 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
   3137 
   3138 	case strings.EqualFold("NoSuchKeySigningKey", errorCode):
   3139 		return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
   3140 
   3141 	default:
   3142 		genericError := &smithy.GenericAPIError{
   3143 			Code:    errorCode,
   3144 			Message: errorMessage,
   3145 		}
   3146 		return genericError
   3147 
   3148 	}
   3149 }
   3150 
   3151 func awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(v **DeleteKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
   3152 	if v == nil {
   3153 		return fmt.Errorf("unexpected nil of type %T", v)
   3154 	}
   3155 	var sv *DeleteKeySigningKeyOutput
   3156 	if *v == nil {
   3157 		sv = &DeleteKeySigningKeyOutput{}
   3158 	} else {
   3159 		sv = *v
   3160 	}
   3161 
   3162 	for {
   3163 		t, done, err := decoder.Token()
   3164 		if err != nil {
   3165 			return err
   3166 		}
   3167 		if done {
   3168 			break
   3169 		}
   3170 		originalDecoder := decoder
   3171 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3172 		switch {
   3173 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3174 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3175 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3176 				return err
   3177 			}
   3178 
   3179 		default:
   3180 			// Do nothing and ignore the unexpected tag element
   3181 			err = decoder.Decoder.Skip()
   3182 			if err != nil {
   3183 				return err
   3184 			}
   3185 
   3186 		}
   3187 		decoder = originalDecoder
   3188 	}
   3189 	*v = sv
   3190 	return nil
   3191 }
   3192 
   3193 type awsRestxml_deserializeOpDeleteQueryLoggingConfig struct {
   3194 }
   3195 
   3196 func (*awsRestxml_deserializeOpDeleteQueryLoggingConfig) ID() string {
   3197 	return "OperationDeserializer"
   3198 }
   3199 
   3200 func (m *awsRestxml_deserializeOpDeleteQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3201 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3202 ) {
   3203 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3204 	if err != nil {
   3205 		return out, metadata, err
   3206 	}
   3207 
   3208 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3209 	if !ok {
   3210 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3211 	}
   3212 
   3213 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   3214 
   3215 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3216 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3217 	defer endTimer()
   3218 	defer span.End()
   3219 
   3220 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3221 		return out, metadata, awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response, &metadata)
   3222 	}
   3223 	output := &DeleteQueryLoggingConfigOutput{}
   3224 	out.Result = output
   3225 
   3226 	span.End()
   3227 	return out, metadata, err
   3228 }
   3229 
   3230 func awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3231 	var errorBuffer bytes.Buffer
   3232 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3233 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3234 	}
   3235 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3236 
   3237 	errorCode := "UnknownError"
   3238 	errorMessage := errorCode
   3239 
   3240 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3241 	if err != nil {
   3242 		return err
   3243 	}
   3244 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3245 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3246 	}
   3247 	if len(errorComponents.Code) != 0 {
   3248 		errorCode = errorComponents.Code
   3249 	}
   3250 	if len(errorComponents.Message) != 0 {
   3251 		errorMessage = errorComponents.Message
   3252 	}
   3253 	errorBody.Seek(0, io.SeekStart)
   3254 	switch {
   3255 	case strings.EqualFold("ConcurrentModification", errorCode):
   3256 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3257 
   3258 	case strings.EqualFold("InvalidInput", errorCode):
   3259 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3260 
   3261 	case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode):
   3262 		return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody)
   3263 
   3264 	default:
   3265 		genericError := &smithy.GenericAPIError{
   3266 			Code:    errorCode,
   3267 			Message: errorMessage,
   3268 		}
   3269 		return genericError
   3270 
   3271 	}
   3272 }
   3273 
   3274 type awsRestxml_deserializeOpDeleteReusableDelegationSet struct {
   3275 }
   3276 
   3277 func (*awsRestxml_deserializeOpDeleteReusableDelegationSet) ID() string {
   3278 	return "OperationDeserializer"
   3279 }
   3280 
   3281 func (m *awsRestxml_deserializeOpDeleteReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3282 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3283 ) {
   3284 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3285 	if err != nil {
   3286 		return out, metadata, err
   3287 	}
   3288 
   3289 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3290 	if !ok {
   3291 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3292 	}
   3293 
   3294 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   3295 
   3296 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3297 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3298 	defer endTimer()
   3299 	defer span.End()
   3300 
   3301 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3302 		return out, metadata, awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response, &metadata)
   3303 	}
   3304 	output := &DeleteReusableDelegationSetOutput{}
   3305 	out.Result = output
   3306 
   3307 	span.End()
   3308 	return out, metadata, err
   3309 }
   3310 
   3311 func awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3312 	var errorBuffer bytes.Buffer
   3313 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3314 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3315 	}
   3316 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3317 
   3318 	errorCode := "UnknownError"
   3319 	errorMessage := errorCode
   3320 
   3321 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3322 	if err != nil {
   3323 		return err
   3324 	}
   3325 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3326 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3327 	}
   3328 	if len(errorComponents.Code) != 0 {
   3329 		errorCode = errorComponents.Code
   3330 	}
   3331 	if len(errorComponents.Message) != 0 {
   3332 		errorMessage = errorComponents.Message
   3333 	}
   3334 	errorBody.Seek(0, io.SeekStart)
   3335 	switch {
   3336 	case strings.EqualFold("DelegationSetInUse", errorCode):
   3337 		return awsRestxml_deserializeErrorDelegationSetInUse(response, errorBody)
   3338 
   3339 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   3340 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   3341 
   3342 	case strings.EqualFold("InvalidInput", errorCode):
   3343 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3344 
   3345 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   3346 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   3347 
   3348 	default:
   3349 		genericError := &smithy.GenericAPIError{
   3350 			Code:    errorCode,
   3351 			Message: errorMessage,
   3352 		}
   3353 		return genericError
   3354 
   3355 	}
   3356 }
   3357 
   3358 type awsRestxml_deserializeOpDeleteTrafficPolicy struct {
   3359 }
   3360 
   3361 func (*awsRestxml_deserializeOpDeleteTrafficPolicy) ID() string {
   3362 	return "OperationDeserializer"
   3363 }
   3364 
   3365 func (m *awsRestxml_deserializeOpDeleteTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3366 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3367 ) {
   3368 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3369 	if err != nil {
   3370 		return out, metadata, err
   3371 	}
   3372 
   3373 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3374 	if !ok {
   3375 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3376 	}
   3377 
   3378 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   3379 
   3380 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3381 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3382 	defer endTimer()
   3383 	defer span.End()
   3384 
   3385 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3386 		return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response, &metadata)
   3387 	}
   3388 	output := &DeleteTrafficPolicyOutput{}
   3389 	out.Result = output
   3390 
   3391 	span.End()
   3392 	return out, metadata, err
   3393 }
   3394 
   3395 func awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3396 	var errorBuffer bytes.Buffer
   3397 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3398 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3399 	}
   3400 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3401 
   3402 	errorCode := "UnknownError"
   3403 	errorMessage := errorCode
   3404 
   3405 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3406 	if err != nil {
   3407 		return err
   3408 	}
   3409 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3410 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3411 	}
   3412 	if len(errorComponents.Code) != 0 {
   3413 		errorCode = errorComponents.Code
   3414 	}
   3415 	if len(errorComponents.Message) != 0 {
   3416 		errorMessage = errorComponents.Message
   3417 	}
   3418 	errorBody.Seek(0, io.SeekStart)
   3419 	switch {
   3420 	case strings.EqualFold("ConcurrentModification", errorCode):
   3421 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3422 
   3423 	case strings.EqualFold("InvalidInput", errorCode):
   3424 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3425 
   3426 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   3427 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   3428 
   3429 	case strings.EqualFold("TrafficPolicyInUse", errorCode):
   3430 		return awsRestxml_deserializeErrorTrafficPolicyInUse(response, errorBody)
   3431 
   3432 	default:
   3433 		genericError := &smithy.GenericAPIError{
   3434 			Code:    errorCode,
   3435 			Message: errorMessage,
   3436 		}
   3437 		return genericError
   3438 
   3439 	}
   3440 }
   3441 
   3442 type awsRestxml_deserializeOpDeleteTrafficPolicyInstance struct {
   3443 }
   3444 
   3445 func (*awsRestxml_deserializeOpDeleteTrafficPolicyInstance) ID() string {
   3446 	return "OperationDeserializer"
   3447 }
   3448 
   3449 func (m *awsRestxml_deserializeOpDeleteTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3450 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3451 ) {
   3452 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3453 	if err != nil {
   3454 		return out, metadata, err
   3455 	}
   3456 
   3457 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3458 	if !ok {
   3459 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3460 	}
   3461 
   3462 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   3463 
   3464 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3465 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3466 	defer endTimer()
   3467 	defer span.End()
   3468 
   3469 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3470 		return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response, &metadata)
   3471 	}
   3472 	output := &DeleteTrafficPolicyInstanceOutput{}
   3473 	out.Result = output
   3474 
   3475 	span.End()
   3476 	return out, metadata, err
   3477 }
   3478 
   3479 func awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3480 	var errorBuffer bytes.Buffer
   3481 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3482 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3483 	}
   3484 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3485 
   3486 	errorCode := "UnknownError"
   3487 	errorMessage := errorCode
   3488 
   3489 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3490 	if err != nil {
   3491 		return err
   3492 	}
   3493 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3494 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3495 	}
   3496 	if len(errorComponents.Code) != 0 {
   3497 		errorCode = errorComponents.Code
   3498 	}
   3499 	if len(errorComponents.Message) != 0 {
   3500 		errorMessage = errorComponents.Message
   3501 	}
   3502 	errorBody.Seek(0, io.SeekStart)
   3503 	switch {
   3504 	case strings.EqualFold("InvalidInput", errorCode):
   3505 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3506 
   3507 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   3508 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   3509 
   3510 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   3511 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   3512 
   3513 	default:
   3514 		genericError := &smithy.GenericAPIError{
   3515 			Code:    errorCode,
   3516 			Message: errorMessage,
   3517 		}
   3518 		return genericError
   3519 
   3520 	}
   3521 }
   3522 
   3523 type awsRestxml_deserializeOpDeleteVPCAssociationAuthorization struct {
   3524 }
   3525 
   3526 func (*awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) ID() string {
   3527 	return "OperationDeserializer"
   3528 }
   3529 
   3530 func (m *awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3531 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3532 ) {
   3533 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3534 	if err != nil {
   3535 		return out, metadata, err
   3536 	}
   3537 
   3538 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3539 	if !ok {
   3540 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3541 	}
   3542 
   3543 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   3544 
   3545 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3546 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3547 	defer endTimer()
   3548 	defer span.End()
   3549 
   3550 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3551 		return out, metadata, awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response, &metadata)
   3552 	}
   3553 	output := &DeleteVPCAssociationAuthorizationOutput{}
   3554 	out.Result = output
   3555 
   3556 	span.End()
   3557 	return out, metadata, err
   3558 }
   3559 
   3560 func awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3561 	var errorBuffer bytes.Buffer
   3562 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3563 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3564 	}
   3565 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3566 
   3567 	errorCode := "UnknownError"
   3568 	errorMessage := errorCode
   3569 
   3570 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3571 	if err != nil {
   3572 		return err
   3573 	}
   3574 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3575 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3576 	}
   3577 	if len(errorComponents.Code) != 0 {
   3578 		errorCode = errorComponents.Code
   3579 	}
   3580 	if len(errorComponents.Message) != 0 {
   3581 		errorMessage = errorComponents.Message
   3582 	}
   3583 	errorBody.Seek(0, io.SeekStart)
   3584 	switch {
   3585 	case strings.EqualFold("ConcurrentModification", errorCode):
   3586 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3587 
   3588 	case strings.EqualFold("InvalidInput", errorCode):
   3589 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3590 
   3591 	case strings.EqualFold("InvalidVPCId", errorCode):
   3592 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   3593 
   3594 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3595 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3596 
   3597 	case strings.EqualFold("VPCAssociationAuthorizationNotFound", errorCode):
   3598 		return awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response, errorBody)
   3599 
   3600 	default:
   3601 		genericError := &smithy.GenericAPIError{
   3602 			Code:    errorCode,
   3603 			Message: errorMessage,
   3604 		}
   3605 		return genericError
   3606 
   3607 	}
   3608 }
   3609 
   3610 type awsRestxml_deserializeOpDisableHostedZoneDNSSEC struct {
   3611 }
   3612 
   3613 func (*awsRestxml_deserializeOpDisableHostedZoneDNSSEC) ID() string {
   3614 	return "OperationDeserializer"
   3615 }
   3616 
   3617 func (m *awsRestxml_deserializeOpDisableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3618 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3619 ) {
   3620 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3621 	if err != nil {
   3622 		return out, metadata, err
   3623 	}
   3624 
   3625 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3626 	if !ok {
   3627 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3628 	}
   3629 
   3630 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   3631 
   3632 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3633 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3634 	defer endTimer()
   3635 	defer span.End()
   3636 
   3637 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3638 		return out, metadata, awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response, &metadata)
   3639 	}
   3640 	output := &DisableHostedZoneDNSSECOutput{}
   3641 	out.Result = output
   3642 
   3643 	var buff [1024]byte
   3644 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3645 	body := io.TeeReader(response.Body, ringBuffer)
   3646 	rootDecoder := xml.NewDecoder(body)
   3647 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3648 	if err == io.EOF {
   3649 		return out, metadata, nil
   3650 	}
   3651 	if err != nil {
   3652 		var snapshot bytes.Buffer
   3653 		io.Copy(&snapshot, ringBuffer)
   3654 		return out, metadata, &smithy.DeserializationError{
   3655 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3656 			Snapshot: snapshot.Bytes(),
   3657 		}
   3658 	}
   3659 
   3660 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3661 	err = awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(&output, decoder)
   3662 	if err != nil {
   3663 		var snapshot bytes.Buffer
   3664 		io.Copy(&snapshot, ringBuffer)
   3665 		return out, metadata, &smithy.DeserializationError{
   3666 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3667 			Snapshot: snapshot.Bytes(),
   3668 		}
   3669 	}
   3670 
   3671 	span.End()
   3672 	return out, metadata, err
   3673 }
   3674 
   3675 func awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3676 	var errorBuffer bytes.Buffer
   3677 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3678 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3679 	}
   3680 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3681 
   3682 	errorCode := "UnknownError"
   3683 	errorMessage := errorCode
   3684 
   3685 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3686 	if err != nil {
   3687 		return err
   3688 	}
   3689 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3690 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3691 	}
   3692 	if len(errorComponents.Code) != 0 {
   3693 		errorCode = errorComponents.Code
   3694 	}
   3695 	if len(errorComponents.Message) != 0 {
   3696 		errorMessage = errorComponents.Message
   3697 	}
   3698 	errorBody.Seek(0, io.SeekStart)
   3699 	switch {
   3700 	case strings.EqualFold("ConcurrentModification", errorCode):
   3701 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3702 
   3703 	case strings.EqualFold("DNSSECNotFound", errorCode):
   3704 		return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody)
   3705 
   3706 	case strings.EqualFold("InvalidArgument", errorCode):
   3707 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   3708 
   3709 	case strings.EqualFold("InvalidInput", errorCode):
   3710 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3711 
   3712 	case strings.EqualFold("InvalidKMSArn", errorCode):
   3713 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   3714 
   3715 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   3716 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   3717 
   3718 	case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode):
   3719 		return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody)
   3720 
   3721 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3722 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3723 
   3724 	default:
   3725 		genericError := &smithy.GenericAPIError{
   3726 			Code:    errorCode,
   3727 			Message: errorMessage,
   3728 		}
   3729 		return genericError
   3730 
   3731 	}
   3732 }
   3733 
   3734 func awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(v **DisableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error {
   3735 	if v == nil {
   3736 		return fmt.Errorf("unexpected nil of type %T", v)
   3737 	}
   3738 	var sv *DisableHostedZoneDNSSECOutput
   3739 	if *v == nil {
   3740 		sv = &DisableHostedZoneDNSSECOutput{}
   3741 	} else {
   3742 		sv = *v
   3743 	}
   3744 
   3745 	for {
   3746 		t, done, err := decoder.Token()
   3747 		if err != nil {
   3748 			return err
   3749 		}
   3750 		if done {
   3751 			break
   3752 		}
   3753 		originalDecoder := decoder
   3754 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3755 		switch {
   3756 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3757 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3758 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3759 				return err
   3760 			}
   3761 
   3762 		default:
   3763 			// Do nothing and ignore the unexpected tag element
   3764 			err = decoder.Decoder.Skip()
   3765 			if err != nil {
   3766 				return err
   3767 			}
   3768 
   3769 		}
   3770 		decoder = originalDecoder
   3771 	}
   3772 	*v = sv
   3773 	return nil
   3774 }
   3775 
   3776 type awsRestxml_deserializeOpDisassociateVPCFromHostedZone struct {
   3777 }
   3778 
   3779 func (*awsRestxml_deserializeOpDisassociateVPCFromHostedZone) ID() string {
   3780 	return "OperationDeserializer"
   3781 }
   3782 
   3783 func (m *awsRestxml_deserializeOpDisassociateVPCFromHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3784 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3785 ) {
   3786 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3787 	if err != nil {
   3788 		return out, metadata, err
   3789 	}
   3790 
   3791 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3792 	if !ok {
   3793 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3794 	}
   3795 
   3796 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   3797 
   3798 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3799 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3800 	defer endTimer()
   3801 	defer span.End()
   3802 
   3803 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3804 		return out, metadata, awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response, &metadata)
   3805 	}
   3806 	output := &DisassociateVPCFromHostedZoneOutput{}
   3807 	out.Result = output
   3808 
   3809 	var buff [1024]byte
   3810 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3811 	body := io.TeeReader(response.Body, ringBuffer)
   3812 	rootDecoder := xml.NewDecoder(body)
   3813 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3814 	if err == io.EOF {
   3815 		return out, metadata, nil
   3816 	}
   3817 	if err != nil {
   3818 		var snapshot bytes.Buffer
   3819 		io.Copy(&snapshot, ringBuffer)
   3820 		return out, metadata, &smithy.DeserializationError{
   3821 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3822 			Snapshot: snapshot.Bytes(),
   3823 		}
   3824 	}
   3825 
   3826 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3827 	err = awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(&output, decoder)
   3828 	if err != nil {
   3829 		var snapshot bytes.Buffer
   3830 		io.Copy(&snapshot, ringBuffer)
   3831 		return out, metadata, &smithy.DeserializationError{
   3832 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3833 			Snapshot: snapshot.Bytes(),
   3834 		}
   3835 	}
   3836 
   3837 	span.End()
   3838 	return out, metadata, err
   3839 }
   3840 
   3841 func awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3842 	var errorBuffer bytes.Buffer
   3843 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3844 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3845 	}
   3846 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3847 
   3848 	errorCode := "UnknownError"
   3849 	errorMessage := errorCode
   3850 
   3851 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3852 	if err != nil {
   3853 		return err
   3854 	}
   3855 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3856 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3857 	}
   3858 	if len(errorComponents.Code) != 0 {
   3859 		errorCode = errorComponents.Code
   3860 	}
   3861 	if len(errorComponents.Message) != 0 {
   3862 		errorMessage = errorComponents.Message
   3863 	}
   3864 	errorBody.Seek(0, io.SeekStart)
   3865 	switch {
   3866 	case strings.EqualFold("InvalidInput", errorCode):
   3867 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3868 
   3869 	case strings.EqualFold("InvalidVPCId", errorCode):
   3870 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   3871 
   3872 	case strings.EqualFold("LastVPCAssociation", errorCode):
   3873 		return awsRestxml_deserializeErrorLastVPCAssociation(response, errorBody)
   3874 
   3875 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3876 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3877 
   3878 	case strings.EqualFold("VPCAssociationNotFound", errorCode):
   3879 		return awsRestxml_deserializeErrorVPCAssociationNotFound(response, errorBody)
   3880 
   3881 	default:
   3882 		genericError := &smithy.GenericAPIError{
   3883 			Code:    errorCode,
   3884 			Message: errorMessage,
   3885 		}
   3886 		return genericError
   3887 
   3888 	}
   3889 }
   3890 
   3891 func awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(v **DisassociateVPCFromHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   3892 	if v == nil {
   3893 		return fmt.Errorf("unexpected nil of type %T", v)
   3894 	}
   3895 	var sv *DisassociateVPCFromHostedZoneOutput
   3896 	if *v == nil {
   3897 		sv = &DisassociateVPCFromHostedZoneOutput{}
   3898 	} else {
   3899 		sv = *v
   3900 	}
   3901 
   3902 	for {
   3903 		t, done, err := decoder.Token()
   3904 		if err != nil {
   3905 			return err
   3906 		}
   3907 		if done {
   3908 			break
   3909 		}
   3910 		originalDecoder := decoder
   3911 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3912 		switch {
   3913 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3914 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3915 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3916 				return err
   3917 			}
   3918 
   3919 		default:
   3920 			// Do nothing and ignore the unexpected tag element
   3921 			err = decoder.Decoder.Skip()
   3922 			if err != nil {
   3923 				return err
   3924 			}
   3925 
   3926 		}
   3927 		decoder = originalDecoder
   3928 	}
   3929 	*v = sv
   3930 	return nil
   3931 }
   3932 
   3933 type awsRestxml_deserializeOpEnableHostedZoneDNSSEC struct {
   3934 }
   3935 
   3936 func (*awsRestxml_deserializeOpEnableHostedZoneDNSSEC) ID() string {
   3937 	return "OperationDeserializer"
   3938 }
   3939 
   3940 func (m *awsRestxml_deserializeOpEnableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3941 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3942 ) {
   3943 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3944 	if err != nil {
   3945 		return out, metadata, err
   3946 	}
   3947 
   3948 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3949 	if !ok {
   3950 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3951 	}
   3952 
   3953 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   3954 
   3955 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3956 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3957 	defer endTimer()
   3958 	defer span.End()
   3959 
   3960 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3961 		return out, metadata, awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response, &metadata)
   3962 	}
   3963 	output := &EnableHostedZoneDNSSECOutput{}
   3964 	out.Result = output
   3965 
   3966 	var buff [1024]byte
   3967 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3968 	body := io.TeeReader(response.Body, ringBuffer)
   3969 	rootDecoder := xml.NewDecoder(body)
   3970 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3971 	if err == io.EOF {
   3972 		return out, metadata, nil
   3973 	}
   3974 	if err != nil {
   3975 		var snapshot bytes.Buffer
   3976 		io.Copy(&snapshot, ringBuffer)
   3977 		return out, metadata, &smithy.DeserializationError{
   3978 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3979 			Snapshot: snapshot.Bytes(),
   3980 		}
   3981 	}
   3982 
   3983 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3984 	err = awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(&output, decoder)
   3985 	if err != nil {
   3986 		var snapshot bytes.Buffer
   3987 		io.Copy(&snapshot, ringBuffer)
   3988 		return out, metadata, &smithy.DeserializationError{
   3989 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3990 			Snapshot: snapshot.Bytes(),
   3991 		}
   3992 	}
   3993 
   3994 	span.End()
   3995 	return out, metadata, err
   3996 }
   3997 
   3998 func awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3999 	var errorBuffer bytes.Buffer
   4000 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4001 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4002 	}
   4003 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4004 
   4005 	errorCode := "UnknownError"
   4006 	errorMessage := errorCode
   4007 
   4008 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4009 	if err != nil {
   4010 		return err
   4011 	}
   4012 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4013 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4014 	}
   4015 	if len(errorComponents.Code) != 0 {
   4016 		errorCode = errorComponents.Code
   4017 	}
   4018 	if len(errorComponents.Message) != 0 {
   4019 		errorMessage = errorComponents.Message
   4020 	}
   4021 	errorBody.Seek(0, io.SeekStart)
   4022 	switch {
   4023 	case strings.EqualFold("ConcurrentModification", errorCode):
   4024 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   4025 
   4026 	case strings.EqualFold("DNSSECNotFound", errorCode):
   4027 		return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody)
   4028 
   4029 	case strings.EqualFold("HostedZonePartiallyDelegated", errorCode):
   4030 		return awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response, errorBody)
   4031 
   4032 	case strings.EqualFold("InvalidArgument", errorCode):
   4033 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   4034 
   4035 	case strings.EqualFold("InvalidInput", errorCode):
   4036 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4037 
   4038 	case strings.EqualFold("InvalidKMSArn", errorCode):
   4039 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   4040 
   4041 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   4042 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   4043 
   4044 	case strings.EqualFold("KeySigningKeyWithActiveStatusNotFound", errorCode):
   4045 		return awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response, errorBody)
   4046 
   4047 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   4048 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   4049 
   4050 	default:
   4051 		genericError := &smithy.GenericAPIError{
   4052 			Code:    errorCode,
   4053 			Message: errorMessage,
   4054 		}
   4055 		return genericError
   4056 
   4057 	}
   4058 }
   4059 
   4060 func awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(v **EnableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error {
   4061 	if v == nil {
   4062 		return fmt.Errorf("unexpected nil of type %T", v)
   4063 	}
   4064 	var sv *EnableHostedZoneDNSSECOutput
   4065 	if *v == nil {
   4066 		sv = &EnableHostedZoneDNSSECOutput{}
   4067 	} else {
   4068 		sv = *v
   4069 	}
   4070 
   4071 	for {
   4072 		t, done, err := decoder.Token()
   4073 		if err != nil {
   4074 			return err
   4075 		}
   4076 		if done {
   4077 			break
   4078 		}
   4079 		originalDecoder := decoder
   4080 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4081 		switch {
   4082 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   4083 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4084 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   4085 				return err
   4086 			}
   4087 
   4088 		default:
   4089 			// Do nothing and ignore the unexpected tag element
   4090 			err = decoder.Decoder.Skip()
   4091 			if err != nil {
   4092 				return err
   4093 			}
   4094 
   4095 		}
   4096 		decoder = originalDecoder
   4097 	}
   4098 	*v = sv
   4099 	return nil
   4100 }
   4101 
   4102 type awsRestxml_deserializeOpGetAccountLimit struct {
   4103 }
   4104 
   4105 func (*awsRestxml_deserializeOpGetAccountLimit) ID() string {
   4106 	return "OperationDeserializer"
   4107 }
   4108 
   4109 func (m *awsRestxml_deserializeOpGetAccountLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4110 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4111 ) {
   4112 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4113 	if err != nil {
   4114 		return out, metadata, err
   4115 	}
   4116 
   4117 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4118 	if !ok {
   4119 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4120 	}
   4121 
   4122 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   4123 
   4124 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4125 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4126 	defer endTimer()
   4127 	defer span.End()
   4128 
   4129 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4130 		return out, metadata, awsRestxml_deserializeOpErrorGetAccountLimit(response, &metadata)
   4131 	}
   4132 	output := &GetAccountLimitOutput{}
   4133 	out.Result = output
   4134 
   4135 	var buff [1024]byte
   4136 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4137 	body := io.TeeReader(response.Body, ringBuffer)
   4138 	rootDecoder := xml.NewDecoder(body)
   4139 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4140 	if err == io.EOF {
   4141 		return out, metadata, nil
   4142 	}
   4143 	if err != nil {
   4144 		var snapshot bytes.Buffer
   4145 		io.Copy(&snapshot, ringBuffer)
   4146 		return out, metadata, &smithy.DeserializationError{
   4147 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4148 			Snapshot: snapshot.Bytes(),
   4149 		}
   4150 	}
   4151 
   4152 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4153 	err = awsRestxml_deserializeOpDocumentGetAccountLimitOutput(&output, decoder)
   4154 	if err != nil {
   4155 		var snapshot bytes.Buffer
   4156 		io.Copy(&snapshot, ringBuffer)
   4157 		return out, metadata, &smithy.DeserializationError{
   4158 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4159 			Snapshot: snapshot.Bytes(),
   4160 		}
   4161 	}
   4162 
   4163 	span.End()
   4164 	return out, metadata, err
   4165 }
   4166 
   4167 func awsRestxml_deserializeOpErrorGetAccountLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4168 	var errorBuffer bytes.Buffer
   4169 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4170 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4171 	}
   4172 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4173 
   4174 	errorCode := "UnknownError"
   4175 	errorMessage := errorCode
   4176 
   4177 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4178 	if err != nil {
   4179 		return err
   4180 	}
   4181 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4182 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4183 	}
   4184 	if len(errorComponents.Code) != 0 {
   4185 		errorCode = errorComponents.Code
   4186 	}
   4187 	if len(errorComponents.Message) != 0 {
   4188 		errorMessage = errorComponents.Message
   4189 	}
   4190 	errorBody.Seek(0, io.SeekStart)
   4191 	switch {
   4192 	case strings.EqualFold("InvalidInput", errorCode):
   4193 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4194 
   4195 	default:
   4196 		genericError := &smithy.GenericAPIError{
   4197 			Code:    errorCode,
   4198 			Message: errorMessage,
   4199 		}
   4200 		return genericError
   4201 
   4202 	}
   4203 }
   4204 
   4205 func awsRestxml_deserializeOpDocumentGetAccountLimitOutput(v **GetAccountLimitOutput, decoder smithyxml.NodeDecoder) error {
   4206 	if v == nil {
   4207 		return fmt.Errorf("unexpected nil of type %T", v)
   4208 	}
   4209 	var sv *GetAccountLimitOutput
   4210 	if *v == nil {
   4211 		sv = &GetAccountLimitOutput{}
   4212 	} else {
   4213 		sv = *v
   4214 	}
   4215 
   4216 	for {
   4217 		t, done, err := decoder.Token()
   4218 		if err != nil {
   4219 			return err
   4220 		}
   4221 		if done {
   4222 			break
   4223 		}
   4224 		originalDecoder := decoder
   4225 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4226 		switch {
   4227 		case strings.EqualFold("Count", t.Name.Local):
   4228 			val, err := decoder.Value()
   4229 			if err != nil {
   4230 				return err
   4231 			}
   4232 			if val == nil {
   4233 				break
   4234 			}
   4235 			{
   4236 				xtv := string(val)
   4237 				i64, err := strconv.ParseInt(xtv, 10, 64)
   4238 				if err != nil {
   4239 					return err
   4240 				}
   4241 				sv.Count = i64
   4242 			}
   4243 
   4244 		case strings.EqualFold("Limit", t.Name.Local):
   4245 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4246 			if err := awsRestxml_deserializeDocumentAccountLimit(&sv.Limit, nodeDecoder); err != nil {
   4247 				return err
   4248 			}
   4249 
   4250 		default:
   4251 			// Do nothing and ignore the unexpected tag element
   4252 			err = decoder.Decoder.Skip()
   4253 			if err != nil {
   4254 				return err
   4255 			}
   4256 
   4257 		}
   4258 		decoder = originalDecoder
   4259 	}
   4260 	*v = sv
   4261 	return nil
   4262 }
   4263 
   4264 type awsRestxml_deserializeOpGetChange struct {
   4265 }
   4266 
   4267 func (*awsRestxml_deserializeOpGetChange) ID() string {
   4268 	return "OperationDeserializer"
   4269 }
   4270 
   4271 func (m *awsRestxml_deserializeOpGetChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4272 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4273 ) {
   4274 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4275 	if err != nil {
   4276 		return out, metadata, err
   4277 	}
   4278 
   4279 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4280 	if !ok {
   4281 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4282 	}
   4283 
   4284 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   4285 
   4286 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4287 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4288 	defer endTimer()
   4289 	defer span.End()
   4290 
   4291 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4292 		return out, metadata, awsRestxml_deserializeOpErrorGetChange(response, &metadata)
   4293 	}
   4294 	output := &GetChangeOutput{}
   4295 	out.Result = output
   4296 
   4297 	var buff [1024]byte
   4298 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4299 	body := io.TeeReader(response.Body, ringBuffer)
   4300 	rootDecoder := xml.NewDecoder(body)
   4301 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4302 	if err == io.EOF {
   4303 		return out, metadata, nil
   4304 	}
   4305 	if err != nil {
   4306 		var snapshot bytes.Buffer
   4307 		io.Copy(&snapshot, ringBuffer)
   4308 		return out, metadata, &smithy.DeserializationError{
   4309 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4310 			Snapshot: snapshot.Bytes(),
   4311 		}
   4312 	}
   4313 
   4314 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4315 	err = awsRestxml_deserializeOpDocumentGetChangeOutput(&output, decoder)
   4316 	if err != nil {
   4317 		var snapshot bytes.Buffer
   4318 		io.Copy(&snapshot, ringBuffer)
   4319 		return out, metadata, &smithy.DeserializationError{
   4320 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4321 			Snapshot: snapshot.Bytes(),
   4322 		}
   4323 	}
   4324 
   4325 	span.End()
   4326 	return out, metadata, err
   4327 }
   4328 
   4329 func awsRestxml_deserializeOpErrorGetChange(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4330 	var errorBuffer bytes.Buffer
   4331 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4332 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4333 	}
   4334 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4335 
   4336 	errorCode := "UnknownError"
   4337 	errorMessage := errorCode
   4338 
   4339 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4340 	if err != nil {
   4341 		return err
   4342 	}
   4343 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4344 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4345 	}
   4346 	if len(errorComponents.Code) != 0 {
   4347 		errorCode = errorComponents.Code
   4348 	}
   4349 	if len(errorComponents.Message) != 0 {
   4350 		errorMessage = errorComponents.Message
   4351 	}
   4352 	errorBody.Seek(0, io.SeekStart)
   4353 	switch {
   4354 	case strings.EqualFold("InvalidInput", errorCode):
   4355 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4356 
   4357 	case strings.EqualFold("NoSuchChange", errorCode):
   4358 		return awsRestxml_deserializeErrorNoSuchChange(response, errorBody)
   4359 
   4360 	default:
   4361 		genericError := &smithy.GenericAPIError{
   4362 			Code:    errorCode,
   4363 			Message: errorMessage,
   4364 		}
   4365 		return genericError
   4366 
   4367 	}
   4368 }
   4369 
   4370 func awsRestxml_deserializeOpDocumentGetChangeOutput(v **GetChangeOutput, decoder smithyxml.NodeDecoder) error {
   4371 	if v == nil {
   4372 		return fmt.Errorf("unexpected nil of type %T", v)
   4373 	}
   4374 	var sv *GetChangeOutput
   4375 	if *v == nil {
   4376 		sv = &GetChangeOutput{}
   4377 	} else {
   4378 		sv = *v
   4379 	}
   4380 
   4381 	for {
   4382 		t, done, err := decoder.Token()
   4383 		if err != nil {
   4384 			return err
   4385 		}
   4386 		if done {
   4387 			break
   4388 		}
   4389 		originalDecoder := decoder
   4390 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4391 		switch {
   4392 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   4393 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4394 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   4395 				return err
   4396 			}
   4397 
   4398 		default:
   4399 			// Do nothing and ignore the unexpected tag element
   4400 			err = decoder.Decoder.Skip()
   4401 			if err != nil {
   4402 				return err
   4403 			}
   4404 
   4405 		}
   4406 		decoder = originalDecoder
   4407 	}
   4408 	*v = sv
   4409 	return nil
   4410 }
   4411 
   4412 type awsRestxml_deserializeOpGetCheckerIpRanges struct {
   4413 }
   4414 
   4415 func (*awsRestxml_deserializeOpGetCheckerIpRanges) ID() string {
   4416 	return "OperationDeserializer"
   4417 }
   4418 
   4419 func (m *awsRestxml_deserializeOpGetCheckerIpRanges) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4420 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4421 ) {
   4422 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4423 	if err != nil {
   4424 		return out, metadata, err
   4425 	}
   4426 
   4427 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4428 	if !ok {
   4429 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4430 	}
   4431 
   4432 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   4433 
   4434 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4435 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4436 	defer endTimer()
   4437 	defer span.End()
   4438 
   4439 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4440 		return out, metadata, awsRestxml_deserializeOpErrorGetCheckerIpRanges(response, &metadata)
   4441 	}
   4442 	output := &GetCheckerIpRangesOutput{}
   4443 	out.Result = output
   4444 
   4445 	var buff [1024]byte
   4446 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4447 	body := io.TeeReader(response.Body, ringBuffer)
   4448 	rootDecoder := xml.NewDecoder(body)
   4449 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4450 	if err == io.EOF {
   4451 		return out, metadata, nil
   4452 	}
   4453 	if err != nil {
   4454 		var snapshot bytes.Buffer
   4455 		io.Copy(&snapshot, ringBuffer)
   4456 		return out, metadata, &smithy.DeserializationError{
   4457 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4458 			Snapshot: snapshot.Bytes(),
   4459 		}
   4460 	}
   4461 
   4462 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4463 	err = awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(&output, decoder)
   4464 	if err != nil {
   4465 		var snapshot bytes.Buffer
   4466 		io.Copy(&snapshot, ringBuffer)
   4467 		return out, metadata, &smithy.DeserializationError{
   4468 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4469 			Snapshot: snapshot.Bytes(),
   4470 		}
   4471 	}
   4472 
   4473 	span.End()
   4474 	return out, metadata, err
   4475 }
   4476 
   4477 func awsRestxml_deserializeOpErrorGetCheckerIpRanges(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4478 	var errorBuffer bytes.Buffer
   4479 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4480 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4481 	}
   4482 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4483 
   4484 	errorCode := "UnknownError"
   4485 	errorMessage := errorCode
   4486 
   4487 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4488 	if err != nil {
   4489 		return err
   4490 	}
   4491 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4492 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4493 	}
   4494 	if len(errorComponents.Code) != 0 {
   4495 		errorCode = errorComponents.Code
   4496 	}
   4497 	if len(errorComponents.Message) != 0 {
   4498 		errorMessage = errorComponents.Message
   4499 	}
   4500 	errorBody.Seek(0, io.SeekStart)
   4501 	switch {
   4502 	default:
   4503 		genericError := &smithy.GenericAPIError{
   4504 			Code:    errorCode,
   4505 			Message: errorMessage,
   4506 		}
   4507 		return genericError
   4508 
   4509 	}
   4510 }
   4511 
   4512 func awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(v **GetCheckerIpRangesOutput, decoder smithyxml.NodeDecoder) error {
   4513 	if v == nil {
   4514 		return fmt.Errorf("unexpected nil of type %T", v)
   4515 	}
   4516 	var sv *GetCheckerIpRangesOutput
   4517 	if *v == nil {
   4518 		sv = &GetCheckerIpRangesOutput{}
   4519 	} else {
   4520 		sv = *v
   4521 	}
   4522 
   4523 	for {
   4524 		t, done, err := decoder.Token()
   4525 		if err != nil {
   4526 			return err
   4527 		}
   4528 		if done {
   4529 			break
   4530 		}
   4531 		originalDecoder := decoder
   4532 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4533 		switch {
   4534 		case strings.EqualFold("CheckerIpRanges", t.Name.Local):
   4535 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4536 			if err := awsRestxml_deserializeDocumentCheckerIpRanges(&sv.CheckerIpRanges, nodeDecoder); err != nil {
   4537 				return err
   4538 			}
   4539 
   4540 		default:
   4541 			// Do nothing and ignore the unexpected tag element
   4542 			err = decoder.Decoder.Skip()
   4543 			if err != nil {
   4544 				return err
   4545 			}
   4546 
   4547 		}
   4548 		decoder = originalDecoder
   4549 	}
   4550 	*v = sv
   4551 	return nil
   4552 }
   4553 
   4554 type awsRestxml_deserializeOpGetDNSSEC struct {
   4555 }
   4556 
   4557 func (*awsRestxml_deserializeOpGetDNSSEC) ID() string {
   4558 	return "OperationDeserializer"
   4559 }
   4560 
   4561 func (m *awsRestxml_deserializeOpGetDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4562 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4563 ) {
   4564 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4565 	if err != nil {
   4566 		return out, metadata, err
   4567 	}
   4568 
   4569 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4570 	if !ok {
   4571 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4572 	}
   4573 
   4574 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   4575 
   4576 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4577 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4578 	defer endTimer()
   4579 	defer span.End()
   4580 
   4581 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4582 		return out, metadata, awsRestxml_deserializeOpErrorGetDNSSEC(response, &metadata)
   4583 	}
   4584 	output := &GetDNSSECOutput{}
   4585 	out.Result = output
   4586 
   4587 	var buff [1024]byte
   4588 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4589 	body := io.TeeReader(response.Body, ringBuffer)
   4590 	rootDecoder := xml.NewDecoder(body)
   4591 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4592 	if err == io.EOF {
   4593 		return out, metadata, nil
   4594 	}
   4595 	if err != nil {
   4596 		var snapshot bytes.Buffer
   4597 		io.Copy(&snapshot, ringBuffer)
   4598 		return out, metadata, &smithy.DeserializationError{
   4599 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4600 			Snapshot: snapshot.Bytes(),
   4601 		}
   4602 	}
   4603 
   4604 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4605 	err = awsRestxml_deserializeOpDocumentGetDNSSECOutput(&output, decoder)
   4606 	if err != nil {
   4607 		var snapshot bytes.Buffer
   4608 		io.Copy(&snapshot, ringBuffer)
   4609 		return out, metadata, &smithy.DeserializationError{
   4610 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4611 			Snapshot: snapshot.Bytes(),
   4612 		}
   4613 	}
   4614 
   4615 	span.End()
   4616 	return out, metadata, err
   4617 }
   4618 
   4619 func awsRestxml_deserializeOpErrorGetDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4620 	var errorBuffer bytes.Buffer
   4621 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4622 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4623 	}
   4624 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4625 
   4626 	errorCode := "UnknownError"
   4627 	errorMessage := errorCode
   4628 
   4629 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4630 	if err != nil {
   4631 		return err
   4632 	}
   4633 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4634 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4635 	}
   4636 	if len(errorComponents.Code) != 0 {
   4637 		errorCode = errorComponents.Code
   4638 	}
   4639 	if len(errorComponents.Message) != 0 {
   4640 		errorMessage = errorComponents.Message
   4641 	}
   4642 	errorBody.Seek(0, io.SeekStart)
   4643 	switch {
   4644 	case strings.EqualFold("InvalidArgument", errorCode):
   4645 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   4646 
   4647 	case strings.EqualFold("InvalidInput", errorCode):
   4648 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4649 
   4650 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   4651 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   4652 
   4653 	default:
   4654 		genericError := &smithy.GenericAPIError{
   4655 			Code:    errorCode,
   4656 			Message: errorMessage,
   4657 		}
   4658 		return genericError
   4659 
   4660 	}
   4661 }
   4662 
   4663 func awsRestxml_deserializeOpDocumentGetDNSSECOutput(v **GetDNSSECOutput, decoder smithyxml.NodeDecoder) error {
   4664 	if v == nil {
   4665 		return fmt.Errorf("unexpected nil of type %T", v)
   4666 	}
   4667 	var sv *GetDNSSECOutput
   4668 	if *v == nil {
   4669 		sv = &GetDNSSECOutput{}
   4670 	} else {
   4671 		sv = *v
   4672 	}
   4673 
   4674 	for {
   4675 		t, done, err := decoder.Token()
   4676 		if err != nil {
   4677 			return err
   4678 		}
   4679 		if done {
   4680 			break
   4681 		}
   4682 		originalDecoder := decoder
   4683 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4684 		switch {
   4685 		case strings.EqualFold("KeySigningKeys", t.Name.Local):
   4686 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4687 			if err := awsRestxml_deserializeDocumentKeySigningKeys(&sv.KeySigningKeys, nodeDecoder); err != nil {
   4688 				return err
   4689 			}
   4690 
   4691 		case strings.EqualFold("Status", t.Name.Local):
   4692 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4693 			if err := awsRestxml_deserializeDocumentDNSSECStatus(&sv.Status, nodeDecoder); err != nil {
   4694 				return err
   4695 			}
   4696 
   4697 		default:
   4698 			// Do nothing and ignore the unexpected tag element
   4699 			err = decoder.Decoder.Skip()
   4700 			if err != nil {
   4701 				return err
   4702 			}
   4703 
   4704 		}
   4705 		decoder = originalDecoder
   4706 	}
   4707 	*v = sv
   4708 	return nil
   4709 }
   4710 
   4711 type awsRestxml_deserializeOpGetGeoLocation struct {
   4712 }
   4713 
   4714 func (*awsRestxml_deserializeOpGetGeoLocation) ID() string {
   4715 	return "OperationDeserializer"
   4716 }
   4717 
   4718 func (m *awsRestxml_deserializeOpGetGeoLocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4719 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4720 ) {
   4721 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4722 	if err != nil {
   4723 		return out, metadata, err
   4724 	}
   4725 
   4726 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4727 	if !ok {
   4728 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4729 	}
   4730 
   4731 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   4732 
   4733 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4734 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4735 	defer endTimer()
   4736 	defer span.End()
   4737 
   4738 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4739 		return out, metadata, awsRestxml_deserializeOpErrorGetGeoLocation(response, &metadata)
   4740 	}
   4741 	output := &GetGeoLocationOutput{}
   4742 	out.Result = output
   4743 
   4744 	var buff [1024]byte
   4745 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4746 	body := io.TeeReader(response.Body, ringBuffer)
   4747 	rootDecoder := xml.NewDecoder(body)
   4748 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4749 	if err == io.EOF {
   4750 		return out, metadata, nil
   4751 	}
   4752 	if err != nil {
   4753 		var snapshot bytes.Buffer
   4754 		io.Copy(&snapshot, ringBuffer)
   4755 		return out, metadata, &smithy.DeserializationError{
   4756 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4757 			Snapshot: snapshot.Bytes(),
   4758 		}
   4759 	}
   4760 
   4761 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4762 	err = awsRestxml_deserializeOpDocumentGetGeoLocationOutput(&output, decoder)
   4763 	if err != nil {
   4764 		var snapshot bytes.Buffer
   4765 		io.Copy(&snapshot, ringBuffer)
   4766 		return out, metadata, &smithy.DeserializationError{
   4767 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4768 			Snapshot: snapshot.Bytes(),
   4769 		}
   4770 	}
   4771 
   4772 	span.End()
   4773 	return out, metadata, err
   4774 }
   4775 
   4776 func awsRestxml_deserializeOpErrorGetGeoLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4777 	var errorBuffer bytes.Buffer
   4778 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4779 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4780 	}
   4781 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4782 
   4783 	errorCode := "UnknownError"
   4784 	errorMessage := errorCode
   4785 
   4786 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4787 	if err != nil {
   4788 		return err
   4789 	}
   4790 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4791 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4792 	}
   4793 	if len(errorComponents.Code) != 0 {
   4794 		errorCode = errorComponents.Code
   4795 	}
   4796 	if len(errorComponents.Message) != 0 {
   4797 		errorMessage = errorComponents.Message
   4798 	}
   4799 	errorBody.Seek(0, io.SeekStart)
   4800 	switch {
   4801 	case strings.EqualFold("InvalidInput", errorCode):
   4802 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4803 
   4804 	case strings.EqualFold("NoSuchGeoLocation", errorCode):
   4805 		return awsRestxml_deserializeErrorNoSuchGeoLocation(response, errorBody)
   4806 
   4807 	default:
   4808 		genericError := &smithy.GenericAPIError{
   4809 			Code:    errorCode,
   4810 			Message: errorMessage,
   4811 		}
   4812 		return genericError
   4813 
   4814 	}
   4815 }
   4816 
   4817 func awsRestxml_deserializeOpDocumentGetGeoLocationOutput(v **GetGeoLocationOutput, decoder smithyxml.NodeDecoder) error {
   4818 	if v == nil {
   4819 		return fmt.Errorf("unexpected nil of type %T", v)
   4820 	}
   4821 	var sv *GetGeoLocationOutput
   4822 	if *v == nil {
   4823 		sv = &GetGeoLocationOutput{}
   4824 	} else {
   4825 		sv = *v
   4826 	}
   4827 
   4828 	for {
   4829 		t, done, err := decoder.Token()
   4830 		if err != nil {
   4831 			return err
   4832 		}
   4833 		if done {
   4834 			break
   4835 		}
   4836 		originalDecoder := decoder
   4837 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4838 		switch {
   4839 		case strings.EqualFold("GeoLocationDetails", t.Name.Local):
   4840 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4841 			if err := awsRestxml_deserializeDocumentGeoLocationDetails(&sv.GeoLocationDetails, nodeDecoder); err != nil {
   4842 				return err
   4843 			}
   4844 
   4845 		default:
   4846 			// Do nothing and ignore the unexpected tag element
   4847 			err = decoder.Decoder.Skip()
   4848 			if err != nil {
   4849 				return err
   4850 			}
   4851 
   4852 		}
   4853 		decoder = originalDecoder
   4854 	}
   4855 	*v = sv
   4856 	return nil
   4857 }
   4858 
   4859 type awsRestxml_deserializeOpGetHealthCheck struct {
   4860 }
   4861 
   4862 func (*awsRestxml_deserializeOpGetHealthCheck) ID() string {
   4863 	return "OperationDeserializer"
   4864 }
   4865 
   4866 func (m *awsRestxml_deserializeOpGetHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4867 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4868 ) {
   4869 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4870 	if err != nil {
   4871 		return out, metadata, err
   4872 	}
   4873 
   4874 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4875 	if !ok {
   4876 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4877 	}
   4878 
   4879 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   4880 
   4881 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4882 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4883 	defer endTimer()
   4884 	defer span.End()
   4885 
   4886 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4887 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheck(response, &metadata)
   4888 	}
   4889 	output := &GetHealthCheckOutput{}
   4890 	out.Result = output
   4891 
   4892 	var buff [1024]byte
   4893 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4894 	body := io.TeeReader(response.Body, ringBuffer)
   4895 	rootDecoder := xml.NewDecoder(body)
   4896 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4897 	if err == io.EOF {
   4898 		return out, metadata, nil
   4899 	}
   4900 	if err != nil {
   4901 		var snapshot bytes.Buffer
   4902 		io.Copy(&snapshot, ringBuffer)
   4903 		return out, metadata, &smithy.DeserializationError{
   4904 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4905 			Snapshot: snapshot.Bytes(),
   4906 		}
   4907 	}
   4908 
   4909 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4910 	err = awsRestxml_deserializeOpDocumentGetHealthCheckOutput(&output, decoder)
   4911 	if err != nil {
   4912 		var snapshot bytes.Buffer
   4913 		io.Copy(&snapshot, ringBuffer)
   4914 		return out, metadata, &smithy.DeserializationError{
   4915 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4916 			Snapshot: snapshot.Bytes(),
   4917 		}
   4918 	}
   4919 
   4920 	span.End()
   4921 	return out, metadata, err
   4922 }
   4923 
   4924 func awsRestxml_deserializeOpErrorGetHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4925 	var errorBuffer bytes.Buffer
   4926 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4927 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4928 	}
   4929 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4930 
   4931 	errorCode := "UnknownError"
   4932 	errorMessage := errorCode
   4933 
   4934 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4935 	if err != nil {
   4936 		return err
   4937 	}
   4938 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4939 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4940 	}
   4941 	if len(errorComponents.Code) != 0 {
   4942 		errorCode = errorComponents.Code
   4943 	}
   4944 	if len(errorComponents.Message) != 0 {
   4945 		errorMessage = errorComponents.Message
   4946 	}
   4947 	errorBody.Seek(0, io.SeekStart)
   4948 	switch {
   4949 	case strings.EqualFold("IncompatibleVersion", errorCode):
   4950 		return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody)
   4951 
   4952 	case strings.EqualFold("InvalidInput", errorCode):
   4953 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4954 
   4955 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   4956 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   4957 
   4958 	default:
   4959 		genericError := &smithy.GenericAPIError{
   4960 			Code:    errorCode,
   4961 			Message: errorMessage,
   4962 		}
   4963 		return genericError
   4964 
   4965 	}
   4966 }
   4967 
   4968 func awsRestxml_deserializeOpDocumentGetHealthCheckOutput(v **GetHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
   4969 	if v == nil {
   4970 		return fmt.Errorf("unexpected nil of type %T", v)
   4971 	}
   4972 	var sv *GetHealthCheckOutput
   4973 	if *v == nil {
   4974 		sv = &GetHealthCheckOutput{}
   4975 	} else {
   4976 		sv = *v
   4977 	}
   4978 
   4979 	for {
   4980 		t, done, err := decoder.Token()
   4981 		if err != nil {
   4982 			return err
   4983 		}
   4984 		if done {
   4985 			break
   4986 		}
   4987 		originalDecoder := decoder
   4988 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4989 		switch {
   4990 		case strings.EqualFold("HealthCheck", t.Name.Local):
   4991 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4992 			if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
   4993 				return err
   4994 			}
   4995 
   4996 		default:
   4997 			// Do nothing and ignore the unexpected tag element
   4998 			err = decoder.Decoder.Skip()
   4999 			if err != nil {
   5000 				return err
   5001 			}
   5002 
   5003 		}
   5004 		decoder = originalDecoder
   5005 	}
   5006 	*v = sv
   5007 	return nil
   5008 }
   5009 
   5010 type awsRestxml_deserializeOpGetHealthCheckCount struct {
   5011 }
   5012 
   5013 func (*awsRestxml_deserializeOpGetHealthCheckCount) ID() string {
   5014 	return "OperationDeserializer"
   5015 }
   5016 
   5017 func (m *awsRestxml_deserializeOpGetHealthCheckCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5018 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5019 ) {
   5020 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5021 	if err != nil {
   5022 		return out, metadata, err
   5023 	}
   5024 
   5025 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5026 	if !ok {
   5027 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5028 	}
   5029 
   5030 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   5031 
   5032 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5033 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5034 	defer endTimer()
   5035 	defer span.End()
   5036 
   5037 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5038 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckCount(response, &metadata)
   5039 	}
   5040 	output := &GetHealthCheckCountOutput{}
   5041 	out.Result = output
   5042 
   5043 	var buff [1024]byte
   5044 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5045 	body := io.TeeReader(response.Body, ringBuffer)
   5046 	rootDecoder := xml.NewDecoder(body)
   5047 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5048 	if err == io.EOF {
   5049 		return out, metadata, nil
   5050 	}
   5051 	if err != nil {
   5052 		var snapshot bytes.Buffer
   5053 		io.Copy(&snapshot, ringBuffer)
   5054 		return out, metadata, &smithy.DeserializationError{
   5055 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5056 			Snapshot: snapshot.Bytes(),
   5057 		}
   5058 	}
   5059 
   5060 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5061 	err = awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(&output, decoder)
   5062 	if err != nil {
   5063 		var snapshot bytes.Buffer
   5064 		io.Copy(&snapshot, ringBuffer)
   5065 		return out, metadata, &smithy.DeserializationError{
   5066 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5067 			Snapshot: snapshot.Bytes(),
   5068 		}
   5069 	}
   5070 
   5071 	span.End()
   5072 	return out, metadata, err
   5073 }
   5074 
   5075 func awsRestxml_deserializeOpErrorGetHealthCheckCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5076 	var errorBuffer bytes.Buffer
   5077 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5078 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5079 	}
   5080 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5081 
   5082 	errorCode := "UnknownError"
   5083 	errorMessage := errorCode
   5084 
   5085 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5086 	if err != nil {
   5087 		return err
   5088 	}
   5089 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5090 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5091 	}
   5092 	if len(errorComponents.Code) != 0 {
   5093 		errorCode = errorComponents.Code
   5094 	}
   5095 	if len(errorComponents.Message) != 0 {
   5096 		errorMessage = errorComponents.Message
   5097 	}
   5098 	errorBody.Seek(0, io.SeekStart)
   5099 	switch {
   5100 	default:
   5101 		genericError := &smithy.GenericAPIError{
   5102 			Code:    errorCode,
   5103 			Message: errorMessage,
   5104 		}
   5105 		return genericError
   5106 
   5107 	}
   5108 }
   5109 
   5110 func awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(v **GetHealthCheckCountOutput, decoder smithyxml.NodeDecoder) error {
   5111 	if v == nil {
   5112 		return fmt.Errorf("unexpected nil of type %T", v)
   5113 	}
   5114 	var sv *GetHealthCheckCountOutput
   5115 	if *v == nil {
   5116 		sv = &GetHealthCheckCountOutput{}
   5117 	} else {
   5118 		sv = *v
   5119 	}
   5120 
   5121 	for {
   5122 		t, done, err := decoder.Token()
   5123 		if err != nil {
   5124 			return err
   5125 		}
   5126 		if done {
   5127 			break
   5128 		}
   5129 		originalDecoder := decoder
   5130 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5131 		switch {
   5132 		case strings.EqualFold("HealthCheckCount", t.Name.Local):
   5133 			val, err := decoder.Value()
   5134 			if err != nil {
   5135 				return err
   5136 			}
   5137 			if val == nil {
   5138 				break
   5139 			}
   5140 			{
   5141 				xtv := string(val)
   5142 				i64, err := strconv.ParseInt(xtv, 10, 64)
   5143 				if err != nil {
   5144 					return err
   5145 				}
   5146 				sv.HealthCheckCount = ptr.Int64(i64)
   5147 			}
   5148 
   5149 		default:
   5150 			// Do nothing and ignore the unexpected tag element
   5151 			err = decoder.Decoder.Skip()
   5152 			if err != nil {
   5153 				return err
   5154 			}
   5155 
   5156 		}
   5157 		decoder = originalDecoder
   5158 	}
   5159 	*v = sv
   5160 	return nil
   5161 }
   5162 
   5163 type awsRestxml_deserializeOpGetHealthCheckLastFailureReason struct {
   5164 }
   5165 
   5166 func (*awsRestxml_deserializeOpGetHealthCheckLastFailureReason) ID() string {
   5167 	return "OperationDeserializer"
   5168 }
   5169 
   5170 func (m *awsRestxml_deserializeOpGetHealthCheckLastFailureReason) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5171 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5172 ) {
   5173 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5174 	if err != nil {
   5175 		return out, metadata, err
   5176 	}
   5177 
   5178 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5179 	if !ok {
   5180 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5181 	}
   5182 
   5183 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   5184 
   5185 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5186 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5187 	defer endTimer()
   5188 	defer span.End()
   5189 
   5190 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5191 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response, &metadata)
   5192 	}
   5193 	output := &GetHealthCheckLastFailureReasonOutput{}
   5194 	out.Result = output
   5195 
   5196 	var buff [1024]byte
   5197 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5198 	body := io.TeeReader(response.Body, ringBuffer)
   5199 	rootDecoder := xml.NewDecoder(body)
   5200 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5201 	if err == io.EOF {
   5202 		return out, metadata, nil
   5203 	}
   5204 	if err != nil {
   5205 		var snapshot bytes.Buffer
   5206 		io.Copy(&snapshot, ringBuffer)
   5207 		return out, metadata, &smithy.DeserializationError{
   5208 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5209 			Snapshot: snapshot.Bytes(),
   5210 		}
   5211 	}
   5212 
   5213 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5214 	err = awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(&output, decoder)
   5215 	if err != nil {
   5216 		var snapshot bytes.Buffer
   5217 		io.Copy(&snapshot, ringBuffer)
   5218 		return out, metadata, &smithy.DeserializationError{
   5219 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5220 			Snapshot: snapshot.Bytes(),
   5221 		}
   5222 	}
   5223 
   5224 	span.End()
   5225 	return out, metadata, err
   5226 }
   5227 
   5228 func awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5229 	var errorBuffer bytes.Buffer
   5230 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5231 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5232 	}
   5233 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5234 
   5235 	errorCode := "UnknownError"
   5236 	errorMessage := errorCode
   5237 
   5238 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5239 	if err != nil {
   5240 		return err
   5241 	}
   5242 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5243 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5244 	}
   5245 	if len(errorComponents.Code) != 0 {
   5246 		errorCode = errorComponents.Code
   5247 	}
   5248 	if len(errorComponents.Message) != 0 {
   5249 		errorMessage = errorComponents.Message
   5250 	}
   5251 	errorBody.Seek(0, io.SeekStart)
   5252 	switch {
   5253 	case strings.EqualFold("InvalidInput", errorCode):
   5254 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5255 
   5256 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   5257 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   5258 
   5259 	default:
   5260 		genericError := &smithy.GenericAPIError{
   5261 			Code:    errorCode,
   5262 			Message: errorMessage,
   5263 		}
   5264 		return genericError
   5265 
   5266 	}
   5267 }
   5268 
   5269 func awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(v **GetHealthCheckLastFailureReasonOutput, decoder smithyxml.NodeDecoder) error {
   5270 	if v == nil {
   5271 		return fmt.Errorf("unexpected nil of type %T", v)
   5272 	}
   5273 	var sv *GetHealthCheckLastFailureReasonOutput
   5274 	if *v == nil {
   5275 		sv = &GetHealthCheckLastFailureReasonOutput{}
   5276 	} else {
   5277 		sv = *v
   5278 	}
   5279 
   5280 	for {
   5281 		t, done, err := decoder.Token()
   5282 		if err != nil {
   5283 			return err
   5284 		}
   5285 		if done {
   5286 			break
   5287 		}
   5288 		originalDecoder := decoder
   5289 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5290 		switch {
   5291 		case strings.EqualFold("HealthCheckObservations", t.Name.Local):
   5292 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5293 			if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil {
   5294 				return err
   5295 			}
   5296 
   5297 		default:
   5298 			// Do nothing and ignore the unexpected tag element
   5299 			err = decoder.Decoder.Skip()
   5300 			if err != nil {
   5301 				return err
   5302 			}
   5303 
   5304 		}
   5305 		decoder = originalDecoder
   5306 	}
   5307 	*v = sv
   5308 	return nil
   5309 }
   5310 
   5311 type awsRestxml_deserializeOpGetHealthCheckStatus struct {
   5312 }
   5313 
   5314 func (*awsRestxml_deserializeOpGetHealthCheckStatus) ID() string {
   5315 	return "OperationDeserializer"
   5316 }
   5317 
   5318 func (m *awsRestxml_deserializeOpGetHealthCheckStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5319 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5320 ) {
   5321 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5322 	if err != nil {
   5323 		return out, metadata, err
   5324 	}
   5325 
   5326 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5327 	if !ok {
   5328 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5329 	}
   5330 
   5331 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   5332 
   5333 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5334 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5335 	defer endTimer()
   5336 	defer span.End()
   5337 
   5338 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5339 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckStatus(response, &metadata)
   5340 	}
   5341 	output := &GetHealthCheckStatusOutput{}
   5342 	out.Result = output
   5343 
   5344 	var buff [1024]byte
   5345 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5346 	body := io.TeeReader(response.Body, ringBuffer)
   5347 	rootDecoder := xml.NewDecoder(body)
   5348 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5349 	if err == io.EOF {
   5350 		return out, metadata, nil
   5351 	}
   5352 	if err != nil {
   5353 		var snapshot bytes.Buffer
   5354 		io.Copy(&snapshot, ringBuffer)
   5355 		return out, metadata, &smithy.DeserializationError{
   5356 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5357 			Snapshot: snapshot.Bytes(),
   5358 		}
   5359 	}
   5360 
   5361 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5362 	err = awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(&output, decoder)
   5363 	if err != nil {
   5364 		var snapshot bytes.Buffer
   5365 		io.Copy(&snapshot, ringBuffer)
   5366 		return out, metadata, &smithy.DeserializationError{
   5367 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5368 			Snapshot: snapshot.Bytes(),
   5369 		}
   5370 	}
   5371 
   5372 	span.End()
   5373 	return out, metadata, err
   5374 }
   5375 
   5376 func awsRestxml_deserializeOpErrorGetHealthCheckStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5377 	var errorBuffer bytes.Buffer
   5378 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5379 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5380 	}
   5381 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5382 
   5383 	errorCode := "UnknownError"
   5384 	errorMessage := errorCode
   5385 
   5386 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5387 	if err != nil {
   5388 		return err
   5389 	}
   5390 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5391 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5392 	}
   5393 	if len(errorComponents.Code) != 0 {
   5394 		errorCode = errorComponents.Code
   5395 	}
   5396 	if len(errorComponents.Message) != 0 {
   5397 		errorMessage = errorComponents.Message
   5398 	}
   5399 	errorBody.Seek(0, io.SeekStart)
   5400 	switch {
   5401 	case strings.EqualFold("InvalidInput", errorCode):
   5402 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5403 
   5404 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   5405 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   5406 
   5407 	default:
   5408 		genericError := &smithy.GenericAPIError{
   5409 			Code:    errorCode,
   5410 			Message: errorMessage,
   5411 		}
   5412 		return genericError
   5413 
   5414 	}
   5415 }
   5416 
   5417 func awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(v **GetHealthCheckStatusOutput, decoder smithyxml.NodeDecoder) error {
   5418 	if v == nil {
   5419 		return fmt.Errorf("unexpected nil of type %T", v)
   5420 	}
   5421 	var sv *GetHealthCheckStatusOutput
   5422 	if *v == nil {
   5423 		sv = &GetHealthCheckStatusOutput{}
   5424 	} else {
   5425 		sv = *v
   5426 	}
   5427 
   5428 	for {
   5429 		t, done, err := decoder.Token()
   5430 		if err != nil {
   5431 			return err
   5432 		}
   5433 		if done {
   5434 			break
   5435 		}
   5436 		originalDecoder := decoder
   5437 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5438 		switch {
   5439 		case strings.EqualFold("HealthCheckObservations", t.Name.Local):
   5440 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5441 			if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil {
   5442 				return err
   5443 			}
   5444 
   5445 		default:
   5446 			// Do nothing and ignore the unexpected tag element
   5447 			err = decoder.Decoder.Skip()
   5448 			if err != nil {
   5449 				return err
   5450 			}
   5451 
   5452 		}
   5453 		decoder = originalDecoder
   5454 	}
   5455 	*v = sv
   5456 	return nil
   5457 }
   5458 
   5459 type awsRestxml_deserializeOpGetHostedZone struct {
   5460 }
   5461 
   5462 func (*awsRestxml_deserializeOpGetHostedZone) ID() string {
   5463 	return "OperationDeserializer"
   5464 }
   5465 
   5466 func (m *awsRestxml_deserializeOpGetHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5467 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5468 ) {
   5469 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5470 	if err != nil {
   5471 		return out, metadata, err
   5472 	}
   5473 
   5474 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5475 	if !ok {
   5476 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5477 	}
   5478 
   5479 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   5480 
   5481 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5482 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5483 	defer endTimer()
   5484 	defer span.End()
   5485 
   5486 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5487 		return out, metadata, awsRestxml_deserializeOpErrorGetHostedZone(response, &metadata)
   5488 	}
   5489 	output := &GetHostedZoneOutput{}
   5490 	out.Result = output
   5491 
   5492 	var buff [1024]byte
   5493 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5494 	body := io.TeeReader(response.Body, ringBuffer)
   5495 	rootDecoder := xml.NewDecoder(body)
   5496 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5497 	if err == io.EOF {
   5498 		return out, metadata, nil
   5499 	}
   5500 	if err != nil {
   5501 		var snapshot bytes.Buffer
   5502 		io.Copy(&snapshot, ringBuffer)
   5503 		return out, metadata, &smithy.DeserializationError{
   5504 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5505 			Snapshot: snapshot.Bytes(),
   5506 		}
   5507 	}
   5508 
   5509 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5510 	err = awsRestxml_deserializeOpDocumentGetHostedZoneOutput(&output, decoder)
   5511 	if err != nil {
   5512 		var snapshot bytes.Buffer
   5513 		io.Copy(&snapshot, ringBuffer)
   5514 		return out, metadata, &smithy.DeserializationError{
   5515 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5516 			Snapshot: snapshot.Bytes(),
   5517 		}
   5518 	}
   5519 
   5520 	span.End()
   5521 	return out, metadata, err
   5522 }
   5523 
   5524 func awsRestxml_deserializeOpErrorGetHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5525 	var errorBuffer bytes.Buffer
   5526 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5527 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5528 	}
   5529 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5530 
   5531 	errorCode := "UnknownError"
   5532 	errorMessage := errorCode
   5533 
   5534 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5535 	if err != nil {
   5536 		return err
   5537 	}
   5538 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5539 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5540 	}
   5541 	if len(errorComponents.Code) != 0 {
   5542 		errorCode = errorComponents.Code
   5543 	}
   5544 	if len(errorComponents.Message) != 0 {
   5545 		errorMessage = errorComponents.Message
   5546 	}
   5547 	errorBody.Seek(0, io.SeekStart)
   5548 	switch {
   5549 	case strings.EqualFold("InvalidInput", errorCode):
   5550 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5551 
   5552 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   5553 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   5554 
   5555 	default:
   5556 		genericError := &smithy.GenericAPIError{
   5557 			Code:    errorCode,
   5558 			Message: errorMessage,
   5559 		}
   5560 		return genericError
   5561 
   5562 	}
   5563 }
   5564 
   5565 func awsRestxml_deserializeOpDocumentGetHostedZoneOutput(v **GetHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   5566 	if v == nil {
   5567 		return fmt.Errorf("unexpected nil of type %T", v)
   5568 	}
   5569 	var sv *GetHostedZoneOutput
   5570 	if *v == nil {
   5571 		sv = &GetHostedZoneOutput{}
   5572 	} else {
   5573 		sv = *v
   5574 	}
   5575 
   5576 	for {
   5577 		t, done, err := decoder.Token()
   5578 		if err != nil {
   5579 			return err
   5580 		}
   5581 		if done {
   5582 			break
   5583 		}
   5584 		originalDecoder := decoder
   5585 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5586 		switch {
   5587 		case strings.EqualFold("DelegationSet", t.Name.Local):
   5588 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5589 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   5590 				return err
   5591 			}
   5592 
   5593 		case strings.EqualFold("HostedZone", t.Name.Local):
   5594 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5595 			if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
   5596 				return err
   5597 			}
   5598 
   5599 		case strings.EqualFold("VPCs", t.Name.Local):
   5600 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5601 			if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil {
   5602 				return err
   5603 			}
   5604 
   5605 		default:
   5606 			// Do nothing and ignore the unexpected tag element
   5607 			err = decoder.Decoder.Skip()
   5608 			if err != nil {
   5609 				return err
   5610 			}
   5611 
   5612 		}
   5613 		decoder = originalDecoder
   5614 	}
   5615 	*v = sv
   5616 	return nil
   5617 }
   5618 
   5619 type awsRestxml_deserializeOpGetHostedZoneCount struct {
   5620 }
   5621 
   5622 func (*awsRestxml_deserializeOpGetHostedZoneCount) ID() string {
   5623 	return "OperationDeserializer"
   5624 }
   5625 
   5626 func (m *awsRestxml_deserializeOpGetHostedZoneCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5627 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5628 ) {
   5629 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5630 	if err != nil {
   5631 		return out, metadata, err
   5632 	}
   5633 
   5634 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5635 	if !ok {
   5636 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5637 	}
   5638 
   5639 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   5640 
   5641 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5642 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5643 	defer endTimer()
   5644 	defer span.End()
   5645 
   5646 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5647 		return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneCount(response, &metadata)
   5648 	}
   5649 	output := &GetHostedZoneCountOutput{}
   5650 	out.Result = output
   5651 
   5652 	var buff [1024]byte
   5653 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5654 	body := io.TeeReader(response.Body, ringBuffer)
   5655 	rootDecoder := xml.NewDecoder(body)
   5656 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5657 	if err == io.EOF {
   5658 		return out, metadata, nil
   5659 	}
   5660 	if err != nil {
   5661 		var snapshot bytes.Buffer
   5662 		io.Copy(&snapshot, ringBuffer)
   5663 		return out, metadata, &smithy.DeserializationError{
   5664 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5665 			Snapshot: snapshot.Bytes(),
   5666 		}
   5667 	}
   5668 
   5669 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5670 	err = awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(&output, decoder)
   5671 	if err != nil {
   5672 		var snapshot bytes.Buffer
   5673 		io.Copy(&snapshot, ringBuffer)
   5674 		return out, metadata, &smithy.DeserializationError{
   5675 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5676 			Snapshot: snapshot.Bytes(),
   5677 		}
   5678 	}
   5679 
   5680 	span.End()
   5681 	return out, metadata, err
   5682 }
   5683 
   5684 func awsRestxml_deserializeOpErrorGetHostedZoneCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5685 	var errorBuffer bytes.Buffer
   5686 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5687 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5688 	}
   5689 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5690 
   5691 	errorCode := "UnknownError"
   5692 	errorMessage := errorCode
   5693 
   5694 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5695 	if err != nil {
   5696 		return err
   5697 	}
   5698 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5699 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5700 	}
   5701 	if len(errorComponents.Code) != 0 {
   5702 		errorCode = errorComponents.Code
   5703 	}
   5704 	if len(errorComponents.Message) != 0 {
   5705 		errorMessage = errorComponents.Message
   5706 	}
   5707 	errorBody.Seek(0, io.SeekStart)
   5708 	switch {
   5709 	case strings.EqualFold("InvalidInput", errorCode):
   5710 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5711 
   5712 	default:
   5713 		genericError := &smithy.GenericAPIError{
   5714 			Code:    errorCode,
   5715 			Message: errorMessage,
   5716 		}
   5717 		return genericError
   5718 
   5719 	}
   5720 }
   5721 
   5722 func awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(v **GetHostedZoneCountOutput, decoder smithyxml.NodeDecoder) error {
   5723 	if v == nil {
   5724 		return fmt.Errorf("unexpected nil of type %T", v)
   5725 	}
   5726 	var sv *GetHostedZoneCountOutput
   5727 	if *v == nil {
   5728 		sv = &GetHostedZoneCountOutput{}
   5729 	} else {
   5730 		sv = *v
   5731 	}
   5732 
   5733 	for {
   5734 		t, done, err := decoder.Token()
   5735 		if err != nil {
   5736 			return err
   5737 		}
   5738 		if done {
   5739 			break
   5740 		}
   5741 		originalDecoder := decoder
   5742 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5743 		switch {
   5744 		case strings.EqualFold("HostedZoneCount", t.Name.Local):
   5745 			val, err := decoder.Value()
   5746 			if err != nil {
   5747 				return err
   5748 			}
   5749 			if val == nil {
   5750 				break
   5751 			}
   5752 			{
   5753 				xtv := string(val)
   5754 				i64, err := strconv.ParseInt(xtv, 10, 64)
   5755 				if err != nil {
   5756 					return err
   5757 				}
   5758 				sv.HostedZoneCount = ptr.Int64(i64)
   5759 			}
   5760 
   5761 		default:
   5762 			// Do nothing and ignore the unexpected tag element
   5763 			err = decoder.Decoder.Skip()
   5764 			if err != nil {
   5765 				return err
   5766 			}
   5767 
   5768 		}
   5769 		decoder = originalDecoder
   5770 	}
   5771 	*v = sv
   5772 	return nil
   5773 }
   5774 
   5775 type awsRestxml_deserializeOpGetHostedZoneLimit struct {
   5776 }
   5777 
   5778 func (*awsRestxml_deserializeOpGetHostedZoneLimit) ID() string {
   5779 	return "OperationDeserializer"
   5780 }
   5781 
   5782 func (m *awsRestxml_deserializeOpGetHostedZoneLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5783 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5784 ) {
   5785 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5786 	if err != nil {
   5787 		return out, metadata, err
   5788 	}
   5789 
   5790 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5791 	if !ok {
   5792 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5793 	}
   5794 
   5795 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   5796 
   5797 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5798 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5799 	defer endTimer()
   5800 	defer span.End()
   5801 
   5802 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5803 		return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneLimit(response, &metadata)
   5804 	}
   5805 	output := &GetHostedZoneLimitOutput{}
   5806 	out.Result = output
   5807 
   5808 	var buff [1024]byte
   5809 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5810 	body := io.TeeReader(response.Body, ringBuffer)
   5811 	rootDecoder := xml.NewDecoder(body)
   5812 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5813 	if err == io.EOF {
   5814 		return out, metadata, nil
   5815 	}
   5816 	if err != nil {
   5817 		var snapshot bytes.Buffer
   5818 		io.Copy(&snapshot, ringBuffer)
   5819 		return out, metadata, &smithy.DeserializationError{
   5820 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5821 			Snapshot: snapshot.Bytes(),
   5822 		}
   5823 	}
   5824 
   5825 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5826 	err = awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(&output, decoder)
   5827 	if err != nil {
   5828 		var snapshot bytes.Buffer
   5829 		io.Copy(&snapshot, ringBuffer)
   5830 		return out, metadata, &smithy.DeserializationError{
   5831 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5832 			Snapshot: snapshot.Bytes(),
   5833 		}
   5834 	}
   5835 
   5836 	span.End()
   5837 	return out, metadata, err
   5838 }
   5839 
   5840 func awsRestxml_deserializeOpErrorGetHostedZoneLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5841 	var errorBuffer bytes.Buffer
   5842 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5843 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5844 	}
   5845 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5846 
   5847 	errorCode := "UnknownError"
   5848 	errorMessage := errorCode
   5849 
   5850 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5851 	if err != nil {
   5852 		return err
   5853 	}
   5854 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5855 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5856 	}
   5857 	if len(errorComponents.Code) != 0 {
   5858 		errorCode = errorComponents.Code
   5859 	}
   5860 	if len(errorComponents.Message) != 0 {
   5861 		errorMessage = errorComponents.Message
   5862 	}
   5863 	errorBody.Seek(0, io.SeekStart)
   5864 	switch {
   5865 	case strings.EqualFold("HostedZoneNotPrivate", errorCode):
   5866 		return awsRestxml_deserializeErrorHostedZoneNotPrivate(response, errorBody)
   5867 
   5868 	case strings.EqualFold("InvalidInput", errorCode):
   5869 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5870 
   5871 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   5872 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   5873 
   5874 	default:
   5875 		genericError := &smithy.GenericAPIError{
   5876 			Code:    errorCode,
   5877 			Message: errorMessage,
   5878 		}
   5879 		return genericError
   5880 
   5881 	}
   5882 }
   5883 
   5884 func awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(v **GetHostedZoneLimitOutput, decoder smithyxml.NodeDecoder) error {
   5885 	if v == nil {
   5886 		return fmt.Errorf("unexpected nil of type %T", v)
   5887 	}
   5888 	var sv *GetHostedZoneLimitOutput
   5889 	if *v == nil {
   5890 		sv = &GetHostedZoneLimitOutput{}
   5891 	} else {
   5892 		sv = *v
   5893 	}
   5894 
   5895 	for {
   5896 		t, done, err := decoder.Token()
   5897 		if err != nil {
   5898 			return err
   5899 		}
   5900 		if done {
   5901 			break
   5902 		}
   5903 		originalDecoder := decoder
   5904 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5905 		switch {
   5906 		case strings.EqualFold("Count", t.Name.Local):
   5907 			val, err := decoder.Value()
   5908 			if err != nil {
   5909 				return err
   5910 			}
   5911 			if val == nil {
   5912 				break
   5913 			}
   5914 			{
   5915 				xtv := string(val)
   5916 				i64, err := strconv.ParseInt(xtv, 10, 64)
   5917 				if err != nil {
   5918 					return err
   5919 				}
   5920 				sv.Count = i64
   5921 			}
   5922 
   5923 		case strings.EqualFold("Limit", t.Name.Local):
   5924 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5925 			if err := awsRestxml_deserializeDocumentHostedZoneLimit(&sv.Limit, nodeDecoder); err != nil {
   5926 				return err
   5927 			}
   5928 
   5929 		default:
   5930 			// Do nothing and ignore the unexpected tag element
   5931 			err = decoder.Decoder.Skip()
   5932 			if err != nil {
   5933 				return err
   5934 			}
   5935 
   5936 		}
   5937 		decoder = originalDecoder
   5938 	}
   5939 	*v = sv
   5940 	return nil
   5941 }
   5942 
   5943 type awsRestxml_deserializeOpGetQueryLoggingConfig struct {
   5944 }
   5945 
   5946 func (*awsRestxml_deserializeOpGetQueryLoggingConfig) ID() string {
   5947 	return "OperationDeserializer"
   5948 }
   5949 
   5950 func (m *awsRestxml_deserializeOpGetQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5951 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5952 ) {
   5953 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5954 	if err != nil {
   5955 		return out, metadata, err
   5956 	}
   5957 
   5958 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5959 	if !ok {
   5960 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5961 	}
   5962 
   5963 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   5964 
   5965 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5966 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5967 	defer endTimer()
   5968 	defer span.End()
   5969 
   5970 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5971 		return out, metadata, awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response, &metadata)
   5972 	}
   5973 	output := &GetQueryLoggingConfigOutput{}
   5974 	out.Result = output
   5975 
   5976 	var buff [1024]byte
   5977 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5978 	body := io.TeeReader(response.Body, ringBuffer)
   5979 	rootDecoder := xml.NewDecoder(body)
   5980 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5981 	if err == io.EOF {
   5982 		return out, metadata, nil
   5983 	}
   5984 	if err != nil {
   5985 		var snapshot bytes.Buffer
   5986 		io.Copy(&snapshot, ringBuffer)
   5987 		return out, metadata, &smithy.DeserializationError{
   5988 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5989 			Snapshot: snapshot.Bytes(),
   5990 		}
   5991 	}
   5992 
   5993 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5994 	err = awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(&output, decoder)
   5995 	if err != nil {
   5996 		var snapshot bytes.Buffer
   5997 		io.Copy(&snapshot, ringBuffer)
   5998 		return out, metadata, &smithy.DeserializationError{
   5999 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6000 			Snapshot: snapshot.Bytes(),
   6001 		}
   6002 	}
   6003 
   6004 	span.End()
   6005 	return out, metadata, err
   6006 }
   6007 
   6008 func awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6009 	var errorBuffer bytes.Buffer
   6010 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6011 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6012 	}
   6013 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6014 
   6015 	errorCode := "UnknownError"
   6016 	errorMessage := errorCode
   6017 
   6018 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6019 	if err != nil {
   6020 		return err
   6021 	}
   6022 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6023 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6024 	}
   6025 	if len(errorComponents.Code) != 0 {
   6026 		errorCode = errorComponents.Code
   6027 	}
   6028 	if len(errorComponents.Message) != 0 {
   6029 		errorMessage = errorComponents.Message
   6030 	}
   6031 	errorBody.Seek(0, io.SeekStart)
   6032 	switch {
   6033 	case strings.EqualFold("InvalidInput", errorCode):
   6034 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6035 
   6036 	case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode):
   6037 		return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody)
   6038 
   6039 	default:
   6040 		genericError := &smithy.GenericAPIError{
   6041 			Code:    errorCode,
   6042 			Message: errorMessage,
   6043 		}
   6044 		return genericError
   6045 
   6046 	}
   6047 }
   6048 
   6049 func awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(v **GetQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error {
   6050 	if v == nil {
   6051 		return fmt.Errorf("unexpected nil of type %T", v)
   6052 	}
   6053 	var sv *GetQueryLoggingConfigOutput
   6054 	if *v == nil {
   6055 		sv = &GetQueryLoggingConfigOutput{}
   6056 	} else {
   6057 		sv = *v
   6058 	}
   6059 
   6060 	for {
   6061 		t, done, err := decoder.Token()
   6062 		if err != nil {
   6063 			return err
   6064 		}
   6065 		if done {
   6066 			break
   6067 		}
   6068 		originalDecoder := decoder
   6069 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6070 		switch {
   6071 		case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
   6072 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6073 			if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil {
   6074 				return err
   6075 			}
   6076 
   6077 		default:
   6078 			// Do nothing and ignore the unexpected tag element
   6079 			err = decoder.Decoder.Skip()
   6080 			if err != nil {
   6081 				return err
   6082 			}
   6083 
   6084 		}
   6085 		decoder = originalDecoder
   6086 	}
   6087 	*v = sv
   6088 	return nil
   6089 }
   6090 
   6091 type awsRestxml_deserializeOpGetReusableDelegationSet struct {
   6092 }
   6093 
   6094 func (*awsRestxml_deserializeOpGetReusableDelegationSet) ID() string {
   6095 	return "OperationDeserializer"
   6096 }
   6097 
   6098 func (m *awsRestxml_deserializeOpGetReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6099 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6100 ) {
   6101 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6102 	if err != nil {
   6103 		return out, metadata, err
   6104 	}
   6105 
   6106 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6107 	if !ok {
   6108 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6109 	}
   6110 
   6111 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   6112 
   6113 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6114 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6115 	defer endTimer()
   6116 	defer span.End()
   6117 
   6118 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6119 		return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSet(response, &metadata)
   6120 	}
   6121 	output := &GetReusableDelegationSetOutput{}
   6122 	out.Result = output
   6123 
   6124 	var buff [1024]byte
   6125 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6126 	body := io.TeeReader(response.Body, ringBuffer)
   6127 	rootDecoder := xml.NewDecoder(body)
   6128 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6129 	if err == io.EOF {
   6130 		return out, metadata, nil
   6131 	}
   6132 	if err != nil {
   6133 		var snapshot bytes.Buffer
   6134 		io.Copy(&snapshot, ringBuffer)
   6135 		return out, metadata, &smithy.DeserializationError{
   6136 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6137 			Snapshot: snapshot.Bytes(),
   6138 		}
   6139 	}
   6140 
   6141 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6142 	err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(&output, decoder)
   6143 	if err != nil {
   6144 		var snapshot bytes.Buffer
   6145 		io.Copy(&snapshot, ringBuffer)
   6146 		return out, metadata, &smithy.DeserializationError{
   6147 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6148 			Snapshot: snapshot.Bytes(),
   6149 		}
   6150 	}
   6151 
   6152 	span.End()
   6153 	return out, metadata, err
   6154 }
   6155 
   6156 func awsRestxml_deserializeOpErrorGetReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6157 	var errorBuffer bytes.Buffer
   6158 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6159 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6160 	}
   6161 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6162 
   6163 	errorCode := "UnknownError"
   6164 	errorMessage := errorCode
   6165 
   6166 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6167 	if err != nil {
   6168 		return err
   6169 	}
   6170 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6171 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6172 	}
   6173 	if len(errorComponents.Code) != 0 {
   6174 		errorCode = errorComponents.Code
   6175 	}
   6176 	if len(errorComponents.Message) != 0 {
   6177 		errorMessage = errorComponents.Message
   6178 	}
   6179 	errorBody.Seek(0, io.SeekStart)
   6180 	switch {
   6181 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   6182 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   6183 
   6184 	case strings.EqualFold("InvalidInput", errorCode):
   6185 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6186 
   6187 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   6188 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   6189 
   6190 	default:
   6191 		genericError := &smithy.GenericAPIError{
   6192 			Code:    errorCode,
   6193 			Message: errorMessage,
   6194 		}
   6195 		return genericError
   6196 
   6197 	}
   6198 }
   6199 
   6200 func awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(v **GetReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error {
   6201 	if v == nil {
   6202 		return fmt.Errorf("unexpected nil of type %T", v)
   6203 	}
   6204 	var sv *GetReusableDelegationSetOutput
   6205 	if *v == nil {
   6206 		sv = &GetReusableDelegationSetOutput{}
   6207 	} else {
   6208 		sv = *v
   6209 	}
   6210 
   6211 	for {
   6212 		t, done, err := decoder.Token()
   6213 		if err != nil {
   6214 			return err
   6215 		}
   6216 		if done {
   6217 			break
   6218 		}
   6219 		originalDecoder := decoder
   6220 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6221 		switch {
   6222 		case strings.EqualFold("DelegationSet", t.Name.Local):
   6223 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6224 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   6225 				return err
   6226 			}
   6227 
   6228 		default:
   6229 			// Do nothing and ignore the unexpected tag element
   6230 			err = decoder.Decoder.Skip()
   6231 			if err != nil {
   6232 				return err
   6233 			}
   6234 
   6235 		}
   6236 		decoder = originalDecoder
   6237 	}
   6238 	*v = sv
   6239 	return nil
   6240 }
   6241 
   6242 type awsRestxml_deserializeOpGetReusableDelegationSetLimit struct {
   6243 }
   6244 
   6245 func (*awsRestxml_deserializeOpGetReusableDelegationSetLimit) ID() string {
   6246 	return "OperationDeserializer"
   6247 }
   6248 
   6249 func (m *awsRestxml_deserializeOpGetReusableDelegationSetLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6250 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6251 ) {
   6252 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6253 	if err != nil {
   6254 		return out, metadata, err
   6255 	}
   6256 
   6257 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6258 	if !ok {
   6259 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6260 	}
   6261 
   6262 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   6263 
   6264 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6265 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6266 	defer endTimer()
   6267 	defer span.End()
   6268 
   6269 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6270 		return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response, &metadata)
   6271 	}
   6272 	output := &GetReusableDelegationSetLimitOutput{}
   6273 	out.Result = output
   6274 
   6275 	var buff [1024]byte
   6276 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6277 	body := io.TeeReader(response.Body, ringBuffer)
   6278 	rootDecoder := xml.NewDecoder(body)
   6279 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6280 	if err == io.EOF {
   6281 		return out, metadata, nil
   6282 	}
   6283 	if err != nil {
   6284 		var snapshot bytes.Buffer
   6285 		io.Copy(&snapshot, ringBuffer)
   6286 		return out, metadata, &smithy.DeserializationError{
   6287 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6288 			Snapshot: snapshot.Bytes(),
   6289 		}
   6290 	}
   6291 
   6292 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6293 	err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(&output, decoder)
   6294 	if err != nil {
   6295 		var snapshot bytes.Buffer
   6296 		io.Copy(&snapshot, ringBuffer)
   6297 		return out, metadata, &smithy.DeserializationError{
   6298 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6299 			Snapshot: snapshot.Bytes(),
   6300 		}
   6301 	}
   6302 
   6303 	span.End()
   6304 	return out, metadata, err
   6305 }
   6306 
   6307 func awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6308 	var errorBuffer bytes.Buffer
   6309 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6310 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6311 	}
   6312 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6313 
   6314 	errorCode := "UnknownError"
   6315 	errorMessage := errorCode
   6316 
   6317 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6318 	if err != nil {
   6319 		return err
   6320 	}
   6321 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6322 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6323 	}
   6324 	if len(errorComponents.Code) != 0 {
   6325 		errorCode = errorComponents.Code
   6326 	}
   6327 	if len(errorComponents.Message) != 0 {
   6328 		errorMessage = errorComponents.Message
   6329 	}
   6330 	errorBody.Seek(0, io.SeekStart)
   6331 	switch {
   6332 	case strings.EqualFold("InvalidInput", errorCode):
   6333 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6334 
   6335 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   6336 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   6337 
   6338 	default:
   6339 		genericError := &smithy.GenericAPIError{
   6340 			Code:    errorCode,
   6341 			Message: errorMessage,
   6342 		}
   6343 		return genericError
   6344 
   6345 	}
   6346 }
   6347 
   6348 func awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(v **GetReusableDelegationSetLimitOutput, decoder smithyxml.NodeDecoder) error {
   6349 	if v == nil {
   6350 		return fmt.Errorf("unexpected nil of type %T", v)
   6351 	}
   6352 	var sv *GetReusableDelegationSetLimitOutput
   6353 	if *v == nil {
   6354 		sv = &GetReusableDelegationSetLimitOutput{}
   6355 	} else {
   6356 		sv = *v
   6357 	}
   6358 
   6359 	for {
   6360 		t, done, err := decoder.Token()
   6361 		if err != nil {
   6362 			return err
   6363 		}
   6364 		if done {
   6365 			break
   6366 		}
   6367 		originalDecoder := decoder
   6368 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6369 		switch {
   6370 		case strings.EqualFold("Count", t.Name.Local):
   6371 			val, err := decoder.Value()
   6372 			if err != nil {
   6373 				return err
   6374 			}
   6375 			if val == nil {
   6376 				break
   6377 			}
   6378 			{
   6379 				xtv := string(val)
   6380 				i64, err := strconv.ParseInt(xtv, 10, 64)
   6381 				if err != nil {
   6382 					return err
   6383 				}
   6384 				sv.Count = i64
   6385 			}
   6386 
   6387 		case strings.EqualFold("Limit", t.Name.Local):
   6388 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6389 			if err := awsRestxml_deserializeDocumentReusableDelegationSetLimit(&sv.Limit, nodeDecoder); err != nil {
   6390 				return err
   6391 			}
   6392 
   6393 		default:
   6394 			// Do nothing and ignore the unexpected tag element
   6395 			err = decoder.Decoder.Skip()
   6396 			if err != nil {
   6397 				return err
   6398 			}
   6399 
   6400 		}
   6401 		decoder = originalDecoder
   6402 	}
   6403 	*v = sv
   6404 	return nil
   6405 }
   6406 
   6407 type awsRestxml_deserializeOpGetTrafficPolicy struct {
   6408 }
   6409 
   6410 func (*awsRestxml_deserializeOpGetTrafficPolicy) ID() string {
   6411 	return "OperationDeserializer"
   6412 }
   6413 
   6414 func (m *awsRestxml_deserializeOpGetTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6415 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6416 ) {
   6417 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6418 	if err != nil {
   6419 		return out, metadata, err
   6420 	}
   6421 
   6422 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6423 	if !ok {
   6424 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6425 	}
   6426 
   6427 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   6428 
   6429 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6430 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6431 	defer endTimer()
   6432 	defer span.End()
   6433 
   6434 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6435 		return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicy(response, &metadata)
   6436 	}
   6437 	output := &GetTrafficPolicyOutput{}
   6438 	out.Result = output
   6439 
   6440 	var buff [1024]byte
   6441 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6442 	body := io.TeeReader(response.Body, ringBuffer)
   6443 	rootDecoder := xml.NewDecoder(body)
   6444 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6445 	if err == io.EOF {
   6446 		return out, metadata, nil
   6447 	}
   6448 	if err != nil {
   6449 		var snapshot bytes.Buffer
   6450 		io.Copy(&snapshot, ringBuffer)
   6451 		return out, metadata, &smithy.DeserializationError{
   6452 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6453 			Snapshot: snapshot.Bytes(),
   6454 		}
   6455 	}
   6456 
   6457 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6458 	err = awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(&output, decoder)
   6459 	if err != nil {
   6460 		var snapshot bytes.Buffer
   6461 		io.Copy(&snapshot, ringBuffer)
   6462 		return out, metadata, &smithy.DeserializationError{
   6463 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6464 			Snapshot: snapshot.Bytes(),
   6465 		}
   6466 	}
   6467 
   6468 	span.End()
   6469 	return out, metadata, err
   6470 }
   6471 
   6472 func awsRestxml_deserializeOpErrorGetTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6473 	var errorBuffer bytes.Buffer
   6474 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6475 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6476 	}
   6477 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6478 
   6479 	errorCode := "UnknownError"
   6480 	errorMessage := errorCode
   6481 
   6482 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6483 	if err != nil {
   6484 		return err
   6485 	}
   6486 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6487 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6488 	}
   6489 	if len(errorComponents.Code) != 0 {
   6490 		errorCode = errorComponents.Code
   6491 	}
   6492 	if len(errorComponents.Message) != 0 {
   6493 		errorMessage = errorComponents.Message
   6494 	}
   6495 	errorBody.Seek(0, io.SeekStart)
   6496 	switch {
   6497 	case strings.EqualFold("InvalidInput", errorCode):
   6498 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6499 
   6500 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   6501 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   6502 
   6503 	default:
   6504 		genericError := &smithy.GenericAPIError{
   6505 			Code:    errorCode,
   6506 			Message: errorMessage,
   6507 		}
   6508 		return genericError
   6509 
   6510 	}
   6511 }
   6512 
   6513 func awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(v **GetTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error {
   6514 	if v == nil {
   6515 		return fmt.Errorf("unexpected nil of type %T", v)
   6516 	}
   6517 	var sv *GetTrafficPolicyOutput
   6518 	if *v == nil {
   6519 		sv = &GetTrafficPolicyOutput{}
   6520 	} else {
   6521 		sv = *v
   6522 	}
   6523 
   6524 	for {
   6525 		t, done, err := decoder.Token()
   6526 		if err != nil {
   6527 			return err
   6528 		}
   6529 		if done {
   6530 			break
   6531 		}
   6532 		originalDecoder := decoder
   6533 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6534 		switch {
   6535 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
   6536 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6537 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
   6538 				return err
   6539 			}
   6540 
   6541 		default:
   6542 			// Do nothing and ignore the unexpected tag element
   6543 			err = decoder.Decoder.Skip()
   6544 			if err != nil {
   6545 				return err
   6546 			}
   6547 
   6548 		}
   6549 		decoder = originalDecoder
   6550 	}
   6551 	*v = sv
   6552 	return nil
   6553 }
   6554 
   6555 type awsRestxml_deserializeOpGetTrafficPolicyInstance struct {
   6556 }
   6557 
   6558 func (*awsRestxml_deserializeOpGetTrafficPolicyInstance) ID() string {
   6559 	return "OperationDeserializer"
   6560 }
   6561 
   6562 func (m *awsRestxml_deserializeOpGetTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6563 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6564 ) {
   6565 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6566 	if err != nil {
   6567 		return out, metadata, err
   6568 	}
   6569 
   6570 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6571 	if !ok {
   6572 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6573 	}
   6574 
   6575 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   6576 
   6577 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6578 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6579 	defer endTimer()
   6580 	defer span.End()
   6581 
   6582 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6583 		return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response, &metadata)
   6584 	}
   6585 	output := &GetTrafficPolicyInstanceOutput{}
   6586 	out.Result = output
   6587 
   6588 	var buff [1024]byte
   6589 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6590 	body := io.TeeReader(response.Body, ringBuffer)
   6591 	rootDecoder := xml.NewDecoder(body)
   6592 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6593 	if err == io.EOF {
   6594 		return out, metadata, nil
   6595 	}
   6596 	if err != nil {
   6597 		var snapshot bytes.Buffer
   6598 		io.Copy(&snapshot, ringBuffer)
   6599 		return out, metadata, &smithy.DeserializationError{
   6600 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6601 			Snapshot: snapshot.Bytes(),
   6602 		}
   6603 	}
   6604 
   6605 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6606 	err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(&output, decoder)
   6607 	if err != nil {
   6608 		var snapshot bytes.Buffer
   6609 		io.Copy(&snapshot, ringBuffer)
   6610 		return out, metadata, &smithy.DeserializationError{
   6611 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6612 			Snapshot: snapshot.Bytes(),
   6613 		}
   6614 	}
   6615 
   6616 	span.End()
   6617 	return out, metadata, err
   6618 }
   6619 
   6620 func awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6621 	var errorBuffer bytes.Buffer
   6622 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6623 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6624 	}
   6625 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6626 
   6627 	errorCode := "UnknownError"
   6628 	errorMessage := errorCode
   6629 
   6630 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6631 	if err != nil {
   6632 		return err
   6633 	}
   6634 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6635 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6636 	}
   6637 	if len(errorComponents.Code) != 0 {
   6638 		errorCode = errorComponents.Code
   6639 	}
   6640 	if len(errorComponents.Message) != 0 {
   6641 		errorMessage = errorComponents.Message
   6642 	}
   6643 	errorBody.Seek(0, io.SeekStart)
   6644 	switch {
   6645 	case strings.EqualFold("InvalidInput", errorCode):
   6646 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6647 
   6648 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   6649 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   6650 
   6651 	default:
   6652 		genericError := &smithy.GenericAPIError{
   6653 			Code:    errorCode,
   6654 			Message: errorMessage,
   6655 		}
   6656 		return genericError
   6657 
   6658 	}
   6659 }
   6660 
   6661 func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(v **GetTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
   6662 	if v == nil {
   6663 		return fmt.Errorf("unexpected nil of type %T", v)
   6664 	}
   6665 	var sv *GetTrafficPolicyInstanceOutput
   6666 	if *v == nil {
   6667 		sv = &GetTrafficPolicyInstanceOutput{}
   6668 	} else {
   6669 		sv = *v
   6670 	}
   6671 
   6672 	for {
   6673 		t, done, err := decoder.Token()
   6674 		if err != nil {
   6675 			return err
   6676 		}
   6677 		if done {
   6678 			break
   6679 		}
   6680 		originalDecoder := decoder
   6681 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6682 		switch {
   6683 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
   6684 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6685 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
   6686 				return err
   6687 			}
   6688 
   6689 		default:
   6690 			// Do nothing and ignore the unexpected tag element
   6691 			err = decoder.Decoder.Skip()
   6692 			if err != nil {
   6693 				return err
   6694 			}
   6695 
   6696 		}
   6697 		decoder = originalDecoder
   6698 	}
   6699 	*v = sv
   6700 	return nil
   6701 }
   6702 
   6703 type awsRestxml_deserializeOpGetTrafficPolicyInstanceCount struct {
   6704 }
   6705 
   6706 func (*awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) ID() string {
   6707 	return "OperationDeserializer"
   6708 }
   6709 
   6710 func (m *awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6711 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6712 ) {
   6713 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6714 	if err != nil {
   6715 		return out, metadata, err
   6716 	}
   6717 
   6718 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6719 	if !ok {
   6720 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6721 	}
   6722 
   6723 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   6724 
   6725 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6726 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6727 	defer endTimer()
   6728 	defer span.End()
   6729 
   6730 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6731 		return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response, &metadata)
   6732 	}
   6733 	output := &GetTrafficPolicyInstanceCountOutput{}
   6734 	out.Result = output
   6735 
   6736 	var buff [1024]byte
   6737 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6738 	body := io.TeeReader(response.Body, ringBuffer)
   6739 	rootDecoder := xml.NewDecoder(body)
   6740 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6741 	if err == io.EOF {
   6742 		return out, metadata, nil
   6743 	}
   6744 	if err != nil {
   6745 		var snapshot bytes.Buffer
   6746 		io.Copy(&snapshot, ringBuffer)
   6747 		return out, metadata, &smithy.DeserializationError{
   6748 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6749 			Snapshot: snapshot.Bytes(),
   6750 		}
   6751 	}
   6752 
   6753 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6754 	err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(&output, decoder)
   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 	span.End()
   6765 	return out, metadata, err
   6766 }
   6767 
   6768 func awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6769 	var errorBuffer bytes.Buffer
   6770 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6771 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6772 	}
   6773 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6774 
   6775 	errorCode := "UnknownError"
   6776 	errorMessage := errorCode
   6777 
   6778 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6779 	if err != nil {
   6780 		return err
   6781 	}
   6782 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6783 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6784 	}
   6785 	if len(errorComponents.Code) != 0 {
   6786 		errorCode = errorComponents.Code
   6787 	}
   6788 	if len(errorComponents.Message) != 0 {
   6789 		errorMessage = errorComponents.Message
   6790 	}
   6791 	errorBody.Seek(0, io.SeekStart)
   6792 	switch {
   6793 	default:
   6794 		genericError := &smithy.GenericAPIError{
   6795 			Code:    errorCode,
   6796 			Message: errorMessage,
   6797 		}
   6798 		return genericError
   6799 
   6800 	}
   6801 }
   6802 
   6803 func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(v **GetTrafficPolicyInstanceCountOutput, decoder smithyxml.NodeDecoder) error {
   6804 	if v == nil {
   6805 		return fmt.Errorf("unexpected nil of type %T", v)
   6806 	}
   6807 	var sv *GetTrafficPolicyInstanceCountOutput
   6808 	if *v == nil {
   6809 		sv = &GetTrafficPolicyInstanceCountOutput{}
   6810 	} else {
   6811 		sv = *v
   6812 	}
   6813 
   6814 	for {
   6815 		t, done, err := decoder.Token()
   6816 		if err != nil {
   6817 			return err
   6818 		}
   6819 		if done {
   6820 			break
   6821 		}
   6822 		originalDecoder := decoder
   6823 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6824 		switch {
   6825 		case strings.EqualFold("TrafficPolicyInstanceCount", t.Name.Local):
   6826 			val, err := decoder.Value()
   6827 			if err != nil {
   6828 				return err
   6829 			}
   6830 			if val == nil {
   6831 				break
   6832 			}
   6833 			{
   6834 				xtv := string(val)
   6835 				i64, err := strconv.ParseInt(xtv, 10, 64)
   6836 				if err != nil {
   6837 					return err
   6838 				}
   6839 				sv.TrafficPolicyInstanceCount = ptr.Int32(int32(i64))
   6840 			}
   6841 
   6842 		default:
   6843 			// Do nothing and ignore the unexpected tag element
   6844 			err = decoder.Decoder.Skip()
   6845 			if err != nil {
   6846 				return err
   6847 			}
   6848 
   6849 		}
   6850 		decoder = originalDecoder
   6851 	}
   6852 	*v = sv
   6853 	return nil
   6854 }
   6855 
   6856 type awsRestxml_deserializeOpListCidrBlocks struct {
   6857 }
   6858 
   6859 func (*awsRestxml_deserializeOpListCidrBlocks) ID() string {
   6860 	return "OperationDeserializer"
   6861 }
   6862 
   6863 func (m *awsRestxml_deserializeOpListCidrBlocks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6864 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6865 ) {
   6866 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6867 	if err != nil {
   6868 		return out, metadata, err
   6869 	}
   6870 
   6871 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6872 	if !ok {
   6873 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6874 	}
   6875 
   6876 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   6877 
   6878 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6879 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6880 	defer endTimer()
   6881 	defer span.End()
   6882 
   6883 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6884 		return out, metadata, awsRestxml_deserializeOpErrorListCidrBlocks(response, &metadata)
   6885 	}
   6886 	output := &ListCidrBlocksOutput{}
   6887 	out.Result = output
   6888 
   6889 	var buff [1024]byte
   6890 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6891 	body := io.TeeReader(response.Body, ringBuffer)
   6892 	rootDecoder := xml.NewDecoder(body)
   6893 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6894 	if err == io.EOF {
   6895 		return out, metadata, nil
   6896 	}
   6897 	if err != nil {
   6898 		var snapshot bytes.Buffer
   6899 		io.Copy(&snapshot, ringBuffer)
   6900 		return out, metadata, &smithy.DeserializationError{
   6901 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6902 			Snapshot: snapshot.Bytes(),
   6903 		}
   6904 	}
   6905 
   6906 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6907 	err = awsRestxml_deserializeOpDocumentListCidrBlocksOutput(&output, decoder)
   6908 	if err != nil {
   6909 		var snapshot bytes.Buffer
   6910 		io.Copy(&snapshot, ringBuffer)
   6911 		return out, metadata, &smithy.DeserializationError{
   6912 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6913 			Snapshot: snapshot.Bytes(),
   6914 		}
   6915 	}
   6916 
   6917 	span.End()
   6918 	return out, metadata, err
   6919 }
   6920 
   6921 func awsRestxml_deserializeOpErrorListCidrBlocks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6922 	var errorBuffer bytes.Buffer
   6923 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6924 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6925 	}
   6926 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6927 
   6928 	errorCode := "UnknownError"
   6929 	errorMessage := errorCode
   6930 
   6931 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6932 	if err != nil {
   6933 		return err
   6934 	}
   6935 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6936 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6937 	}
   6938 	if len(errorComponents.Code) != 0 {
   6939 		errorCode = errorComponents.Code
   6940 	}
   6941 	if len(errorComponents.Message) != 0 {
   6942 		errorMessage = errorComponents.Message
   6943 	}
   6944 	errorBody.Seek(0, io.SeekStart)
   6945 	switch {
   6946 	case strings.EqualFold("InvalidInput", errorCode):
   6947 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6948 
   6949 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
   6950 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
   6951 
   6952 	case strings.EqualFold("NoSuchCidrLocationException", errorCode):
   6953 		return awsRestxml_deserializeErrorNoSuchCidrLocationException(response, errorBody)
   6954 
   6955 	default:
   6956 		genericError := &smithy.GenericAPIError{
   6957 			Code:    errorCode,
   6958 			Message: errorMessage,
   6959 		}
   6960 		return genericError
   6961 
   6962 	}
   6963 }
   6964 
   6965 func awsRestxml_deserializeOpDocumentListCidrBlocksOutput(v **ListCidrBlocksOutput, decoder smithyxml.NodeDecoder) error {
   6966 	if v == nil {
   6967 		return fmt.Errorf("unexpected nil of type %T", v)
   6968 	}
   6969 	var sv *ListCidrBlocksOutput
   6970 	if *v == nil {
   6971 		sv = &ListCidrBlocksOutput{}
   6972 	} else {
   6973 		sv = *v
   6974 	}
   6975 
   6976 	for {
   6977 		t, done, err := decoder.Token()
   6978 		if err != nil {
   6979 			return err
   6980 		}
   6981 		if done {
   6982 			break
   6983 		}
   6984 		originalDecoder := decoder
   6985 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6986 		switch {
   6987 		case strings.EqualFold("CidrBlocks", t.Name.Local):
   6988 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6989 			if err := awsRestxml_deserializeDocumentCidrBlockSummaries(&sv.CidrBlocks, nodeDecoder); err != nil {
   6990 				return err
   6991 			}
   6992 
   6993 		case strings.EqualFold("NextToken", t.Name.Local):
   6994 			val, err := decoder.Value()
   6995 			if err != nil {
   6996 				return err
   6997 			}
   6998 			if val == nil {
   6999 				break
   7000 			}
   7001 			{
   7002 				xtv := string(val)
   7003 				sv.NextToken = ptr.String(xtv)
   7004 			}
   7005 
   7006 		default:
   7007 			// Do nothing and ignore the unexpected tag element
   7008 			err = decoder.Decoder.Skip()
   7009 			if err != nil {
   7010 				return err
   7011 			}
   7012 
   7013 		}
   7014 		decoder = originalDecoder
   7015 	}
   7016 	*v = sv
   7017 	return nil
   7018 }
   7019 
   7020 type awsRestxml_deserializeOpListCidrCollections struct {
   7021 }
   7022 
   7023 func (*awsRestxml_deserializeOpListCidrCollections) ID() string {
   7024 	return "OperationDeserializer"
   7025 }
   7026 
   7027 func (m *awsRestxml_deserializeOpListCidrCollections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7028 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7029 ) {
   7030 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7031 	if err != nil {
   7032 		return out, metadata, err
   7033 	}
   7034 
   7035 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7036 	if !ok {
   7037 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7038 	}
   7039 
   7040 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   7041 
   7042 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7043 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7044 	defer endTimer()
   7045 	defer span.End()
   7046 
   7047 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7048 		return out, metadata, awsRestxml_deserializeOpErrorListCidrCollections(response, &metadata)
   7049 	}
   7050 	output := &ListCidrCollectionsOutput{}
   7051 	out.Result = output
   7052 
   7053 	var buff [1024]byte
   7054 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7055 	body := io.TeeReader(response.Body, ringBuffer)
   7056 	rootDecoder := xml.NewDecoder(body)
   7057 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7058 	if err == io.EOF {
   7059 		return out, metadata, nil
   7060 	}
   7061 	if err != nil {
   7062 		var snapshot bytes.Buffer
   7063 		io.Copy(&snapshot, ringBuffer)
   7064 		return out, metadata, &smithy.DeserializationError{
   7065 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7066 			Snapshot: snapshot.Bytes(),
   7067 		}
   7068 	}
   7069 
   7070 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7071 	err = awsRestxml_deserializeOpDocumentListCidrCollectionsOutput(&output, decoder)
   7072 	if err != nil {
   7073 		var snapshot bytes.Buffer
   7074 		io.Copy(&snapshot, ringBuffer)
   7075 		return out, metadata, &smithy.DeserializationError{
   7076 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7077 			Snapshot: snapshot.Bytes(),
   7078 		}
   7079 	}
   7080 
   7081 	span.End()
   7082 	return out, metadata, err
   7083 }
   7084 
   7085 func awsRestxml_deserializeOpErrorListCidrCollections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7086 	var errorBuffer bytes.Buffer
   7087 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7088 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7089 	}
   7090 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7091 
   7092 	errorCode := "UnknownError"
   7093 	errorMessage := errorCode
   7094 
   7095 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7096 	if err != nil {
   7097 		return err
   7098 	}
   7099 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7100 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7101 	}
   7102 	if len(errorComponents.Code) != 0 {
   7103 		errorCode = errorComponents.Code
   7104 	}
   7105 	if len(errorComponents.Message) != 0 {
   7106 		errorMessage = errorComponents.Message
   7107 	}
   7108 	errorBody.Seek(0, io.SeekStart)
   7109 	switch {
   7110 	case strings.EqualFold("InvalidInput", errorCode):
   7111 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7112 
   7113 	default:
   7114 		genericError := &smithy.GenericAPIError{
   7115 			Code:    errorCode,
   7116 			Message: errorMessage,
   7117 		}
   7118 		return genericError
   7119 
   7120 	}
   7121 }
   7122 
   7123 func awsRestxml_deserializeOpDocumentListCidrCollectionsOutput(v **ListCidrCollectionsOutput, decoder smithyxml.NodeDecoder) error {
   7124 	if v == nil {
   7125 		return fmt.Errorf("unexpected nil of type %T", v)
   7126 	}
   7127 	var sv *ListCidrCollectionsOutput
   7128 	if *v == nil {
   7129 		sv = &ListCidrCollectionsOutput{}
   7130 	} else {
   7131 		sv = *v
   7132 	}
   7133 
   7134 	for {
   7135 		t, done, err := decoder.Token()
   7136 		if err != nil {
   7137 			return err
   7138 		}
   7139 		if done {
   7140 			break
   7141 		}
   7142 		originalDecoder := decoder
   7143 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7144 		switch {
   7145 		case strings.EqualFold("CidrCollections", t.Name.Local):
   7146 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7147 			if err := awsRestxml_deserializeDocumentCollectionSummaries(&sv.CidrCollections, nodeDecoder); err != nil {
   7148 				return err
   7149 			}
   7150 
   7151 		case strings.EqualFold("NextToken", t.Name.Local):
   7152 			val, err := decoder.Value()
   7153 			if err != nil {
   7154 				return err
   7155 			}
   7156 			if val == nil {
   7157 				break
   7158 			}
   7159 			{
   7160 				xtv := string(val)
   7161 				sv.NextToken = ptr.String(xtv)
   7162 			}
   7163 
   7164 		default:
   7165 			// Do nothing and ignore the unexpected tag element
   7166 			err = decoder.Decoder.Skip()
   7167 			if err != nil {
   7168 				return err
   7169 			}
   7170 
   7171 		}
   7172 		decoder = originalDecoder
   7173 	}
   7174 	*v = sv
   7175 	return nil
   7176 }
   7177 
   7178 type awsRestxml_deserializeOpListCidrLocations struct {
   7179 }
   7180 
   7181 func (*awsRestxml_deserializeOpListCidrLocations) ID() string {
   7182 	return "OperationDeserializer"
   7183 }
   7184 
   7185 func (m *awsRestxml_deserializeOpListCidrLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7186 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7187 ) {
   7188 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7189 	if err != nil {
   7190 		return out, metadata, err
   7191 	}
   7192 
   7193 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7194 	if !ok {
   7195 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7196 	}
   7197 
   7198 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   7199 
   7200 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7201 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7202 	defer endTimer()
   7203 	defer span.End()
   7204 
   7205 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7206 		return out, metadata, awsRestxml_deserializeOpErrorListCidrLocations(response, &metadata)
   7207 	}
   7208 	output := &ListCidrLocationsOutput{}
   7209 	out.Result = output
   7210 
   7211 	var buff [1024]byte
   7212 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7213 	body := io.TeeReader(response.Body, ringBuffer)
   7214 	rootDecoder := xml.NewDecoder(body)
   7215 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7216 	if err == io.EOF {
   7217 		return out, metadata, nil
   7218 	}
   7219 	if err != nil {
   7220 		var snapshot bytes.Buffer
   7221 		io.Copy(&snapshot, ringBuffer)
   7222 		return out, metadata, &smithy.DeserializationError{
   7223 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7224 			Snapshot: snapshot.Bytes(),
   7225 		}
   7226 	}
   7227 
   7228 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7229 	err = awsRestxml_deserializeOpDocumentListCidrLocationsOutput(&output, decoder)
   7230 	if err != nil {
   7231 		var snapshot bytes.Buffer
   7232 		io.Copy(&snapshot, ringBuffer)
   7233 		return out, metadata, &smithy.DeserializationError{
   7234 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7235 			Snapshot: snapshot.Bytes(),
   7236 		}
   7237 	}
   7238 
   7239 	span.End()
   7240 	return out, metadata, err
   7241 }
   7242 
   7243 func awsRestxml_deserializeOpErrorListCidrLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7244 	var errorBuffer bytes.Buffer
   7245 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7246 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7247 	}
   7248 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7249 
   7250 	errorCode := "UnknownError"
   7251 	errorMessage := errorCode
   7252 
   7253 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7254 	if err != nil {
   7255 		return err
   7256 	}
   7257 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7258 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7259 	}
   7260 	if len(errorComponents.Code) != 0 {
   7261 		errorCode = errorComponents.Code
   7262 	}
   7263 	if len(errorComponents.Message) != 0 {
   7264 		errorMessage = errorComponents.Message
   7265 	}
   7266 	errorBody.Seek(0, io.SeekStart)
   7267 	switch {
   7268 	case strings.EqualFold("InvalidInput", errorCode):
   7269 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7270 
   7271 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
   7272 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
   7273 
   7274 	default:
   7275 		genericError := &smithy.GenericAPIError{
   7276 			Code:    errorCode,
   7277 			Message: errorMessage,
   7278 		}
   7279 		return genericError
   7280 
   7281 	}
   7282 }
   7283 
   7284 func awsRestxml_deserializeOpDocumentListCidrLocationsOutput(v **ListCidrLocationsOutput, decoder smithyxml.NodeDecoder) error {
   7285 	if v == nil {
   7286 		return fmt.Errorf("unexpected nil of type %T", v)
   7287 	}
   7288 	var sv *ListCidrLocationsOutput
   7289 	if *v == nil {
   7290 		sv = &ListCidrLocationsOutput{}
   7291 	} else {
   7292 		sv = *v
   7293 	}
   7294 
   7295 	for {
   7296 		t, done, err := decoder.Token()
   7297 		if err != nil {
   7298 			return err
   7299 		}
   7300 		if done {
   7301 			break
   7302 		}
   7303 		originalDecoder := decoder
   7304 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7305 		switch {
   7306 		case strings.EqualFold("CidrLocations", t.Name.Local):
   7307 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7308 			if err := awsRestxml_deserializeDocumentLocationSummaries(&sv.CidrLocations, nodeDecoder); err != nil {
   7309 				return err
   7310 			}
   7311 
   7312 		case strings.EqualFold("NextToken", t.Name.Local):
   7313 			val, err := decoder.Value()
   7314 			if err != nil {
   7315 				return err
   7316 			}
   7317 			if val == nil {
   7318 				break
   7319 			}
   7320 			{
   7321 				xtv := string(val)
   7322 				sv.NextToken = ptr.String(xtv)
   7323 			}
   7324 
   7325 		default:
   7326 			// Do nothing and ignore the unexpected tag element
   7327 			err = decoder.Decoder.Skip()
   7328 			if err != nil {
   7329 				return err
   7330 			}
   7331 
   7332 		}
   7333 		decoder = originalDecoder
   7334 	}
   7335 	*v = sv
   7336 	return nil
   7337 }
   7338 
   7339 type awsRestxml_deserializeOpListGeoLocations struct {
   7340 }
   7341 
   7342 func (*awsRestxml_deserializeOpListGeoLocations) ID() string {
   7343 	return "OperationDeserializer"
   7344 }
   7345 
   7346 func (m *awsRestxml_deserializeOpListGeoLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7347 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7348 ) {
   7349 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7350 	if err != nil {
   7351 		return out, metadata, err
   7352 	}
   7353 
   7354 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7355 	if !ok {
   7356 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7357 	}
   7358 
   7359 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   7360 
   7361 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7362 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7363 	defer endTimer()
   7364 	defer span.End()
   7365 
   7366 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7367 		return out, metadata, awsRestxml_deserializeOpErrorListGeoLocations(response, &metadata)
   7368 	}
   7369 	output := &ListGeoLocationsOutput{}
   7370 	out.Result = output
   7371 
   7372 	var buff [1024]byte
   7373 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7374 	body := io.TeeReader(response.Body, ringBuffer)
   7375 	rootDecoder := xml.NewDecoder(body)
   7376 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7377 	if err == io.EOF {
   7378 		return out, metadata, nil
   7379 	}
   7380 	if err != nil {
   7381 		var snapshot bytes.Buffer
   7382 		io.Copy(&snapshot, ringBuffer)
   7383 		return out, metadata, &smithy.DeserializationError{
   7384 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7385 			Snapshot: snapshot.Bytes(),
   7386 		}
   7387 	}
   7388 
   7389 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7390 	err = awsRestxml_deserializeOpDocumentListGeoLocationsOutput(&output, decoder)
   7391 	if err != nil {
   7392 		var snapshot bytes.Buffer
   7393 		io.Copy(&snapshot, ringBuffer)
   7394 		return out, metadata, &smithy.DeserializationError{
   7395 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7396 			Snapshot: snapshot.Bytes(),
   7397 		}
   7398 	}
   7399 
   7400 	span.End()
   7401 	return out, metadata, err
   7402 }
   7403 
   7404 func awsRestxml_deserializeOpErrorListGeoLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7405 	var errorBuffer bytes.Buffer
   7406 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7407 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7408 	}
   7409 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7410 
   7411 	errorCode := "UnknownError"
   7412 	errorMessage := errorCode
   7413 
   7414 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7415 	if err != nil {
   7416 		return err
   7417 	}
   7418 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7419 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7420 	}
   7421 	if len(errorComponents.Code) != 0 {
   7422 		errorCode = errorComponents.Code
   7423 	}
   7424 	if len(errorComponents.Message) != 0 {
   7425 		errorMessage = errorComponents.Message
   7426 	}
   7427 	errorBody.Seek(0, io.SeekStart)
   7428 	switch {
   7429 	case strings.EqualFold("InvalidInput", errorCode):
   7430 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7431 
   7432 	default:
   7433 		genericError := &smithy.GenericAPIError{
   7434 			Code:    errorCode,
   7435 			Message: errorMessage,
   7436 		}
   7437 		return genericError
   7438 
   7439 	}
   7440 }
   7441 
   7442 func awsRestxml_deserializeOpDocumentListGeoLocationsOutput(v **ListGeoLocationsOutput, decoder smithyxml.NodeDecoder) error {
   7443 	if v == nil {
   7444 		return fmt.Errorf("unexpected nil of type %T", v)
   7445 	}
   7446 	var sv *ListGeoLocationsOutput
   7447 	if *v == nil {
   7448 		sv = &ListGeoLocationsOutput{}
   7449 	} else {
   7450 		sv = *v
   7451 	}
   7452 
   7453 	for {
   7454 		t, done, err := decoder.Token()
   7455 		if err != nil {
   7456 			return err
   7457 		}
   7458 		if done {
   7459 			break
   7460 		}
   7461 		originalDecoder := decoder
   7462 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7463 		switch {
   7464 		case strings.EqualFold("GeoLocationDetailsList", t.Name.Local):
   7465 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7466 			if err := awsRestxml_deserializeDocumentGeoLocationDetailsList(&sv.GeoLocationDetailsList, nodeDecoder); err != nil {
   7467 				return err
   7468 			}
   7469 
   7470 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7471 			val, err := decoder.Value()
   7472 			if err != nil {
   7473 				return err
   7474 			}
   7475 			if val == nil {
   7476 				break
   7477 			}
   7478 			{
   7479 				xtv, err := strconv.ParseBool(string(val))
   7480 				if err != nil {
   7481 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7482 				}
   7483 				sv.IsTruncated = xtv
   7484 			}
   7485 
   7486 		case strings.EqualFold("MaxItems", t.Name.Local):
   7487 			val, err := decoder.Value()
   7488 			if err != nil {
   7489 				return err
   7490 			}
   7491 			if val == nil {
   7492 				break
   7493 			}
   7494 			{
   7495 				xtv := string(val)
   7496 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7497 				if err != nil {
   7498 					return err
   7499 				}
   7500 				sv.MaxItems = ptr.Int32(int32(i64))
   7501 			}
   7502 
   7503 		case strings.EqualFold("NextContinentCode", t.Name.Local):
   7504 			val, err := decoder.Value()
   7505 			if err != nil {
   7506 				return err
   7507 			}
   7508 			if val == nil {
   7509 				break
   7510 			}
   7511 			{
   7512 				xtv := string(val)
   7513 				sv.NextContinentCode = ptr.String(xtv)
   7514 			}
   7515 
   7516 		case strings.EqualFold("NextCountryCode", t.Name.Local):
   7517 			val, err := decoder.Value()
   7518 			if err != nil {
   7519 				return err
   7520 			}
   7521 			if val == nil {
   7522 				break
   7523 			}
   7524 			{
   7525 				xtv := string(val)
   7526 				sv.NextCountryCode = ptr.String(xtv)
   7527 			}
   7528 
   7529 		case strings.EqualFold("NextSubdivisionCode", t.Name.Local):
   7530 			val, err := decoder.Value()
   7531 			if err != nil {
   7532 				return err
   7533 			}
   7534 			if val == nil {
   7535 				break
   7536 			}
   7537 			{
   7538 				xtv := string(val)
   7539 				sv.NextSubdivisionCode = ptr.String(xtv)
   7540 			}
   7541 
   7542 		default:
   7543 			// Do nothing and ignore the unexpected tag element
   7544 			err = decoder.Decoder.Skip()
   7545 			if err != nil {
   7546 				return err
   7547 			}
   7548 
   7549 		}
   7550 		decoder = originalDecoder
   7551 	}
   7552 	*v = sv
   7553 	return nil
   7554 }
   7555 
   7556 type awsRestxml_deserializeOpListHealthChecks struct {
   7557 }
   7558 
   7559 func (*awsRestxml_deserializeOpListHealthChecks) ID() string {
   7560 	return "OperationDeserializer"
   7561 }
   7562 
   7563 func (m *awsRestxml_deserializeOpListHealthChecks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7564 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7565 ) {
   7566 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7567 	if err != nil {
   7568 		return out, metadata, err
   7569 	}
   7570 
   7571 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7572 	if !ok {
   7573 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7574 	}
   7575 
   7576 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   7577 
   7578 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7579 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7580 	defer endTimer()
   7581 	defer span.End()
   7582 
   7583 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7584 		return out, metadata, awsRestxml_deserializeOpErrorListHealthChecks(response, &metadata)
   7585 	}
   7586 	output := &ListHealthChecksOutput{}
   7587 	out.Result = output
   7588 
   7589 	var buff [1024]byte
   7590 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7591 	body := io.TeeReader(response.Body, ringBuffer)
   7592 	rootDecoder := xml.NewDecoder(body)
   7593 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7594 	if err == io.EOF {
   7595 		return out, metadata, nil
   7596 	}
   7597 	if err != nil {
   7598 		var snapshot bytes.Buffer
   7599 		io.Copy(&snapshot, ringBuffer)
   7600 		return out, metadata, &smithy.DeserializationError{
   7601 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7602 			Snapshot: snapshot.Bytes(),
   7603 		}
   7604 	}
   7605 
   7606 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7607 	err = awsRestxml_deserializeOpDocumentListHealthChecksOutput(&output, decoder)
   7608 	if err != nil {
   7609 		var snapshot bytes.Buffer
   7610 		io.Copy(&snapshot, ringBuffer)
   7611 		return out, metadata, &smithy.DeserializationError{
   7612 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7613 			Snapshot: snapshot.Bytes(),
   7614 		}
   7615 	}
   7616 
   7617 	span.End()
   7618 	return out, metadata, err
   7619 }
   7620 
   7621 func awsRestxml_deserializeOpErrorListHealthChecks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7622 	var errorBuffer bytes.Buffer
   7623 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7624 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7625 	}
   7626 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7627 
   7628 	errorCode := "UnknownError"
   7629 	errorMessage := errorCode
   7630 
   7631 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7632 	if err != nil {
   7633 		return err
   7634 	}
   7635 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7636 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7637 	}
   7638 	if len(errorComponents.Code) != 0 {
   7639 		errorCode = errorComponents.Code
   7640 	}
   7641 	if len(errorComponents.Message) != 0 {
   7642 		errorMessage = errorComponents.Message
   7643 	}
   7644 	errorBody.Seek(0, io.SeekStart)
   7645 	switch {
   7646 	case strings.EqualFold("IncompatibleVersion", errorCode):
   7647 		return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody)
   7648 
   7649 	case strings.EqualFold("InvalidInput", errorCode):
   7650 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7651 
   7652 	default:
   7653 		genericError := &smithy.GenericAPIError{
   7654 			Code:    errorCode,
   7655 			Message: errorMessage,
   7656 		}
   7657 		return genericError
   7658 
   7659 	}
   7660 }
   7661 
   7662 func awsRestxml_deserializeOpDocumentListHealthChecksOutput(v **ListHealthChecksOutput, decoder smithyxml.NodeDecoder) error {
   7663 	if v == nil {
   7664 		return fmt.Errorf("unexpected nil of type %T", v)
   7665 	}
   7666 	var sv *ListHealthChecksOutput
   7667 	if *v == nil {
   7668 		sv = &ListHealthChecksOutput{}
   7669 	} else {
   7670 		sv = *v
   7671 	}
   7672 
   7673 	for {
   7674 		t, done, err := decoder.Token()
   7675 		if err != nil {
   7676 			return err
   7677 		}
   7678 		if done {
   7679 			break
   7680 		}
   7681 		originalDecoder := decoder
   7682 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7683 		switch {
   7684 		case strings.EqualFold("HealthChecks", t.Name.Local):
   7685 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7686 			if err := awsRestxml_deserializeDocumentHealthChecks(&sv.HealthChecks, nodeDecoder); err != nil {
   7687 				return err
   7688 			}
   7689 
   7690 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7691 			val, err := decoder.Value()
   7692 			if err != nil {
   7693 				return err
   7694 			}
   7695 			if val == nil {
   7696 				break
   7697 			}
   7698 			{
   7699 				xtv, err := strconv.ParseBool(string(val))
   7700 				if err != nil {
   7701 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7702 				}
   7703 				sv.IsTruncated = xtv
   7704 			}
   7705 
   7706 		case strings.EqualFold("Marker", t.Name.Local):
   7707 			val, err := decoder.Value()
   7708 			if err != nil {
   7709 				return err
   7710 			}
   7711 			if val == nil {
   7712 				break
   7713 			}
   7714 			{
   7715 				xtv := string(val)
   7716 				sv.Marker = ptr.String(xtv)
   7717 			}
   7718 
   7719 		case strings.EqualFold("MaxItems", t.Name.Local):
   7720 			val, err := decoder.Value()
   7721 			if err != nil {
   7722 				return err
   7723 			}
   7724 			if val == nil {
   7725 				break
   7726 			}
   7727 			{
   7728 				xtv := string(val)
   7729 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7730 				if err != nil {
   7731 					return err
   7732 				}
   7733 				sv.MaxItems = ptr.Int32(int32(i64))
   7734 			}
   7735 
   7736 		case strings.EqualFold("NextMarker", t.Name.Local):
   7737 			val, err := decoder.Value()
   7738 			if err != nil {
   7739 				return err
   7740 			}
   7741 			if val == nil {
   7742 				break
   7743 			}
   7744 			{
   7745 				xtv := string(val)
   7746 				sv.NextMarker = ptr.String(xtv)
   7747 			}
   7748 
   7749 		default:
   7750 			// Do nothing and ignore the unexpected tag element
   7751 			err = decoder.Decoder.Skip()
   7752 			if err != nil {
   7753 				return err
   7754 			}
   7755 
   7756 		}
   7757 		decoder = originalDecoder
   7758 	}
   7759 	*v = sv
   7760 	return nil
   7761 }
   7762 
   7763 type awsRestxml_deserializeOpListHostedZones struct {
   7764 }
   7765 
   7766 func (*awsRestxml_deserializeOpListHostedZones) ID() string {
   7767 	return "OperationDeserializer"
   7768 }
   7769 
   7770 func (m *awsRestxml_deserializeOpListHostedZones) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7771 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7772 ) {
   7773 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7774 	if err != nil {
   7775 		return out, metadata, err
   7776 	}
   7777 
   7778 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7779 	if !ok {
   7780 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7781 	}
   7782 
   7783 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   7784 
   7785 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7786 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7787 	defer endTimer()
   7788 	defer span.End()
   7789 
   7790 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7791 		return out, metadata, awsRestxml_deserializeOpErrorListHostedZones(response, &metadata)
   7792 	}
   7793 	output := &ListHostedZonesOutput{}
   7794 	out.Result = output
   7795 
   7796 	var buff [1024]byte
   7797 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7798 	body := io.TeeReader(response.Body, ringBuffer)
   7799 	rootDecoder := xml.NewDecoder(body)
   7800 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7801 	if err == io.EOF {
   7802 		return out, metadata, nil
   7803 	}
   7804 	if err != nil {
   7805 		var snapshot bytes.Buffer
   7806 		io.Copy(&snapshot, ringBuffer)
   7807 		return out, metadata, &smithy.DeserializationError{
   7808 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7809 			Snapshot: snapshot.Bytes(),
   7810 		}
   7811 	}
   7812 
   7813 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7814 	err = awsRestxml_deserializeOpDocumentListHostedZonesOutput(&output, decoder)
   7815 	if err != nil {
   7816 		var snapshot bytes.Buffer
   7817 		io.Copy(&snapshot, ringBuffer)
   7818 		return out, metadata, &smithy.DeserializationError{
   7819 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7820 			Snapshot: snapshot.Bytes(),
   7821 		}
   7822 	}
   7823 
   7824 	span.End()
   7825 	return out, metadata, err
   7826 }
   7827 
   7828 func awsRestxml_deserializeOpErrorListHostedZones(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7829 	var errorBuffer bytes.Buffer
   7830 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7831 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7832 	}
   7833 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7834 
   7835 	errorCode := "UnknownError"
   7836 	errorMessage := errorCode
   7837 
   7838 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7839 	if err != nil {
   7840 		return err
   7841 	}
   7842 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7843 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7844 	}
   7845 	if len(errorComponents.Code) != 0 {
   7846 		errorCode = errorComponents.Code
   7847 	}
   7848 	if len(errorComponents.Message) != 0 {
   7849 		errorMessage = errorComponents.Message
   7850 	}
   7851 	errorBody.Seek(0, io.SeekStart)
   7852 	switch {
   7853 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   7854 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   7855 
   7856 	case strings.EqualFold("InvalidInput", errorCode):
   7857 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7858 
   7859 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   7860 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   7861 
   7862 	default:
   7863 		genericError := &smithy.GenericAPIError{
   7864 			Code:    errorCode,
   7865 			Message: errorMessage,
   7866 		}
   7867 		return genericError
   7868 
   7869 	}
   7870 }
   7871 
   7872 func awsRestxml_deserializeOpDocumentListHostedZonesOutput(v **ListHostedZonesOutput, decoder smithyxml.NodeDecoder) error {
   7873 	if v == nil {
   7874 		return fmt.Errorf("unexpected nil of type %T", v)
   7875 	}
   7876 	var sv *ListHostedZonesOutput
   7877 	if *v == nil {
   7878 		sv = &ListHostedZonesOutput{}
   7879 	} else {
   7880 		sv = *v
   7881 	}
   7882 
   7883 	for {
   7884 		t, done, err := decoder.Token()
   7885 		if err != nil {
   7886 			return err
   7887 		}
   7888 		if done {
   7889 			break
   7890 		}
   7891 		originalDecoder := decoder
   7892 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7893 		switch {
   7894 		case strings.EqualFold("HostedZones", t.Name.Local):
   7895 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7896 			if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil {
   7897 				return err
   7898 			}
   7899 
   7900 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7901 			val, err := decoder.Value()
   7902 			if err != nil {
   7903 				return err
   7904 			}
   7905 			if val == nil {
   7906 				break
   7907 			}
   7908 			{
   7909 				xtv, err := strconv.ParseBool(string(val))
   7910 				if err != nil {
   7911 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7912 				}
   7913 				sv.IsTruncated = xtv
   7914 			}
   7915 
   7916 		case strings.EqualFold("Marker", t.Name.Local):
   7917 			val, err := decoder.Value()
   7918 			if err != nil {
   7919 				return err
   7920 			}
   7921 			if val == nil {
   7922 				break
   7923 			}
   7924 			{
   7925 				xtv := string(val)
   7926 				sv.Marker = ptr.String(xtv)
   7927 			}
   7928 
   7929 		case strings.EqualFold("MaxItems", t.Name.Local):
   7930 			val, err := decoder.Value()
   7931 			if err != nil {
   7932 				return err
   7933 			}
   7934 			if val == nil {
   7935 				break
   7936 			}
   7937 			{
   7938 				xtv := string(val)
   7939 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7940 				if err != nil {
   7941 					return err
   7942 				}
   7943 				sv.MaxItems = ptr.Int32(int32(i64))
   7944 			}
   7945 
   7946 		case strings.EqualFold("NextMarker", t.Name.Local):
   7947 			val, err := decoder.Value()
   7948 			if err != nil {
   7949 				return err
   7950 			}
   7951 			if val == nil {
   7952 				break
   7953 			}
   7954 			{
   7955 				xtv := string(val)
   7956 				sv.NextMarker = ptr.String(xtv)
   7957 			}
   7958 
   7959 		default:
   7960 			// Do nothing and ignore the unexpected tag element
   7961 			err = decoder.Decoder.Skip()
   7962 			if err != nil {
   7963 				return err
   7964 			}
   7965 
   7966 		}
   7967 		decoder = originalDecoder
   7968 	}
   7969 	*v = sv
   7970 	return nil
   7971 }
   7972 
   7973 type awsRestxml_deserializeOpListHostedZonesByName struct {
   7974 }
   7975 
   7976 func (*awsRestxml_deserializeOpListHostedZonesByName) ID() string {
   7977 	return "OperationDeserializer"
   7978 }
   7979 
   7980 func (m *awsRestxml_deserializeOpListHostedZonesByName) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7981 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7982 ) {
   7983 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7984 	if err != nil {
   7985 		return out, metadata, err
   7986 	}
   7987 
   7988 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7989 	if !ok {
   7990 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7991 	}
   7992 
   7993 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   7994 
   7995 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7996 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7997 	defer endTimer()
   7998 	defer span.End()
   7999 
   8000 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8001 		return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByName(response, &metadata)
   8002 	}
   8003 	output := &ListHostedZonesByNameOutput{}
   8004 	out.Result = output
   8005 
   8006 	var buff [1024]byte
   8007 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8008 	body := io.TeeReader(response.Body, ringBuffer)
   8009 	rootDecoder := xml.NewDecoder(body)
   8010 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8011 	if err == io.EOF {
   8012 		return out, metadata, nil
   8013 	}
   8014 	if err != nil {
   8015 		var snapshot bytes.Buffer
   8016 		io.Copy(&snapshot, ringBuffer)
   8017 		return out, metadata, &smithy.DeserializationError{
   8018 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8019 			Snapshot: snapshot.Bytes(),
   8020 		}
   8021 	}
   8022 
   8023 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8024 	err = awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(&output, decoder)
   8025 	if err != nil {
   8026 		var snapshot bytes.Buffer
   8027 		io.Copy(&snapshot, ringBuffer)
   8028 		return out, metadata, &smithy.DeserializationError{
   8029 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8030 			Snapshot: snapshot.Bytes(),
   8031 		}
   8032 	}
   8033 
   8034 	span.End()
   8035 	return out, metadata, err
   8036 }
   8037 
   8038 func awsRestxml_deserializeOpErrorListHostedZonesByName(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8039 	var errorBuffer bytes.Buffer
   8040 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8041 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8042 	}
   8043 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8044 
   8045 	errorCode := "UnknownError"
   8046 	errorMessage := errorCode
   8047 
   8048 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8049 	if err != nil {
   8050 		return err
   8051 	}
   8052 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8053 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8054 	}
   8055 	if len(errorComponents.Code) != 0 {
   8056 		errorCode = errorComponents.Code
   8057 	}
   8058 	if len(errorComponents.Message) != 0 {
   8059 		errorMessage = errorComponents.Message
   8060 	}
   8061 	errorBody.Seek(0, io.SeekStart)
   8062 	switch {
   8063 	case strings.EqualFold("InvalidDomainName", errorCode):
   8064 		return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
   8065 
   8066 	case strings.EqualFold("InvalidInput", errorCode):
   8067 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8068 
   8069 	default:
   8070 		genericError := &smithy.GenericAPIError{
   8071 			Code:    errorCode,
   8072 			Message: errorMessage,
   8073 		}
   8074 		return genericError
   8075 
   8076 	}
   8077 }
   8078 
   8079 func awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(v **ListHostedZonesByNameOutput, decoder smithyxml.NodeDecoder) error {
   8080 	if v == nil {
   8081 		return fmt.Errorf("unexpected nil of type %T", v)
   8082 	}
   8083 	var sv *ListHostedZonesByNameOutput
   8084 	if *v == nil {
   8085 		sv = &ListHostedZonesByNameOutput{}
   8086 	} else {
   8087 		sv = *v
   8088 	}
   8089 
   8090 	for {
   8091 		t, done, err := decoder.Token()
   8092 		if err != nil {
   8093 			return err
   8094 		}
   8095 		if done {
   8096 			break
   8097 		}
   8098 		originalDecoder := decoder
   8099 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8100 		switch {
   8101 		case strings.EqualFold("DNSName", t.Name.Local):
   8102 			val, err := decoder.Value()
   8103 			if err != nil {
   8104 				return err
   8105 			}
   8106 			if val == nil {
   8107 				break
   8108 			}
   8109 			{
   8110 				xtv := string(val)
   8111 				sv.DNSName = ptr.String(xtv)
   8112 			}
   8113 
   8114 		case strings.EqualFold("HostedZoneId", t.Name.Local):
   8115 			val, err := decoder.Value()
   8116 			if err != nil {
   8117 				return err
   8118 			}
   8119 			if val == nil {
   8120 				break
   8121 			}
   8122 			{
   8123 				xtv := string(val)
   8124 				sv.HostedZoneId = ptr.String(xtv)
   8125 			}
   8126 
   8127 		case strings.EqualFold("HostedZones", t.Name.Local):
   8128 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8129 			if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil {
   8130 				return err
   8131 			}
   8132 
   8133 		case strings.EqualFold("IsTruncated", t.Name.Local):
   8134 			val, err := decoder.Value()
   8135 			if err != nil {
   8136 				return err
   8137 			}
   8138 			if val == nil {
   8139 				break
   8140 			}
   8141 			{
   8142 				xtv, err := strconv.ParseBool(string(val))
   8143 				if err != nil {
   8144 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   8145 				}
   8146 				sv.IsTruncated = xtv
   8147 			}
   8148 
   8149 		case strings.EqualFold("MaxItems", t.Name.Local):
   8150 			val, err := decoder.Value()
   8151 			if err != nil {
   8152 				return err
   8153 			}
   8154 			if val == nil {
   8155 				break
   8156 			}
   8157 			{
   8158 				xtv := string(val)
   8159 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8160 				if err != nil {
   8161 					return err
   8162 				}
   8163 				sv.MaxItems = ptr.Int32(int32(i64))
   8164 			}
   8165 
   8166 		case strings.EqualFold("NextDNSName", t.Name.Local):
   8167 			val, err := decoder.Value()
   8168 			if err != nil {
   8169 				return err
   8170 			}
   8171 			if val == nil {
   8172 				break
   8173 			}
   8174 			{
   8175 				xtv := string(val)
   8176 				sv.NextDNSName = ptr.String(xtv)
   8177 			}
   8178 
   8179 		case strings.EqualFold("NextHostedZoneId", t.Name.Local):
   8180 			val, err := decoder.Value()
   8181 			if err != nil {
   8182 				return err
   8183 			}
   8184 			if val == nil {
   8185 				break
   8186 			}
   8187 			{
   8188 				xtv := string(val)
   8189 				sv.NextHostedZoneId = ptr.String(xtv)
   8190 			}
   8191 
   8192 		default:
   8193 			// Do nothing and ignore the unexpected tag element
   8194 			err = decoder.Decoder.Skip()
   8195 			if err != nil {
   8196 				return err
   8197 			}
   8198 
   8199 		}
   8200 		decoder = originalDecoder
   8201 	}
   8202 	*v = sv
   8203 	return nil
   8204 }
   8205 
   8206 type awsRestxml_deserializeOpListHostedZonesByVPC struct {
   8207 }
   8208 
   8209 func (*awsRestxml_deserializeOpListHostedZonesByVPC) ID() string {
   8210 	return "OperationDeserializer"
   8211 }
   8212 
   8213 func (m *awsRestxml_deserializeOpListHostedZonesByVPC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8214 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8215 ) {
   8216 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8217 	if err != nil {
   8218 		return out, metadata, err
   8219 	}
   8220 
   8221 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8222 	if !ok {
   8223 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8224 	}
   8225 
   8226 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   8227 
   8228 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8229 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8230 	defer endTimer()
   8231 	defer span.End()
   8232 
   8233 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8234 		return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByVPC(response, &metadata)
   8235 	}
   8236 	output := &ListHostedZonesByVPCOutput{}
   8237 	out.Result = output
   8238 
   8239 	var buff [1024]byte
   8240 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8241 	body := io.TeeReader(response.Body, ringBuffer)
   8242 	rootDecoder := xml.NewDecoder(body)
   8243 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8244 	if err == io.EOF {
   8245 		return out, metadata, nil
   8246 	}
   8247 	if err != nil {
   8248 		var snapshot bytes.Buffer
   8249 		io.Copy(&snapshot, ringBuffer)
   8250 		return out, metadata, &smithy.DeserializationError{
   8251 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8252 			Snapshot: snapshot.Bytes(),
   8253 		}
   8254 	}
   8255 
   8256 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8257 	err = awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(&output, decoder)
   8258 	if err != nil {
   8259 		var snapshot bytes.Buffer
   8260 		io.Copy(&snapshot, ringBuffer)
   8261 		return out, metadata, &smithy.DeserializationError{
   8262 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8263 			Snapshot: snapshot.Bytes(),
   8264 		}
   8265 	}
   8266 
   8267 	span.End()
   8268 	return out, metadata, err
   8269 }
   8270 
   8271 func awsRestxml_deserializeOpErrorListHostedZonesByVPC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8272 	var errorBuffer bytes.Buffer
   8273 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8274 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8275 	}
   8276 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8277 
   8278 	errorCode := "UnknownError"
   8279 	errorMessage := errorCode
   8280 
   8281 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8282 	if err != nil {
   8283 		return err
   8284 	}
   8285 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8286 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8287 	}
   8288 	if len(errorComponents.Code) != 0 {
   8289 		errorCode = errorComponents.Code
   8290 	}
   8291 	if len(errorComponents.Message) != 0 {
   8292 		errorMessage = errorComponents.Message
   8293 	}
   8294 	errorBody.Seek(0, io.SeekStart)
   8295 	switch {
   8296 	case strings.EqualFold("InvalidInput", errorCode):
   8297 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8298 
   8299 	case strings.EqualFold("InvalidPaginationToken", errorCode):
   8300 		return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
   8301 
   8302 	default:
   8303 		genericError := &smithy.GenericAPIError{
   8304 			Code:    errorCode,
   8305 			Message: errorMessage,
   8306 		}
   8307 		return genericError
   8308 
   8309 	}
   8310 }
   8311 
   8312 func awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(v **ListHostedZonesByVPCOutput, decoder smithyxml.NodeDecoder) error {
   8313 	if v == nil {
   8314 		return fmt.Errorf("unexpected nil of type %T", v)
   8315 	}
   8316 	var sv *ListHostedZonesByVPCOutput
   8317 	if *v == nil {
   8318 		sv = &ListHostedZonesByVPCOutput{}
   8319 	} else {
   8320 		sv = *v
   8321 	}
   8322 
   8323 	for {
   8324 		t, done, err := decoder.Token()
   8325 		if err != nil {
   8326 			return err
   8327 		}
   8328 		if done {
   8329 			break
   8330 		}
   8331 		originalDecoder := decoder
   8332 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8333 		switch {
   8334 		case strings.EqualFold("HostedZoneSummaries", t.Name.Local):
   8335 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8336 			if err := awsRestxml_deserializeDocumentHostedZoneSummaries(&sv.HostedZoneSummaries, nodeDecoder); err != nil {
   8337 				return err
   8338 			}
   8339 
   8340 		case strings.EqualFold("MaxItems", t.Name.Local):
   8341 			val, err := decoder.Value()
   8342 			if err != nil {
   8343 				return err
   8344 			}
   8345 			if val == nil {
   8346 				break
   8347 			}
   8348 			{
   8349 				xtv := string(val)
   8350 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8351 				if err != nil {
   8352 					return err
   8353 				}
   8354 				sv.MaxItems = ptr.Int32(int32(i64))
   8355 			}
   8356 
   8357 		case strings.EqualFold("NextToken", t.Name.Local):
   8358 			val, err := decoder.Value()
   8359 			if err != nil {
   8360 				return err
   8361 			}
   8362 			if val == nil {
   8363 				break
   8364 			}
   8365 			{
   8366 				xtv := string(val)
   8367 				sv.NextToken = ptr.String(xtv)
   8368 			}
   8369 
   8370 		default:
   8371 			// Do nothing and ignore the unexpected tag element
   8372 			err = decoder.Decoder.Skip()
   8373 			if err != nil {
   8374 				return err
   8375 			}
   8376 
   8377 		}
   8378 		decoder = originalDecoder
   8379 	}
   8380 	*v = sv
   8381 	return nil
   8382 }
   8383 
   8384 type awsRestxml_deserializeOpListQueryLoggingConfigs struct {
   8385 }
   8386 
   8387 func (*awsRestxml_deserializeOpListQueryLoggingConfigs) ID() string {
   8388 	return "OperationDeserializer"
   8389 }
   8390 
   8391 func (m *awsRestxml_deserializeOpListQueryLoggingConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8392 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8393 ) {
   8394 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8395 	if err != nil {
   8396 		return out, metadata, err
   8397 	}
   8398 
   8399 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8400 	if !ok {
   8401 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8402 	}
   8403 
   8404 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   8405 
   8406 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8407 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8408 	defer endTimer()
   8409 	defer span.End()
   8410 
   8411 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8412 		return out, metadata, awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response, &metadata)
   8413 	}
   8414 	output := &ListQueryLoggingConfigsOutput{}
   8415 	out.Result = output
   8416 
   8417 	var buff [1024]byte
   8418 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8419 	body := io.TeeReader(response.Body, ringBuffer)
   8420 	rootDecoder := xml.NewDecoder(body)
   8421 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8422 	if err == io.EOF {
   8423 		return out, metadata, nil
   8424 	}
   8425 	if err != nil {
   8426 		var snapshot bytes.Buffer
   8427 		io.Copy(&snapshot, ringBuffer)
   8428 		return out, metadata, &smithy.DeserializationError{
   8429 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8430 			Snapshot: snapshot.Bytes(),
   8431 		}
   8432 	}
   8433 
   8434 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8435 	err = awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(&output, decoder)
   8436 	if err != nil {
   8437 		var snapshot bytes.Buffer
   8438 		io.Copy(&snapshot, ringBuffer)
   8439 		return out, metadata, &smithy.DeserializationError{
   8440 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8441 			Snapshot: snapshot.Bytes(),
   8442 		}
   8443 	}
   8444 
   8445 	span.End()
   8446 	return out, metadata, err
   8447 }
   8448 
   8449 func awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8450 	var errorBuffer bytes.Buffer
   8451 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8452 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8453 	}
   8454 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8455 
   8456 	errorCode := "UnknownError"
   8457 	errorMessage := errorCode
   8458 
   8459 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8460 	if err != nil {
   8461 		return err
   8462 	}
   8463 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8464 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8465 	}
   8466 	if len(errorComponents.Code) != 0 {
   8467 		errorCode = errorComponents.Code
   8468 	}
   8469 	if len(errorComponents.Message) != 0 {
   8470 		errorMessage = errorComponents.Message
   8471 	}
   8472 	errorBody.Seek(0, io.SeekStart)
   8473 	switch {
   8474 	case strings.EqualFold("InvalidInput", errorCode):
   8475 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8476 
   8477 	case strings.EqualFold("InvalidPaginationToken", errorCode):
   8478 		return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
   8479 
   8480 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   8481 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   8482 
   8483 	default:
   8484 		genericError := &smithy.GenericAPIError{
   8485 			Code:    errorCode,
   8486 			Message: errorMessage,
   8487 		}
   8488 		return genericError
   8489 
   8490 	}
   8491 }
   8492 
   8493 func awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(v **ListQueryLoggingConfigsOutput, decoder smithyxml.NodeDecoder) error {
   8494 	if v == nil {
   8495 		return fmt.Errorf("unexpected nil of type %T", v)
   8496 	}
   8497 	var sv *ListQueryLoggingConfigsOutput
   8498 	if *v == nil {
   8499 		sv = &ListQueryLoggingConfigsOutput{}
   8500 	} else {
   8501 		sv = *v
   8502 	}
   8503 
   8504 	for {
   8505 		t, done, err := decoder.Token()
   8506 		if err != nil {
   8507 			return err
   8508 		}
   8509 		if done {
   8510 			break
   8511 		}
   8512 		originalDecoder := decoder
   8513 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8514 		switch {
   8515 		case strings.EqualFold("NextToken", t.Name.Local):
   8516 			val, err := decoder.Value()
   8517 			if err != nil {
   8518 				return err
   8519 			}
   8520 			if val == nil {
   8521 				break
   8522 			}
   8523 			{
   8524 				xtv := string(val)
   8525 				sv.NextToken = ptr.String(xtv)
   8526 			}
   8527 
   8528 		case strings.EqualFold("QueryLoggingConfigs", t.Name.Local):
   8529 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8530 			if err := awsRestxml_deserializeDocumentQueryLoggingConfigs(&sv.QueryLoggingConfigs, nodeDecoder); err != nil {
   8531 				return err
   8532 			}
   8533 
   8534 		default:
   8535 			// Do nothing and ignore the unexpected tag element
   8536 			err = decoder.Decoder.Skip()
   8537 			if err != nil {
   8538 				return err
   8539 			}
   8540 
   8541 		}
   8542 		decoder = originalDecoder
   8543 	}
   8544 	*v = sv
   8545 	return nil
   8546 }
   8547 
   8548 type awsRestxml_deserializeOpListResourceRecordSets struct {
   8549 }
   8550 
   8551 func (*awsRestxml_deserializeOpListResourceRecordSets) ID() string {
   8552 	return "OperationDeserializer"
   8553 }
   8554 
   8555 func (m *awsRestxml_deserializeOpListResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8556 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8557 ) {
   8558 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8559 	if err != nil {
   8560 		return out, metadata, err
   8561 	}
   8562 
   8563 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8564 	if !ok {
   8565 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8566 	}
   8567 
   8568 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   8569 
   8570 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8571 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8572 	defer endTimer()
   8573 	defer span.End()
   8574 
   8575 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8576 		return out, metadata, awsRestxml_deserializeOpErrorListResourceRecordSets(response, &metadata)
   8577 	}
   8578 	output := &ListResourceRecordSetsOutput{}
   8579 	out.Result = output
   8580 
   8581 	var buff [1024]byte
   8582 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8583 	body := io.TeeReader(response.Body, ringBuffer)
   8584 	rootDecoder := xml.NewDecoder(body)
   8585 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8586 	if err == io.EOF {
   8587 		return out, metadata, nil
   8588 	}
   8589 	if err != nil {
   8590 		var snapshot bytes.Buffer
   8591 		io.Copy(&snapshot, ringBuffer)
   8592 		return out, metadata, &smithy.DeserializationError{
   8593 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8594 			Snapshot: snapshot.Bytes(),
   8595 		}
   8596 	}
   8597 
   8598 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8599 	err = awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(&output, decoder)
   8600 	if err != nil {
   8601 		var snapshot bytes.Buffer
   8602 		io.Copy(&snapshot, ringBuffer)
   8603 		return out, metadata, &smithy.DeserializationError{
   8604 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8605 			Snapshot: snapshot.Bytes(),
   8606 		}
   8607 	}
   8608 
   8609 	span.End()
   8610 	return out, metadata, err
   8611 }
   8612 
   8613 func awsRestxml_deserializeOpErrorListResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8614 	var errorBuffer bytes.Buffer
   8615 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8616 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8617 	}
   8618 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8619 
   8620 	errorCode := "UnknownError"
   8621 	errorMessage := errorCode
   8622 
   8623 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8624 	if err != nil {
   8625 		return err
   8626 	}
   8627 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8628 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8629 	}
   8630 	if len(errorComponents.Code) != 0 {
   8631 		errorCode = errorComponents.Code
   8632 	}
   8633 	if len(errorComponents.Message) != 0 {
   8634 		errorMessage = errorComponents.Message
   8635 	}
   8636 	errorBody.Seek(0, io.SeekStart)
   8637 	switch {
   8638 	case strings.EqualFold("InvalidInput", errorCode):
   8639 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8640 
   8641 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   8642 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   8643 
   8644 	default:
   8645 		genericError := &smithy.GenericAPIError{
   8646 			Code:    errorCode,
   8647 			Message: errorMessage,
   8648 		}
   8649 		return genericError
   8650 
   8651 	}
   8652 }
   8653 
   8654 func awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(v **ListResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error {
   8655 	if v == nil {
   8656 		return fmt.Errorf("unexpected nil of type %T", v)
   8657 	}
   8658 	var sv *ListResourceRecordSetsOutput
   8659 	if *v == nil {
   8660 		sv = &ListResourceRecordSetsOutput{}
   8661 	} else {
   8662 		sv = *v
   8663 	}
   8664 
   8665 	for {
   8666 		t, done, err := decoder.Token()
   8667 		if err != nil {
   8668 			return err
   8669 		}
   8670 		if done {
   8671 			break
   8672 		}
   8673 		originalDecoder := decoder
   8674 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8675 		switch {
   8676 		case strings.EqualFold("IsTruncated", t.Name.Local):
   8677 			val, err := decoder.Value()
   8678 			if err != nil {
   8679 				return err
   8680 			}
   8681 			if val == nil {
   8682 				break
   8683 			}
   8684 			{
   8685 				xtv, err := strconv.ParseBool(string(val))
   8686 				if err != nil {
   8687 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   8688 				}
   8689 				sv.IsTruncated = xtv
   8690 			}
   8691 
   8692 		case strings.EqualFold("MaxItems", t.Name.Local):
   8693 			val, err := decoder.Value()
   8694 			if err != nil {
   8695 				return err
   8696 			}
   8697 			if val == nil {
   8698 				break
   8699 			}
   8700 			{
   8701 				xtv := string(val)
   8702 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8703 				if err != nil {
   8704 					return err
   8705 				}
   8706 				sv.MaxItems = ptr.Int32(int32(i64))
   8707 			}
   8708 
   8709 		case strings.EqualFold("NextRecordIdentifier", t.Name.Local):
   8710 			val, err := decoder.Value()
   8711 			if err != nil {
   8712 				return err
   8713 			}
   8714 			if val == nil {
   8715 				break
   8716 			}
   8717 			{
   8718 				xtv := string(val)
   8719 				sv.NextRecordIdentifier = ptr.String(xtv)
   8720 			}
   8721 
   8722 		case strings.EqualFold("NextRecordName", t.Name.Local):
   8723 			val, err := decoder.Value()
   8724 			if err != nil {
   8725 				return err
   8726 			}
   8727 			if val == nil {
   8728 				break
   8729 			}
   8730 			{
   8731 				xtv := string(val)
   8732 				sv.NextRecordName = ptr.String(xtv)
   8733 			}
   8734 
   8735 		case strings.EqualFold("NextRecordType", t.Name.Local):
   8736 			val, err := decoder.Value()
   8737 			if err != nil {
   8738 				return err
   8739 			}
   8740 			if val == nil {
   8741 				break
   8742 			}
   8743 			{
   8744 				xtv := string(val)
   8745 				sv.NextRecordType = types.RRType(xtv)
   8746 			}
   8747 
   8748 		case strings.EqualFold("ResourceRecordSets", t.Name.Local):
   8749 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8750 			if err := awsRestxml_deserializeDocumentResourceRecordSets(&sv.ResourceRecordSets, nodeDecoder); err != nil {
   8751 				return err
   8752 			}
   8753 
   8754 		default:
   8755 			// Do nothing and ignore the unexpected tag element
   8756 			err = decoder.Decoder.Skip()
   8757 			if err != nil {
   8758 				return err
   8759 			}
   8760 
   8761 		}
   8762 		decoder = originalDecoder
   8763 	}
   8764 	*v = sv
   8765 	return nil
   8766 }
   8767 
   8768 type awsRestxml_deserializeOpListReusableDelegationSets struct {
   8769 }
   8770 
   8771 func (*awsRestxml_deserializeOpListReusableDelegationSets) ID() string {
   8772 	return "OperationDeserializer"
   8773 }
   8774 
   8775 func (m *awsRestxml_deserializeOpListReusableDelegationSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8776 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8777 ) {
   8778 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8779 	if err != nil {
   8780 		return out, metadata, err
   8781 	}
   8782 
   8783 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8784 	if !ok {
   8785 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8786 	}
   8787 
   8788 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   8789 
   8790 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8791 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8792 	defer endTimer()
   8793 	defer span.End()
   8794 
   8795 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8796 		return out, metadata, awsRestxml_deserializeOpErrorListReusableDelegationSets(response, &metadata)
   8797 	}
   8798 	output := &ListReusableDelegationSetsOutput{}
   8799 	out.Result = output
   8800 
   8801 	var buff [1024]byte
   8802 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8803 	body := io.TeeReader(response.Body, ringBuffer)
   8804 	rootDecoder := xml.NewDecoder(body)
   8805 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8806 	if err == io.EOF {
   8807 		return out, metadata, nil
   8808 	}
   8809 	if err != nil {
   8810 		var snapshot bytes.Buffer
   8811 		io.Copy(&snapshot, ringBuffer)
   8812 		return out, metadata, &smithy.DeserializationError{
   8813 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8814 			Snapshot: snapshot.Bytes(),
   8815 		}
   8816 	}
   8817 
   8818 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8819 	err = awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(&output, decoder)
   8820 	if err != nil {
   8821 		var snapshot bytes.Buffer
   8822 		io.Copy(&snapshot, ringBuffer)
   8823 		return out, metadata, &smithy.DeserializationError{
   8824 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8825 			Snapshot: snapshot.Bytes(),
   8826 		}
   8827 	}
   8828 
   8829 	span.End()
   8830 	return out, metadata, err
   8831 }
   8832 
   8833 func awsRestxml_deserializeOpErrorListReusableDelegationSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8834 	var errorBuffer bytes.Buffer
   8835 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8836 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8837 	}
   8838 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8839 
   8840 	errorCode := "UnknownError"
   8841 	errorMessage := errorCode
   8842 
   8843 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8844 	if err != nil {
   8845 		return err
   8846 	}
   8847 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8848 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8849 	}
   8850 	if len(errorComponents.Code) != 0 {
   8851 		errorCode = errorComponents.Code
   8852 	}
   8853 	if len(errorComponents.Message) != 0 {
   8854 		errorMessage = errorComponents.Message
   8855 	}
   8856 	errorBody.Seek(0, io.SeekStart)
   8857 	switch {
   8858 	case strings.EqualFold("InvalidInput", errorCode):
   8859 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8860 
   8861 	default:
   8862 		genericError := &smithy.GenericAPIError{
   8863 			Code:    errorCode,
   8864 			Message: errorMessage,
   8865 		}
   8866 		return genericError
   8867 
   8868 	}
   8869 }
   8870 
   8871 func awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(v **ListReusableDelegationSetsOutput, decoder smithyxml.NodeDecoder) error {
   8872 	if v == nil {
   8873 		return fmt.Errorf("unexpected nil of type %T", v)
   8874 	}
   8875 	var sv *ListReusableDelegationSetsOutput
   8876 	if *v == nil {
   8877 		sv = &ListReusableDelegationSetsOutput{}
   8878 	} else {
   8879 		sv = *v
   8880 	}
   8881 
   8882 	for {
   8883 		t, done, err := decoder.Token()
   8884 		if err != nil {
   8885 			return err
   8886 		}
   8887 		if done {
   8888 			break
   8889 		}
   8890 		originalDecoder := decoder
   8891 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8892 		switch {
   8893 		case strings.EqualFold("DelegationSets", t.Name.Local):
   8894 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8895 			if err := awsRestxml_deserializeDocumentDelegationSets(&sv.DelegationSets, nodeDecoder); err != nil {
   8896 				return err
   8897 			}
   8898 
   8899 		case strings.EqualFold("IsTruncated", t.Name.Local):
   8900 			val, err := decoder.Value()
   8901 			if err != nil {
   8902 				return err
   8903 			}
   8904 			if val == nil {
   8905 				break
   8906 			}
   8907 			{
   8908 				xtv, err := strconv.ParseBool(string(val))
   8909 				if err != nil {
   8910 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   8911 				}
   8912 				sv.IsTruncated = xtv
   8913 			}
   8914 
   8915 		case strings.EqualFold("Marker", t.Name.Local):
   8916 			val, err := decoder.Value()
   8917 			if err != nil {
   8918 				return err
   8919 			}
   8920 			if val == nil {
   8921 				break
   8922 			}
   8923 			{
   8924 				xtv := string(val)
   8925 				sv.Marker = ptr.String(xtv)
   8926 			}
   8927 
   8928 		case strings.EqualFold("MaxItems", t.Name.Local):
   8929 			val, err := decoder.Value()
   8930 			if err != nil {
   8931 				return err
   8932 			}
   8933 			if val == nil {
   8934 				break
   8935 			}
   8936 			{
   8937 				xtv := string(val)
   8938 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8939 				if err != nil {
   8940 					return err
   8941 				}
   8942 				sv.MaxItems = ptr.Int32(int32(i64))
   8943 			}
   8944 
   8945 		case strings.EqualFold("NextMarker", t.Name.Local):
   8946 			val, err := decoder.Value()
   8947 			if err != nil {
   8948 				return err
   8949 			}
   8950 			if val == nil {
   8951 				break
   8952 			}
   8953 			{
   8954 				xtv := string(val)
   8955 				sv.NextMarker = ptr.String(xtv)
   8956 			}
   8957 
   8958 		default:
   8959 			// Do nothing and ignore the unexpected tag element
   8960 			err = decoder.Decoder.Skip()
   8961 			if err != nil {
   8962 				return err
   8963 			}
   8964 
   8965 		}
   8966 		decoder = originalDecoder
   8967 	}
   8968 	*v = sv
   8969 	return nil
   8970 }
   8971 
   8972 type awsRestxml_deserializeOpListTagsForResource struct {
   8973 }
   8974 
   8975 func (*awsRestxml_deserializeOpListTagsForResource) ID() string {
   8976 	return "OperationDeserializer"
   8977 }
   8978 
   8979 func (m *awsRestxml_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8980 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8981 ) {
   8982 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8983 	if err != nil {
   8984 		return out, metadata, err
   8985 	}
   8986 
   8987 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8988 	if !ok {
   8989 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8990 	}
   8991 
   8992 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   8993 
   8994 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8995 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8996 	defer endTimer()
   8997 	defer span.End()
   8998 
   8999 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9000 		return out, metadata, awsRestxml_deserializeOpErrorListTagsForResource(response, &metadata)
   9001 	}
   9002 	output := &ListTagsForResourceOutput{}
   9003 	out.Result = output
   9004 
   9005 	var buff [1024]byte
   9006 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9007 	body := io.TeeReader(response.Body, ringBuffer)
   9008 	rootDecoder := xml.NewDecoder(body)
   9009 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9010 	if err == io.EOF {
   9011 		return out, metadata, nil
   9012 	}
   9013 	if err != nil {
   9014 		var snapshot bytes.Buffer
   9015 		io.Copy(&snapshot, ringBuffer)
   9016 		return out, metadata, &smithy.DeserializationError{
   9017 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9018 			Snapshot: snapshot.Bytes(),
   9019 		}
   9020 	}
   9021 
   9022 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9023 	err = awsRestxml_deserializeOpDocumentListTagsForResourceOutput(&output, decoder)
   9024 	if err != nil {
   9025 		var snapshot bytes.Buffer
   9026 		io.Copy(&snapshot, ringBuffer)
   9027 		return out, metadata, &smithy.DeserializationError{
   9028 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9029 			Snapshot: snapshot.Bytes(),
   9030 		}
   9031 	}
   9032 
   9033 	span.End()
   9034 	return out, metadata, err
   9035 }
   9036 
   9037 func awsRestxml_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9038 	var errorBuffer bytes.Buffer
   9039 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9040 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9041 	}
   9042 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9043 
   9044 	errorCode := "UnknownError"
   9045 	errorMessage := errorCode
   9046 
   9047 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9048 	if err != nil {
   9049 		return err
   9050 	}
   9051 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9052 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9053 	}
   9054 	if len(errorComponents.Code) != 0 {
   9055 		errorCode = errorComponents.Code
   9056 	}
   9057 	if len(errorComponents.Message) != 0 {
   9058 		errorMessage = errorComponents.Message
   9059 	}
   9060 	errorBody.Seek(0, io.SeekStart)
   9061 	switch {
   9062 	case strings.EqualFold("InvalidInput", errorCode):
   9063 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9064 
   9065 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   9066 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   9067 
   9068 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   9069 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   9070 
   9071 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   9072 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   9073 
   9074 	case strings.EqualFold("ThrottlingException", errorCode):
   9075 		return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
   9076 
   9077 	default:
   9078 		genericError := &smithy.GenericAPIError{
   9079 			Code:    errorCode,
   9080 			Message: errorMessage,
   9081 		}
   9082 		return genericError
   9083 
   9084 	}
   9085 }
   9086 
   9087 func awsRestxml_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, decoder smithyxml.NodeDecoder) error {
   9088 	if v == nil {
   9089 		return fmt.Errorf("unexpected nil of type %T", v)
   9090 	}
   9091 	var sv *ListTagsForResourceOutput
   9092 	if *v == nil {
   9093 		sv = &ListTagsForResourceOutput{}
   9094 	} else {
   9095 		sv = *v
   9096 	}
   9097 
   9098 	for {
   9099 		t, done, err := decoder.Token()
   9100 		if err != nil {
   9101 			return err
   9102 		}
   9103 		if done {
   9104 			break
   9105 		}
   9106 		originalDecoder := decoder
   9107 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9108 		switch {
   9109 		case strings.EqualFold("ResourceTagSet", t.Name.Local):
   9110 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9111 			if err := awsRestxml_deserializeDocumentResourceTagSet(&sv.ResourceTagSet, nodeDecoder); err != nil {
   9112 				return err
   9113 			}
   9114 
   9115 		default:
   9116 			// Do nothing and ignore the unexpected tag element
   9117 			err = decoder.Decoder.Skip()
   9118 			if err != nil {
   9119 				return err
   9120 			}
   9121 
   9122 		}
   9123 		decoder = originalDecoder
   9124 	}
   9125 	*v = sv
   9126 	return nil
   9127 }
   9128 
   9129 type awsRestxml_deserializeOpListTagsForResources struct {
   9130 }
   9131 
   9132 func (*awsRestxml_deserializeOpListTagsForResources) ID() string {
   9133 	return "OperationDeserializer"
   9134 }
   9135 
   9136 func (m *awsRestxml_deserializeOpListTagsForResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9137 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9138 ) {
   9139 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9140 	if err != nil {
   9141 		return out, metadata, err
   9142 	}
   9143 
   9144 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9145 	if !ok {
   9146 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9147 	}
   9148 
   9149 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   9150 
   9151 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   9152 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   9153 	defer endTimer()
   9154 	defer span.End()
   9155 
   9156 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9157 		return out, metadata, awsRestxml_deserializeOpErrorListTagsForResources(response, &metadata)
   9158 	}
   9159 	output := &ListTagsForResourcesOutput{}
   9160 	out.Result = output
   9161 
   9162 	var buff [1024]byte
   9163 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9164 	body := io.TeeReader(response.Body, ringBuffer)
   9165 	rootDecoder := xml.NewDecoder(body)
   9166 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9167 	if err == io.EOF {
   9168 		return out, metadata, nil
   9169 	}
   9170 	if err != nil {
   9171 		var snapshot bytes.Buffer
   9172 		io.Copy(&snapshot, ringBuffer)
   9173 		return out, metadata, &smithy.DeserializationError{
   9174 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9175 			Snapshot: snapshot.Bytes(),
   9176 		}
   9177 	}
   9178 
   9179 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9180 	err = awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(&output, decoder)
   9181 	if err != nil {
   9182 		var snapshot bytes.Buffer
   9183 		io.Copy(&snapshot, ringBuffer)
   9184 		return out, metadata, &smithy.DeserializationError{
   9185 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9186 			Snapshot: snapshot.Bytes(),
   9187 		}
   9188 	}
   9189 
   9190 	span.End()
   9191 	return out, metadata, err
   9192 }
   9193 
   9194 func awsRestxml_deserializeOpErrorListTagsForResources(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9195 	var errorBuffer bytes.Buffer
   9196 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9197 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9198 	}
   9199 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9200 
   9201 	errorCode := "UnknownError"
   9202 	errorMessage := errorCode
   9203 
   9204 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9205 	if err != nil {
   9206 		return err
   9207 	}
   9208 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9209 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9210 	}
   9211 	if len(errorComponents.Code) != 0 {
   9212 		errorCode = errorComponents.Code
   9213 	}
   9214 	if len(errorComponents.Message) != 0 {
   9215 		errorMessage = errorComponents.Message
   9216 	}
   9217 	errorBody.Seek(0, io.SeekStart)
   9218 	switch {
   9219 	case strings.EqualFold("InvalidInput", errorCode):
   9220 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9221 
   9222 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   9223 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   9224 
   9225 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   9226 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   9227 
   9228 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   9229 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   9230 
   9231 	case strings.EqualFold("ThrottlingException", errorCode):
   9232 		return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
   9233 
   9234 	default:
   9235 		genericError := &smithy.GenericAPIError{
   9236 			Code:    errorCode,
   9237 			Message: errorMessage,
   9238 		}
   9239 		return genericError
   9240 
   9241 	}
   9242 }
   9243 
   9244 func awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(v **ListTagsForResourcesOutput, decoder smithyxml.NodeDecoder) error {
   9245 	if v == nil {
   9246 		return fmt.Errorf("unexpected nil of type %T", v)
   9247 	}
   9248 	var sv *ListTagsForResourcesOutput
   9249 	if *v == nil {
   9250 		sv = &ListTagsForResourcesOutput{}
   9251 	} else {
   9252 		sv = *v
   9253 	}
   9254 
   9255 	for {
   9256 		t, done, err := decoder.Token()
   9257 		if err != nil {
   9258 			return err
   9259 		}
   9260 		if done {
   9261 			break
   9262 		}
   9263 		originalDecoder := decoder
   9264 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9265 		switch {
   9266 		case strings.EqualFold("ResourceTagSets", t.Name.Local):
   9267 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9268 			if err := awsRestxml_deserializeDocumentResourceTagSetList(&sv.ResourceTagSets, nodeDecoder); err != nil {
   9269 				return err
   9270 			}
   9271 
   9272 		default:
   9273 			// Do nothing and ignore the unexpected tag element
   9274 			err = decoder.Decoder.Skip()
   9275 			if err != nil {
   9276 				return err
   9277 			}
   9278 
   9279 		}
   9280 		decoder = originalDecoder
   9281 	}
   9282 	*v = sv
   9283 	return nil
   9284 }
   9285 
   9286 type awsRestxml_deserializeOpListTrafficPolicies struct {
   9287 }
   9288 
   9289 func (*awsRestxml_deserializeOpListTrafficPolicies) ID() string {
   9290 	return "OperationDeserializer"
   9291 }
   9292 
   9293 func (m *awsRestxml_deserializeOpListTrafficPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9294 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9295 ) {
   9296 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9297 	if err != nil {
   9298 		return out, metadata, err
   9299 	}
   9300 
   9301 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9302 	if !ok {
   9303 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9304 	}
   9305 
   9306 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   9307 
   9308 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   9309 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   9310 	defer endTimer()
   9311 	defer span.End()
   9312 
   9313 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9314 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicies(response, &metadata)
   9315 	}
   9316 	output := &ListTrafficPoliciesOutput{}
   9317 	out.Result = output
   9318 
   9319 	var buff [1024]byte
   9320 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9321 	body := io.TeeReader(response.Body, ringBuffer)
   9322 	rootDecoder := xml.NewDecoder(body)
   9323 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9324 	if err == io.EOF {
   9325 		return out, metadata, nil
   9326 	}
   9327 	if err != nil {
   9328 		var snapshot bytes.Buffer
   9329 		io.Copy(&snapshot, ringBuffer)
   9330 		return out, metadata, &smithy.DeserializationError{
   9331 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9332 			Snapshot: snapshot.Bytes(),
   9333 		}
   9334 	}
   9335 
   9336 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9337 	err = awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(&output, decoder)
   9338 	if err != nil {
   9339 		var snapshot bytes.Buffer
   9340 		io.Copy(&snapshot, ringBuffer)
   9341 		return out, metadata, &smithy.DeserializationError{
   9342 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9343 			Snapshot: snapshot.Bytes(),
   9344 		}
   9345 	}
   9346 
   9347 	span.End()
   9348 	return out, metadata, err
   9349 }
   9350 
   9351 func awsRestxml_deserializeOpErrorListTrafficPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9352 	var errorBuffer bytes.Buffer
   9353 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9354 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9355 	}
   9356 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9357 
   9358 	errorCode := "UnknownError"
   9359 	errorMessage := errorCode
   9360 
   9361 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9362 	if err != nil {
   9363 		return err
   9364 	}
   9365 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9366 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9367 	}
   9368 	if len(errorComponents.Code) != 0 {
   9369 		errorCode = errorComponents.Code
   9370 	}
   9371 	if len(errorComponents.Message) != 0 {
   9372 		errorMessage = errorComponents.Message
   9373 	}
   9374 	errorBody.Seek(0, io.SeekStart)
   9375 	switch {
   9376 	case strings.EqualFold("InvalidInput", errorCode):
   9377 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9378 
   9379 	default:
   9380 		genericError := &smithy.GenericAPIError{
   9381 			Code:    errorCode,
   9382 			Message: errorMessage,
   9383 		}
   9384 		return genericError
   9385 
   9386 	}
   9387 }
   9388 
   9389 func awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(v **ListTrafficPoliciesOutput, decoder smithyxml.NodeDecoder) error {
   9390 	if v == nil {
   9391 		return fmt.Errorf("unexpected nil of type %T", v)
   9392 	}
   9393 	var sv *ListTrafficPoliciesOutput
   9394 	if *v == nil {
   9395 		sv = &ListTrafficPoliciesOutput{}
   9396 	} else {
   9397 		sv = *v
   9398 	}
   9399 
   9400 	for {
   9401 		t, done, err := decoder.Token()
   9402 		if err != nil {
   9403 			return err
   9404 		}
   9405 		if done {
   9406 			break
   9407 		}
   9408 		originalDecoder := decoder
   9409 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9410 		switch {
   9411 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9412 			val, err := decoder.Value()
   9413 			if err != nil {
   9414 				return err
   9415 			}
   9416 			if val == nil {
   9417 				break
   9418 			}
   9419 			{
   9420 				xtv, err := strconv.ParseBool(string(val))
   9421 				if err != nil {
   9422 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9423 				}
   9424 				sv.IsTruncated = xtv
   9425 			}
   9426 
   9427 		case strings.EqualFold("MaxItems", t.Name.Local):
   9428 			val, err := decoder.Value()
   9429 			if err != nil {
   9430 				return err
   9431 			}
   9432 			if val == nil {
   9433 				break
   9434 			}
   9435 			{
   9436 				xtv := string(val)
   9437 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9438 				if err != nil {
   9439 					return err
   9440 				}
   9441 				sv.MaxItems = ptr.Int32(int32(i64))
   9442 			}
   9443 
   9444 		case strings.EqualFold("TrafficPolicyIdMarker", t.Name.Local):
   9445 			val, err := decoder.Value()
   9446 			if err != nil {
   9447 				return err
   9448 			}
   9449 			if val == nil {
   9450 				break
   9451 			}
   9452 			{
   9453 				xtv := string(val)
   9454 				sv.TrafficPolicyIdMarker = ptr.String(xtv)
   9455 			}
   9456 
   9457 		case strings.EqualFold("TrafficPolicySummaries", t.Name.Local):
   9458 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9459 			if err := awsRestxml_deserializeDocumentTrafficPolicySummaries(&sv.TrafficPolicySummaries, nodeDecoder); err != nil {
   9460 				return err
   9461 			}
   9462 
   9463 		default:
   9464 			// Do nothing and ignore the unexpected tag element
   9465 			err = decoder.Decoder.Skip()
   9466 			if err != nil {
   9467 				return err
   9468 			}
   9469 
   9470 		}
   9471 		decoder = originalDecoder
   9472 	}
   9473 	*v = sv
   9474 	return nil
   9475 }
   9476 
   9477 type awsRestxml_deserializeOpListTrafficPolicyInstances struct {
   9478 }
   9479 
   9480 func (*awsRestxml_deserializeOpListTrafficPolicyInstances) ID() string {
   9481 	return "OperationDeserializer"
   9482 }
   9483 
   9484 func (m *awsRestxml_deserializeOpListTrafficPolicyInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9485 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9486 ) {
   9487 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9488 	if err != nil {
   9489 		return out, metadata, err
   9490 	}
   9491 
   9492 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9493 	if !ok {
   9494 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9495 	}
   9496 
   9497 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   9498 
   9499 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   9500 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   9501 	defer endTimer()
   9502 	defer span.End()
   9503 
   9504 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9505 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response, &metadata)
   9506 	}
   9507 	output := &ListTrafficPolicyInstancesOutput{}
   9508 	out.Result = output
   9509 
   9510 	var buff [1024]byte
   9511 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9512 	body := io.TeeReader(response.Body, ringBuffer)
   9513 	rootDecoder := xml.NewDecoder(body)
   9514 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9515 	if err == io.EOF {
   9516 		return out, metadata, nil
   9517 	}
   9518 	if err != nil {
   9519 		var snapshot bytes.Buffer
   9520 		io.Copy(&snapshot, ringBuffer)
   9521 		return out, metadata, &smithy.DeserializationError{
   9522 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9523 			Snapshot: snapshot.Bytes(),
   9524 		}
   9525 	}
   9526 
   9527 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9528 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(&output, decoder)
   9529 	if err != nil {
   9530 		var snapshot bytes.Buffer
   9531 		io.Copy(&snapshot, ringBuffer)
   9532 		return out, metadata, &smithy.DeserializationError{
   9533 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9534 			Snapshot: snapshot.Bytes(),
   9535 		}
   9536 	}
   9537 
   9538 	span.End()
   9539 	return out, metadata, err
   9540 }
   9541 
   9542 func awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9543 	var errorBuffer bytes.Buffer
   9544 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9545 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9546 	}
   9547 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9548 
   9549 	errorCode := "UnknownError"
   9550 	errorMessage := errorCode
   9551 
   9552 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9553 	if err != nil {
   9554 		return err
   9555 	}
   9556 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9557 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9558 	}
   9559 	if len(errorComponents.Code) != 0 {
   9560 		errorCode = errorComponents.Code
   9561 	}
   9562 	if len(errorComponents.Message) != 0 {
   9563 		errorMessage = errorComponents.Message
   9564 	}
   9565 	errorBody.Seek(0, io.SeekStart)
   9566 	switch {
   9567 	case strings.EqualFold("InvalidInput", errorCode):
   9568 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9569 
   9570 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   9571 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   9572 
   9573 	default:
   9574 		genericError := &smithy.GenericAPIError{
   9575 			Code:    errorCode,
   9576 			Message: errorMessage,
   9577 		}
   9578 		return genericError
   9579 
   9580 	}
   9581 }
   9582 
   9583 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(v **ListTrafficPolicyInstancesOutput, decoder smithyxml.NodeDecoder) error {
   9584 	if v == nil {
   9585 		return fmt.Errorf("unexpected nil of type %T", v)
   9586 	}
   9587 	var sv *ListTrafficPolicyInstancesOutput
   9588 	if *v == nil {
   9589 		sv = &ListTrafficPolicyInstancesOutput{}
   9590 	} else {
   9591 		sv = *v
   9592 	}
   9593 
   9594 	for {
   9595 		t, done, err := decoder.Token()
   9596 		if err != nil {
   9597 			return err
   9598 		}
   9599 		if done {
   9600 			break
   9601 		}
   9602 		originalDecoder := decoder
   9603 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9604 		switch {
   9605 		case strings.EqualFold("HostedZoneIdMarker", t.Name.Local):
   9606 			val, err := decoder.Value()
   9607 			if err != nil {
   9608 				return err
   9609 			}
   9610 			if val == nil {
   9611 				break
   9612 			}
   9613 			{
   9614 				xtv := string(val)
   9615 				sv.HostedZoneIdMarker = ptr.String(xtv)
   9616 			}
   9617 
   9618 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9619 			val, err := decoder.Value()
   9620 			if err != nil {
   9621 				return err
   9622 			}
   9623 			if val == nil {
   9624 				break
   9625 			}
   9626 			{
   9627 				xtv, err := strconv.ParseBool(string(val))
   9628 				if err != nil {
   9629 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9630 				}
   9631 				sv.IsTruncated = xtv
   9632 			}
   9633 
   9634 		case strings.EqualFold("MaxItems", t.Name.Local):
   9635 			val, err := decoder.Value()
   9636 			if err != nil {
   9637 				return err
   9638 			}
   9639 			if val == nil {
   9640 				break
   9641 			}
   9642 			{
   9643 				xtv := string(val)
   9644 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9645 				if err != nil {
   9646 					return err
   9647 				}
   9648 				sv.MaxItems = ptr.Int32(int32(i64))
   9649 			}
   9650 
   9651 		case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
   9652 			val, err := decoder.Value()
   9653 			if err != nil {
   9654 				return err
   9655 			}
   9656 			if val == nil {
   9657 				break
   9658 			}
   9659 			{
   9660 				xtv := string(val)
   9661 				sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
   9662 			}
   9663 
   9664 		case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
   9665 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9666 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
   9667 				return err
   9668 			}
   9669 
   9670 		case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
   9671 			val, err := decoder.Value()
   9672 			if err != nil {
   9673 				return err
   9674 			}
   9675 			if val == nil {
   9676 				break
   9677 			}
   9678 			{
   9679 				xtv := string(val)
   9680 				sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
   9681 			}
   9682 
   9683 		default:
   9684 			// Do nothing and ignore the unexpected tag element
   9685 			err = decoder.Decoder.Skip()
   9686 			if err != nil {
   9687 				return err
   9688 			}
   9689 
   9690 		}
   9691 		decoder = originalDecoder
   9692 	}
   9693 	*v = sv
   9694 	return nil
   9695 }
   9696 
   9697 type awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone struct {
   9698 }
   9699 
   9700 func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) ID() string {
   9701 	return "OperationDeserializer"
   9702 }
   9703 
   9704 func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9705 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9706 ) {
   9707 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9708 	if err != nil {
   9709 		return out, metadata, err
   9710 	}
   9711 
   9712 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9713 	if !ok {
   9714 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9715 	}
   9716 
   9717 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   9718 
   9719 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   9720 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   9721 	defer endTimer()
   9722 	defer span.End()
   9723 
   9724 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9725 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response, &metadata)
   9726 	}
   9727 	output := &ListTrafficPolicyInstancesByHostedZoneOutput{}
   9728 	out.Result = output
   9729 
   9730 	var buff [1024]byte
   9731 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9732 	body := io.TeeReader(response.Body, ringBuffer)
   9733 	rootDecoder := xml.NewDecoder(body)
   9734 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9735 	if err == io.EOF {
   9736 		return out, metadata, nil
   9737 	}
   9738 	if err != nil {
   9739 		var snapshot bytes.Buffer
   9740 		io.Copy(&snapshot, ringBuffer)
   9741 		return out, metadata, &smithy.DeserializationError{
   9742 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9743 			Snapshot: snapshot.Bytes(),
   9744 		}
   9745 	}
   9746 
   9747 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9748 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(&output, decoder)
   9749 	if err != nil {
   9750 		var snapshot bytes.Buffer
   9751 		io.Copy(&snapshot, ringBuffer)
   9752 		return out, metadata, &smithy.DeserializationError{
   9753 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9754 			Snapshot: snapshot.Bytes(),
   9755 		}
   9756 	}
   9757 
   9758 	span.End()
   9759 	return out, metadata, err
   9760 }
   9761 
   9762 func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9763 	var errorBuffer bytes.Buffer
   9764 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9765 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9766 	}
   9767 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9768 
   9769 	errorCode := "UnknownError"
   9770 	errorMessage := errorCode
   9771 
   9772 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9773 	if err != nil {
   9774 		return err
   9775 	}
   9776 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9777 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9778 	}
   9779 	if len(errorComponents.Code) != 0 {
   9780 		errorCode = errorComponents.Code
   9781 	}
   9782 	if len(errorComponents.Message) != 0 {
   9783 		errorMessage = errorComponents.Message
   9784 	}
   9785 	errorBody.Seek(0, io.SeekStart)
   9786 	switch {
   9787 	case strings.EqualFold("InvalidInput", errorCode):
   9788 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9789 
   9790 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   9791 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   9792 
   9793 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   9794 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   9795 
   9796 	default:
   9797 		genericError := &smithy.GenericAPIError{
   9798 			Code:    errorCode,
   9799 			Message: errorMessage,
   9800 		}
   9801 		return genericError
   9802 
   9803 	}
   9804 }
   9805 
   9806 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(v **ListTrafficPolicyInstancesByHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   9807 	if v == nil {
   9808 		return fmt.Errorf("unexpected nil of type %T", v)
   9809 	}
   9810 	var sv *ListTrafficPolicyInstancesByHostedZoneOutput
   9811 	if *v == nil {
   9812 		sv = &ListTrafficPolicyInstancesByHostedZoneOutput{}
   9813 	} else {
   9814 		sv = *v
   9815 	}
   9816 
   9817 	for {
   9818 		t, done, err := decoder.Token()
   9819 		if err != nil {
   9820 			return err
   9821 		}
   9822 		if done {
   9823 			break
   9824 		}
   9825 		originalDecoder := decoder
   9826 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9827 		switch {
   9828 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9829 			val, err := decoder.Value()
   9830 			if err != nil {
   9831 				return err
   9832 			}
   9833 			if val == nil {
   9834 				break
   9835 			}
   9836 			{
   9837 				xtv, err := strconv.ParseBool(string(val))
   9838 				if err != nil {
   9839 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9840 				}
   9841 				sv.IsTruncated = xtv
   9842 			}
   9843 
   9844 		case strings.EqualFold("MaxItems", t.Name.Local):
   9845 			val, err := decoder.Value()
   9846 			if err != nil {
   9847 				return err
   9848 			}
   9849 			if val == nil {
   9850 				break
   9851 			}
   9852 			{
   9853 				xtv := string(val)
   9854 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9855 				if err != nil {
   9856 					return err
   9857 				}
   9858 				sv.MaxItems = ptr.Int32(int32(i64))
   9859 			}
   9860 
   9861 		case strings.EqualFold("TrafficPolicyInstanceNameMarker", 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 := string(val)
   9871 				sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
   9872 			}
   9873 
   9874 		case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
   9875 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9876 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
   9877 				return err
   9878 			}
   9879 
   9880 		case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
   9881 			val, err := decoder.Value()
   9882 			if err != nil {
   9883 				return err
   9884 			}
   9885 			if val == nil {
   9886 				break
   9887 			}
   9888 			{
   9889 				xtv := string(val)
   9890 				sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
   9891 			}
   9892 
   9893 		default:
   9894 			// Do nothing and ignore the unexpected tag element
   9895 			err = decoder.Decoder.Skip()
   9896 			if err != nil {
   9897 				return err
   9898 			}
   9899 
   9900 		}
   9901 		decoder = originalDecoder
   9902 	}
   9903 	*v = sv
   9904 	return nil
   9905 }
   9906 
   9907 type awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy struct {
   9908 }
   9909 
   9910 func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) ID() string {
   9911 	return "OperationDeserializer"
   9912 }
   9913 
   9914 func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9915 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9916 ) {
   9917 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9918 	if err != nil {
   9919 		return out, metadata, err
   9920 	}
   9921 
   9922 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9923 	if !ok {
   9924 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9925 	}
   9926 
   9927 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   9928 
   9929 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   9930 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   9931 	defer endTimer()
   9932 	defer span.End()
   9933 
   9934 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9935 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response, &metadata)
   9936 	}
   9937 	output := &ListTrafficPolicyInstancesByPolicyOutput{}
   9938 	out.Result = output
   9939 
   9940 	var buff [1024]byte
   9941 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9942 	body := io.TeeReader(response.Body, ringBuffer)
   9943 	rootDecoder := xml.NewDecoder(body)
   9944 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9945 	if err == io.EOF {
   9946 		return out, metadata, nil
   9947 	}
   9948 	if err != nil {
   9949 		var snapshot bytes.Buffer
   9950 		io.Copy(&snapshot, ringBuffer)
   9951 		return out, metadata, &smithy.DeserializationError{
   9952 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9953 			Snapshot: snapshot.Bytes(),
   9954 		}
   9955 	}
   9956 
   9957 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9958 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(&output, decoder)
   9959 	if err != nil {
   9960 		var snapshot bytes.Buffer
   9961 		io.Copy(&snapshot, ringBuffer)
   9962 		return out, metadata, &smithy.DeserializationError{
   9963 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9964 			Snapshot: snapshot.Bytes(),
   9965 		}
   9966 	}
   9967 
   9968 	span.End()
   9969 	return out, metadata, err
   9970 }
   9971 
   9972 func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9973 	var errorBuffer bytes.Buffer
   9974 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9975 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9976 	}
   9977 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9978 
   9979 	errorCode := "UnknownError"
   9980 	errorMessage := errorCode
   9981 
   9982 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9983 	if err != nil {
   9984 		return err
   9985 	}
   9986 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9987 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9988 	}
   9989 	if len(errorComponents.Code) != 0 {
   9990 		errorCode = errorComponents.Code
   9991 	}
   9992 	if len(errorComponents.Message) != 0 {
   9993 		errorMessage = errorComponents.Message
   9994 	}
   9995 	errorBody.Seek(0, io.SeekStart)
   9996 	switch {
   9997 	case strings.EqualFold("InvalidInput", errorCode):
   9998 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9999 
  10000 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
  10001 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
  10002 
  10003 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
  10004 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
  10005 
  10006 	default:
  10007 		genericError := &smithy.GenericAPIError{
  10008 			Code:    errorCode,
  10009 			Message: errorMessage,
  10010 		}
  10011 		return genericError
  10012 
  10013 	}
  10014 }
  10015 
  10016 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(v **ListTrafficPolicyInstancesByPolicyOutput, decoder smithyxml.NodeDecoder) error {
  10017 	if v == nil {
  10018 		return fmt.Errorf("unexpected nil of type %T", v)
  10019 	}
  10020 	var sv *ListTrafficPolicyInstancesByPolicyOutput
  10021 	if *v == nil {
  10022 		sv = &ListTrafficPolicyInstancesByPolicyOutput{}
  10023 	} else {
  10024 		sv = *v
  10025 	}
  10026 
  10027 	for {
  10028 		t, done, err := decoder.Token()
  10029 		if err != nil {
  10030 			return err
  10031 		}
  10032 		if done {
  10033 			break
  10034 		}
  10035 		originalDecoder := decoder
  10036 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10037 		switch {
  10038 		case strings.EqualFold("HostedZoneIdMarker", t.Name.Local):
  10039 			val, err := decoder.Value()
  10040 			if err != nil {
  10041 				return err
  10042 			}
  10043 			if val == nil {
  10044 				break
  10045 			}
  10046 			{
  10047 				xtv := string(val)
  10048 				sv.HostedZoneIdMarker = ptr.String(xtv)
  10049 			}
  10050 
  10051 		case strings.EqualFold("IsTruncated", t.Name.Local):
  10052 			val, err := decoder.Value()
  10053 			if err != nil {
  10054 				return err
  10055 			}
  10056 			if val == nil {
  10057 				break
  10058 			}
  10059 			{
  10060 				xtv, err := strconv.ParseBool(string(val))
  10061 				if err != nil {
  10062 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
  10063 				}
  10064 				sv.IsTruncated = xtv
  10065 			}
  10066 
  10067 		case strings.EqualFold("MaxItems", t.Name.Local):
  10068 			val, err := decoder.Value()
  10069 			if err != nil {
  10070 				return err
  10071 			}
  10072 			if val == nil {
  10073 				break
  10074 			}
  10075 			{
  10076 				xtv := string(val)
  10077 				i64, err := strconv.ParseInt(xtv, 10, 64)
  10078 				if err != nil {
  10079 					return err
  10080 				}
  10081 				sv.MaxItems = ptr.Int32(int32(i64))
  10082 			}
  10083 
  10084 		case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
  10085 			val, err := decoder.Value()
  10086 			if err != nil {
  10087 				return err
  10088 			}
  10089 			if val == nil {
  10090 				break
  10091 			}
  10092 			{
  10093 				xtv := string(val)
  10094 				sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
  10095 			}
  10096 
  10097 		case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
  10098 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10099 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
  10100 				return err
  10101 			}
  10102 
  10103 		case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
  10104 			val, err := decoder.Value()
  10105 			if err != nil {
  10106 				return err
  10107 			}
  10108 			if val == nil {
  10109 				break
  10110 			}
  10111 			{
  10112 				xtv := string(val)
  10113 				sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
  10114 			}
  10115 
  10116 		default:
  10117 			// Do nothing and ignore the unexpected tag element
  10118 			err = decoder.Decoder.Skip()
  10119 			if err != nil {
  10120 				return err
  10121 			}
  10122 
  10123 		}
  10124 		decoder = originalDecoder
  10125 	}
  10126 	*v = sv
  10127 	return nil
  10128 }
  10129 
  10130 type awsRestxml_deserializeOpListTrafficPolicyVersions struct {
  10131 }
  10132 
  10133 func (*awsRestxml_deserializeOpListTrafficPolicyVersions) ID() string {
  10134 	return "OperationDeserializer"
  10135 }
  10136 
  10137 func (m *awsRestxml_deserializeOpListTrafficPolicyVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10138 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10139 ) {
  10140 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10141 	if err != nil {
  10142 		return out, metadata, err
  10143 	}
  10144 
  10145 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10146 	if !ok {
  10147 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10148 	}
  10149 
  10150 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
  10151 
  10152 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10153 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10154 	defer endTimer()
  10155 	defer span.End()
  10156 
  10157 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10158 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response, &metadata)
  10159 	}
  10160 	output := &ListTrafficPolicyVersionsOutput{}
  10161 	out.Result = output
  10162 
  10163 	var buff [1024]byte
  10164 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10165 	body := io.TeeReader(response.Body, ringBuffer)
  10166 	rootDecoder := xml.NewDecoder(body)
  10167 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10168 	if err == io.EOF {
  10169 		return out, metadata, nil
  10170 	}
  10171 	if err != nil {
  10172 		var snapshot bytes.Buffer
  10173 		io.Copy(&snapshot, ringBuffer)
  10174 		return out, metadata, &smithy.DeserializationError{
  10175 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10176 			Snapshot: snapshot.Bytes(),
  10177 		}
  10178 	}
  10179 
  10180 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10181 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(&output, decoder)
  10182 	if err != nil {
  10183 		var snapshot bytes.Buffer
  10184 		io.Copy(&snapshot, ringBuffer)
  10185 		return out, metadata, &smithy.DeserializationError{
  10186 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10187 			Snapshot: snapshot.Bytes(),
  10188 		}
  10189 	}
  10190 
  10191 	span.End()
  10192 	return out, metadata, err
  10193 }
  10194 
  10195 func awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10196 	var errorBuffer bytes.Buffer
  10197 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10198 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10199 	}
  10200 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10201 
  10202 	errorCode := "UnknownError"
  10203 	errorMessage := errorCode
  10204 
  10205 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10206 	if err != nil {
  10207 		return err
  10208 	}
  10209 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10210 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10211 	}
  10212 	if len(errorComponents.Code) != 0 {
  10213 		errorCode = errorComponents.Code
  10214 	}
  10215 	if len(errorComponents.Message) != 0 {
  10216 		errorMessage = errorComponents.Message
  10217 	}
  10218 	errorBody.Seek(0, io.SeekStart)
  10219 	switch {
  10220 	case strings.EqualFold("InvalidInput", errorCode):
  10221 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10222 
  10223 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
  10224 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
  10225 
  10226 	default:
  10227 		genericError := &smithy.GenericAPIError{
  10228 			Code:    errorCode,
  10229 			Message: errorMessage,
  10230 		}
  10231 		return genericError
  10232 
  10233 	}
  10234 }
  10235 
  10236 func awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(v **ListTrafficPolicyVersionsOutput, decoder smithyxml.NodeDecoder) error {
  10237 	if v == nil {
  10238 		return fmt.Errorf("unexpected nil of type %T", v)
  10239 	}
  10240 	var sv *ListTrafficPolicyVersionsOutput
  10241 	if *v == nil {
  10242 		sv = &ListTrafficPolicyVersionsOutput{}
  10243 	} else {
  10244 		sv = *v
  10245 	}
  10246 
  10247 	for {
  10248 		t, done, err := decoder.Token()
  10249 		if err != nil {
  10250 			return err
  10251 		}
  10252 		if done {
  10253 			break
  10254 		}
  10255 		originalDecoder := decoder
  10256 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10257 		switch {
  10258 		case strings.EqualFold("IsTruncated", t.Name.Local):
  10259 			val, err := decoder.Value()
  10260 			if err != nil {
  10261 				return err
  10262 			}
  10263 			if val == nil {
  10264 				break
  10265 			}
  10266 			{
  10267 				xtv, err := strconv.ParseBool(string(val))
  10268 				if err != nil {
  10269 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
  10270 				}
  10271 				sv.IsTruncated = xtv
  10272 			}
  10273 
  10274 		case strings.EqualFold("MaxItems", t.Name.Local):
  10275 			val, err := decoder.Value()
  10276 			if err != nil {
  10277 				return err
  10278 			}
  10279 			if val == nil {
  10280 				break
  10281 			}
  10282 			{
  10283 				xtv := string(val)
  10284 				i64, err := strconv.ParseInt(xtv, 10, 64)
  10285 				if err != nil {
  10286 					return err
  10287 				}
  10288 				sv.MaxItems = ptr.Int32(int32(i64))
  10289 			}
  10290 
  10291 		case strings.EqualFold("TrafficPolicies", t.Name.Local):
  10292 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10293 			if err := awsRestxml_deserializeDocumentTrafficPolicies(&sv.TrafficPolicies, nodeDecoder); err != nil {
  10294 				return err
  10295 			}
  10296 
  10297 		case strings.EqualFold("TrafficPolicyVersionMarker", t.Name.Local):
  10298 			val, err := decoder.Value()
  10299 			if err != nil {
  10300 				return err
  10301 			}
  10302 			if val == nil {
  10303 				break
  10304 			}
  10305 			{
  10306 				xtv := string(val)
  10307 				sv.TrafficPolicyVersionMarker = ptr.String(xtv)
  10308 			}
  10309 
  10310 		default:
  10311 			// Do nothing and ignore the unexpected tag element
  10312 			err = decoder.Decoder.Skip()
  10313 			if err != nil {
  10314 				return err
  10315 			}
  10316 
  10317 		}
  10318 		decoder = originalDecoder
  10319 	}
  10320 	*v = sv
  10321 	return nil
  10322 }
  10323 
  10324 type awsRestxml_deserializeOpListVPCAssociationAuthorizations struct {
  10325 }
  10326 
  10327 func (*awsRestxml_deserializeOpListVPCAssociationAuthorizations) ID() string {
  10328 	return "OperationDeserializer"
  10329 }
  10330 
  10331 func (m *awsRestxml_deserializeOpListVPCAssociationAuthorizations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10332 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10333 ) {
  10334 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10335 	if err != nil {
  10336 		return out, metadata, err
  10337 	}
  10338 
  10339 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10340 	if !ok {
  10341 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10342 	}
  10343 
  10344 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
  10345 
  10346 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10347 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10348 	defer endTimer()
  10349 	defer span.End()
  10350 
  10351 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10352 		return out, metadata, awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response, &metadata)
  10353 	}
  10354 	output := &ListVPCAssociationAuthorizationsOutput{}
  10355 	out.Result = output
  10356 
  10357 	var buff [1024]byte
  10358 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10359 	body := io.TeeReader(response.Body, ringBuffer)
  10360 	rootDecoder := xml.NewDecoder(body)
  10361 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10362 	if err == io.EOF {
  10363 		return out, metadata, nil
  10364 	}
  10365 	if err != nil {
  10366 		var snapshot bytes.Buffer
  10367 		io.Copy(&snapshot, ringBuffer)
  10368 		return out, metadata, &smithy.DeserializationError{
  10369 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10370 			Snapshot: snapshot.Bytes(),
  10371 		}
  10372 	}
  10373 
  10374 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10375 	err = awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(&output, decoder)
  10376 	if err != nil {
  10377 		var snapshot bytes.Buffer
  10378 		io.Copy(&snapshot, ringBuffer)
  10379 		return out, metadata, &smithy.DeserializationError{
  10380 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10381 			Snapshot: snapshot.Bytes(),
  10382 		}
  10383 	}
  10384 
  10385 	span.End()
  10386 	return out, metadata, err
  10387 }
  10388 
  10389 func awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10390 	var errorBuffer bytes.Buffer
  10391 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10392 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10393 	}
  10394 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10395 
  10396 	errorCode := "UnknownError"
  10397 	errorMessage := errorCode
  10398 
  10399 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10400 	if err != nil {
  10401 		return err
  10402 	}
  10403 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10404 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10405 	}
  10406 	if len(errorComponents.Code) != 0 {
  10407 		errorCode = errorComponents.Code
  10408 	}
  10409 	if len(errorComponents.Message) != 0 {
  10410 		errorMessage = errorComponents.Message
  10411 	}
  10412 	errorBody.Seek(0, io.SeekStart)
  10413 	switch {
  10414 	case strings.EqualFold("InvalidInput", errorCode):
  10415 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10416 
  10417 	case strings.EqualFold("InvalidPaginationToken", errorCode):
  10418 		return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
  10419 
  10420 	case strings.EqualFold("NoSuchHostedZone", errorCode):
  10421 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
  10422 
  10423 	default:
  10424 		genericError := &smithy.GenericAPIError{
  10425 			Code:    errorCode,
  10426 			Message: errorMessage,
  10427 		}
  10428 		return genericError
  10429 
  10430 	}
  10431 }
  10432 
  10433 func awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(v **ListVPCAssociationAuthorizationsOutput, decoder smithyxml.NodeDecoder) error {
  10434 	if v == nil {
  10435 		return fmt.Errorf("unexpected nil of type %T", v)
  10436 	}
  10437 	var sv *ListVPCAssociationAuthorizationsOutput
  10438 	if *v == nil {
  10439 		sv = &ListVPCAssociationAuthorizationsOutput{}
  10440 	} else {
  10441 		sv = *v
  10442 	}
  10443 
  10444 	for {
  10445 		t, done, err := decoder.Token()
  10446 		if err != nil {
  10447 			return err
  10448 		}
  10449 		if done {
  10450 			break
  10451 		}
  10452 		originalDecoder := decoder
  10453 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10454 		switch {
  10455 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  10456 			val, err := decoder.Value()
  10457 			if err != nil {
  10458 				return err
  10459 			}
  10460 			if val == nil {
  10461 				break
  10462 			}
  10463 			{
  10464 				xtv := string(val)
  10465 				sv.HostedZoneId = ptr.String(xtv)
  10466 			}
  10467 
  10468 		case strings.EqualFold("NextToken", t.Name.Local):
  10469 			val, err := decoder.Value()
  10470 			if err != nil {
  10471 				return err
  10472 			}
  10473 			if val == nil {
  10474 				break
  10475 			}
  10476 			{
  10477 				xtv := string(val)
  10478 				sv.NextToken = ptr.String(xtv)
  10479 			}
  10480 
  10481 		case strings.EqualFold("VPCs", t.Name.Local):
  10482 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10483 			if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil {
  10484 				return err
  10485 			}
  10486 
  10487 		default:
  10488 			// Do nothing and ignore the unexpected tag element
  10489 			err = decoder.Decoder.Skip()
  10490 			if err != nil {
  10491 				return err
  10492 			}
  10493 
  10494 		}
  10495 		decoder = originalDecoder
  10496 	}
  10497 	*v = sv
  10498 	return nil
  10499 }
  10500 
  10501 type awsRestxml_deserializeOpTestDNSAnswer struct {
  10502 }
  10503 
  10504 func (*awsRestxml_deserializeOpTestDNSAnswer) ID() string {
  10505 	return "OperationDeserializer"
  10506 }
  10507 
  10508 func (m *awsRestxml_deserializeOpTestDNSAnswer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10509 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10510 ) {
  10511 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10512 	if err != nil {
  10513 		return out, metadata, err
  10514 	}
  10515 
  10516 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10517 	if !ok {
  10518 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10519 	}
  10520 
  10521 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
  10522 
  10523 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10524 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10525 	defer endTimer()
  10526 	defer span.End()
  10527 
  10528 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10529 		return out, metadata, awsRestxml_deserializeOpErrorTestDNSAnswer(response, &metadata)
  10530 	}
  10531 	output := &TestDNSAnswerOutput{}
  10532 	out.Result = output
  10533 
  10534 	var buff [1024]byte
  10535 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10536 	body := io.TeeReader(response.Body, ringBuffer)
  10537 	rootDecoder := xml.NewDecoder(body)
  10538 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10539 	if err == io.EOF {
  10540 		return out, metadata, nil
  10541 	}
  10542 	if err != nil {
  10543 		var snapshot bytes.Buffer
  10544 		io.Copy(&snapshot, ringBuffer)
  10545 		return out, metadata, &smithy.DeserializationError{
  10546 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10547 			Snapshot: snapshot.Bytes(),
  10548 		}
  10549 	}
  10550 
  10551 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10552 	err = awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(&output, decoder)
  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 	span.End()
  10563 	return out, metadata, err
  10564 }
  10565 
  10566 func awsRestxml_deserializeOpErrorTestDNSAnswer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10567 	var errorBuffer bytes.Buffer
  10568 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10569 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10570 	}
  10571 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10572 
  10573 	errorCode := "UnknownError"
  10574 	errorMessage := errorCode
  10575 
  10576 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10577 	if err != nil {
  10578 		return err
  10579 	}
  10580 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10581 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10582 	}
  10583 	if len(errorComponents.Code) != 0 {
  10584 		errorCode = errorComponents.Code
  10585 	}
  10586 	if len(errorComponents.Message) != 0 {
  10587 		errorMessage = errorComponents.Message
  10588 	}
  10589 	errorBody.Seek(0, io.SeekStart)
  10590 	switch {
  10591 	case strings.EqualFold("InvalidInput", errorCode):
  10592 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10593 
  10594 	case strings.EqualFold("NoSuchHostedZone", errorCode):
  10595 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
  10596 
  10597 	default:
  10598 		genericError := &smithy.GenericAPIError{
  10599 			Code:    errorCode,
  10600 			Message: errorMessage,
  10601 		}
  10602 		return genericError
  10603 
  10604 	}
  10605 }
  10606 
  10607 func awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(v **TestDNSAnswerOutput, decoder smithyxml.NodeDecoder) error {
  10608 	if v == nil {
  10609 		return fmt.Errorf("unexpected nil of type %T", v)
  10610 	}
  10611 	var sv *TestDNSAnswerOutput
  10612 	if *v == nil {
  10613 		sv = &TestDNSAnswerOutput{}
  10614 	} else {
  10615 		sv = *v
  10616 	}
  10617 
  10618 	for {
  10619 		t, done, err := decoder.Token()
  10620 		if err != nil {
  10621 			return err
  10622 		}
  10623 		if done {
  10624 			break
  10625 		}
  10626 		originalDecoder := decoder
  10627 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10628 		switch {
  10629 		case strings.EqualFold("Nameserver", t.Name.Local):
  10630 			val, err := decoder.Value()
  10631 			if err != nil {
  10632 				return err
  10633 			}
  10634 			if val == nil {
  10635 				break
  10636 			}
  10637 			{
  10638 				xtv := string(val)
  10639 				sv.Nameserver = ptr.String(xtv)
  10640 			}
  10641 
  10642 		case strings.EqualFold("Protocol", t.Name.Local):
  10643 			val, err := decoder.Value()
  10644 			if err != nil {
  10645 				return err
  10646 			}
  10647 			if val == nil {
  10648 				break
  10649 			}
  10650 			{
  10651 				xtv := string(val)
  10652 				sv.Protocol = ptr.String(xtv)
  10653 			}
  10654 
  10655 		case strings.EqualFold("RecordData", t.Name.Local):
  10656 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10657 			if err := awsRestxml_deserializeDocumentRecordData(&sv.RecordData, nodeDecoder); err != nil {
  10658 				return err
  10659 			}
  10660 
  10661 		case strings.EqualFold("RecordName", t.Name.Local):
  10662 			val, err := decoder.Value()
  10663 			if err != nil {
  10664 				return err
  10665 			}
  10666 			if val == nil {
  10667 				break
  10668 			}
  10669 			{
  10670 				xtv := string(val)
  10671 				sv.RecordName = ptr.String(xtv)
  10672 			}
  10673 
  10674 		case strings.EqualFold("RecordType", t.Name.Local):
  10675 			val, err := decoder.Value()
  10676 			if err != nil {
  10677 				return err
  10678 			}
  10679 			if val == nil {
  10680 				break
  10681 			}
  10682 			{
  10683 				xtv := string(val)
  10684 				sv.RecordType = types.RRType(xtv)
  10685 			}
  10686 
  10687 		case strings.EqualFold("ResponseCode", t.Name.Local):
  10688 			val, err := decoder.Value()
  10689 			if err != nil {
  10690 				return err
  10691 			}
  10692 			if val == nil {
  10693 				break
  10694 			}
  10695 			{
  10696 				xtv := string(val)
  10697 				sv.ResponseCode = ptr.String(xtv)
  10698 			}
  10699 
  10700 		default:
  10701 			// Do nothing and ignore the unexpected tag element
  10702 			err = decoder.Decoder.Skip()
  10703 			if err != nil {
  10704 				return err
  10705 			}
  10706 
  10707 		}
  10708 		decoder = originalDecoder
  10709 	}
  10710 	*v = sv
  10711 	return nil
  10712 }
  10713 
  10714 type awsRestxml_deserializeOpUpdateHealthCheck struct {
  10715 }
  10716 
  10717 func (*awsRestxml_deserializeOpUpdateHealthCheck) ID() string {
  10718 	return "OperationDeserializer"
  10719 }
  10720 
  10721 func (m *awsRestxml_deserializeOpUpdateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10722 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10723 ) {
  10724 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10725 	if err != nil {
  10726 		return out, metadata, err
  10727 	}
  10728 
  10729 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10730 	if !ok {
  10731 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10732 	}
  10733 
  10734 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
  10735 
  10736 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10737 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10738 	defer endTimer()
  10739 	defer span.End()
  10740 
  10741 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10742 		return out, metadata, awsRestxml_deserializeOpErrorUpdateHealthCheck(response, &metadata)
  10743 	}
  10744 	output := &UpdateHealthCheckOutput{}
  10745 	out.Result = output
  10746 
  10747 	var buff [1024]byte
  10748 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10749 	body := io.TeeReader(response.Body, ringBuffer)
  10750 	rootDecoder := xml.NewDecoder(body)
  10751 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10752 	if err == io.EOF {
  10753 		return out, metadata, nil
  10754 	}
  10755 	if err != nil {
  10756 		var snapshot bytes.Buffer
  10757 		io.Copy(&snapshot, ringBuffer)
  10758 		return out, metadata, &smithy.DeserializationError{
  10759 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10760 			Snapshot: snapshot.Bytes(),
  10761 		}
  10762 	}
  10763 
  10764 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10765 	err = awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(&output, decoder)
  10766 	if err != nil {
  10767 		var snapshot bytes.Buffer
  10768 		io.Copy(&snapshot, ringBuffer)
  10769 		return out, metadata, &smithy.DeserializationError{
  10770 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10771 			Snapshot: snapshot.Bytes(),
  10772 		}
  10773 	}
  10774 
  10775 	span.End()
  10776 	return out, metadata, err
  10777 }
  10778 
  10779 func awsRestxml_deserializeOpErrorUpdateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10780 	var errorBuffer bytes.Buffer
  10781 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10782 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10783 	}
  10784 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10785 
  10786 	errorCode := "UnknownError"
  10787 	errorMessage := errorCode
  10788 
  10789 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10790 	if err != nil {
  10791 		return err
  10792 	}
  10793 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10794 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10795 	}
  10796 	if len(errorComponents.Code) != 0 {
  10797 		errorCode = errorComponents.Code
  10798 	}
  10799 	if len(errorComponents.Message) != 0 {
  10800 		errorMessage = errorComponents.Message
  10801 	}
  10802 	errorBody.Seek(0, io.SeekStart)
  10803 	switch {
  10804 	case strings.EqualFold("HealthCheckVersionMismatch", errorCode):
  10805 		return awsRestxml_deserializeErrorHealthCheckVersionMismatch(response, errorBody)
  10806 
  10807 	case strings.EqualFold("InvalidInput", errorCode):
  10808 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10809 
  10810 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
  10811 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
  10812 
  10813 	default:
  10814 		genericError := &smithy.GenericAPIError{
  10815 			Code:    errorCode,
  10816 			Message: errorMessage,
  10817 		}
  10818 		return genericError
  10819 
  10820 	}
  10821 }
  10822 
  10823 func awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(v **UpdateHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
  10824 	if v == nil {
  10825 		return fmt.Errorf("unexpected nil of type %T", v)
  10826 	}
  10827 	var sv *UpdateHealthCheckOutput
  10828 	if *v == nil {
  10829 		sv = &UpdateHealthCheckOutput{}
  10830 	} else {
  10831 		sv = *v
  10832 	}
  10833 
  10834 	for {
  10835 		t, done, err := decoder.Token()
  10836 		if err != nil {
  10837 			return err
  10838 		}
  10839 		if done {
  10840 			break
  10841 		}
  10842 		originalDecoder := decoder
  10843 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10844 		switch {
  10845 		case strings.EqualFold("HealthCheck", t.Name.Local):
  10846 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10847 			if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
  10848 				return err
  10849 			}
  10850 
  10851 		default:
  10852 			// Do nothing and ignore the unexpected tag element
  10853 			err = decoder.Decoder.Skip()
  10854 			if err != nil {
  10855 				return err
  10856 			}
  10857 
  10858 		}
  10859 		decoder = originalDecoder
  10860 	}
  10861 	*v = sv
  10862 	return nil
  10863 }
  10864 
  10865 type awsRestxml_deserializeOpUpdateHostedZoneComment struct {
  10866 }
  10867 
  10868 func (*awsRestxml_deserializeOpUpdateHostedZoneComment) ID() string {
  10869 	return "OperationDeserializer"
  10870 }
  10871 
  10872 func (m *awsRestxml_deserializeOpUpdateHostedZoneComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10873 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10874 ) {
  10875 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10876 	if err != nil {
  10877 		return out, metadata, err
  10878 	}
  10879 
  10880 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10881 	if !ok {
  10882 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10883 	}
  10884 
  10885 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
  10886 
  10887 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10888 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10889 	defer endTimer()
  10890 	defer span.End()
  10891 
  10892 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10893 		return out, metadata, awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response, &metadata)
  10894 	}
  10895 	output := &UpdateHostedZoneCommentOutput{}
  10896 	out.Result = output
  10897 
  10898 	var buff [1024]byte
  10899 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10900 	body := io.TeeReader(response.Body, ringBuffer)
  10901 	rootDecoder := xml.NewDecoder(body)
  10902 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10903 	if err == io.EOF {
  10904 		return out, metadata, nil
  10905 	}
  10906 	if err != nil {
  10907 		var snapshot bytes.Buffer
  10908 		io.Copy(&snapshot, ringBuffer)
  10909 		return out, metadata, &smithy.DeserializationError{
  10910 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10911 			Snapshot: snapshot.Bytes(),
  10912 		}
  10913 	}
  10914 
  10915 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10916 	err = awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(&output, decoder)
  10917 	if err != nil {
  10918 		var snapshot bytes.Buffer
  10919 		io.Copy(&snapshot, ringBuffer)
  10920 		return out, metadata, &smithy.DeserializationError{
  10921 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10922 			Snapshot: snapshot.Bytes(),
  10923 		}
  10924 	}
  10925 
  10926 	span.End()
  10927 	return out, metadata, err
  10928 }
  10929 
  10930 func awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10931 	var errorBuffer bytes.Buffer
  10932 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10933 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10934 	}
  10935 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10936 
  10937 	errorCode := "UnknownError"
  10938 	errorMessage := errorCode
  10939 
  10940 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10941 	if err != nil {
  10942 		return err
  10943 	}
  10944 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10945 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10946 	}
  10947 	if len(errorComponents.Code) != 0 {
  10948 		errorCode = errorComponents.Code
  10949 	}
  10950 	if len(errorComponents.Message) != 0 {
  10951 		errorMessage = errorComponents.Message
  10952 	}
  10953 	errorBody.Seek(0, io.SeekStart)
  10954 	switch {
  10955 	case strings.EqualFold("InvalidInput", errorCode):
  10956 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10957 
  10958 	case strings.EqualFold("NoSuchHostedZone", errorCode):
  10959 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
  10960 
  10961 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
  10962 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
  10963 
  10964 	default:
  10965 		genericError := &smithy.GenericAPIError{
  10966 			Code:    errorCode,
  10967 			Message: errorMessage,
  10968 		}
  10969 		return genericError
  10970 
  10971 	}
  10972 }
  10973 
  10974 func awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(v **UpdateHostedZoneCommentOutput, decoder smithyxml.NodeDecoder) error {
  10975 	if v == nil {
  10976 		return fmt.Errorf("unexpected nil of type %T", v)
  10977 	}
  10978 	var sv *UpdateHostedZoneCommentOutput
  10979 	if *v == nil {
  10980 		sv = &UpdateHostedZoneCommentOutput{}
  10981 	} else {
  10982 		sv = *v
  10983 	}
  10984 
  10985 	for {
  10986 		t, done, err := decoder.Token()
  10987 		if err != nil {
  10988 			return err
  10989 		}
  10990 		if done {
  10991 			break
  10992 		}
  10993 		originalDecoder := decoder
  10994 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10995 		switch {
  10996 		case strings.EqualFold("HostedZone", t.Name.Local):
  10997 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10998 			if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
  10999 				return err
  11000 			}
  11001 
  11002 		default:
  11003 			// Do nothing and ignore the unexpected tag element
  11004 			err = decoder.Decoder.Skip()
  11005 			if err != nil {
  11006 				return err
  11007 			}
  11008 
  11009 		}
  11010 		decoder = originalDecoder
  11011 	}
  11012 	*v = sv
  11013 	return nil
  11014 }
  11015 
  11016 type awsRestxml_deserializeOpUpdateHostedZoneFeatures struct {
  11017 }
  11018 
  11019 func (*awsRestxml_deserializeOpUpdateHostedZoneFeatures) ID() string {
  11020 	return "OperationDeserializer"
  11021 }
  11022 
  11023 func (m *awsRestxml_deserializeOpUpdateHostedZoneFeatures) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  11024 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  11025 ) {
  11026 	out, metadata, err = next.HandleDeserialize(ctx, in)
  11027 	if err != nil {
  11028 		return out, metadata, err
  11029 	}
  11030 
  11031 	response, ok := out.RawResponse.(*smithyhttp.Response)
  11032 	if !ok {
  11033 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  11034 	}
  11035 
  11036 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
  11037 
  11038 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  11039 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  11040 	defer endTimer()
  11041 	defer span.End()
  11042 
  11043 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  11044 		return out, metadata, awsRestxml_deserializeOpErrorUpdateHostedZoneFeatures(response, &metadata)
  11045 	}
  11046 	output := &UpdateHostedZoneFeaturesOutput{}
  11047 	out.Result = output
  11048 
  11049 	span.End()
  11050 	return out, metadata, err
  11051 }
  11052 
  11053 func awsRestxml_deserializeOpErrorUpdateHostedZoneFeatures(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  11054 	var errorBuffer bytes.Buffer
  11055 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  11056 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  11057 	}
  11058 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  11059 
  11060 	errorCode := "UnknownError"
  11061 	errorMessage := errorCode
  11062 
  11063 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  11064 	if err != nil {
  11065 		return err
  11066 	}
  11067 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  11068 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  11069 	}
  11070 	if len(errorComponents.Code) != 0 {
  11071 		errorCode = errorComponents.Code
  11072 	}
  11073 	if len(errorComponents.Message) != 0 {
  11074 		errorMessage = errorComponents.Message
  11075 	}
  11076 	errorBody.Seek(0, io.SeekStart)
  11077 	switch {
  11078 	case strings.EqualFold("InvalidInput", errorCode):
  11079 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  11080 
  11081 	case strings.EqualFold("LimitsExceeded", errorCode):
  11082 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
  11083 
  11084 	case strings.EqualFold("NoSuchHostedZone", errorCode):
  11085 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
  11086 
  11087 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
  11088 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
  11089 
  11090 	default:
  11091 		genericError := &smithy.GenericAPIError{
  11092 			Code:    errorCode,
  11093 			Message: errorMessage,
  11094 		}
  11095 		return genericError
  11096 
  11097 	}
  11098 }
  11099 
  11100 type awsRestxml_deserializeOpUpdateTrafficPolicyComment struct {
  11101 }
  11102 
  11103 func (*awsRestxml_deserializeOpUpdateTrafficPolicyComment) ID() string {
  11104 	return "OperationDeserializer"
  11105 }
  11106 
  11107 func (m *awsRestxml_deserializeOpUpdateTrafficPolicyComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  11108 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  11109 ) {
  11110 	out, metadata, err = next.HandleDeserialize(ctx, in)
  11111 	if err != nil {
  11112 		return out, metadata, err
  11113 	}
  11114 
  11115 	response, ok := out.RawResponse.(*smithyhttp.Response)
  11116 	if !ok {
  11117 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  11118 	}
  11119 
  11120 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
  11121 
  11122 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  11123 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  11124 	defer endTimer()
  11125 	defer span.End()
  11126 
  11127 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  11128 		return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response, &metadata)
  11129 	}
  11130 	output := &UpdateTrafficPolicyCommentOutput{}
  11131 	out.Result = output
  11132 
  11133 	var buff [1024]byte
  11134 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11135 	body := io.TeeReader(response.Body, ringBuffer)
  11136 	rootDecoder := xml.NewDecoder(body)
  11137 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11138 	if err == io.EOF {
  11139 		return out, metadata, nil
  11140 	}
  11141 	if err != nil {
  11142 		var snapshot bytes.Buffer
  11143 		io.Copy(&snapshot, ringBuffer)
  11144 		return out, metadata, &smithy.DeserializationError{
  11145 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11146 			Snapshot: snapshot.Bytes(),
  11147 		}
  11148 	}
  11149 
  11150 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11151 	err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(&output, decoder)
  11152 	if err != nil {
  11153 		var snapshot bytes.Buffer
  11154 		io.Copy(&snapshot, ringBuffer)
  11155 		return out, metadata, &smithy.DeserializationError{
  11156 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11157 			Snapshot: snapshot.Bytes(),
  11158 		}
  11159 	}
  11160 
  11161 	span.End()
  11162 	return out, metadata, err
  11163 }
  11164 
  11165 func awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  11166 	var errorBuffer bytes.Buffer
  11167 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  11168 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  11169 	}
  11170 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  11171 
  11172 	errorCode := "UnknownError"
  11173 	errorMessage := errorCode
  11174 
  11175 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  11176 	if err != nil {
  11177 		return err
  11178 	}
  11179 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  11180 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  11181 	}
  11182 	if len(errorComponents.Code) != 0 {
  11183 		errorCode = errorComponents.Code
  11184 	}
  11185 	if len(errorComponents.Message) != 0 {
  11186 		errorMessage = errorComponents.Message
  11187 	}
  11188 	errorBody.Seek(0, io.SeekStart)
  11189 	switch {
  11190 	case strings.EqualFold("ConcurrentModification", errorCode):
  11191 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
  11192 
  11193 	case strings.EqualFold("InvalidInput", errorCode):
  11194 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  11195 
  11196 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
  11197 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
  11198 
  11199 	default:
  11200 		genericError := &smithy.GenericAPIError{
  11201 			Code:    errorCode,
  11202 			Message: errorMessage,
  11203 		}
  11204 		return genericError
  11205 
  11206 	}
  11207 }
  11208 
  11209 func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(v **UpdateTrafficPolicyCommentOutput, decoder smithyxml.NodeDecoder) error {
  11210 	if v == nil {
  11211 		return fmt.Errorf("unexpected nil of type %T", v)
  11212 	}
  11213 	var sv *UpdateTrafficPolicyCommentOutput
  11214 	if *v == nil {
  11215 		sv = &UpdateTrafficPolicyCommentOutput{}
  11216 	} else {
  11217 		sv = *v
  11218 	}
  11219 
  11220 	for {
  11221 		t, done, err := decoder.Token()
  11222 		if err != nil {
  11223 			return err
  11224 		}
  11225 		if done {
  11226 			break
  11227 		}
  11228 		originalDecoder := decoder
  11229 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  11230 		switch {
  11231 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
  11232 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11233 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
  11234 				return err
  11235 			}
  11236 
  11237 		default:
  11238 			// Do nothing and ignore the unexpected tag element
  11239 			err = decoder.Decoder.Skip()
  11240 			if err != nil {
  11241 				return err
  11242 			}
  11243 
  11244 		}
  11245 		decoder = originalDecoder
  11246 	}
  11247 	*v = sv
  11248 	return nil
  11249 }
  11250 
  11251 type awsRestxml_deserializeOpUpdateTrafficPolicyInstance struct {
  11252 }
  11253 
  11254 func (*awsRestxml_deserializeOpUpdateTrafficPolicyInstance) ID() string {
  11255 	return "OperationDeserializer"
  11256 }
  11257 
  11258 func (m *awsRestxml_deserializeOpUpdateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  11259 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  11260 ) {
  11261 	out, metadata, err = next.HandleDeserialize(ctx, in)
  11262 	if err != nil {
  11263 		return out, metadata, err
  11264 	}
  11265 
  11266 	response, ok := out.RawResponse.(*smithyhttp.Response)
  11267 	if !ok {
  11268 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  11269 	}
  11270 
  11271 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
  11272 
  11273 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  11274 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  11275 	defer endTimer()
  11276 	defer span.End()
  11277 
  11278 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  11279 		return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response, &metadata)
  11280 	}
  11281 	output := &UpdateTrafficPolicyInstanceOutput{}
  11282 	out.Result = output
  11283 
  11284 	var buff [1024]byte
  11285 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11286 	body := io.TeeReader(response.Body, ringBuffer)
  11287 	rootDecoder := xml.NewDecoder(body)
  11288 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11289 	if err == io.EOF {
  11290 		return out, metadata, nil
  11291 	}
  11292 	if err != nil {
  11293 		var snapshot bytes.Buffer
  11294 		io.Copy(&snapshot, ringBuffer)
  11295 		return out, metadata, &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 	err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(&output, decoder)
  11303 	if err != nil {
  11304 		var snapshot bytes.Buffer
  11305 		io.Copy(&snapshot, ringBuffer)
  11306 		return out, metadata, &smithy.DeserializationError{
  11307 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11308 			Snapshot: snapshot.Bytes(),
  11309 		}
  11310 	}
  11311 
  11312 	span.End()
  11313 	return out, metadata, err
  11314 }
  11315 
  11316 func awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  11317 	var errorBuffer bytes.Buffer
  11318 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  11319 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  11320 	}
  11321 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  11322 
  11323 	errorCode := "UnknownError"
  11324 	errorMessage := errorCode
  11325 
  11326 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  11327 	if err != nil {
  11328 		return err
  11329 	}
  11330 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  11331 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  11332 	}
  11333 	if len(errorComponents.Code) != 0 {
  11334 		errorCode = errorComponents.Code
  11335 	}
  11336 	if len(errorComponents.Message) != 0 {
  11337 		errorMessage = errorComponents.Message
  11338 	}
  11339 	errorBody.Seek(0, io.SeekStart)
  11340 	switch {
  11341 	case strings.EqualFold("ConflictingTypes", errorCode):
  11342 		return awsRestxml_deserializeErrorConflictingTypes(response, errorBody)
  11343 
  11344 	case strings.EqualFold("InvalidInput", errorCode):
  11345 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  11346 
  11347 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
  11348 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
  11349 
  11350 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
  11351 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
  11352 
  11353 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
  11354 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
  11355 
  11356 	default:
  11357 		genericError := &smithy.GenericAPIError{
  11358 			Code:    errorCode,
  11359 			Message: errorMessage,
  11360 		}
  11361 		return genericError
  11362 
  11363 	}
  11364 }
  11365 
  11366 func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(v **UpdateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
  11367 	if v == nil {
  11368 		return fmt.Errorf("unexpected nil of type %T", v)
  11369 	}
  11370 	var sv *UpdateTrafficPolicyInstanceOutput
  11371 	if *v == nil {
  11372 		sv = &UpdateTrafficPolicyInstanceOutput{}
  11373 	} else {
  11374 		sv = *v
  11375 	}
  11376 
  11377 	for {
  11378 		t, done, err := decoder.Token()
  11379 		if err != nil {
  11380 			return err
  11381 		}
  11382 		if done {
  11383 			break
  11384 		}
  11385 		originalDecoder := decoder
  11386 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  11387 		switch {
  11388 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
  11389 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11390 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
  11391 				return err
  11392 			}
  11393 
  11394 		default:
  11395 			// Do nothing and ignore the unexpected tag element
  11396 			err = decoder.Decoder.Skip()
  11397 			if err != nil {
  11398 				return err
  11399 			}
  11400 
  11401 		}
  11402 		decoder = originalDecoder
  11403 	}
  11404 	*v = sv
  11405 	return nil
  11406 }
  11407 
  11408 func awsRestxml_deserializeErrorCidrBlockInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11409 	output := &types.CidrBlockInUseException{}
  11410 	var buff [1024]byte
  11411 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11412 	body := io.TeeReader(errorBody, ringBuffer)
  11413 	rootDecoder := xml.NewDecoder(body)
  11414 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11415 	if err == io.EOF {
  11416 		return output
  11417 	}
  11418 	if err != nil {
  11419 		var snapshot bytes.Buffer
  11420 		io.Copy(&snapshot, ringBuffer)
  11421 		return &smithy.DeserializationError{
  11422 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11423 			Snapshot: snapshot.Bytes(),
  11424 		}
  11425 	}
  11426 
  11427 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11428 	t, err = decoder.GetElement("Error")
  11429 	if err != nil {
  11430 		var snapshot bytes.Buffer
  11431 		io.Copy(&snapshot, ringBuffer)
  11432 		return &smithy.DeserializationError{
  11433 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11434 			Snapshot: snapshot.Bytes(),
  11435 		}
  11436 	}
  11437 
  11438 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11439 	err = awsRestxml_deserializeDocumentCidrBlockInUseException(&output, decoder)
  11440 	if err != nil {
  11441 		var snapshot bytes.Buffer
  11442 		io.Copy(&snapshot, ringBuffer)
  11443 		return &smithy.DeserializationError{
  11444 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11445 			Snapshot: snapshot.Bytes(),
  11446 		}
  11447 	}
  11448 
  11449 	return output
  11450 }
  11451 
  11452 func awsRestxml_deserializeErrorCidrCollectionAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11453 	output := &types.CidrCollectionAlreadyExistsException{}
  11454 	var buff [1024]byte
  11455 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11456 	body := io.TeeReader(errorBody, ringBuffer)
  11457 	rootDecoder := xml.NewDecoder(body)
  11458 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11459 	if err == io.EOF {
  11460 		return output
  11461 	}
  11462 	if err != nil {
  11463 		var snapshot bytes.Buffer
  11464 		io.Copy(&snapshot, ringBuffer)
  11465 		return &smithy.DeserializationError{
  11466 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11467 			Snapshot: snapshot.Bytes(),
  11468 		}
  11469 	}
  11470 
  11471 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11472 	t, err = decoder.GetElement("Error")
  11473 	if err != nil {
  11474 		var snapshot bytes.Buffer
  11475 		io.Copy(&snapshot, ringBuffer)
  11476 		return &smithy.DeserializationError{
  11477 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11478 			Snapshot: snapshot.Bytes(),
  11479 		}
  11480 	}
  11481 
  11482 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11483 	err = awsRestxml_deserializeDocumentCidrCollectionAlreadyExistsException(&output, decoder)
  11484 	if err != nil {
  11485 		var snapshot bytes.Buffer
  11486 		io.Copy(&snapshot, ringBuffer)
  11487 		return &smithy.DeserializationError{
  11488 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11489 			Snapshot: snapshot.Bytes(),
  11490 		}
  11491 	}
  11492 
  11493 	return output
  11494 }
  11495 
  11496 func awsRestxml_deserializeErrorCidrCollectionInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11497 	output := &types.CidrCollectionInUseException{}
  11498 	var buff [1024]byte
  11499 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11500 	body := io.TeeReader(errorBody, ringBuffer)
  11501 	rootDecoder := xml.NewDecoder(body)
  11502 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11503 	if err == io.EOF {
  11504 		return output
  11505 	}
  11506 	if err != nil {
  11507 		var snapshot bytes.Buffer
  11508 		io.Copy(&snapshot, ringBuffer)
  11509 		return &smithy.DeserializationError{
  11510 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11511 			Snapshot: snapshot.Bytes(),
  11512 		}
  11513 	}
  11514 
  11515 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11516 	t, err = decoder.GetElement("Error")
  11517 	if err != nil {
  11518 		var snapshot bytes.Buffer
  11519 		io.Copy(&snapshot, ringBuffer)
  11520 		return &smithy.DeserializationError{
  11521 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11522 			Snapshot: snapshot.Bytes(),
  11523 		}
  11524 	}
  11525 
  11526 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11527 	err = awsRestxml_deserializeDocumentCidrCollectionInUseException(&output, decoder)
  11528 	if err != nil {
  11529 		var snapshot bytes.Buffer
  11530 		io.Copy(&snapshot, ringBuffer)
  11531 		return &smithy.DeserializationError{
  11532 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11533 			Snapshot: snapshot.Bytes(),
  11534 		}
  11535 	}
  11536 
  11537 	return output
  11538 }
  11539 
  11540 func awsRestxml_deserializeErrorCidrCollectionVersionMismatchException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11541 	output := &types.CidrCollectionVersionMismatchException{}
  11542 	var buff [1024]byte
  11543 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11544 	body := io.TeeReader(errorBody, ringBuffer)
  11545 	rootDecoder := xml.NewDecoder(body)
  11546 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11547 	if err == io.EOF {
  11548 		return output
  11549 	}
  11550 	if err != nil {
  11551 		var snapshot bytes.Buffer
  11552 		io.Copy(&snapshot, ringBuffer)
  11553 		return &smithy.DeserializationError{
  11554 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11555 			Snapshot: snapshot.Bytes(),
  11556 		}
  11557 	}
  11558 
  11559 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11560 	t, err = decoder.GetElement("Error")
  11561 	if err != nil {
  11562 		var snapshot bytes.Buffer
  11563 		io.Copy(&snapshot, ringBuffer)
  11564 		return &smithy.DeserializationError{
  11565 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11566 			Snapshot: snapshot.Bytes(),
  11567 		}
  11568 	}
  11569 
  11570 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11571 	err = awsRestxml_deserializeDocumentCidrCollectionVersionMismatchException(&output, decoder)
  11572 	if err != nil {
  11573 		var snapshot bytes.Buffer
  11574 		io.Copy(&snapshot, ringBuffer)
  11575 		return &smithy.DeserializationError{
  11576 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11577 			Snapshot: snapshot.Bytes(),
  11578 		}
  11579 	}
  11580 
  11581 	return output
  11582 }
  11583 
  11584 func awsRestxml_deserializeErrorConcurrentModification(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11585 	output := &types.ConcurrentModification{}
  11586 	var buff [1024]byte
  11587 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11588 	body := io.TeeReader(errorBody, ringBuffer)
  11589 	rootDecoder := xml.NewDecoder(body)
  11590 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11591 	if err == io.EOF {
  11592 		return output
  11593 	}
  11594 	if err != nil {
  11595 		var snapshot bytes.Buffer
  11596 		io.Copy(&snapshot, ringBuffer)
  11597 		return &smithy.DeserializationError{
  11598 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11599 			Snapshot: snapshot.Bytes(),
  11600 		}
  11601 	}
  11602 
  11603 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11604 	t, err = decoder.GetElement("Error")
  11605 	if err != nil {
  11606 		var snapshot bytes.Buffer
  11607 		io.Copy(&snapshot, ringBuffer)
  11608 		return &smithy.DeserializationError{
  11609 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11610 			Snapshot: snapshot.Bytes(),
  11611 		}
  11612 	}
  11613 
  11614 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11615 	err = awsRestxml_deserializeDocumentConcurrentModification(&output, decoder)
  11616 	if err != nil {
  11617 		var snapshot bytes.Buffer
  11618 		io.Copy(&snapshot, ringBuffer)
  11619 		return &smithy.DeserializationError{
  11620 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11621 			Snapshot: snapshot.Bytes(),
  11622 		}
  11623 	}
  11624 
  11625 	return output
  11626 }
  11627 
  11628 func awsRestxml_deserializeErrorConflictingDomainExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11629 	output := &types.ConflictingDomainExists{}
  11630 	var buff [1024]byte
  11631 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11632 	body := io.TeeReader(errorBody, ringBuffer)
  11633 	rootDecoder := xml.NewDecoder(body)
  11634 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11635 	if err == io.EOF {
  11636 		return output
  11637 	}
  11638 	if err != nil {
  11639 		var snapshot bytes.Buffer
  11640 		io.Copy(&snapshot, ringBuffer)
  11641 		return &smithy.DeserializationError{
  11642 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11643 			Snapshot: snapshot.Bytes(),
  11644 		}
  11645 	}
  11646 
  11647 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11648 	t, err = decoder.GetElement("Error")
  11649 	if err != nil {
  11650 		var snapshot bytes.Buffer
  11651 		io.Copy(&snapshot, ringBuffer)
  11652 		return &smithy.DeserializationError{
  11653 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11654 			Snapshot: snapshot.Bytes(),
  11655 		}
  11656 	}
  11657 
  11658 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11659 	err = awsRestxml_deserializeDocumentConflictingDomainExists(&output, decoder)
  11660 	if err != nil {
  11661 		var snapshot bytes.Buffer
  11662 		io.Copy(&snapshot, ringBuffer)
  11663 		return &smithy.DeserializationError{
  11664 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11665 			Snapshot: snapshot.Bytes(),
  11666 		}
  11667 	}
  11668 
  11669 	return output
  11670 }
  11671 
  11672 func awsRestxml_deserializeErrorConflictingTypes(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11673 	output := &types.ConflictingTypes{}
  11674 	var buff [1024]byte
  11675 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11676 	body := io.TeeReader(errorBody, ringBuffer)
  11677 	rootDecoder := xml.NewDecoder(body)
  11678 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11679 	if err == io.EOF {
  11680 		return output
  11681 	}
  11682 	if err != nil {
  11683 		var snapshot bytes.Buffer
  11684 		io.Copy(&snapshot, ringBuffer)
  11685 		return &smithy.DeserializationError{
  11686 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11687 			Snapshot: snapshot.Bytes(),
  11688 		}
  11689 	}
  11690 
  11691 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11692 	t, err = decoder.GetElement("Error")
  11693 	if err != nil {
  11694 		var snapshot bytes.Buffer
  11695 		io.Copy(&snapshot, ringBuffer)
  11696 		return &smithy.DeserializationError{
  11697 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11698 			Snapshot: snapshot.Bytes(),
  11699 		}
  11700 	}
  11701 
  11702 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11703 	err = awsRestxml_deserializeDocumentConflictingTypes(&output, decoder)
  11704 	if err != nil {
  11705 		var snapshot bytes.Buffer
  11706 		io.Copy(&snapshot, ringBuffer)
  11707 		return &smithy.DeserializationError{
  11708 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11709 			Snapshot: snapshot.Bytes(),
  11710 		}
  11711 	}
  11712 
  11713 	return output
  11714 }
  11715 
  11716 func awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11717 	output := &types.DelegationSetAlreadyCreated{}
  11718 	var buff [1024]byte
  11719 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11720 	body := io.TeeReader(errorBody, ringBuffer)
  11721 	rootDecoder := xml.NewDecoder(body)
  11722 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11723 	if err == io.EOF {
  11724 		return output
  11725 	}
  11726 	if err != nil {
  11727 		var snapshot bytes.Buffer
  11728 		io.Copy(&snapshot, ringBuffer)
  11729 		return &smithy.DeserializationError{
  11730 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11731 			Snapshot: snapshot.Bytes(),
  11732 		}
  11733 	}
  11734 
  11735 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11736 	t, err = decoder.GetElement("Error")
  11737 	if err != nil {
  11738 		var snapshot bytes.Buffer
  11739 		io.Copy(&snapshot, ringBuffer)
  11740 		return &smithy.DeserializationError{
  11741 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11742 			Snapshot: snapshot.Bytes(),
  11743 		}
  11744 	}
  11745 
  11746 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11747 	err = awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(&output, decoder)
  11748 	if err != nil {
  11749 		var snapshot bytes.Buffer
  11750 		io.Copy(&snapshot, ringBuffer)
  11751 		return &smithy.DeserializationError{
  11752 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11753 			Snapshot: snapshot.Bytes(),
  11754 		}
  11755 	}
  11756 
  11757 	return output
  11758 }
  11759 
  11760 func awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11761 	output := &types.DelegationSetAlreadyReusable{}
  11762 	var buff [1024]byte
  11763 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11764 	body := io.TeeReader(errorBody, ringBuffer)
  11765 	rootDecoder := xml.NewDecoder(body)
  11766 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11767 	if err == io.EOF {
  11768 		return output
  11769 	}
  11770 	if err != nil {
  11771 		var snapshot bytes.Buffer
  11772 		io.Copy(&snapshot, ringBuffer)
  11773 		return &smithy.DeserializationError{
  11774 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11775 			Snapshot: snapshot.Bytes(),
  11776 		}
  11777 	}
  11778 
  11779 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11780 	t, err = decoder.GetElement("Error")
  11781 	if err != nil {
  11782 		var snapshot bytes.Buffer
  11783 		io.Copy(&snapshot, ringBuffer)
  11784 		return &smithy.DeserializationError{
  11785 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11786 			Snapshot: snapshot.Bytes(),
  11787 		}
  11788 	}
  11789 
  11790 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11791 	err = awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(&output, decoder)
  11792 	if err != nil {
  11793 		var snapshot bytes.Buffer
  11794 		io.Copy(&snapshot, ringBuffer)
  11795 		return &smithy.DeserializationError{
  11796 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11797 			Snapshot: snapshot.Bytes(),
  11798 		}
  11799 	}
  11800 
  11801 	return output
  11802 }
  11803 
  11804 func awsRestxml_deserializeErrorDelegationSetInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11805 	output := &types.DelegationSetInUse{}
  11806 	var buff [1024]byte
  11807 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11808 	body := io.TeeReader(errorBody, ringBuffer)
  11809 	rootDecoder := xml.NewDecoder(body)
  11810 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11811 	if err == io.EOF {
  11812 		return output
  11813 	}
  11814 	if err != nil {
  11815 		var snapshot bytes.Buffer
  11816 		io.Copy(&snapshot, ringBuffer)
  11817 		return &smithy.DeserializationError{
  11818 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11819 			Snapshot: snapshot.Bytes(),
  11820 		}
  11821 	}
  11822 
  11823 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11824 	t, err = decoder.GetElement("Error")
  11825 	if err != nil {
  11826 		var snapshot bytes.Buffer
  11827 		io.Copy(&snapshot, ringBuffer)
  11828 		return &smithy.DeserializationError{
  11829 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11830 			Snapshot: snapshot.Bytes(),
  11831 		}
  11832 	}
  11833 
  11834 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11835 	err = awsRestxml_deserializeDocumentDelegationSetInUse(&output, decoder)
  11836 	if err != nil {
  11837 		var snapshot bytes.Buffer
  11838 		io.Copy(&snapshot, ringBuffer)
  11839 		return &smithy.DeserializationError{
  11840 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11841 			Snapshot: snapshot.Bytes(),
  11842 		}
  11843 	}
  11844 
  11845 	return output
  11846 }
  11847 
  11848 func awsRestxml_deserializeErrorDelegationSetNotAvailable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11849 	output := &types.DelegationSetNotAvailable{}
  11850 	var buff [1024]byte
  11851 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11852 	body := io.TeeReader(errorBody, ringBuffer)
  11853 	rootDecoder := xml.NewDecoder(body)
  11854 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11855 	if err == io.EOF {
  11856 		return output
  11857 	}
  11858 	if err != nil {
  11859 		var snapshot bytes.Buffer
  11860 		io.Copy(&snapshot, ringBuffer)
  11861 		return &smithy.DeserializationError{
  11862 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11863 			Snapshot: snapshot.Bytes(),
  11864 		}
  11865 	}
  11866 
  11867 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11868 	t, err = decoder.GetElement("Error")
  11869 	if err != nil {
  11870 		var snapshot bytes.Buffer
  11871 		io.Copy(&snapshot, ringBuffer)
  11872 		return &smithy.DeserializationError{
  11873 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11874 			Snapshot: snapshot.Bytes(),
  11875 		}
  11876 	}
  11877 
  11878 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11879 	err = awsRestxml_deserializeDocumentDelegationSetNotAvailable(&output, decoder)
  11880 	if err != nil {
  11881 		var snapshot bytes.Buffer
  11882 		io.Copy(&snapshot, ringBuffer)
  11883 		return &smithy.DeserializationError{
  11884 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11885 			Snapshot: snapshot.Bytes(),
  11886 		}
  11887 	}
  11888 
  11889 	return output
  11890 }
  11891 
  11892 func awsRestxml_deserializeErrorDelegationSetNotReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11893 	output := &types.DelegationSetNotReusable{}
  11894 	var buff [1024]byte
  11895 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11896 	body := io.TeeReader(errorBody, ringBuffer)
  11897 	rootDecoder := xml.NewDecoder(body)
  11898 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11899 	if err == io.EOF {
  11900 		return output
  11901 	}
  11902 	if err != nil {
  11903 		var snapshot bytes.Buffer
  11904 		io.Copy(&snapshot, ringBuffer)
  11905 		return &smithy.DeserializationError{
  11906 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11907 			Snapshot: snapshot.Bytes(),
  11908 		}
  11909 	}
  11910 
  11911 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11912 	t, err = decoder.GetElement("Error")
  11913 	if err != nil {
  11914 		var snapshot bytes.Buffer
  11915 		io.Copy(&snapshot, ringBuffer)
  11916 		return &smithy.DeserializationError{
  11917 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11918 			Snapshot: snapshot.Bytes(),
  11919 		}
  11920 	}
  11921 
  11922 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11923 	err = awsRestxml_deserializeDocumentDelegationSetNotReusable(&output, decoder)
  11924 	if err != nil {
  11925 		var snapshot bytes.Buffer
  11926 		io.Copy(&snapshot, ringBuffer)
  11927 		return &smithy.DeserializationError{
  11928 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11929 			Snapshot: snapshot.Bytes(),
  11930 		}
  11931 	}
  11932 
  11933 	return output
  11934 }
  11935 
  11936 func awsRestxml_deserializeErrorDNSSECNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11937 	output := &types.DNSSECNotFound{}
  11938 	var buff [1024]byte
  11939 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11940 	body := io.TeeReader(errorBody, ringBuffer)
  11941 	rootDecoder := xml.NewDecoder(body)
  11942 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11943 	if err == io.EOF {
  11944 		return output
  11945 	}
  11946 	if err != nil {
  11947 		var snapshot bytes.Buffer
  11948 		io.Copy(&snapshot, ringBuffer)
  11949 		return &smithy.DeserializationError{
  11950 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11951 			Snapshot: snapshot.Bytes(),
  11952 		}
  11953 	}
  11954 
  11955 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11956 	t, err = decoder.GetElement("Error")
  11957 	if err != nil {
  11958 		var snapshot bytes.Buffer
  11959 		io.Copy(&snapshot, ringBuffer)
  11960 		return &smithy.DeserializationError{
  11961 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11962 			Snapshot: snapshot.Bytes(),
  11963 		}
  11964 	}
  11965 
  11966 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11967 	err = awsRestxml_deserializeDocumentDNSSECNotFound(&output, decoder)
  11968 	if err != nil {
  11969 		var snapshot bytes.Buffer
  11970 		io.Copy(&snapshot, ringBuffer)
  11971 		return &smithy.DeserializationError{
  11972 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11973 			Snapshot: snapshot.Bytes(),
  11974 		}
  11975 	}
  11976 
  11977 	return output
  11978 }
  11979 
  11980 func awsRestxml_deserializeErrorHealthCheckAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11981 	output := &types.HealthCheckAlreadyExists{}
  11982 	var buff [1024]byte
  11983 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11984 	body := io.TeeReader(errorBody, ringBuffer)
  11985 	rootDecoder := xml.NewDecoder(body)
  11986 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11987 	if err == io.EOF {
  11988 		return output
  11989 	}
  11990 	if err != nil {
  11991 		var snapshot bytes.Buffer
  11992 		io.Copy(&snapshot, ringBuffer)
  11993 		return &smithy.DeserializationError{
  11994 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11995 			Snapshot: snapshot.Bytes(),
  11996 		}
  11997 	}
  11998 
  11999 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12000 	t, err = decoder.GetElement("Error")
  12001 	if err != nil {
  12002 		var snapshot bytes.Buffer
  12003 		io.Copy(&snapshot, ringBuffer)
  12004 		return &smithy.DeserializationError{
  12005 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12006 			Snapshot: snapshot.Bytes(),
  12007 		}
  12008 	}
  12009 
  12010 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12011 	err = awsRestxml_deserializeDocumentHealthCheckAlreadyExists(&output, decoder)
  12012 	if err != nil {
  12013 		var snapshot bytes.Buffer
  12014 		io.Copy(&snapshot, ringBuffer)
  12015 		return &smithy.DeserializationError{
  12016 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12017 			Snapshot: snapshot.Bytes(),
  12018 		}
  12019 	}
  12020 
  12021 	return output
  12022 }
  12023 
  12024 func awsRestxml_deserializeErrorHealthCheckInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12025 	output := &types.HealthCheckInUse{}
  12026 	var buff [1024]byte
  12027 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12028 	body := io.TeeReader(errorBody, ringBuffer)
  12029 	rootDecoder := xml.NewDecoder(body)
  12030 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12031 	if err == io.EOF {
  12032 		return output
  12033 	}
  12034 	if err != nil {
  12035 		var snapshot bytes.Buffer
  12036 		io.Copy(&snapshot, ringBuffer)
  12037 		return &smithy.DeserializationError{
  12038 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12039 			Snapshot: snapshot.Bytes(),
  12040 		}
  12041 	}
  12042 
  12043 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12044 	t, err = decoder.GetElement("Error")
  12045 	if err != nil {
  12046 		var snapshot bytes.Buffer
  12047 		io.Copy(&snapshot, ringBuffer)
  12048 		return &smithy.DeserializationError{
  12049 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12050 			Snapshot: snapshot.Bytes(),
  12051 		}
  12052 	}
  12053 
  12054 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12055 	err = awsRestxml_deserializeDocumentHealthCheckInUse(&output, decoder)
  12056 	if err != nil {
  12057 		var snapshot bytes.Buffer
  12058 		io.Copy(&snapshot, ringBuffer)
  12059 		return &smithy.DeserializationError{
  12060 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12061 			Snapshot: snapshot.Bytes(),
  12062 		}
  12063 	}
  12064 
  12065 	return output
  12066 }
  12067 
  12068 func awsRestxml_deserializeErrorHealthCheckVersionMismatch(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12069 	output := &types.HealthCheckVersionMismatch{}
  12070 	var buff [1024]byte
  12071 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12072 	body := io.TeeReader(errorBody, ringBuffer)
  12073 	rootDecoder := xml.NewDecoder(body)
  12074 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12075 	if err == io.EOF {
  12076 		return output
  12077 	}
  12078 	if err != nil {
  12079 		var snapshot bytes.Buffer
  12080 		io.Copy(&snapshot, ringBuffer)
  12081 		return &smithy.DeserializationError{
  12082 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12083 			Snapshot: snapshot.Bytes(),
  12084 		}
  12085 	}
  12086 
  12087 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12088 	t, err = decoder.GetElement("Error")
  12089 	if err != nil {
  12090 		var snapshot bytes.Buffer
  12091 		io.Copy(&snapshot, ringBuffer)
  12092 		return &smithy.DeserializationError{
  12093 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12094 			Snapshot: snapshot.Bytes(),
  12095 		}
  12096 	}
  12097 
  12098 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12099 	err = awsRestxml_deserializeDocumentHealthCheckVersionMismatch(&output, decoder)
  12100 	if err != nil {
  12101 		var snapshot bytes.Buffer
  12102 		io.Copy(&snapshot, ringBuffer)
  12103 		return &smithy.DeserializationError{
  12104 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12105 			Snapshot: snapshot.Bytes(),
  12106 		}
  12107 	}
  12108 
  12109 	return output
  12110 }
  12111 
  12112 func awsRestxml_deserializeErrorHostedZoneAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12113 	output := &types.HostedZoneAlreadyExists{}
  12114 	var buff [1024]byte
  12115 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12116 	body := io.TeeReader(errorBody, ringBuffer)
  12117 	rootDecoder := xml.NewDecoder(body)
  12118 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12119 	if err == io.EOF {
  12120 		return output
  12121 	}
  12122 	if err != nil {
  12123 		var snapshot bytes.Buffer
  12124 		io.Copy(&snapshot, ringBuffer)
  12125 		return &smithy.DeserializationError{
  12126 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12127 			Snapshot: snapshot.Bytes(),
  12128 		}
  12129 	}
  12130 
  12131 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12132 	t, err = decoder.GetElement("Error")
  12133 	if err != nil {
  12134 		var snapshot bytes.Buffer
  12135 		io.Copy(&snapshot, ringBuffer)
  12136 		return &smithy.DeserializationError{
  12137 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12138 			Snapshot: snapshot.Bytes(),
  12139 		}
  12140 	}
  12141 
  12142 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12143 	err = awsRestxml_deserializeDocumentHostedZoneAlreadyExists(&output, decoder)
  12144 	if err != nil {
  12145 		var snapshot bytes.Buffer
  12146 		io.Copy(&snapshot, ringBuffer)
  12147 		return &smithy.DeserializationError{
  12148 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12149 			Snapshot: snapshot.Bytes(),
  12150 		}
  12151 	}
  12152 
  12153 	return output
  12154 }
  12155 
  12156 func awsRestxml_deserializeErrorHostedZoneNotEmpty(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12157 	output := &types.HostedZoneNotEmpty{}
  12158 	var buff [1024]byte
  12159 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12160 	body := io.TeeReader(errorBody, ringBuffer)
  12161 	rootDecoder := xml.NewDecoder(body)
  12162 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12163 	if err == io.EOF {
  12164 		return output
  12165 	}
  12166 	if err != nil {
  12167 		var snapshot bytes.Buffer
  12168 		io.Copy(&snapshot, ringBuffer)
  12169 		return &smithy.DeserializationError{
  12170 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12171 			Snapshot: snapshot.Bytes(),
  12172 		}
  12173 	}
  12174 
  12175 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12176 	t, err = decoder.GetElement("Error")
  12177 	if err != nil {
  12178 		var snapshot bytes.Buffer
  12179 		io.Copy(&snapshot, ringBuffer)
  12180 		return &smithy.DeserializationError{
  12181 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12182 			Snapshot: snapshot.Bytes(),
  12183 		}
  12184 	}
  12185 
  12186 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12187 	err = awsRestxml_deserializeDocumentHostedZoneNotEmpty(&output, decoder)
  12188 	if err != nil {
  12189 		var snapshot bytes.Buffer
  12190 		io.Copy(&snapshot, ringBuffer)
  12191 		return &smithy.DeserializationError{
  12192 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12193 			Snapshot: snapshot.Bytes(),
  12194 		}
  12195 	}
  12196 
  12197 	return output
  12198 }
  12199 
  12200 func awsRestxml_deserializeErrorHostedZoneNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12201 	output := &types.HostedZoneNotFound{}
  12202 	var buff [1024]byte
  12203 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12204 	body := io.TeeReader(errorBody, ringBuffer)
  12205 	rootDecoder := xml.NewDecoder(body)
  12206 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12207 	if err == io.EOF {
  12208 		return output
  12209 	}
  12210 	if err != nil {
  12211 		var snapshot bytes.Buffer
  12212 		io.Copy(&snapshot, ringBuffer)
  12213 		return &smithy.DeserializationError{
  12214 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12215 			Snapshot: snapshot.Bytes(),
  12216 		}
  12217 	}
  12218 
  12219 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12220 	t, err = decoder.GetElement("Error")
  12221 	if err != nil {
  12222 		var snapshot bytes.Buffer
  12223 		io.Copy(&snapshot, ringBuffer)
  12224 		return &smithy.DeserializationError{
  12225 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12226 			Snapshot: snapshot.Bytes(),
  12227 		}
  12228 	}
  12229 
  12230 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12231 	err = awsRestxml_deserializeDocumentHostedZoneNotFound(&output, decoder)
  12232 	if err != nil {
  12233 		var snapshot bytes.Buffer
  12234 		io.Copy(&snapshot, ringBuffer)
  12235 		return &smithy.DeserializationError{
  12236 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12237 			Snapshot: snapshot.Bytes(),
  12238 		}
  12239 	}
  12240 
  12241 	return output
  12242 }
  12243 
  12244 func awsRestxml_deserializeErrorHostedZoneNotPrivate(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12245 	output := &types.HostedZoneNotPrivate{}
  12246 	var buff [1024]byte
  12247 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12248 	body := io.TeeReader(errorBody, ringBuffer)
  12249 	rootDecoder := xml.NewDecoder(body)
  12250 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12251 	if err == io.EOF {
  12252 		return output
  12253 	}
  12254 	if err != nil {
  12255 		var snapshot bytes.Buffer
  12256 		io.Copy(&snapshot, ringBuffer)
  12257 		return &smithy.DeserializationError{
  12258 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12259 			Snapshot: snapshot.Bytes(),
  12260 		}
  12261 	}
  12262 
  12263 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12264 	t, err = decoder.GetElement("Error")
  12265 	if err != nil {
  12266 		var snapshot bytes.Buffer
  12267 		io.Copy(&snapshot, ringBuffer)
  12268 		return &smithy.DeserializationError{
  12269 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12270 			Snapshot: snapshot.Bytes(),
  12271 		}
  12272 	}
  12273 
  12274 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12275 	err = awsRestxml_deserializeDocumentHostedZoneNotPrivate(&output, decoder)
  12276 	if err != nil {
  12277 		var snapshot bytes.Buffer
  12278 		io.Copy(&snapshot, ringBuffer)
  12279 		return &smithy.DeserializationError{
  12280 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12281 			Snapshot: snapshot.Bytes(),
  12282 		}
  12283 	}
  12284 
  12285 	return output
  12286 }
  12287 
  12288 func awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12289 	output := &types.HostedZonePartiallyDelegated{}
  12290 	var buff [1024]byte
  12291 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12292 	body := io.TeeReader(errorBody, ringBuffer)
  12293 	rootDecoder := xml.NewDecoder(body)
  12294 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12295 	if err == io.EOF {
  12296 		return output
  12297 	}
  12298 	if err != nil {
  12299 		var snapshot bytes.Buffer
  12300 		io.Copy(&snapshot, ringBuffer)
  12301 		return &smithy.DeserializationError{
  12302 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12303 			Snapshot: snapshot.Bytes(),
  12304 		}
  12305 	}
  12306 
  12307 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12308 	t, err = decoder.GetElement("Error")
  12309 	if err != nil {
  12310 		var snapshot bytes.Buffer
  12311 		io.Copy(&snapshot, ringBuffer)
  12312 		return &smithy.DeserializationError{
  12313 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12314 			Snapshot: snapshot.Bytes(),
  12315 		}
  12316 	}
  12317 
  12318 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12319 	err = awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(&output, decoder)
  12320 	if err != nil {
  12321 		var snapshot bytes.Buffer
  12322 		io.Copy(&snapshot, ringBuffer)
  12323 		return &smithy.DeserializationError{
  12324 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12325 			Snapshot: snapshot.Bytes(),
  12326 		}
  12327 	}
  12328 
  12329 	return output
  12330 }
  12331 
  12332 func awsRestxml_deserializeErrorIncompatibleVersion(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12333 	output := &types.IncompatibleVersion{}
  12334 	var buff [1024]byte
  12335 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12336 	body := io.TeeReader(errorBody, ringBuffer)
  12337 	rootDecoder := xml.NewDecoder(body)
  12338 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12339 	if err == io.EOF {
  12340 		return output
  12341 	}
  12342 	if err != nil {
  12343 		var snapshot bytes.Buffer
  12344 		io.Copy(&snapshot, ringBuffer)
  12345 		return &smithy.DeserializationError{
  12346 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12347 			Snapshot: snapshot.Bytes(),
  12348 		}
  12349 	}
  12350 
  12351 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12352 	t, err = decoder.GetElement("Error")
  12353 	if err != nil {
  12354 		var snapshot bytes.Buffer
  12355 		io.Copy(&snapshot, ringBuffer)
  12356 		return &smithy.DeserializationError{
  12357 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12358 			Snapshot: snapshot.Bytes(),
  12359 		}
  12360 	}
  12361 
  12362 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12363 	err = awsRestxml_deserializeDocumentIncompatibleVersion(&output, decoder)
  12364 	if err != nil {
  12365 		var snapshot bytes.Buffer
  12366 		io.Copy(&snapshot, ringBuffer)
  12367 		return &smithy.DeserializationError{
  12368 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12369 			Snapshot: snapshot.Bytes(),
  12370 		}
  12371 	}
  12372 
  12373 	return output
  12374 }
  12375 
  12376 func awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12377 	output := &types.InsufficientCloudWatchLogsResourcePolicy{}
  12378 	var buff [1024]byte
  12379 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12380 	body := io.TeeReader(errorBody, ringBuffer)
  12381 	rootDecoder := xml.NewDecoder(body)
  12382 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12383 	if err == io.EOF {
  12384 		return output
  12385 	}
  12386 	if err != nil {
  12387 		var snapshot bytes.Buffer
  12388 		io.Copy(&snapshot, ringBuffer)
  12389 		return &smithy.DeserializationError{
  12390 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12391 			Snapshot: snapshot.Bytes(),
  12392 		}
  12393 	}
  12394 
  12395 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12396 	t, err = decoder.GetElement("Error")
  12397 	if err != nil {
  12398 		var snapshot bytes.Buffer
  12399 		io.Copy(&snapshot, ringBuffer)
  12400 		return &smithy.DeserializationError{
  12401 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12402 			Snapshot: snapshot.Bytes(),
  12403 		}
  12404 	}
  12405 
  12406 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12407 	err = awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(&output, decoder)
  12408 	if err != nil {
  12409 		var snapshot bytes.Buffer
  12410 		io.Copy(&snapshot, ringBuffer)
  12411 		return &smithy.DeserializationError{
  12412 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12413 			Snapshot: snapshot.Bytes(),
  12414 		}
  12415 	}
  12416 
  12417 	return output
  12418 }
  12419 
  12420 func awsRestxml_deserializeErrorInvalidArgument(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12421 	output := &types.InvalidArgument{}
  12422 	var buff [1024]byte
  12423 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12424 	body := io.TeeReader(errorBody, ringBuffer)
  12425 	rootDecoder := xml.NewDecoder(body)
  12426 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12427 	if err == io.EOF {
  12428 		return output
  12429 	}
  12430 	if err != nil {
  12431 		var snapshot bytes.Buffer
  12432 		io.Copy(&snapshot, ringBuffer)
  12433 		return &smithy.DeserializationError{
  12434 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12435 			Snapshot: snapshot.Bytes(),
  12436 		}
  12437 	}
  12438 
  12439 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12440 	t, err = decoder.GetElement("Error")
  12441 	if err != nil {
  12442 		var snapshot bytes.Buffer
  12443 		io.Copy(&snapshot, ringBuffer)
  12444 		return &smithy.DeserializationError{
  12445 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12446 			Snapshot: snapshot.Bytes(),
  12447 		}
  12448 	}
  12449 
  12450 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12451 	err = awsRestxml_deserializeDocumentInvalidArgument(&output, decoder)
  12452 	if err != nil {
  12453 		var snapshot bytes.Buffer
  12454 		io.Copy(&snapshot, ringBuffer)
  12455 		return &smithy.DeserializationError{
  12456 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12457 			Snapshot: snapshot.Bytes(),
  12458 		}
  12459 	}
  12460 
  12461 	return output
  12462 }
  12463 
  12464 func awsRestxml_deserializeErrorInvalidChangeBatch(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12465 	output := &types.InvalidChangeBatch{}
  12466 	var buff [1024]byte
  12467 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12468 	body := io.TeeReader(errorBody, ringBuffer)
  12469 	rootDecoder := xml.NewDecoder(body)
  12470 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12471 	if err == io.EOF {
  12472 		return output
  12473 	}
  12474 	if err != nil {
  12475 		var snapshot bytes.Buffer
  12476 		io.Copy(&snapshot, ringBuffer)
  12477 		return &smithy.DeserializationError{
  12478 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12479 			Snapshot: snapshot.Bytes(),
  12480 		}
  12481 	}
  12482 
  12483 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12484 	t, err = decoder.GetElement("Error")
  12485 	if err != nil {
  12486 		var snapshot bytes.Buffer
  12487 		io.Copy(&snapshot, ringBuffer)
  12488 		return &smithy.DeserializationError{
  12489 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12490 			Snapshot: snapshot.Bytes(),
  12491 		}
  12492 	}
  12493 
  12494 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12495 	err = awsRestxml_deserializeDocumentInvalidChangeBatch(&output, decoder)
  12496 	if err != nil {
  12497 		var snapshot bytes.Buffer
  12498 		io.Copy(&snapshot, ringBuffer)
  12499 		return &smithy.DeserializationError{
  12500 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12501 			Snapshot: snapshot.Bytes(),
  12502 		}
  12503 	}
  12504 
  12505 	return output
  12506 }
  12507 
  12508 func awsRestxml_deserializeErrorInvalidDomainName(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12509 	output := &types.InvalidDomainName{}
  12510 	var buff [1024]byte
  12511 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12512 	body := io.TeeReader(errorBody, ringBuffer)
  12513 	rootDecoder := xml.NewDecoder(body)
  12514 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12515 	if err == io.EOF {
  12516 		return output
  12517 	}
  12518 	if err != nil {
  12519 		var snapshot bytes.Buffer
  12520 		io.Copy(&snapshot, ringBuffer)
  12521 		return &smithy.DeserializationError{
  12522 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12523 			Snapshot: snapshot.Bytes(),
  12524 		}
  12525 	}
  12526 
  12527 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12528 	t, err = decoder.GetElement("Error")
  12529 	if err != nil {
  12530 		var snapshot bytes.Buffer
  12531 		io.Copy(&snapshot, ringBuffer)
  12532 		return &smithy.DeserializationError{
  12533 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12534 			Snapshot: snapshot.Bytes(),
  12535 		}
  12536 	}
  12537 
  12538 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12539 	err = awsRestxml_deserializeDocumentInvalidDomainName(&output, decoder)
  12540 	if err != nil {
  12541 		var snapshot bytes.Buffer
  12542 		io.Copy(&snapshot, ringBuffer)
  12543 		return &smithy.DeserializationError{
  12544 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12545 			Snapshot: snapshot.Bytes(),
  12546 		}
  12547 	}
  12548 
  12549 	return output
  12550 }
  12551 
  12552 func awsRestxml_deserializeErrorInvalidInput(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12553 	output := &types.InvalidInput{}
  12554 	var buff [1024]byte
  12555 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12556 	body := io.TeeReader(errorBody, ringBuffer)
  12557 	rootDecoder := xml.NewDecoder(body)
  12558 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12559 	if err == io.EOF {
  12560 		return output
  12561 	}
  12562 	if err != nil {
  12563 		var snapshot bytes.Buffer
  12564 		io.Copy(&snapshot, ringBuffer)
  12565 		return &smithy.DeserializationError{
  12566 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12567 			Snapshot: snapshot.Bytes(),
  12568 		}
  12569 	}
  12570 
  12571 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12572 	t, err = decoder.GetElement("Error")
  12573 	if err != nil {
  12574 		var snapshot bytes.Buffer
  12575 		io.Copy(&snapshot, ringBuffer)
  12576 		return &smithy.DeserializationError{
  12577 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12578 			Snapshot: snapshot.Bytes(),
  12579 		}
  12580 	}
  12581 
  12582 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12583 	err = awsRestxml_deserializeDocumentInvalidInput(&output, decoder)
  12584 	if err != nil {
  12585 		var snapshot bytes.Buffer
  12586 		io.Copy(&snapshot, ringBuffer)
  12587 		return &smithy.DeserializationError{
  12588 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12589 			Snapshot: snapshot.Bytes(),
  12590 		}
  12591 	}
  12592 
  12593 	return output
  12594 }
  12595 
  12596 func awsRestxml_deserializeErrorInvalidKeySigningKeyName(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12597 	output := &types.InvalidKeySigningKeyName{}
  12598 	var buff [1024]byte
  12599 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12600 	body := io.TeeReader(errorBody, ringBuffer)
  12601 	rootDecoder := xml.NewDecoder(body)
  12602 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12603 	if err == io.EOF {
  12604 		return output
  12605 	}
  12606 	if err != nil {
  12607 		var snapshot bytes.Buffer
  12608 		io.Copy(&snapshot, ringBuffer)
  12609 		return &smithy.DeserializationError{
  12610 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12611 			Snapshot: snapshot.Bytes(),
  12612 		}
  12613 	}
  12614 
  12615 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12616 	t, err = decoder.GetElement("Error")
  12617 	if err != nil {
  12618 		var snapshot bytes.Buffer
  12619 		io.Copy(&snapshot, ringBuffer)
  12620 		return &smithy.DeserializationError{
  12621 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12622 			Snapshot: snapshot.Bytes(),
  12623 		}
  12624 	}
  12625 
  12626 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12627 	err = awsRestxml_deserializeDocumentInvalidKeySigningKeyName(&output, decoder)
  12628 	if err != nil {
  12629 		var snapshot bytes.Buffer
  12630 		io.Copy(&snapshot, ringBuffer)
  12631 		return &smithy.DeserializationError{
  12632 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12633 			Snapshot: snapshot.Bytes(),
  12634 		}
  12635 	}
  12636 
  12637 	return output
  12638 }
  12639 
  12640 func awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12641 	output := &types.InvalidKeySigningKeyStatus{}
  12642 	var buff [1024]byte
  12643 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12644 	body := io.TeeReader(errorBody, ringBuffer)
  12645 	rootDecoder := xml.NewDecoder(body)
  12646 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12647 	if err == io.EOF {
  12648 		return output
  12649 	}
  12650 	if err != nil {
  12651 		var snapshot bytes.Buffer
  12652 		io.Copy(&snapshot, ringBuffer)
  12653 		return &smithy.DeserializationError{
  12654 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12655 			Snapshot: snapshot.Bytes(),
  12656 		}
  12657 	}
  12658 
  12659 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12660 	t, err = decoder.GetElement("Error")
  12661 	if err != nil {
  12662 		var snapshot bytes.Buffer
  12663 		io.Copy(&snapshot, ringBuffer)
  12664 		return &smithy.DeserializationError{
  12665 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12666 			Snapshot: snapshot.Bytes(),
  12667 		}
  12668 	}
  12669 
  12670 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12671 	err = awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(&output, decoder)
  12672 	if err != nil {
  12673 		var snapshot bytes.Buffer
  12674 		io.Copy(&snapshot, ringBuffer)
  12675 		return &smithy.DeserializationError{
  12676 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12677 			Snapshot: snapshot.Bytes(),
  12678 		}
  12679 	}
  12680 
  12681 	return output
  12682 }
  12683 
  12684 func awsRestxml_deserializeErrorInvalidKMSArn(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12685 	output := &types.InvalidKMSArn{}
  12686 	var buff [1024]byte
  12687 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12688 	body := io.TeeReader(errorBody, ringBuffer)
  12689 	rootDecoder := xml.NewDecoder(body)
  12690 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12691 	if err == io.EOF {
  12692 		return output
  12693 	}
  12694 	if err != nil {
  12695 		var snapshot bytes.Buffer
  12696 		io.Copy(&snapshot, ringBuffer)
  12697 		return &smithy.DeserializationError{
  12698 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12699 			Snapshot: snapshot.Bytes(),
  12700 		}
  12701 	}
  12702 
  12703 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12704 	t, err = decoder.GetElement("Error")
  12705 	if err != nil {
  12706 		var snapshot bytes.Buffer
  12707 		io.Copy(&snapshot, ringBuffer)
  12708 		return &smithy.DeserializationError{
  12709 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12710 			Snapshot: snapshot.Bytes(),
  12711 		}
  12712 	}
  12713 
  12714 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12715 	err = awsRestxml_deserializeDocumentInvalidKMSArn(&output, decoder)
  12716 	if err != nil {
  12717 		var snapshot bytes.Buffer
  12718 		io.Copy(&snapshot, ringBuffer)
  12719 		return &smithy.DeserializationError{
  12720 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12721 			Snapshot: snapshot.Bytes(),
  12722 		}
  12723 	}
  12724 
  12725 	return output
  12726 }
  12727 
  12728 func awsRestxml_deserializeErrorInvalidPaginationToken(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12729 	output := &types.InvalidPaginationToken{}
  12730 	var buff [1024]byte
  12731 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12732 	body := io.TeeReader(errorBody, ringBuffer)
  12733 	rootDecoder := xml.NewDecoder(body)
  12734 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12735 	if err == io.EOF {
  12736 		return output
  12737 	}
  12738 	if err != nil {
  12739 		var snapshot bytes.Buffer
  12740 		io.Copy(&snapshot, ringBuffer)
  12741 		return &smithy.DeserializationError{
  12742 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12743 			Snapshot: snapshot.Bytes(),
  12744 		}
  12745 	}
  12746 
  12747 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12748 	t, err = decoder.GetElement("Error")
  12749 	if err != nil {
  12750 		var snapshot bytes.Buffer
  12751 		io.Copy(&snapshot, ringBuffer)
  12752 		return &smithy.DeserializationError{
  12753 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12754 			Snapshot: snapshot.Bytes(),
  12755 		}
  12756 	}
  12757 
  12758 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12759 	err = awsRestxml_deserializeDocumentInvalidPaginationToken(&output, decoder)
  12760 	if err != nil {
  12761 		var snapshot bytes.Buffer
  12762 		io.Copy(&snapshot, ringBuffer)
  12763 		return &smithy.DeserializationError{
  12764 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12765 			Snapshot: snapshot.Bytes(),
  12766 		}
  12767 	}
  12768 
  12769 	return output
  12770 }
  12771 
  12772 func awsRestxml_deserializeErrorInvalidSigningStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12773 	output := &types.InvalidSigningStatus{}
  12774 	var buff [1024]byte
  12775 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12776 	body := io.TeeReader(errorBody, ringBuffer)
  12777 	rootDecoder := xml.NewDecoder(body)
  12778 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12779 	if err == io.EOF {
  12780 		return output
  12781 	}
  12782 	if err != nil {
  12783 		var snapshot bytes.Buffer
  12784 		io.Copy(&snapshot, ringBuffer)
  12785 		return &smithy.DeserializationError{
  12786 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12787 			Snapshot: snapshot.Bytes(),
  12788 		}
  12789 	}
  12790 
  12791 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12792 	t, err = decoder.GetElement("Error")
  12793 	if err != nil {
  12794 		var snapshot bytes.Buffer
  12795 		io.Copy(&snapshot, ringBuffer)
  12796 		return &smithy.DeserializationError{
  12797 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12798 			Snapshot: snapshot.Bytes(),
  12799 		}
  12800 	}
  12801 
  12802 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12803 	err = awsRestxml_deserializeDocumentInvalidSigningStatus(&output, decoder)
  12804 	if err != nil {
  12805 		var snapshot bytes.Buffer
  12806 		io.Copy(&snapshot, ringBuffer)
  12807 		return &smithy.DeserializationError{
  12808 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12809 			Snapshot: snapshot.Bytes(),
  12810 		}
  12811 	}
  12812 
  12813 	return output
  12814 }
  12815 
  12816 func awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12817 	output := &types.InvalidTrafficPolicyDocument{}
  12818 	var buff [1024]byte
  12819 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12820 	body := io.TeeReader(errorBody, ringBuffer)
  12821 	rootDecoder := xml.NewDecoder(body)
  12822 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12823 	if err == io.EOF {
  12824 		return output
  12825 	}
  12826 	if err != nil {
  12827 		var snapshot bytes.Buffer
  12828 		io.Copy(&snapshot, ringBuffer)
  12829 		return &smithy.DeserializationError{
  12830 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12831 			Snapshot: snapshot.Bytes(),
  12832 		}
  12833 	}
  12834 
  12835 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12836 	t, err = decoder.GetElement("Error")
  12837 	if err != nil {
  12838 		var snapshot bytes.Buffer
  12839 		io.Copy(&snapshot, ringBuffer)
  12840 		return &smithy.DeserializationError{
  12841 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12842 			Snapshot: snapshot.Bytes(),
  12843 		}
  12844 	}
  12845 
  12846 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12847 	err = awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(&output, decoder)
  12848 	if err != nil {
  12849 		var snapshot bytes.Buffer
  12850 		io.Copy(&snapshot, ringBuffer)
  12851 		return &smithy.DeserializationError{
  12852 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12853 			Snapshot: snapshot.Bytes(),
  12854 		}
  12855 	}
  12856 
  12857 	return output
  12858 }
  12859 
  12860 func awsRestxml_deserializeErrorInvalidVPCId(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12861 	output := &types.InvalidVPCId{}
  12862 	var buff [1024]byte
  12863 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12864 	body := io.TeeReader(errorBody, ringBuffer)
  12865 	rootDecoder := xml.NewDecoder(body)
  12866 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12867 	if err == io.EOF {
  12868 		return output
  12869 	}
  12870 	if err != nil {
  12871 		var snapshot bytes.Buffer
  12872 		io.Copy(&snapshot, ringBuffer)
  12873 		return &smithy.DeserializationError{
  12874 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12875 			Snapshot: snapshot.Bytes(),
  12876 		}
  12877 	}
  12878 
  12879 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12880 	t, err = decoder.GetElement("Error")
  12881 	if err != nil {
  12882 		var snapshot bytes.Buffer
  12883 		io.Copy(&snapshot, ringBuffer)
  12884 		return &smithy.DeserializationError{
  12885 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12886 			Snapshot: snapshot.Bytes(),
  12887 		}
  12888 	}
  12889 
  12890 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12891 	err = awsRestxml_deserializeDocumentInvalidVPCId(&output, decoder)
  12892 	if err != nil {
  12893 		var snapshot bytes.Buffer
  12894 		io.Copy(&snapshot, ringBuffer)
  12895 		return &smithy.DeserializationError{
  12896 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12897 			Snapshot: snapshot.Bytes(),
  12898 		}
  12899 	}
  12900 
  12901 	return output
  12902 }
  12903 
  12904 func awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12905 	output := &types.KeySigningKeyAlreadyExists{}
  12906 	var buff [1024]byte
  12907 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12908 	body := io.TeeReader(errorBody, ringBuffer)
  12909 	rootDecoder := xml.NewDecoder(body)
  12910 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12911 	if err == io.EOF {
  12912 		return output
  12913 	}
  12914 	if err != nil {
  12915 		var snapshot bytes.Buffer
  12916 		io.Copy(&snapshot, ringBuffer)
  12917 		return &smithy.DeserializationError{
  12918 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12919 			Snapshot: snapshot.Bytes(),
  12920 		}
  12921 	}
  12922 
  12923 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12924 	t, err = decoder.GetElement("Error")
  12925 	if err != nil {
  12926 		var snapshot bytes.Buffer
  12927 		io.Copy(&snapshot, ringBuffer)
  12928 		return &smithy.DeserializationError{
  12929 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12930 			Snapshot: snapshot.Bytes(),
  12931 		}
  12932 	}
  12933 
  12934 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12935 	err = awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(&output, decoder)
  12936 	if err != nil {
  12937 		var snapshot bytes.Buffer
  12938 		io.Copy(&snapshot, ringBuffer)
  12939 		return &smithy.DeserializationError{
  12940 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12941 			Snapshot: snapshot.Bytes(),
  12942 		}
  12943 	}
  12944 
  12945 	return output
  12946 }
  12947 
  12948 func awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12949 	output := &types.KeySigningKeyInParentDSRecord{}
  12950 	var buff [1024]byte
  12951 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12952 	body := io.TeeReader(errorBody, ringBuffer)
  12953 	rootDecoder := xml.NewDecoder(body)
  12954 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12955 	if err == io.EOF {
  12956 		return output
  12957 	}
  12958 	if err != nil {
  12959 		var snapshot bytes.Buffer
  12960 		io.Copy(&snapshot, ringBuffer)
  12961 		return &smithy.DeserializationError{
  12962 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12963 			Snapshot: snapshot.Bytes(),
  12964 		}
  12965 	}
  12966 
  12967 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12968 	t, err = decoder.GetElement("Error")
  12969 	if err != nil {
  12970 		var snapshot bytes.Buffer
  12971 		io.Copy(&snapshot, ringBuffer)
  12972 		return &smithy.DeserializationError{
  12973 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12974 			Snapshot: snapshot.Bytes(),
  12975 		}
  12976 	}
  12977 
  12978 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12979 	err = awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(&output, decoder)
  12980 	if err != nil {
  12981 		var snapshot bytes.Buffer
  12982 		io.Copy(&snapshot, ringBuffer)
  12983 		return &smithy.DeserializationError{
  12984 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12985 			Snapshot: snapshot.Bytes(),
  12986 		}
  12987 	}
  12988 
  12989 	return output
  12990 }
  12991 
  12992 func awsRestxml_deserializeErrorKeySigningKeyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12993 	output := &types.KeySigningKeyInUse{}
  12994 	var buff [1024]byte
  12995 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12996 	body := io.TeeReader(errorBody, ringBuffer)
  12997 	rootDecoder := xml.NewDecoder(body)
  12998 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12999 	if err == io.EOF {
  13000 		return output
  13001 	}
  13002 	if err != nil {
  13003 		var snapshot bytes.Buffer
  13004 		io.Copy(&snapshot, ringBuffer)
  13005 		return &smithy.DeserializationError{
  13006 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13007 			Snapshot: snapshot.Bytes(),
  13008 		}
  13009 	}
  13010 
  13011 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13012 	t, err = decoder.GetElement("Error")
  13013 	if err != nil {
  13014 		var snapshot bytes.Buffer
  13015 		io.Copy(&snapshot, ringBuffer)
  13016 		return &smithy.DeserializationError{
  13017 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13018 			Snapshot: snapshot.Bytes(),
  13019 		}
  13020 	}
  13021 
  13022 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13023 	err = awsRestxml_deserializeDocumentKeySigningKeyInUse(&output, decoder)
  13024 	if err != nil {
  13025 		var snapshot bytes.Buffer
  13026 		io.Copy(&snapshot, ringBuffer)
  13027 		return &smithy.DeserializationError{
  13028 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13029 			Snapshot: snapshot.Bytes(),
  13030 		}
  13031 	}
  13032 
  13033 	return output
  13034 }
  13035 
  13036 func awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13037 	output := &types.KeySigningKeyWithActiveStatusNotFound{}
  13038 	var buff [1024]byte
  13039 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13040 	body := io.TeeReader(errorBody, ringBuffer)
  13041 	rootDecoder := xml.NewDecoder(body)
  13042 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13043 	if err == io.EOF {
  13044 		return output
  13045 	}
  13046 	if err != nil {
  13047 		var snapshot bytes.Buffer
  13048 		io.Copy(&snapshot, ringBuffer)
  13049 		return &smithy.DeserializationError{
  13050 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13051 			Snapshot: snapshot.Bytes(),
  13052 		}
  13053 	}
  13054 
  13055 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13056 	t, err = decoder.GetElement("Error")
  13057 	if err != nil {
  13058 		var snapshot bytes.Buffer
  13059 		io.Copy(&snapshot, ringBuffer)
  13060 		return &smithy.DeserializationError{
  13061 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13062 			Snapshot: snapshot.Bytes(),
  13063 		}
  13064 	}
  13065 
  13066 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13067 	err = awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(&output, decoder)
  13068 	if err != nil {
  13069 		var snapshot bytes.Buffer
  13070 		io.Copy(&snapshot, ringBuffer)
  13071 		return &smithy.DeserializationError{
  13072 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13073 			Snapshot: snapshot.Bytes(),
  13074 		}
  13075 	}
  13076 
  13077 	return output
  13078 }
  13079 
  13080 func awsRestxml_deserializeErrorLastVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13081 	output := &types.LastVPCAssociation{}
  13082 	var buff [1024]byte
  13083 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13084 	body := io.TeeReader(errorBody, ringBuffer)
  13085 	rootDecoder := xml.NewDecoder(body)
  13086 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13087 	if err == io.EOF {
  13088 		return output
  13089 	}
  13090 	if err != nil {
  13091 		var snapshot bytes.Buffer
  13092 		io.Copy(&snapshot, ringBuffer)
  13093 		return &smithy.DeserializationError{
  13094 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13095 			Snapshot: snapshot.Bytes(),
  13096 		}
  13097 	}
  13098 
  13099 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13100 	t, err = decoder.GetElement("Error")
  13101 	if err != nil {
  13102 		var snapshot bytes.Buffer
  13103 		io.Copy(&snapshot, ringBuffer)
  13104 		return &smithy.DeserializationError{
  13105 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13106 			Snapshot: snapshot.Bytes(),
  13107 		}
  13108 	}
  13109 
  13110 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13111 	err = awsRestxml_deserializeDocumentLastVPCAssociation(&output, decoder)
  13112 	if err != nil {
  13113 		var snapshot bytes.Buffer
  13114 		io.Copy(&snapshot, ringBuffer)
  13115 		return &smithy.DeserializationError{
  13116 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13117 			Snapshot: snapshot.Bytes(),
  13118 		}
  13119 	}
  13120 
  13121 	return output
  13122 }
  13123 
  13124 func awsRestxml_deserializeErrorLimitsExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13125 	output := &types.LimitsExceeded{}
  13126 	var buff [1024]byte
  13127 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13128 	body := io.TeeReader(errorBody, ringBuffer)
  13129 	rootDecoder := xml.NewDecoder(body)
  13130 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13131 	if err == io.EOF {
  13132 		return output
  13133 	}
  13134 	if err != nil {
  13135 		var snapshot bytes.Buffer
  13136 		io.Copy(&snapshot, ringBuffer)
  13137 		return &smithy.DeserializationError{
  13138 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13139 			Snapshot: snapshot.Bytes(),
  13140 		}
  13141 	}
  13142 
  13143 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13144 	t, err = decoder.GetElement("Error")
  13145 	if err != nil {
  13146 		var snapshot bytes.Buffer
  13147 		io.Copy(&snapshot, ringBuffer)
  13148 		return &smithy.DeserializationError{
  13149 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13150 			Snapshot: snapshot.Bytes(),
  13151 		}
  13152 	}
  13153 
  13154 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13155 	err = awsRestxml_deserializeDocumentLimitsExceeded(&output, decoder)
  13156 	if err != nil {
  13157 		var snapshot bytes.Buffer
  13158 		io.Copy(&snapshot, ringBuffer)
  13159 		return &smithy.DeserializationError{
  13160 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13161 			Snapshot: snapshot.Bytes(),
  13162 		}
  13163 	}
  13164 
  13165 	return output
  13166 }
  13167 
  13168 func awsRestxml_deserializeErrorNoSuchChange(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13169 	output := &types.NoSuchChange{}
  13170 	var buff [1024]byte
  13171 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13172 	body := io.TeeReader(errorBody, ringBuffer)
  13173 	rootDecoder := xml.NewDecoder(body)
  13174 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13175 	if err == io.EOF {
  13176 		return output
  13177 	}
  13178 	if err != nil {
  13179 		var snapshot bytes.Buffer
  13180 		io.Copy(&snapshot, ringBuffer)
  13181 		return &smithy.DeserializationError{
  13182 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13183 			Snapshot: snapshot.Bytes(),
  13184 		}
  13185 	}
  13186 
  13187 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13188 	t, err = decoder.GetElement("Error")
  13189 	if err != nil {
  13190 		var snapshot bytes.Buffer
  13191 		io.Copy(&snapshot, ringBuffer)
  13192 		return &smithy.DeserializationError{
  13193 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13194 			Snapshot: snapshot.Bytes(),
  13195 		}
  13196 	}
  13197 
  13198 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13199 	err = awsRestxml_deserializeDocumentNoSuchChange(&output, decoder)
  13200 	if err != nil {
  13201 		var snapshot bytes.Buffer
  13202 		io.Copy(&snapshot, ringBuffer)
  13203 		return &smithy.DeserializationError{
  13204 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13205 			Snapshot: snapshot.Bytes(),
  13206 		}
  13207 	}
  13208 
  13209 	return output
  13210 }
  13211 
  13212 func awsRestxml_deserializeErrorNoSuchCidrCollectionException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13213 	output := &types.NoSuchCidrCollectionException{}
  13214 	var buff [1024]byte
  13215 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13216 	body := io.TeeReader(errorBody, ringBuffer)
  13217 	rootDecoder := xml.NewDecoder(body)
  13218 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13219 	if err == io.EOF {
  13220 		return output
  13221 	}
  13222 	if err != nil {
  13223 		var snapshot bytes.Buffer
  13224 		io.Copy(&snapshot, ringBuffer)
  13225 		return &smithy.DeserializationError{
  13226 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13227 			Snapshot: snapshot.Bytes(),
  13228 		}
  13229 	}
  13230 
  13231 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13232 	t, err = decoder.GetElement("Error")
  13233 	if err != nil {
  13234 		var snapshot bytes.Buffer
  13235 		io.Copy(&snapshot, ringBuffer)
  13236 		return &smithy.DeserializationError{
  13237 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13238 			Snapshot: snapshot.Bytes(),
  13239 		}
  13240 	}
  13241 
  13242 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13243 	err = awsRestxml_deserializeDocumentNoSuchCidrCollectionException(&output, decoder)
  13244 	if err != nil {
  13245 		var snapshot bytes.Buffer
  13246 		io.Copy(&snapshot, ringBuffer)
  13247 		return &smithy.DeserializationError{
  13248 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13249 			Snapshot: snapshot.Bytes(),
  13250 		}
  13251 	}
  13252 
  13253 	return output
  13254 }
  13255 
  13256 func awsRestxml_deserializeErrorNoSuchCidrLocationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13257 	output := &types.NoSuchCidrLocationException{}
  13258 	var buff [1024]byte
  13259 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13260 	body := io.TeeReader(errorBody, ringBuffer)
  13261 	rootDecoder := xml.NewDecoder(body)
  13262 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13263 	if err == io.EOF {
  13264 		return output
  13265 	}
  13266 	if err != nil {
  13267 		var snapshot bytes.Buffer
  13268 		io.Copy(&snapshot, ringBuffer)
  13269 		return &smithy.DeserializationError{
  13270 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13271 			Snapshot: snapshot.Bytes(),
  13272 		}
  13273 	}
  13274 
  13275 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13276 	t, err = decoder.GetElement("Error")
  13277 	if err != nil {
  13278 		var snapshot bytes.Buffer
  13279 		io.Copy(&snapshot, ringBuffer)
  13280 		return &smithy.DeserializationError{
  13281 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13282 			Snapshot: snapshot.Bytes(),
  13283 		}
  13284 	}
  13285 
  13286 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13287 	err = awsRestxml_deserializeDocumentNoSuchCidrLocationException(&output, decoder)
  13288 	if err != nil {
  13289 		var snapshot bytes.Buffer
  13290 		io.Copy(&snapshot, ringBuffer)
  13291 		return &smithy.DeserializationError{
  13292 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13293 			Snapshot: snapshot.Bytes(),
  13294 		}
  13295 	}
  13296 
  13297 	return output
  13298 }
  13299 
  13300 func awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13301 	output := &types.NoSuchCloudWatchLogsLogGroup{}
  13302 	var buff [1024]byte
  13303 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13304 	body := io.TeeReader(errorBody, ringBuffer)
  13305 	rootDecoder := xml.NewDecoder(body)
  13306 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13307 	if err == io.EOF {
  13308 		return output
  13309 	}
  13310 	if err != nil {
  13311 		var snapshot bytes.Buffer
  13312 		io.Copy(&snapshot, ringBuffer)
  13313 		return &smithy.DeserializationError{
  13314 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13315 			Snapshot: snapshot.Bytes(),
  13316 		}
  13317 	}
  13318 
  13319 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13320 	t, err = decoder.GetElement("Error")
  13321 	if err != nil {
  13322 		var snapshot bytes.Buffer
  13323 		io.Copy(&snapshot, ringBuffer)
  13324 		return &smithy.DeserializationError{
  13325 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13326 			Snapshot: snapshot.Bytes(),
  13327 		}
  13328 	}
  13329 
  13330 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13331 	err = awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(&output, decoder)
  13332 	if err != nil {
  13333 		var snapshot bytes.Buffer
  13334 		io.Copy(&snapshot, ringBuffer)
  13335 		return &smithy.DeserializationError{
  13336 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13337 			Snapshot: snapshot.Bytes(),
  13338 		}
  13339 	}
  13340 
  13341 	return output
  13342 }
  13343 
  13344 func awsRestxml_deserializeErrorNoSuchDelegationSet(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13345 	output := &types.NoSuchDelegationSet{}
  13346 	var buff [1024]byte
  13347 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13348 	body := io.TeeReader(errorBody, ringBuffer)
  13349 	rootDecoder := xml.NewDecoder(body)
  13350 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13351 	if err == io.EOF {
  13352 		return output
  13353 	}
  13354 	if err != nil {
  13355 		var snapshot bytes.Buffer
  13356 		io.Copy(&snapshot, ringBuffer)
  13357 		return &smithy.DeserializationError{
  13358 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13359 			Snapshot: snapshot.Bytes(),
  13360 		}
  13361 	}
  13362 
  13363 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13364 	t, err = decoder.GetElement("Error")
  13365 	if err != nil {
  13366 		var snapshot bytes.Buffer
  13367 		io.Copy(&snapshot, ringBuffer)
  13368 		return &smithy.DeserializationError{
  13369 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13370 			Snapshot: snapshot.Bytes(),
  13371 		}
  13372 	}
  13373 
  13374 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13375 	err = awsRestxml_deserializeDocumentNoSuchDelegationSet(&output, decoder)
  13376 	if err != nil {
  13377 		var snapshot bytes.Buffer
  13378 		io.Copy(&snapshot, ringBuffer)
  13379 		return &smithy.DeserializationError{
  13380 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13381 			Snapshot: snapshot.Bytes(),
  13382 		}
  13383 	}
  13384 
  13385 	return output
  13386 }
  13387 
  13388 func awsRestxml_deserializeErrorNoSuchGeoLocation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13389 	output := &types.NoSuchGeoLocation{}
  13390 	var buff [1024]byte
  13391 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13392 	body := io.TeeReader(errorBody, ringBuffer)
  13393 	rootDecoder := xml.NewDecoder(body)
  13394 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13395 	if err == io.EOF {
  13396 		return output
  13397 	}
  13398 	if err != nil {
  13399 		var snapshot bytes.Buffer
  13400 		io.Copy(&snapshot, ringBuffer)
  13401 		return &smithy.DeserializationError{
  13402 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13403 			Snapshot: snapshot.Bytes(),
  13404 		}
  13405 	}
  13406 
  13407 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13408 	t, err = decoder.GetElement("Error")
  13409 	if err != nil {
  13410 		var snapshot bytes.Buffer
  13411 		io.Copy(&snapshot, ringBuffer)
  13412 		return &smithy.DeserializationError{
  13413 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13414 			Snapshot: snapshot.Bytes(),
  13415 		}
  13416 	}
  13417 
  13418 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13419 	err = awsRestxml_deserializeDocumentNoSuchGeoLocation(&output, decoder)
  13420 	if err != nil {
  13421 		var snapshot bytes.Buffer
  13422 		io.Copy(&snapshot, ringBuffer)
  13423 		return &smithy.DeserializationError{
  13424 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13425 			Snapshot: snapshot.Bytes(),
  13426 		}
  13427 	}
  13428 
  13429 	return output
  13430 }
  13431 
  13432 func awsRestxml_deserializeErrorNoSuchHealthCheck(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13433 	output := &types.NoSuchHealthCheck{}
  13434 	var buff [1024]byte
  13435 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13436 	body := io.TeeReader(errorBody, ringBuffer)
  13437 	rootDecoder := xml.NewDecoder(body)
  13438 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13439 	if err == io.EOF {
  13440 		return output
  13441 	}
  13442 	if err != nil {
  13443 		var snapshot bytes.Buffer
  13444 		io.Copy(&snapshot, ringBuffer)
  13445 		return &smithy.DeserializationError{
  13446 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13447 			Snapshot: snapshot.Bytes(),
  13448 		}
  13449 	}
  13450 
  13451 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13452 	t, err = decoder.GetElement("Error")
  13453 	if err != nil {
  13454 		var snapshot bytes.Buffer
  13455 		io.Copy(&snapshot, ringBuffer)
  13456 		return &smithy.DeserializationError{
  13457 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13458 			Snapshot: snapshot.Bytes(),
  13459 		}
  13460 	}
  13461 
  13462 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13463 	err = awsRestxml_deserializeDocumentNoSuchHealthCheck(&output, decoder)
  13464 	if err != nil {
  13465 		var snapshot bytes.Buffer
  13466 		io.Copy(&snapshot, ringBuffer)
  13467 		return &smithy.DeserializationError{
  13468 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13469 			Snapshot: snapshot.Bytes(),
  13470 		}
  13471 	}
  13472 
  13473 	return output
  13474 }
  13475 
  13476 func awsRestxml_deserializeErrorNoSuchHostedZone(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13477 	output := &types.NoSuchHostedZone{}
  13478 	var buff [1024]byte
  13479 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13480 	body := io.TeeReader(errorBody, ringBuffer)
  13481 	rootDecoder := xml.NewDecoder(body)
  13482 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13483 	if err == io.EOF {
  13484 		return output
  13485 	}
  13486 	if err != nil {
  13487 		var snapshot bytes.Buffer
  13488 		io.Copy(&snapshot, ringBuffer)
  13489 		return &smithy.DeserializationError{
  13490 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13491 			Snapshot: snapshot.Bytes(),
  13492 		}
  13493 	}
  13494 
  13495 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13496 	t, err = decoder.GetElement("Error")
  13497 	if err != nil {
  13498 		var snapshot bytes.Buffer
  13499 		io.Copy(&snapshot, ringBuffer)
  13500 		return &smithy.DeserializationError{
  13501 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13502 			Snapshot: snapshot.Bytes(),
  13503 		}
  13504 	}
  13505 
  13506 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13507 	err = awsRestxml_deserializeDocumentNoSuchHostedZone(&output, decoder)
  13508 	if err != nil {
  13509 		var snapshot bytes.Buffer
  13510 		io.Copy(&snapshot, ringBuffer)
  13511 		return &smithy.DeserializationError{
  13512 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13513 			Snapshot: snapshot.Bytes(),
  13514 		}
  13515 	}
  13516 
  13517 	return output
  13518 }
  13519 
  13520 func awsRestxml_deserializeErrorNoSuchKeySigningKey(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13521 	output := &types.NoSuchKeySigningKey{}
  13522 	var buff [1024]byte
  13523 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13524 	body := io.TeeReader(errorBody, ringBuffer)
  13525 	rootDecoder := xml.NewDecoder(body)
  13526 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13527 	if err == io.EOF {
  13528 		return output
  13529 	}
  13530 	if err != nil {
  13531 		var snapshot bytes.Buffer
  13532 		io.Copy(&snapshot, ringBuffer)
  13533 		return &smithy.DeserializationError{
  13534 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13535 			Snapshot: snapshot.Bytes(),
  13536 		}
  13537 	}
  13538 
  13539 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13540 	t, err = decoder.GetElement("Error")
  13541 	if err != nil {
  13542 		var snapshot bytes.Buffer
  13543 		io.Copy(&snapshot, ringBuffer)
  13544 		return &smithy.DeserializationError{
  13545 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13546 			Snapshot: snapshot.Bytes(),
  13547 		}
  13548 	}
  13549 
  13550 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13551 	err = awsRestxml_deserializeDocumentNoSuchKeySigningKey(&output, decoder)
  13552 	if err != nil {
  13553 		var snapshot bytes.Buffer
  13554 		io.Copy(&snapshot, ringBuffer)
  13555 		return &smithy.DeserializationError{
  13556 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13557 			Snapshot: snapshot.Bytes(),
  13558 		}
  13559 	}
  13560 
  13561 	return output
  13562 }
  13563 
  13564 func awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13565 	output := &types.NoSuchQueryLoggingConfig{}
  13566 	var buff [1024]byte
  13567 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13568 	body := io.TeeReader(errorBody, ringBuffer)
  13569 	rootDecoder := xml.NewDecoder(body)
  13570 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13571 	if err == io.EOF {
  13572 		return output
  13573 	}
  13574 	if err != nil {
  13575 		var snapshot bytes.Buffer
  13576 		io.Copy(&snapshot, ringBuffer)
  13577 		return &smithy.DeserializationError{
  13578 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13579 			Snapshot: snapshot.Bytes(),
  13580 		}
  13581 	}
  13582 
  13583 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13584 	t, err = decoder.GetElement("Error")
  13585 	if err != nil {
  13586 		var snapshot bytes.Buffer
  13587 		io.Copy(&snapshot, ringBuffer)
  13588 		return &smithy.DeserializationError{
  13589 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13590 			Snapshot: snapshot.Bytes(),
  13591 		}
  13592 	}
  13593 
  13594 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13595 	err = awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(&output, decoder)
  13596 	if err != nil {
  13597 		var snapshot bytes.Buffer
  13598 		io.Copy(&snapshot, ringBuffer)
  13599 		return &smithy.DeserializationError{
  13600 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13601 			Snapshot: snapshot.Bytes(),
  13602 		}
  13603 	}
  13604 
  13605 	return output
  13606 }
  13607 
  13608 func awsRestxml_deserializeErrorNoSuchTrafficPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13609 	output := &types.NoSuchTrafficPolicy{}
  13610 	var buff [1024]byte
  13611 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13612 	body := io.TeeReader(errorBody, ringBuffer)
  13613 	rootDecoder := xml.NewDecoder(body)
  13614 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13615 	if err == io.EOF {
  13616 		return output
  13617 	}
  13618 	if err != nil {
  13619 		var snapshot bytes.Buffer
  13620 		io.Copy(&snapshot, ringBuffer)
  13621 		return &smithy.DeserializationError{
  13622 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13623 			Snapshot: snapshot.Bytes(),
  13624 		}
  13625 	}
  13626 
  13627 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13628 	t, err = decoder.GetElement("Error")
  13629 	if err != nil {
  13630 		var snapshot bytes.Buffer
  13631 		io.Copy(&snapshot, ringBuffer)
  13632 		return &smithy.DeserializationError{
  13633 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13634 			Snapshot: snapshot.Bytes(),
  13635 		}
  13636 	}
  13637 
  13638 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13639 	err = awsRestxml_deserializeDocumentNoSuchTrafficPolicy(&output, decoder)
  13640 	if err != nil {
  13641 		var snapshot bytes.Buffer
  13642 		io.Copy(&snapshot, ringBuffer)
  13643 		return &smithy.DeserializationError{
  13644 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13645 			Snapshot: snapshot.Bytes(),
  13646 		}
  13647 	}
  13648 
  13649 	return output
  13650 }
  13651 
  13652 func awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13653 	output := &types.NoSuchTrafficPolicyInstance{}
  13654 	var buff [1024]byte
  13655 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13656 	body := io.TeeReader(errorBody, ringBuffer)
  13657 	rootDecoder := xml.NewDecoder(body)
  13658 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13659 	if err == io.EOF {
  13660 		return output
  13661 	}
  13662 	if err != nil {
  13663 		var snapshot bytes.Buffer
  13664 		io.Copy(&snapshot, ringBuffer)
  13665 		return &smithy.DeserializationError{
  13666 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13667 			Snapshot: snapshot.Bytes(),
  13668 		}
  13669 	}
  13670 
  13671 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13672 	t, err = decoder.GetElement("Error")
  13673 	if err != nil {
  13674 		var snapshot bytes.Buffer
  13675 		io.Copy(&snapshot, ringBuffer)
  13676 		return &smithy.DeserializationError{
  13677 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13678 			Snapshot: snapshot.Bytes(),
  13679 		}
  13680 	}
  13681 
  13682 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13683 	err = awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(&output, decoder)
  13684 	if err != nil {
  13685 		var snapshot bytes.Buffer
  13686 		io.Copy(&snapshot, ringBuffer)
  13687 		return &smithy.DeserializationError{
  13688 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13689 			Snapshot: snapshot.Bytes(),
  13690 		}
  13691 	}
  13692 
  13693 	return output
  13694 }
  13695 
  13696 func awsRestxml_deserializeErrorNotAuthorizedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13697 	output := &types.NotAuthorizedException{}
  13698 	var buff [1024]byte
  13699 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13700 	body := io.TeeReader(errorBody, ringBuffer)
  13701 	rootDecoder := xml.NewDecoder(body)
  13702 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13703 	if err == io.EOF {
  13704 		return output
  13705 	}
  13706 	if err != nil {
  13707 		var snapshot bytes.Buffer
  13708 		io.Copy(&snapshot, ringBuffer)
  13709 		return &smithy.DeserializationError{
  13710 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13711 			Snapshot: snapshot.Bytes(),
  13712 		}
  13713 	}
  13714 
  13715 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13716 	t, err = decoder.GetElement("Error")
  13717 	if err != nil {
  13718 		var snapshot bytes.Buffer
  13719 		io.Copy(&snapshot, ringBuffer)
  13720 		return &smithy.DeserializationError{
  13721 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13722 			Snapshot: snapshot.Bytes(),
  13723 		}
  13724 	}
  13725 
  13726 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13727 	err = awsRestxml_deserializeDocumentNotAuthorizedException(&output, decoder)
  13728 	if err != nil {
  13729 		var snapshot bytes.Buffer
  13730 		io.Copy(&snapshot, ringBuffer)
  13731 		return &smithy.DeserializationError{
  13732 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13733 			Snapshot: snapshot.Bytes(),
  13734 		}
  13735 	}
  13736 
  13737 	return output
  13738 }
  13739 
  13740 func awsRestxml_deserializeErrorPriorRequestNotComplete(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13741 	output := &types.PriorRequestNotComplete{}
  13742 	var buff [1024]byte
  13743 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13744 	body := io.TeeReader(errorBody, ringBuffer)
  13745 	rootDecoder := xml.NewDecoder(body)
  13746 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13747 	if err == io.EOF {
  13748 		return output
  13749 	}
  13750 	if err != nil {
  13751 		var snapshot bytes.Buffer
  13752 		io.Copy(&snapshot, ringBuffer)
  13753 		return &smithy.DeserializationError{
  13754 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13755 			Snapshot: snapshot.Bytes(),
  13756 		}
  13757 	}
  13758 
  13759 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13760 	t, err = decoder.GetElement("Error")
  13761 	if err != nil {
  13762 		var snapshot bytes.Buffer
  13763 		io.Copy(&snapshot, ringBuffer)
  13764 		return &smithy.DeserializationError{
  13765 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13766 			Snapshot: snapshot.Bytes(),
  13767 		}
  13768 	}
  13769 
  13770 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13771 	err = awsRestxml_deserializeDocumentPriorRequestNotComplete(&output, decoder)
  13772 	if err != nil {
  13773 		var snapshot bytes.Buffer
  13774 		io.Copy(&snapshot, ringBuffer)
  13775 		return &smithy.DeserializationError{
  13776 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13777 			Snapshot: snapshot.Bytes(),
  13778 		}
  13779 	}
  13780 
  13781 	return output
  13782 }
  13783 
  13784 func awsRestxml_deserializeErrorPublicZoneVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13785 	output := &types.PublicZoneVPCAssociation{}
  13786 	var buff [1024]byte
  13787 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13788 	body := io.TeeReader(errorBody, ringBuffer)
  13789 	rootDecoder := xml.NewDecoder(body)
  13790 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13791 	if err == io.EOF {
  13792 		return output
  13793 	}
  13794 	if err != nil {
  13795 		var snapshot bytes.Buffer
  13796 		io.Copy(&snapshot, ringBuffer)
  13797 		return &smithy.DeserializationError{
  13798 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13799 			Snapshot: snapshot.Bytes(),
  13800 		}
  13801 	}
  13802 
  13803 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13804 	t, err = decoder.GetElement("Error")
  13805 	if err != nil {
  13806 		var snapshot bytes.Buffer
  13807 		io.Copy(&snapshot, ringBuffer)
  13808 		return &smithy.DeserializationError{
  13809 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13810 			Snapshot: snapshot.Bytes(),
  13811 		}
  13812 	}
  13813 
  13814 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13815 	err = awsRestxml_deserializeDocumentPublicZoneVPCAssociation(&output, decoder)
  13816 	if err != nil {
  13817 		var snapshot bytes.Buffer
  13818 		io.Copy(&snapshot, ringBuffer)
  13819 		return &smithy.DeserializationError{
  13820 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13821 			Snapshot: snapshot.Bytes(),
  13822 		}
  13823 	}
  13824 
  13825 	return output
  13826 }
  13827 
  13828 func awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13829 	output := &types.QueryLoggingConfigAlreadyExists{}
  13830 	var buff [1024]byte
  13831 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13832 	body := io.TeeReader(errorBody, ringBuffer)
  13833 	rootDecoder := xml.NewDecoder(body)
  13834 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13835 	if err == io.EOF {
  13836 		return output
  13837 	}
  13838 	if err != nil {
  13839 		var snapshot bytes.Buffer
  13840 		io.Copy(&snapshot, ringBuffer)
  13841 		return &smithy.DeserializationError{
  13842 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13843 			Snapshot: snapshot.Bytes(),
  13844 		}
  13845 	}
  13846 
  13847 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13848 	t, err = decoder.GetElement("Error")
  13849 	if err != nil {
  13850 		var snapshot bytes.Buffer
  13851 		io.Copy(&snapshot, ringBuffer)
  13852 		return &smithy.DeserializationError{
  13853 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13854 			Snapshot: snapshot.Bytes(),
  13855 		}
  13856 	}
  13857 
  13858 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13859 	err = awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(&output, decoder)
  13860 	if err != nil {
  13861 		var snapshot bytes.Buffer
  13862 		io.Copy(&snapshot, ringBuffer)
  13863 		return &smithy.DeserializationError{
  13864 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13865 			Snapshot: snapshot.Bytes(),
  13866 		}
  13867 	}
  13868 
  13869 	return output
  13870 }
  13871 
  13872 func awsRestxml_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13873 	output := &types.ThrottlingException{}
  13874 	var buff [1024]byte
  13875 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13876 	body := io.TeeReader(errorBody, ringBuffer)
  13877 	rootDecoder := xml.NewDecoder(body)
  13878 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13879 	if err == io.EOF {
  13880 		return output
  13881 	}
  13882 	if err != nil {
  13883 		var snapshot bytes.Buffer
  13884 		io.Copy(&snapshot, ringBuffer)
  13885 		return &smithy.DeserializationError{
  13886 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13887 			Snapshot: snapshot.Bytes(),
  13888 		}
  13889 	}
  13890 
  13891 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13892 	t, err = decoder.GetElement("Error")
  13893 	if err != nil {
  13894 		var snapshot bytes.Buffer
  13895 		io.Copy(&snapshot, ringBuffer)
  13896 		return &smithy.DeserializationError{
  13897 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13898 			Snapshot: snapshot.Bytes(),
  13899 		}
  13900 	}
  13901 
  13902 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13903 	err = awsRestxml_deserializeDocumentThrottlingException(&output, decoder)
  13904 	if err != nil {
  13905 		var snapshot bytes.Buffer
  13906 		io.Copy(&snapshot, ringBuffer)
  13907 		return &smithy.DeserializationError{
  13908 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13909 			Snapshot: snapshot.Bytes(),
  13910 		}
  13911 	}
  13912 
  13913 	return output
  13914 }
  13915 
  13916 func awsRestxml_deserializeErrorTooManyHealthChecks(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13917 	output := &types.TooManyHealthChecks{}
  13918 	var buff [1024]byte
  13919 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13920 	body := io.TeeReader(errorBody, ringBuffer)
  13921 	rootDecoder := xml.NewDecoder(body)
  13922 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13923 	if err == io.EOF {
  13924 		return output
  13925 	}
  13926 	if err != nil {
  13927 		var snapshot bytes.Buffer
  13928 		io.Copy(&snapshot, ringBuffer)
  13929 		return &smithy.DeserializationError{
  13930 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13931 			Snapshot: snapshot.Bytes(),
  13932 		}
  13933 	}
  13934 
  13935 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13936 	t, err = decoder.GetElement("Error")
  13937 	if err != nil {
  13938 		var snapshot bytes.Buffer
  13939 		io.Copy(&snapshot, ringBuffer)
  13940 		return &smithy.DeserializationError{
  13941 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13942 			Snapshot: snapshot.Bytes(),
  13943 		}
  13944 	}
  13945 
  13946 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13947 	err = awsRestxml_deserializeDocumentTooManyHealthChecks(&output, decoder)
  13948 	if err != nil {
  13949 		var snapshot bytes.Buffer
  13950 		io.Copy(&snapshot, ringBuffer)
  13951 		return &smithy.DeserializationError{
  13952 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13953 			Snapshot: snapshot.Bytes(),
  13954 		}
  13955 	}
  13956 
  13957 	return output
  13958 }
  13959 
  13960 func awsRestxml_deserializeErrorTooManyHostedZones(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13961 	output := &types.TooManyHostedZones{}
  13962 	var buff [1024]byte
  13963 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13964 	body := io.TeeReader(errorBody, ringBuffer)
  13965 	rootDecoder := xml.NewDecoder(body)
  13966 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13967 	if err == io.EOF {
  13968 		return output
  13969 	}
  13970 	if err != nil {
  13971 		var snapshot bytes.Buffer
  13972 		io.Copy(&snapshot, ringBuffer)
  13973 		return &smithy.DeserializationError{
  13974 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13975 			Snapshot: snapshot.Bytes(),
  13976 		}
  13977 	}
  13978 
  13979 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13980 	t, err = decoder.GetElement("Error")
  13981 	if err != nil {
  13982 		var snapshot bytes.Buffer
  13983 		io.Copy(&snapshot, ringBuffer)
  13984 		return &smithy.DeserializationError{
  13985 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13986 			Snapshot: snapshot.Bytes(),
  13987 		}
  13988 	}
  13989 
  13990 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13991 	err = awsRestxml_deserializeDocumentTooManyHostedZones(&output, decoder)
  13992 	if err != nil {
  13993 		var snapshot bytes.Buffer
  13994 		io.Copy(&snapshot, ringBuffer)
  13995 		return &smithy.DeserializationError{
  13996 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13997 			Snapshot: snapshot.Bytes(),
  13998 		}
  13999 	}
  14000 
  14001 	return output
  14002 }
  14003 
  14004 func awsRestxml_deserializeErrorTooManyKeySigningKeys(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14005 	output := &types.TooManyKeySigningKeys{}
  14006 	var buff [1024]byte
  14007 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14008 	body := io.TeeReader(errorBody, ringBuffer)
  14009 	rootDecoder := xml.NewDecoder(body)
  14010 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14011 	if err == io.EOF {
  14012 		return output
  14013 	}
  14014 	if err != nil {
  14015 		var snapshot bytes.Buffer
  14016 		io.Copy(&snapshot, ringBuffer)
  14017 		return &smithy.DeserializationError{
  14018 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14019 			Snapshot: snapshot.Bytes(),
  14020 		}
  14021 	}
  14022 
  14023 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14024 	t, err = decoder.GetElement("Error")
  14025 	if err != nil {
  14026 		var snapshot bytes.Buffer
  14027 		io.Copy(&snapshot, ringBuffer)
  14028 		return &smithy.DeserializationError{
  14029 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14030 			Snapshot: snapshot.Bytes(),
  14031 		}
  14032 	}
  14033 
  14034 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14035 	err = awsRestxml_deserializeDocumentTooManyKeySigningKeys(&output, decoder)
  14036 	if err != nil {
  14037 		var snapshot bytes.Buffer
  14038 		io.Copy(&snapshot, ringBuffer)
  14039 		return &smithy.DeserializationError{
  14040 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14041 			Snapshot: snapshot.Bytes(),
  14042 		}
  14043 	}
  14044 
  14045 	return output
  14046 }
  14047 
  14048 func awsRestxml_deserializeErrorTooManyTrafficPolicies(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14049 	output := &types.TooManyTrafficPolicies{}
  14050 	var buff [1024]byte
  14051 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14052 	body := io.TeeReader(errorBody, ringBuffer)
  14053 	rootDecoder := xml.NewDecoder(body)
  14054 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14055 	if err == io.EOF {
  14056 		return output
  14057 	}
  14058 	if err != nil {
  14059 		var snapshot bytes.Buffer
  14060 		io.Copy(&snapshot, ringBuffer)
  14061 		return &smithy.DeserializationError{
  14062 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14063 			Snapshot: snapshot.Bytes(),
  14064 		}
  14065 	}
  14066 
  14067 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14068 	t, err = decoder.GetElement("Error")
  14069 	if err != nil {
  14070 		var snapshot bytes.Buffer
  14071 		io.Copy(&snapshot, ringBuffer)
  14072 		return &smithy.DeserializationError{
  14073 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14074 			Snapshot: snapshot.Bytes(),
  14075 		}
  14076 	}
  14077 
  14078 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14079 	err = awsRestxml_deserializeDocumentTooManyTrafficPolicies(&output, decoder)
  14080 	if err != nil {
  14081 		var snapshot bytes.Buffer
  14082 		io.Copy(&snapshot, ringBuffer)
  14083 		return &smithy.DeserializationError{
  14084 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14085 			Snapshot: snapshot.Bytes(),
  14086 		}
  14087 	}
  14088 
  14089 	return output
  14090 }
  14091 
  14092 func awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14093 	output := &types.TooManyTrafficPolicyInstances{}
  14094 	var buff [1024]byte
  14095 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14096 	body := io.TeeReader(errorBody, ringBuffer)
  14097 	rootDecoder := xml.NewDecoder(body)
  14098 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14099 	if err == io.EOF {
  14100 		return output
  14101 	}
  14102 	if err != nil {
  14103 		var snapshot bytes.Buffer
  14104 		io.Copy(&snapshot, ringBuffer)
  14105 		return &smithy.DeserializationError{
  14106 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14107 			Snapshot: snapshot.Bytes(),
  14108 		}
  14109 	}
  14110 
  14111 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14112 	t, err = decoder.GetElement("Error")
  14113 	if err != nil {
  14114 		var snapshot bytes.Buffer
  14115 		io.Copy(&snapshot, ringBuffer)
  14116 		return &smithy.DeserializationError{
  14117 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14118 			Snapshot: snapshot.Bytes(),
  14119 		}
  14120 	}
  14121 
  14122 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14123 	err = awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(&output, decoder)
  14124 	if err != nil {
  14125 		var snapshot bytes.Buffer
  14126 		io.Copy(&snapshot, ringBuffer)
  14127 		return &smithy.DeserializationError{
  14128 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14129 			Snapshot: snapshot.Bytes(),
  14130 		}
  14131 	}
  14132 
  14133 	return output
  14134 }
  14135 
  14136 func awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14137 	output := &types.TooManyTrafficPolicyVersionsForCurrentPolicy{}
  14138 	var buff [1024]byte
  14139 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14140 	body := io.TeeReader(errorBody, ringBuffer)
  14141 	rootDecoder := xml.NewDecoder(body)
  14142 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14143 	if err == io.EOF {
  14144 		return output
  14145 	}
  14146 	if err != nil {
  14147 		var snapshot bytes.Buffer
  14148 		io.Copy(&snapshot, ringBuffer)
  14149 		return &smithy.DeserializationError{
  14150 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14151 			Snapshot: snapshot.Bytes(),
  14152 		}
  14153 	}
  14154 
  14155 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14156 	t, err = decoder.GetElement("Error")
  14157 	if err != nil {
  14158 		var snapshot bytes.Buffer
  14159 		io.Copy(&snapshot, ringBuffer)
  14160 		return &smithy.DeserializationError{
  14161 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14162 			Snapshot: snapshot.Bytes(),
  14163 		}
  14164 	}
  14165 
  14166 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14167 	err = awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(&output, decoder)
  14168 	if err != nil {
  14169 		var snapshot bytes.Buffer
  14170 		io.Copy(&snapshot, ringBuffer)
  14171 		return &smithy.DeserializationError{
  14172 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14173 			Snapshot: snapshot.Bytes(),
  14174 		}
  14175 	}
  14176 
  14177 	return output
  14178 }
  14179 
  14180 func awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14181 	output := &types.TooManyVPCAssociationAuthorizations{}
  14182 	var buff [1024]byte
  14183 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14184 	body := io.TeeReader(errorBody, ringBuffer)
  14185 	rootDecoder := xml.NewDecoder(body)
  14186 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14187 	if err == io.EOF {
  14188 		return output
  14189 	}
  14190 	if err != nil {
  14191 		var snapshot bytes.Buffer
  14192 		io.Copy(&snapshot, ringBuffer)
  14193 		return &smithy.DeserializationError{
  14194 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14195 			Snapshot: snapshot.Bytes(),
  14196 		}
  14197 	}
  14198 
  14199 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14200 	t, err = decoder.GetElement("Error")
  14201 	if err != nil {
  14202 		var snapshot bytes.Buffer
  14203 		io.Copy(&snapshot, ringBuffer)
  14204 		return &smithy.DeserializationError{
  14205 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14206 			Snapshot: snapshot.Bytes(),
  14207 		}
  14208 	}
  14209 
  14210 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14211 	err = awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(&output, decoder)
  14212 	if err != nil {
  14213 		var snapshot bytes.Buffer
  14214 		io.Copy(&snapshot, ringBuffer)
  14215 		return &smithy.DeserializationError{
  14216 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14217 			Snapshot: snapshot.Bytes(),
  14218 		}
  14219 	}
  14220 
  14221 	return output
  14222 }
  14223 
  14224 func awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14225 	output := &types.TrafficPolicyAlreadyExists{}
  14226 	var buff [1024]byte
  14227 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14228 	body := io.TeeReader(errorBody, ringBuffer)
  14229 	rootDecoder := xml.NewDecoder(body)
  14230 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14231 	if err == io.EOF {
  14232 		return output
  14233 	}
  14234 	if err != nil {
  14235 		var snapshot bytes.Buffer
  14236 		io.Copy(&snapshot, ringBuffer)
  14237 		return &smithy.DeserializationError{
  14238 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14239 			Snapshot: snapshot.Bytes(),
  14240 		}
  14241 	}
  14242 
  14243 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14244 	t, err = decoder.GetElement("Error")
  14245 	if err != nil {
  14246 		var snapshot bytes.Buffer
  14247 		io.Copy(&snapshot, ringBuffer)
  14248 		return &smithy.DeserializationError{
  14249 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14250 			Snapshot: snapshot.Bytes(),
  14251 		}
  14252 	}
  14253 
  14254 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14255 	err = awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(&output, decoder)
  14256 	if err != nil {
  14257 		var snapshot bytes.Buffer
  14258 		io.Copy(&snapshot, ringBuffer)
  14259 		return &smithy.DeserializationError{
  14260 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14261 			Snapshot: snapshot.Bytes(),
  14262 		}
  14263 	}
  14264 
  14265 	return output
  14266 }
  14267 
  14268 func awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14269 	output := &types.TrafficPolicyInstanceAlreadyExists{}
  14270 	var buff [1024]byte
  14271 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14272 	body := io.TeeReader(errorBody, ringBuffer)
  14273 	rootDecoder := xml.NewDecoder(body)
  14274 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14275 	if err == io.EOF {
  14276 		return output
  14277 	}
  14278 	if err != nil {
  14279 		var snapshot bytes.Buffer
  14280 		io.Copy(&snapshot, ringBuffer)
  14281 		return &smithy.DeserializationError{
  14282 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14283 			Snapshot: snapshot.Bytes(),
  14284 		}
  14285 	}
  14286 
  14287 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14288 	t, err = decoder.GetElement("Error")
  14289 	if err != nil {
  14290 		var snapshot bytes.Buffer
  14291 		io.Copy(&snapshot, ringBuffer)
  14292 		return &smithy.DeserializationError{
  14293 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14294 			Snapshot: snapshot.Bytes(),
  14295 		}
  14296 	}
  14297 
  14298 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14299 	err = awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(&output, decoder)
  14300 	if err != nil {
  14301 		var snapshot bytes.Buffer
  14302 		io.Copy(&snapshot, ringBuffer)
  14303 		return &smithy.DeserializationError{
  14304 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14305 			Snapshot: snapshot.Bytes(),
  14306 		}
  14307 	}
  14308 
  14309 	return output
  14310 }
  14311 
  14312 func awsRestxml_deserializeErrorTrafficPolicyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14313 	output := &types.TrafficPolicyInUse{}
  14314 	var buff [1024]byte
  14315 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14316 	body := io.TeeReader(errorBody, ringBuffer)
  14317 	rootDecoder := xml.NewDecoder(body)
  14318 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14319 	if err == io.EOF {
  14320 		return output
  14321 	}
  14322 	if err != nil {
  14323 		var snapshot bytes.Buffer
  14324 		io.Copy(&snapshot, ringBuffer)
  14325 		return &smithy.DeserializationError{
  14326 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14327 			Snapshot: snapshot.Bytes(),
  14328 		}
  14329 	}
  14330 
  14331 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14332 	t, err = decoder.GetElement("Error")
  14333 	if err != nil {
  14334 		var snapshot bytes.Buffer
  14335 		io.Copy(&snapshot, ringBuffer)
  14336 		return &smithy.DeserializationError{
  14337 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14338 			Snapshot: snapshot.Bytes(),
  14339 		}
  14340 	}
  14341 
  14342 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14343 	err = awsRestxml_deserializeDocumentTrafficPolicyInUse(&output, decoder)
  14344 	if err != nil {
  14345 		var snapshot bytes.Buffer
  14346 		io.Copy(&snapshot, ringBuffer)
  14347 		return &smithy.DeserializationError{
  14348 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14349 			Snapshot: snapshot.Bytes(),
  14350 		}
  14351 	}
  14352 
  14353 	return output
  14354 }
  14355 
  14356 func awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14357 	output := &types.VPCAssociationAuthorizationNotFound{}
  14358 	var buff [1024]byte
  14359 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14360 	body := io.TeeReader(errorBody, ringBuffer)
  14361 	rootDecoder := xml.NewDecoder(body)
  14362 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14363 	if err == io.EOF {
  14364 		return output
  14365 	}
  14366 	if err != nil {
  14367 		var snapshot bytes.Buffer
  14368 		io.Copy(&snapshot, ringBuffer)
  14369 		return &smithy.DeserializationError{
  14370 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14371 			Snapshot: snapshot.Bytes(),
  14372 		}
  14373 	}
  14374 
  14375 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14376 	t, err = decoder.GetElement("Error")
  14377 	if err != nil {
  14378 		var snapshot bytes.Buffer
  14379 		io.Copy(&snapshot, ringBuffer)
  14380 		return &smithy.DeserializationError{
  14381 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14382 			Snapshot: snapshot.Bytes(),
  14383 		}
  14384 	}
  14385 
  14386 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14387 	err = awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(&output, decoder)
  14388 	if err != nil {
  14389 		var snapshot bytes.Buffer
  14390 		io.Copy(&snapshot, ringBuffer)
  14391 		return &smithy.DeserializationError{
  14392 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14393 			Snapshot: snapshot.Bytes(),
  14394 		}
  14395 	}
  14396 
  14397 	return output
  14398 }
  14399 
  14400 func awsRestxml_deserializeErrorVPCAssociationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14401 	output := &types.VPCAssociationNotFound{}
  14402 	var buff [1024]byte
  14403 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14404 	body := io.TeeReader(errorBody, ringBuffer)
  14405 	rootDecoder := xml.NewDecoder(body)
  14406 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14407 	if err == io.EOF {
  14408 		return output
  14409 	}
  14410 	if err != nil {
  14411 		var snapshot bytes.Buffer
  14412 		io.Copy(&snapshot, ringBuffer)
  14413 		return &smithy.DeserializationError{
  14414 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14415 			Snapshot: snapshot.Bytes(),
  14416 		}
  14417 	}
  14418 
  14419 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14420 	t, err = decoder.GetElement("Error")
  14421 	if err != nil {
  14422 		var snapshot bytes.Buffer
  14423 		io.Copy(&snapshot, ringBuffer)
  14424 		return &smithy.DeserializationError{
  14425 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14426 			Snapshot: snapshot.Bytes(),
  14427 		}
  14428 	}
  14429 
  14430 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14431 	err = awsRestxml_deserializeDocumentVPCAssociationNotFound(&output, decoder)
  14432 	if err != nil {
  14433 		var snapshot bytes.Buffer
  14434 		io.Copy(&snapshot, ringBuffer)
  14435 		return &smithy.DeserializationError{
  14436 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14437 			Snapshot: snapshot.Bytes(),
  14438 		}
  14439 	}
  14440 
  14441 	return output
  14442 }
  14443 
  14444 func awsRestxml_deserializeDocumentAccountLimit(v **types.AccountLimit, decoder smithyxml.NodeDecoder) error {
  14445 	if v == nil {
  14446 		return fmt.Errorf("unexpected nil of type %T", v)
  14447 	}
  14448 	var sv *types.AccountLimit
  14449 	if *v == nil {
  14450 		sv = &types.AccountLimit{}
  14451 	} else {
  14452 		sv = *v
  14453 	}
  14454 
  14455 	for {
  14456 		t, done, err := decoder.Token()
  14457 		if err != nil {
  14458 			return err
  14459 		}
  14460 		if done {
  14461 			break
  14462 		}
  14463 		originalDecoder := decoder
  14464 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14465 		switch {
  14466 		case strings.EqualFold("Type", t.Name.Local):
  14467 			val, err := decoder.Value()
  14468 			if err != nil {
  14469 				return err
  14470 			}
  14471 			if val == nil {
  14472 				break
  14473 			}
  14474 			{
  14475 				xtv := string(val)
  14476 				sv.Type = types.AccountLimitType(xtv)
  14477 			}
  14478 
  14479 		case strings.EqualFold("Value", t.Name.Local):
  14480 			val, err := decoder.Value()
  14481 			if err != nil {
  14482 				return err
  14483 			}
  14484 			if val == nil {
  14485 				break
  14486 			}
  14487 			{
  14488 				xtv := string(val)
  14489 				i64, err := strconv.ParseInt(xtv, 10, 64)
  14490 				if err != nil {
  14491 					return err
  14492 				}
  14493 				sv.Value = ptr.Int64(i64)
  14494 			}
  14495 
  14496 		default:
  14497 			// Do nothing and ignore the unexpected tag element
  14498 			err = decoder.Decoder.Skip()
  14499 			if err != nil {
  14500 				return err
  14501 			}
  14502 
  14503 		}
  14504 		decoder = originalDecoder
  14505 	}
  14506 	*v = sv
  14507 	return nil
  14508 }
  14509 
  14510 func awsRestxml_deserializeDocumentAlarmIdentifier(v **types.AlarmIdentifier, decoder smithyxml.NodeDecoder) error {
  14511 	if v == nil {
  14512 		return fmt.Errorf("unexpected nil of type %T", v)
  14513 	}
  14514 	var sv *types.AlarmIdentifier
  14515 	if *v == nil {
  14516 		sv = &types.AlarmIdentifier{}
  14517 	} else {
  14518 		sv = *v
  14519 	}
  14520 
  14521 	for {
  14522 		t, done, err := decoder.Token()
  14523 		if err != nil {
  14524 			return err
  14525 		}
  14526 		if done {
  14527 			break
  14528 		}
  14529 		originalDecoder := decoder
  14530 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14531 		switch {
  14532 		case strings.EqualFold("Name", t.Name.Local):
  14533 			val, err := decoder.Value()
  14534 			if err != nil {
  14535 				return err
  14536 			}
  14537 			if val == nil {
  14538 				break
  14539 			}
  14540 			{
  14541 				xtv := string(val)
  14542 				sv.Name = ptr.String(xtv)
  14543 			}
  14544 
  14545 		case strings.EqualFold("Region", t.Name.Local):
  14546 			val, err := decoder.Value()
  14547 			if err != nil {
  14548 				return err
  14549 			}
  14550 			if val == nil {
  14551 				break
  14552 			}
  14553 			{
  14554 				xtv := string(val)
  14555 				sv.Region = types.CloudWatchRegion(xtv)
  14556 			}
  14557 
  14558 		default:
  14559 			// Do nothing and ignore the unexpected tag element
  14560 			err = decoder.Decoder.Skip()
  14561 			if err != nil {
  14562 				return err
  14563 			}
  14564 
  14565 		}
  14566 		decoder = originalDecoder
  14567 	}
  14568 	*v = sv
  14569 	return nil
  14570 }
  14571 
  14572 func awsRestxml_deserializeDocumentAliasTarget(v **types.AliasTarget, decoder smithyxml.NodeDecoder) error {
  14573 	if v == nil {
  14574 		return fmt.Errorf("unexpected nil of type %T", v)
  14575 	}
  14576 	var sv *types.AliasTarget
  14577 	if *v == nil {
  14578 		sv = &types.AliasTarget{}
  14579 	} else {
  14580 		sv = *v
  14581 	}
  14582 
  14583 	for {
  14584 		t, done, err := decoder.Token()
  14585 		if err != nil {
  14586 			return err
  14587 		}
  14588 		if done {
  14589 			break
  14590 		}
  14591 		originalDecoder := decoder
  14592 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14593 		switch {
  14594 		case strings.EqualFold("DNSName", t.Name.Local):
  14595 			val, err := decoder.Value()
  14596 			if err != nil {
  14597 				return err
  14598 			}
  14599 			if val == nil {
  14600 				break
  14601 			}
  14602 			{
  14603 				xtv := string(val)
  14604 				sv.DNSName = ptr.String(xtv)
  14605 			}
  14606 
  14607 		case strings.EqualFold("EvaluateTargetHealth", t.Name.Local):
  14608 			val, err := decoder.Value()
  14609 			if err != nil {
  14610 				return err
  14611 			}
  14612 			if val == nil {
  14613 				break
  14614 			}
  14615 			{
  14616 				xtv, err := strconv.ParseBool(string(val))
  14617 				if err != nil {
  14618 					return fmt.Errorf("expected AliasHealthEnabled to be of type *bool, got %T instead", val)
  14619 				}
  14620 				sv.EvaluateTargetHealth = xtv
  14621 			}
  14622 
  14623 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  14624 			val, err := decoder.Value()
  14625 			if err != nil {
  14626 				return err
  14627 			}
  14628 			if val == nil {
  14629 				break
  14630 			}
  14631 			{
  14632 				xtv := string(val)
  14633 				sv.HostedZoneId = ptr.String(xtv)
  14634 			}
  14635 
  14636 		default:
  14637 			// Do nothing and ignore the unexpected tag element
  14638 			err = decoder.Decoder.Skip()
  14639 			if err != nil {
  14640 				return err
  14641 			}
  14642 
  14643 		}
  14644 		decoder = originalDecoder
  14645 	}
  14646 	*v = sv
  14647 	return nil
  14648 }
  14649 
  14650 func awsRestxml_deserializeDocumentChangeInfo(v **types.ChangeInfo, decoder smithyxml.NodeDecoder) error {
  14651 	if v == nil {
  14652 		return fmt.Errorf("unexpected nil of type %T", v)
  14653 	}
  14654 	var sv *types.ChangeInfo
  14655 	if *v == nil {
  14656 		sv = &types.ChangeInfo{}
  14657 	} else {
  14658 		sv = *v
  14659 	}
  14660 
  14661 	for {
  14662 		t, done, err := decoder.Token()
  14663 		if err != nil {
  14664 			return err
  14665 		}
  14666 		if done {
  14667 			break
  14668 		}
  14669 		originalDecoder := decoder
  14670 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14671 		switch {
  14672 		case strings.EqualFold("Comment", t.Name.Local):
  14673 			val, err := decoder.Value()
  14674 			if err != nil {
  14675 				return err
  14676 			}
  14677 			if val == nil {
  14678 				break
  14679 			}
  14680 			{
  14681 				xtv := string(val)
  14682 				sv.Comment = ptr.String(xtv)
  14683 			}
  14684 
  14685 		case strings.EqualFold("Id", t.Name.Local):
  14686 			val, err := decoder.Value()
  14687 			if err != nil {
  14688 				return err
  14689 			}
  14690 			if val == nil {
  14691 				break
  14692 			}
  14693 			{
  14694 				xtv := string(val)
  14695 				sv.Id = ptr.String(xtv)
  14696 			}
  14697 
  14698 		case strings.EqualFold("Status", t.Name.Local):
  14699 			val, err := decoder.Value()
  14700 			if err != nil {
  14701 				return err
  14702 			}
  14703 			if val == nil {
  14704 				break
  14705 			}
  14706 			{
  14707 				xtv := string(val)
  14708 				sv.Status = types.ChangeStatus(xtv)
  14709 			}
  14710 
  14711 		case strings.EqualFold("SubmittedAt", t.Name.Local):
  14712 			val, err := decoder.Value()
  14713 			if err != nil {
  14714 				return err
  14715 			}
  14716 			if val == nil {
  14717 				break
  14718 			}
  14719 			{
  14720 				xtv := string(val)
  14721 				t, err := smithytime.ParseDateTime(xtv)
  14722 				if err != nil {
  14723 					return err
  14724 				}
  14725 				sv.SubmittedAt = ptr.Time(t)
  14726 			}
  14727 
  14728 		default:
  14729 			// Do nothing and ignore the unexpected tag element
  14730 			err = decoder.Decoder.Skip()
  14731 			if err != nil {
  14732 				return err
  14733 			}
  14734 
  14735 		}
  14736 		decoder = originalDecoder
  14737 	}
  14738 	*v = sv
  14739 	return nil
  14740 }
  14741 
  14742 func awsRestxml_deserializeDocumentCheckerIpRanges(v *[]string, decoder smithyxml.NodeDecoder) error {
  14743 	if v == nil {
  14744 		return fmt.Errorf("unexpected nil of type %T", v)
  14745 	}
  14746 	var sv []string
  14747 	if *v == nil {
  14748 		sv = make([]string, 0)
  14749 	} else {
  14750 		sv = *v
  14751 	}
  14752 
  14753 	originalDecoder := decoder
  14754 	for {
  14755 		t, done, err := decoder.Token()
  14756 		if err != nil {
  14757 			return err
  14758 		}
  14759 		if done {
  14760 			break
  14761 		}
  14762 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14763 		decoder = memberDecoder
  14764 		switch {
  14765 		case strings.EqualFold("member", t.Name.Local):
  14766 			var col string
  14767 			val, err := decoder.Value()
  14768 			if err != nil {
  14769 				return err
  14770 			}
  14771 			if val == nil {
  14772 				break
  14773 			}
  14774 			{
  14775 				xtv := string(val)
  14776 				col = xtv
  14777 			}
  14778 			sv = append(sv, col)
  14779 
  14780 		default:
  14781 			err = decoder.Decoder.Skip()
  14782 			if err != nil {
  14783 				return err
  14784 			}
  14785 
  14786 		}
  14787 		decoder = originalDecoder
  14788 	}
  14789 	*v = sv
  14790 	return nil
  14791 }
  14792 
  14793 func awsRestxml_deserializeDocumentCheckerIpRangesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  14794 	var sv []string
  14795 	if *v == nil {
  14796 		sv = make([]string, 0)
  14797 	} else {
  14798 		sv = *v
  14799 	}
  14800 
  14801 	switch {
  14802 	default:
  14803 		var mv string
  14804 		t := decoder.StartEl
  14805 		_ = t
  14806 		val, err := decoder.Value()
  14807 		if err != nil {
  14808 			return err
  14809 		}
  14810 		if val == nil {
  14811 			break
  14812 		}
  14813 		{
  14814 			xtv := string(val)
  14815 			mv = xtv
  14816 		}
  14817 		sv = append(sv, mv)
  14818 	}
  14819 	*v = sv
  14820 	return nil
  14821 }
  14822 func awsRestxml_deserializeDocumentChildHealthCheckList(v *[]string, decoder smithyxml.NodeDecoder) error {
  14823 	if v == nil {
  14824 		return fmt.Errorf("unexpected nil of type %T", v)
  14825 	}
  14826 	var sv []string
  14827 	if *v == nil {
  14828 		sv = make([]string, 0)
  14829 	} else {
  14830 		sv = *v
  14831 	}
  14832 
  14833 	originalDecoder := decoder
  14834 	for {
  14835 		t, done, err := decoder.Token()
  14836 		if err != nil {
  14837 			return err
  14838 		}
  14839 		if done {
  14840 			break
  14841 		}
  14842 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14843 		decoder = memberDecoder
  14844 		switch {
  14845 		case strings.EqualFold("ChildHealthCheck", t.Name.Local):
  14846 			var col string
  14847 			val, err := decoder.Value()
  14848 			if err != nil {
  14849 				return err
  14850 			}
  14851 			if val == nil {
  14852 				break
  14853 			}
  14854 			{
  14855 				xtv := string(val)
  14856 				col = xtv
  14857 			}
  14858 			sv = append(sv, col)
  14859 
  14860 		default:
  14861 			err = decoder.Decoder.Skip()
  14862 			if err != nil {
  14863 				return err
  14864 			}
  14865 
  14866 		}
  14867 		decoder = originalDecoder
  14868 	}
  14869 	*v = sv
  14870 	return nil
  14871 }
  14872 
  14873 func awsRestxml_deserializeDocumentChildHealthCheckListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  14874 	var sv []string
  14875 	if *v == nil {
  14876 		sv = make([]string, 0)
  14877 	} else {
  14878 		sv = *v
  14879 	}
  14880 
  14881 	switch {
  14882 	default:
  14883 		var mv string
  14884 		t := decoder.StartEl
  14885 		_ = t
  14886 		val, err := decoder.Value()
  14887 		if err != nil {
  14888 			return err
  14889 		}
  14890 		if val == nil {
  14891 			break
  14892 		}
  14893 		{
  14894 			xtv := string(val)
  14895 			mv = xtv
  14896 		}
  14897 		sv = append(sv, mv)
  14898 	}
  14899 	*v = sv
  14900 	return nil
  14901 }
  14902 func awsRestxml_deserializeDocumentCidrBlockInUseException(v **types.CidrBlockInUseException, decoder smithyxml.NodeDecoder) error {
  14903 	if v == nil {
  14904 		return fmt.Errorf("unexpected nil of type %T", v)
  14905 	}
  14906 	var sv *types.CidrBlockInUseException
  14907 	if *v == nil {
  14908 		sv = &types.CidrBlockInUseException{}
  14909 	} else {
  14910 		sv = *v
  14911 	}
  14912 
  14913 	for {
  14914 		t, done, err := decoder.Token()
  14915 		if err != nil {
  14916 			return err
  14917 		}
  14918 		if done {
  14919 			break
  14920 		}
  14921 		originalDecoder := decoder
  14922 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14923 		switch {
  14924 		case strings.EqualFold("Message", t.Name.Local):
  14925 			val, err := decoder.Value()
  14926 			if err != nil {
  14927 				return err
  14928 			}
  14929 			if val == nil {
  14930 				break
  14931 			}
  14932 			{
  14933 				xtv := string(val)
  14934 				sv.Message = ptr.String(xtv)
  14935 			}
  14936 
  14937 		default:
  14938 			// Do nothing and ignore the unexpected tag element
  14939 			err = decoder.Decoder.Skip()
  14940 			if err != nil {
  14941 				return err
  14942 			}
  14943 
  14944 		}
  14945 		decoder = originalDecoder
  14946 	}
  14947 	*v = sv
  14948 	return nil
  14949 }
  14950 
  14951 func awsRestxml_deserializeDocumentCidrBlockSummaries(v *[]types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
  14952 	if v == nil {
  14953 		return fmt.Errorf("unexpected nil of type %T", v)
  14954 	}
  14955 	var sv []types.CidrBlockSummary
  14956 	if *v == nil {
  14957 		sv = make([]types.CidrBlockSummary, 0)
  14958 	} else {
  14959 		sv = *v
  14960 	}
  14961 
  14962 	originalDecoder := decoder
  14963 	for {
  14964 		t, done, err := decoder.Token()
  14965 		if err != nil {
  14966 			return err
  14967 		}
  14968 		if done {
  14969 			break
  14970 		}
  14971 		switch {
  14972 		case strings.EqualFold("member", t.Name.Local):
  14973 			var col types.CidrBlockSummary
  14974 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14975 			destAddr := &col
  14976 			if err := awsRestxml_deserializeDocumentCidrBlockSummary(&destAddr, nodeDecoder); err != nil {
  14977 				return err
  14978 			}
  14979 			col = *destAddr
  14980 			sv = append(sv, col)
  14981 
  14982 		default:
  14983 			err = decoder.Decoder.Skip()
  14984 			if err != nil {
  14985 				return err
  14986 			}
  14987 
  14988 		}
  14989 		decoder = originalDecoder
  14990 	}
  14991 	*v = sv
  14992 	return nil
  14993 }
  14994 
  14995 func awsRestxml_deserializeDocumentCidrBlockSummariesUnwrapped(v *[]types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
  14996 	var sv []types.CidrBlockSummary
  14997 	if *v == nil {
  14998 		sv = make([]types.CidrBlockSummary, 0)
  14999 	} else {
  15000 		sv = *v
  15001 	}
  15002 
  15003 	switch {
  15004 	default:
  15005 		var mv types.CidrBlockSummary
  15006 		t := decoder.StartEl
  15007 		_ = t
  15008 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15009 		destAddr := &mv
  15010 		if err := awsRestxml_deserializeDocumentCidrBlockSummary(&destAddr, nodeDecoder); err != nil {
  15011 			return err
  15012 		}
  15013 		mv = *destAddr
  15014 		sv = append(sv, mv)
  15015 	}
  15016 	*v = sv
  15017 	return nil
  15018 }
  15019 func awsRestxml_deserializeDocumentCidrBlockSummary(v **types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
  15020 	if v == nil {
  15021 		return fmt.Errorf("unexpected nil of type %T", v)
  15022 	}
  15023 	var sv *types.CidrBlockSummary
  15024 	if *v == nil {
  15025 		sv = &types.CidrBlockSummary{}
  15026 	} else {
  15027 		sv = *v
  15028 	}
  15029 
  15030 	for {
  15031 		t, done, err := decoder.Token()
  15032 		if err != nil {
  15033 			return err
  15034 		}
  15035 		if done {
  15036 			break
  15037 		}
  15038 		originalDecoder := decoder
  15039 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15040 		switch {
  15041 		case strings.EqualFold("CidrBlock", t.Name.Local):
  15042 			val, err := decoder.Value()
  15043 			if err != nil {
  15044 				return err
  15045 			}
  15046 			if val == nil {
  15047 				break
  15048 			}
  15049 			{
  15050 				xtv := string(val)
  15051 				sv.CidrBlock = ptr.String(xtv)
  15052 			}
  15053 
  15054 		case strings.EqualFold("LocationName", t.Name.Local):
  15055 			val, err := decoder.Value()
  15056 			if err != nil {
  15057 				return err
  15058 			}
  15059 			if val == nil {
  15060 				break
  15061 			}
  15062 			{
  15063 				xtv := string(val)
  15064 				sv.LocationName = ptr.String(xtv)
  15065 			}
  15066 
  15067 		default:
  15068 			// Do nothing and ignore the unexpected tag element
  15069 			err = decoder.Decoder.Skip()
  15070 			if err != nil {
  15071 				return err
  15072 			}
  15073 
  15074 		}
  15075 		decoder = originalDecoder
  15076 	}
  15077 	*v = sv
  15078 	return nil
  15079 }
  15080 
  15081 func awsRestxml_deserializeDocumentCidrCollection(v **types.CidrCollection, decoder smithyxml.NodeDecoder) error {
  15082 	if v == nil {
  15083 		return fmt.Errorf("unexpected nil of type %T", v)
  15084 	}
  15085 	var sv *types.CidrCollection
  15086 	if *v == nil {
  15087 		sv = &types.CidrCollection{}
  15088 	} else {
  15089 		sv = *v
  15090 	}
  15091 
  15092 	for {
  15093 		t, done, err := decoder.Token()
  15094 		if err != nil {
  15095 			return err
  15096 		}
  15097 		if done {
  15098 			break
  15099 		}
  15100 		originalDecoder := decoder
  15101 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15102 		switch {
  15103 		case strings.EqualFold("Arn", t.Name.Local):
  15104 			val, err := decoder.Value()
  15105 			if err != nil {
  15106 				return err
  15107 			}
  15108 			if val == nil {
  15109 				break
  15110 			}
  15111 			{
  15112 				xtv := string(val)
  15113 				sv.Arn = ptr.String(xtv)
  15114 			}
  15115 
  15116 		case strings.EqualFold("Id", t.Name.Local):
  15117 			val, err := decoder.Value()
  15118 			if err != nil {
  15119 				return err
  15120 			}
  15121 			if val == nil {
  15122 				break
  15123 			}
  15124 			{
  15125 				xtv := string(val)
  15126 				sv.Id = ptr.String(xtv)
  15127 			}
  15128 
  15129 		case strings.EqualFold("Name", t.Name.Local):
  15130 			val, err := decoder.Value()
  15131 			if err != nil {
  15132 				return err
  15133 			}
  15134 			if val == nil {
  15135 				break
  15136 			}
  15137 			{
  15138 				xtv := string(val)
  15139 				sv.Name = ptr.String(xtv)
  15140 			}
  15141 
  15142 		case strings.EqualFold("Version", t.Name.Local):
  15143 			val, err := decoder.Value()
  15144 			if err != nil {
  15145 				return err
  15146 			}
  15147 			if val == nil {
  15148 				break
  15149 			}
  15150 			{
  15151 				xtv := string(val)
  15152 				i64, err := strconv.ParseInt(xtv, 10, 64)
  15153 				if err != nil {
  15154 					return err
  15155 				}
  15156 				sv.Version = ptr.Int64(i64)
  15157 			}
  15158 
  15159 		default:
  15160 			// Do nothing and ignore the unexpected tag element
  15161 			err = decoder.Decoder.Skip()
  15162 			if err != nil {
  15163 				return err
  15164 			}
  15165 
  15166 		}
  15167 		decoder = originalDecoder
  15168 	}
  15169 	*v = sv
  15170 	return nil
  15171 }
  15172 
  15173 func awsRestxml_deserializeDocumentCidrCollectionAlreadyExistsException(v **types.CidrCollectionAlreadyExistsException, decoder smithyxml.NodeDecoder) error {
  15174 	if v == nil {
  15175 		return fmt.Errorf("unexpected nil of type %T", v)
  15176 	}
  15177 	var sv *types.CidrCollectionAlreadyExistsException
  15178 	if *v == nil {
  15179 		sv = &types.CidrCollectionAlreadyExistsException{}
  15180 	} else {
  15181 		sv = *v
  15182 	}
  15183 
  15184 	for {
  15185 		t, done, err := decoder.Token()
  15186 		if err != nil {
  15187 			return err
  15188 		}
  15189 		if done {
  15190 			break
  15191 		}
  15192 		originalDecoder := decoder
  15193 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15194 		switch {
  15195 		case strings.EqualFold("Message", t.Name.Local):
  15196 			val, err := decoder.Value()
  15197 			if err != nil {
  15198 				return err
  15199 			}
  15200 			if val == nil {
  15201 				break
  15202 			}
  15203 			{
  15204 				xtv := string(val)
  15205 				sv.Message = ptr.String(xtv)
  15206 			}
  15207 
  15208 		default:
  15209 			// Do nothing and ignore the unexpected tag element
  15210 			err = decoder.Decoder.Skip()
  15211 			if err != nil {
  15212 				return err
  15213 			}
  15214 
  15215 		}
  15216 		decoder = originalDecoder
  15217 	}
  15218 	*v = sv
  15219 	return nil
  15220 }
  15221 
  15222 func awsRestxml_deserializeDocumentCidrCollectionInUseException(v **types.CidrCollectionInUseException, decoder smithyxml.NodeDecoder) error {
  15223 	if v == nil {
  15224 		return fmt.Errorf("unexpected nil of type %T", v)
  15225 	}
  15226 	var sv *types.CidrCollectionInUseException
  15227 	if *v == nil {
  15228 		sv = &types.CidrCollectionInUseException{}
  15229 	} else {
  15230 		sv = *v
  15231 	}
  15232 
  15233 	for {
  15234 		t, done, err := decoder.Token()
  15235 		if err != nil {
  15236 			return err
  15237 		}
  15238 		if done {
  15239 			break
  15240 		}
  15241 		originalDecoder := decoder
  15242 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15243 		switch {
  15244 		case strings.EqualFold("Message", t.Name.Local):
  15245 			val, err := decoder.Value()
  15246 			if err != nil {
  15247 				return err
  15248 			}
  15249 			if val == nil {
  15250 				break
  15251 			}
  15252 			{
  15253 				xtv := string(val)
  15254 				sv.Message = ptr.String(xtv)
  15255 			}
  15256 
  15257 		default:
  15258 			// Do nothing and ignore the unexpected tag element
  15259 			err = decoder.Decoder.Skip()
  15260 			if err != nil {
  15261 				return err
  15262 			}
  15263 
  15264 		}
  15265 		decoder = originalDecoder
  15266 	}
  15267 	*v = sv
  15268 	return nil
  15269 }
  15270 
  15271 func awsRestxml_deserializeDocumentCidrCollectionVersionMismatchException(v **types.CidrCollectionVersionMismatchException, decoder smithyxml.NodeDecoder) error {
  15272 	if v == nil {
  15273 		return fmt.Errorf("unexpected nil of type %T", v)
  15274 	}
  15275 	var sv *types.CidrCollectionVersionMismatchException
  15276 	if *v == nil {
  15277 		sv = &types.CidrCollectionVersionMismatchException{}
  15278 	} else {
  15279 		sv = *v
  15280 	}
  15281 
  15282 	for {
  15283 		t, done, err := decoder.Token()
  15284 		if err != nil {
  15285 			return err
  15286 		}
  15287 		if done {
  15288 			break
  15289 		}
  15290 		originalDecoder := decoder
  15291 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15292 		switch {
  15293 		case strings.EqualFold("Message", t.Name.Local):
  15294 			val, err := decoder.Value()
  15295 			if err != nil {
  15296 				return err
  15297 			}
  15298 			if val == nil {
  15299 				break
  15300 			}
  15301 			{
  15302 				xtv := string(val)
  15303 				sv.Message = ptr.String(xtv)
  15304 			}
  15305 
  15306 		default:
  15307 			// Do nothing and ignore the unexpected tag element
  15308 			err = decoder.Decoder.Skip()
  15309 			if err != nil {
  15310 				return err
  15311 			}
  15312 
  15313 		}
  15314 		decoder = originalDecoder
  15315 	}
  15316 	*v = sv
  15317 	return nil
  15318 }
  15319 
  15320 func awsRestxml_deserializeDocumentCidrRoutingConfig(v **types.CidrRoutingConfig, decoder smithyxml.NodeDecoder) error {
  15321 	if v == nil {
  15322 		return fmt.Errorf("unexpected nil of type %T", v)
  15323 	}
  15324 	var sv *types.CidrRoutingConfig
  15325 	if *v == nil {
  15326 		sv = &types.CidrRoutingConfig{}
  15327 	} else {
  15328 		sv = *v
  15329 	}
  15330 
  15331 	for {
  15332 		t, done, err := decoder.Token()
  15333 		if err != nil {
  15334 			return err
  15335 		}
  15336 		if done {
  15337 			break
  15338 		}
  15339 		originalDecoder := decoder
  15340 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15341 		switch {
  15342 		case strings.EqualFold("CollectionId", t.Name.Local):
  15343 			val, err := decoder.Value()
  15344 			if err != nil {
  15345 				return err
  15346 			}
  15347 			if val == nil {
  15348 				break
  15349 			}
  15350 			{
  15351 				xtv := string(val)
  15352 				sv.CollectionId = ptr.String(xtv)
  15353 			}
  15354 
  15355 		case strings.EqualFold("LocationName", t.Name.Local):
  15356 			val, err := decoder.Value()
  15357 			if err != nil {
  15358 				return err
  15359 			}
  15360 			if val == nil {
  15361 				break
  15362 			}
  15363 			{
  15364 				xtv := string(val)
  15365 				sv.LocationName = ptr.String(xtv)
  15366 			}
  15367 
  15368 		default:
  15369 			// Do nothing and ignore the unexpected tag element
  15370 			err = decoder.Decoder.Skip()
  15371 			if err != nil {
  15372 				return err
  15373 			}
  15374 
  15375 		}
  15376 		decoder = originalDecoder
  15377 	}
  15378 	*v = sv
  15379 	return nil
  15380 }
  15381 
  15382 func awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(v **types.CloudWatchAlarmConfiguration, decoder smithyxml.NodeDecoder) error {
  15383 	if v == nil {
  15384 		return fmt.Errorf("unexpected nil of type %T", v)
  15385 	}
  15386 	var sv *types.CloudWatchAlarmConfiguration
  15387 	if *v == nil {
  15388 		sv = &types.CloudWatchAlarmConfiguration{}
  15389 	} else {
  15390 		sv = *v
  15391 	}
  15392 
  15393 	for {
  15394 		t, done, err := decoder.Token()
  15395 		if err != nil {
  15396 			return err
  15397 		}
  15398 		if done {
  15399 			break
  15400 		}
  15401 		originalDecoder := decoder
  15402 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15403 		switch {
  15404 		case strings.EqualFold("ComparisonOperator", t.Name.Local):
  15405 			val, err := decoder.Value()
  15406 			if err != nil {
  15407 				return err
  15408 			}
  15409 			if val == nil {
  15410 				break
  15411 			}
  15412 			{
  15413 				xtv := string(val)
  15414 				sv.ComparisonOperator = types.ComparisonOperator(xtv)
  15415 			}
  15416 
  15417 		case strings.EqualFold("Dimensions", t.Name.Local):
  15418 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15419 			if err := awsRestxml_deserializeDocumentDimensionList(&sv.Dimensions, nodeDecoder); err != nil {
  15420 				return err
  15421 			}
  15422 
  15423 		case strings.EqualFold("EvaluationPeriods", t.Name.Local):
  15424 			val, err := decoder.Value()
  15425 			if err != nil {
  15426 				return err
  15427 			}
  15428 			if val == nil {
  15429 				break
  15430 			}
  15431 			{
  15432 				xtv := string(val)
  15433 				i64, err := strconv.ParseInt(xtv, 10, 64)
  15434 				if err != nil {
  15435 					return err
  15436 				}
  15437 				sv.EvaluationPeriods = ptr.Int32(int32(i64))
  15438 			}
  15439 
  15440 		case strings.EqualFold("MetricName", t.Name.Local):
  15441 			val, err := decoder.Value()
  15442 			if err != nil {
  15443 				return err
  15444 			}
  15445 			if val == nil {
  15446 				break
  15447 			}
  15448 			{
  15449 				xtv := string(val)
  15450 				sv.MetricName = ptr.String(xtv)
  15451 			}
  15452 
  15453 		case strings.EqualFold("Namespace", t.Name.Local):
  15454 			val, err := decoder.Value()
  15455 			if err != nil {
  15456 				return err
  15457 			}
  15458 			if val == nil {
  15459 				break
  15460 			}
  15461 			{
  15462 				xtv := string(val)
  15463 				sv.Namespace = ptr.String(xtv)
  15464 			}
  15465 
  15466 		case strings.EqualFold("Period", t.Name.Local):
  15467 			val, err := decoder.Value()
  15468 			if err != nil {
  15469 				return err
  15470 			}
  15471 			if val == nil {
  15472 				break
  15473 			}
  15474 			{
  15475 				xtv := string(val)
  15476 				i64, err := strconv.ParseInt(xtv, 10, 64)
  15477 				if err != nil {
  15478 					return err
  15479 				}
  15480 				sv.Period = ptr.Int32(int32(i64))
  15481 			}
  15482 
  15483 		case strings.EqualFold("Statistic", t.Name.Local):
  15484 			val, err := decoder.Value()
  15485 			if err != nil {
  15486 				return err
  15487 			}
  15488 			if val == nil {
  15489 				break
  15490 			}
  15491 			{
  15492 				xtv := string(val)
  15493 				sv.Statistic = types.Statistic(xtv)
  15494 			}
  15495 
  15496 		case strings.EqualFold("Threshold", t.Name.Local):
  15497 			val, err := decoder.Value()
  15498 			if err != nil {
  15499 				return err
  15500 			}
  15501 			if val == nil {
  15502 				break
  15503 			}
  15504 			{
  15505 				xtv := string(val)
  15506 				f64, err := strconv.ParseFloat(xtv, 64)
  15507 				if err != nil {
  15508 					return err
  15509 				}
  15510 				sv.Threshold = ptr.Float64(f64)
  15511 			}
  15512 
  15513 		default:
  15514 			// Do nothing and ignore the unexpected tag element
  15515 			err = decoder.Decoder.Skip()
  15516 			if err != nil {
  15517 				return err
  15518 			}
  15519 
  15520 		}
  15521 		decoder = originalDecoder
  15522 	}
  15523 	*v = sv
  15524 	return nil
  15525 }
  15526 
  15527 func awsRestxml_deserializeDocumentCollectionSummaries(v *[]types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
  15528 	if v == nil {
  15529 		return fmt.Errorf("unexpected nil of type %T", v)
  15530 	}
  15531 	var sv []types.CollectionSummary
  15532 	if *v == nil {
  15533 		sv = make([]types.CollectionSummary, 0)
  15534 	} else {
  15535 		sv = *v
  15536 	}
  15537 
  15538 	originalDecoder := decoder
  15539 	for {
  15540 		t, done, err := decoder.Token()
  15541 		if err != nil {
  15542 			return err
  15543 		}
  15544 		if done {
  15545 			break
  15546 		}
  15547 		switch {
  15548 		case strings.EqualFold("member", t.Name.Local):
  15549 			var col types.CollectionSummary
  15550 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15551 			destAddr := &col
  15552 			if err := awsRestxml_deserializeDocumentCollectionSummary(&destAddr, nodeDecoder); err != nil {
  15553 				return err
  15554 			}
  15555 			col = *destAddr
  15556 			sv = append(sv, col)
  15557 
  15558 		default:
  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_deserializeDocumentCollectionSummariesUnwrapped(v *[]types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
  15572 	var sv []types.CollectionSummary
  15573 	if *v == nil {
  15574 		sv = make([]types.CollectionSummary, 0)
  15575 	} else {
  15576 		sv = *v
  15577 	}
  15578 
  15579 	switch {
  15580 	default:
  15581 		var mv types.CollectionSummary
  15582 		t := decoder.StartEl
  15583 		_ = t
  15584 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15585 		destAddr := &mv
  15586 		if err := awsRestxml_deserializeDocumentCollectionSummary(&destAddr, nodeDecoder); err != nil {
  15587 			return err
  15588 		}
  15589 		mv = *destAddr
  15590 		sv = append(sv, mv)
  15591 	}
  15592 	*v = sv
  15593 	return nil
  15594 }
  15595 func awsRestxml_deserializeDocumentCollectionSummary(v **types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
  15596 	if v == nil {
  15597 		return fmt.Errorf("unexpected nil of type %T", v)
  15598 	}
  15599 	var sv *types.CollectionSummary
  15600 	if *v == nil {
  15601 		sv = &types.CollectionSummary{}
  15602 	} else {
  15603 		sv = *v
  15604 	}
  15605 
  15606 	for {
  15607 		t, done, err := decoder.Token()
  15608 		if err != nil {
  15609 			return err
  15610 		}
  15611 		if done {
  15612 			break
  15613 		}
  15614 		originalDecoder := decoder
  15615 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15616 		switch {
  15617 		case strings.EqualFold("Arn", t.Name.Local):
  15618 			val, err := decoder.Value()
  15619 			if err != nil {
  15620 				return err
  15621 			}
  15622 			if val == nil {
  15623 				break
  15624 			}
  15625 			{
  15626 				xtv := string(val)
  15627 				sv.Arn = ptr.String(xtv)
  15628 			}
  15629 
  15630 		case strings.EqualFold("Id", t.Name.Local):
  15631 			val, err := decoder.Value()
  15632 			if err != nil {
  15633 				return err
  15634 			}
  15635 			if val == nil {
  15636 				break
  15637 			}
  15638 			{
  15639 				xtv := string(val)
  15640 				sv.Id = ptr.String(xtv)
  15641 			}
  15642 
  15643 		case strings.EqualFold("Name", t.Name.Local):
  15644 			val, err := decoder.Value()
  15645 			if err != nil {
  15646 				return err
  15647 			}
  15648 			if val == nil {
  15649 				break
  15650 			}
  15651 			{
  15652 				xtv := string(val)
  15653 				sv.Name = ptr.String(xtv)
  15654 			}
  15655 
  15656 		case strings.EqualFold("Version", t.Name.Local):
  15657 			val, err := decoder.Value()
  15658 			if err != nil {
  15659 				return err
  15660 			}
  15661 			if val == nil {
  15662 				break
  15663 			}
  15664 			{
  15665 				xtv := string(val)
  15666 				i64, err := strconv.ParseInt(xtv, 10, 64)
  15667 				if err != nil {
  15668 					return err
  15669 				}
  15670 				sv.Version = ptr.Int64(i64)
  15671 			}
  15672 
  15673 		default:
  15674 			// Do nothing and ignore the unexpected tag element
  15675 			err = decoder.Decoder.Skip()
  15676 			if err != nil {
  15677 				return err
  15678 			}
  15679 
  15680 		}
  15681 		decoder = originalDecoder
  15682 	}
  15683 	*v = sv
  15684 	return nil
  15685 }
  15686 
  15687 func awsRestxml_deserializeDocumentConcurrentModification(v **types.ConcurrentModification, decoder smithyxml.NodeDecoder) error {
  15688 	if v == nil {
  15689 		return fmt.Errorf("unexpected nil of type %T", v)
  15690 	}
  15691 	var sv *types.ConcurrentModification
  15692 	if *v == nil {
  15693 		sv = &types.ConcurrentModification{}
  15694 	} else {
  15695 		sv = *v
  15696 	}
  15697 
  15698 	for {
  15699 		t, done, err := decoder.Token()
  15700 		if err != nil {
  15701 			return err
  15702 		}
  15703 		if done {
  15704 			break
  15705 		}
  15706 		originalDecoder := decoder
  15707 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15708 		switch {
  15709 		case strings.EqualFold("message", t.Name.Local):
  15710 			val, err := decoder.Value()
  15711 			if err != nil {
  15712 				return err
  15713 			}
  15714 			if val == nil {
  15715 				break
  15716 			}
  15717 			{
  15718 				xtv := string(val)
  15719 				sv.Message = ptr.String(xtv)
  15720 			}
  15721 
  15722 		default:
  15723 			// Do nothing and ignore the unexpected tag element
  15724 			err = decoder.Decoder.Skip()
  15725 			if err != nil {
  15726 				return err
  15727 			}
  15728 
  15729 		}
  15730 		decoder = originalDecoder
  15731 	}
  15732 	*v = sv
  15733 	return nil
  15734 }
  15735 
  15736 func awsRestxml_deserializeDocumentConflictingDomainExists(v **types.ConflictingDomainExists, decoder smithyxml.NodeDecoder) error {
  15737 	if v == nil {
  15738 		return fmt.Errorf("unexpected nil of type %T", v)
  15739 	}
  15740 	var sv *types.ConflictingDomainExists
  15741 	if *v == nil {
  15742 		sv = &types.ConflictingDomainExists{}
  15743 	} else {
  15744 		sv = *v
  15745 	}
  15746 
  15747 	for {
  15748 		t, done, err := decoder.Token()
  15749 		if err != nil {
  15750 			return err
  15751 		}
  15752 		if done {
  15753 			break
  15754 		}
  15755 		originalDecoder := decoder
  15756 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15757 		switch {
  15758 		case strings.EqualFold("message", t.Name.Local):
  15759 			val, err := decoder.Value()
  15760 			if err != nil {
  15761 				return err
  15762 			}
  15763 			if val == nil {
  15764 				break
  15765 			}
  15766 			{
  15767 				xtv := string(val)
  15768 				sv.Message = ptr.String(xtv)
  15769 			}
  15770 
  15771 		default:
  15772 			// Do nothing and ignore the unexpected tag element
  15773 			err = decoder.Decoder.Skip()
  15774 			if err != nil {
  15775 				return err
  15776 			}
  15777 
  15778 		}
  15779 		decoder = originalDecoder
  15780 	}
  15781 	*v = sv
  15782 	return nil
  15783 }
  15784 
  15785 func awsRestxml_deserializeDocumentConflictingTypes(v **types.ConflictingTypes, decoder smithyxml.NodeDecoder) error {
  15786 	if v == nil {
  15787 		return fmt.Errorf("unexpected nil of type %T", v)
  15788 	}
  15789 	var sv *types.ConflictingTypes
  15790 	if *v == nil {
  15791 		sv = &types.ConflictingTypes{}
  15792 	} else {
  15793 		sv = *v
  15794 	}
  15795 
  15796 	for {
  15797 		t, done, err := decoder.Token()
  15798 		if err != nil {
  15799 			return err
  15800 		}
  15801 		if done {
  15802 			break
  15803 		}
  15804 		originalDecoder := decoder
  15805 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15806 		switch {
  15807 		case strings.EqualFold("message", t.Name.Local):
  15808 			val, err := decoder.Value()
  15809 			if err != nil {
  15810 				return err
  15811 			}
  15812 			if val == nil {
  15813 				break
  15814 			}
  15815 			{
  15816 				xtv := string(val)
  15817 				sv.Message = ptr.String(xtv)
  15818 			}
  15819 
  15820 		default:
  15821 			// Do nothing and ignore the unexpected tag element
  15822 			err = decoder.Decoder.Skip()
  15823 			if err != nil {
  15824 				return err
  15825 			}
  15826 
  15827 		}
  15828 		decoder = originalDecoder
  15829 	}
  15830 	*v = sv
  15831 	return nil
  15832 }
  15833 
  15834 func awsRestxml_deserializeDocumentCoordinates(v **types.Coordinates, decoder smithyxml.NodeDecoder) error {
  15835 	if v == nil {
  15836 		return fmt.Errorf("unexpected nil of type %T", v)
  15837 	}
  15838 	var sv *types.Coordinates
  15839 	if *v == nil {
  15840 		sv = &types.Coordinates{}
  15841 	} else {
  15842 		sv = *v
  15843 	}
  15844 
  15845 	for {
  15846 		t, done, err := decoder.Token()
  15847 		if err != nil {
  15848 			return err
  15849 		}
  15850 		if done {
  15851 			break
  15852 		}
  15853 		originalDecoder := decoder
  15854 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15855 		switch {
  15856 		case strings.EqualFold("Latitude", t.Name.Local):
  15857 			val, err := decoder.Value()
  15858 			if err != nil {
  15859 				return err
  15860 			}
  15861 			if val == nil {
  15862 				break
  15863 			}
  15864 			{
  15865 				xtv := string(val)
  15866 				sv.Latitude = ptr.String(xtv)
  15867 			}
  15868 
  15869 		case strings.EqualFold("Longitude", t.Name.Local):
  15870 			val, err := decoder.Value()
  15871 			if err != nil {
  15872 				return err
  15873 			}
  15874 			if val == nil {
  15875 				break
  15876 			}
  15877 			{
  15878 				xtv := string(val)
  15879 				sv.Longitude = ptr.String(xtv)
  15880 			}
  15881 
  15882 		default:
  15883 			// Do nothing and ignore the unexpected tag element
  15884 			err = decoder.Decoder.Skip()
  15885 			if err != nil {
  15886 				return err
  15887 			}
  15888 
  15889 		}
  15890 		decoder = originalDecoder
  15891 	}
  15892 	*v = sv
  15893 	return nil
  15894 }
  15895 
  15896 func awsRestxml_deserializeDocumentDelegationSet(v **types.DelegationSet, decoder smithyxml.NodeDecoder) error {
  15897 	if v == nil {
  15898 		return fmt.Errorf("unexpected nil of type %T", v)
  15899 	}
  15900 	var sv *types.DelegationSet
  15901 	if *v == nil {
  15902 		sv = &types.DelegationSet{}
  15903 	} else {
  15904 		sv = *v
  15905 	}
  15906 
  15907 	for {
  15908 		t, done, err := decoder.Token()
  15909 		if err != nil {
  15910 			return err
  15911 		}
  15912 		if done {
  15913 			break
  15914 		}
  15915 		originalDecoder := decoder
  15916 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15917 		switch {
  15918 		case strings.EqualFold("CallerReference", t.Name.Local):
  15919 			val, err := decoder.Value()
  15920 			if err != nil {
  15921 				return err
  15922 			}
  15923 			if val == nil {
  15924 				break
  15925 			}
  15926 			{
  15927 				xtv := string(val)
  15928 				sv.CallerReference = ptr.String(xtv)
  15929 			}
  15930 
  15931 		case strings.EqualFold("Id", t.Name.Local):
  15932 			val, err := decoder.Value()
  15933 			if err != nil {
  15934 				return err
  15935 			}
  15936 			if val == nil {
  15937 				break
  15938 			}
  15939 			{
  15940 				xtv := string(val)
  15941 				sv.Id = ptr.String(xtv)
  15942 			}
  15943 
  15944 		case strings.EqualFold("NameServers", t.Name.Local):
  15945 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15946 			if err := awsRestxml_deserializeDocumentDelegationSetNameServers(&sv.NameServers, nodeDecoder); err != nil {
  15947 				return err
  15948 			}
  15949 
  15950 		default:
  15951 			// Do nothing and ignore the unexpected tag element
  15952 			err = decoder.Decoder.Skip()
  15953 			if err != nil {
  15954 				return err
  15955 			}
  15956 
  15957 		}
  15958 		decoder = originalDecoder
  15959 	}
  15960 	*v = sv
  15961 	return nil
  15962 }
  15963 
  15964 func awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(v **types.DelegationSetAlreadyCreated, decoder smithyxml.NodeDecoder) error {
  15965 	if v == nil {
  15966 		return fmt.Errorf("unexpected nil of type %T", v)
  15967 	}
  15968 	var sv *types.DelegationSetAlreadyCreated
  15969 	if *v == nil {
  15970 		sv = &types.DelegationSetAlreadyCreated{}
  15971 	} else {
  15972 		sv = *v
  15973 	}
  15974 
  15975 	for {
  15976 		t, done, err := decoder.Token()
  15977 		if err != nil {
  15978 			return err
  15979 		}
  15980 		if done {
  15981 			break
  15982 		}
  15983 		originalDecoder := decoder
  15984 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15985 		switch {
  15986 		case strings.EqualFold("message", t.Name.Local):
  15987 			val, err := decoder.Value()
  15988 			if err != nil {
  15989 				return err
  15990 			}
  15991 			if val == nil {
  15992 				break
  15993 			}
  15994 			{
  15995 				xtv := string(val)
  15996 				sv.Message = ptr.String(xtv)
  15997 			}
  15998 
  15999 		default:
  16000 			// Do nothing and ignore the unexpected tag element
  16001 			err = decoder.Decoder.Skip()
  16002 			if err != nil {
  16003 				return err
  16004 			}
  16005 
  16006 		}
  16007 		decoder = originalDecoder
  16008 	}
  16009 	*v = sv
  16010 	return nil
  16011 }
  16012 
  16013 func awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(v **types.DelegationSetAlreadyReusable, decoder smithyxml.NodeDecoder) error {
  16014 	if v == nil {
  16015 		return fmt.Errorf("unexpected nil of type %T", v)
  16016 	}
  16017 	var sv *types.DelegationSetAlreadyReusable
  16018 	if *v == nil {
  16019 		sv = &types.DelegationSetAlreadyReusable{}
  16020 	} else {
  16021 		sv = *v
  16022 	}
  16023 
  16024 	for {
  16025 		t, done, err := decoder.Token()
  16026 		if err != nil {
  16027 			return err
  16028 		}
  16029 		if done {
  16030 			break
  16031 		}
  16032 		originalDecoder := decoder
  16033 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16034 		switch {
  16035 		case strings.EqualFold("message", t.Name.Local):
  16036 			val, err := decoder.Value()
  16037 			if err != nil {
  16038 				return err
  16039 			}
  16040 			if val == nil {
  16041 				break
  16042 			}
  16043 			{
  16044 				xtv := string(val)
  16045 				sv.Message = ptr.String(xtv)
  16046 			}
  16047 
  16048 		default:
  16049 			// Do nothing and ignore the unexpected tag element
  16050 			err = decoder.Decoder.Skip()
  16051 			if err != nil {
  16052 				return err
  16053 			}
  16054 
  16055 		}
  16056 		decoder = originalDecoder
  16057 	}
  16058 	*v = sv
  16059 	return nil
  16060 }
  16061 
  16062 func awsRestxml_deserializeDocumentDelegationSetInUse(v **types.DelegationSetInUse, decoder smithyxml.NodeDecoder) error {
  16063 	if v == nil {
  16064 		return fmt.Errorf("unexpected nil of type %T", v)
  16065 	}
  16066 	var sv *types.DelegationSetInUse
  16067 	if *v == nil {
  16068 		sv = &types.DelegationSetInUse{}
  16069 	} else {
  16070 		sv = *v
  16071 	}
  16072 
  16073 	for {
  16074 		t, done, err := decoder.Token()
  16075 		if err != nil {
  16076 			return err
  16077 		}
  16078 		if done {
  16079 			break
  16080 		}
  16081 		originalDecoder := decoder
  16082 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16083 		switch {
  16084 		case strings.EqualFold("message", t.Name.Local):
  16085 			val, err := decoder.Value()
  16086 			if err != nil {
  16087 				return err
  16088 			}
  16089 			if val == nil {
  16090 				break
  16091 			}
  16092 			{
  16093 				xtv := string(val)
  16094 				sv.Message = ptr.String(xtv)
  16095 			}
  16096 
  16097 		default:
  16098 			// Do nothing and ignore the unexpected tag element
  16099 			err = decoder.Decoder.Skip()
  16100 			if err != nil {
  16101 				return err
  16102 			}
  16103 
  16104 		}
  16105 		decoder = originalDecoder
  16106 	}
  16107 	*v = sv
  16108 	return nil
  16109 }
  16110 
  16111 func awsRestxml_deserializeDocumentDelegationSetNameServers(v *[]string, decoder smithyxml.NodeDecoder) error {
  16112 	if v == nil {
  16113 		return fmt.Errorf("unexpected nil of type %T", v)
  16114 	}
  16115 	var sv []string
  16116 	if *v == nil {
  16117 		sv = make([]string, 0)
  16118 	} else {
  16119 		sv = *v
  16120 	}
  16121 
  16122 	originalDecoder := decoder
  16123 	for {
  16124 		t, done, err := decoder.Token()
  16125 		if err != nil {
  16126 			return err
  16127 		}
  16128 		if done {
  16129 			break
  16130 		}
  16131 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16132 		decoder = memberDecoder
  16133 		switch {
  16134 		case strings.EqualFold("NameServer", t.Name.Local):
  16135 			var col string
  16136 			val, err := decoder.Value()
  16137 			if err != nil {
  16138 				return err
  16139 			}
  16140 			if val == nil {
  16141 				break
  16142 			}
  16143 			{
  16144 				xtv := string(val)
  16145 				col = xtv
  16146 			}
  16147 			sv = append(sv, col)
  16148 
  16149 		default:
  16150 			err = decoder.Decoder.Skip()
  16151 			if err != nil {
  16152 				return err
  16153 			}
  16154 
  16155 		}
  16156 		decoder = originalDecoder
  16157 	}
  16158 	*v = sv
  16159 	return nil
  16160 }
  16161 
  16162 func awsRestxml_deserializeDocumentDelegationSetNameServersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  16163 	var sv []string
  16164 	if *v == nil {
  16165 		sv = make([]string, 0)
  16166 	} else {
  16167 		sv = *v
  16168 	}
  16169 
  16170 	switch {
  16171 	default:
  16172 		var mv string
  16173 		t := decoder.StartEl
  16174 		_ = t
  16175 		val, err := decoder.Value()
  16176 		if err != nil {
  16177 			return err
  16178 		}
  16179 		if val == nil {
  16180 			break
  16181 		}
  16182 		{
  16183 			xtv := string(val)
  16184 			mv = xtv
  16185 		}
  16186 		sv = append(sv, mv)
  16187 	}
  16188 	*v = sv
  16189 	return nil
  16190 }
  16191 func awsRestxml_deserializeDocumentDelegationSetNotAvailable(v **types.DelegationSetNotAvailable, decoder smithyxml.NodeDecoder) error {
  16192 	if v == nil {
  16193 		return fmt.Errorf("unexpected nil of type %T", v)
  16194 	}
  16195 	var sv *types.DelegationSetNotAvailable
  16196 	if *v == nil {
  16197 		sv = &types.DelegationSetNotAvailable{}
  16198 	} else {
  16199 		sv = *v
  16200 	}
  16201 
  16202 	for {
  16203 		t, done, err := decoder.Token()
  16204 		if err != nil {
  16205 			return err
  16206 		}
  16207 		if done {
  16208 			break
  16209 		}
  16210 		originalDecoder := decoder
  16211 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16212 		switch {
  16213 		case strings.EqualFold("message", t.Name.Local):
  16214 			val, err := decoder.Value()
  16215 			if err != nil {
  16216 				return err
  16217 			}
  16218 			if val == nil {
  16219 				break
  16220 			}
  16221 			{
  16222 				xtv := string(val)
  16223 				sv.Message = ptr.String(xtv)
  16224 			}
  16225 
  16226 		default:
  16227 			// Do nothing and ignore the unexpected tag element
  16228 			err = decoder.Decoder.Skip()
  16229 			if err != nil {
  16230 				return err
  16231 			}
  16232 
  16233 		}
  16234 		decoder = originalDecoder
  16235 	}
  16236 	*v = sv
  16237 	return nil
  16238 }
  16239 
  16240 func awsRestxml_deserializeDocumentDelegationSetNotReusable(v **types.DelegationSetNotReusable, decoder smithyxml.NodeDecoder) error {
  16241 	if v == nil {
  16242 		return fmt.Errorf("unexpected nil of type %T", v)
  16243 	}
  16244 	var sv *types.DelegationSetNotReusable
  16245 	if *v == nil {
  16246 		sv = &types.DelegationSetNotReusable{}
  16247 	} else {
  16248 		sv = *v
  16249 	}
  16250 
  16251 	for {
  16252 		t, done, err := decoder.Token()
  16253 		if err != nil {
  16254 			return err
  16255 		}
  16256 		if done {
  16257 			break
  16258 		}
  16259 		originalDecoder := decoder
  16260 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16261 		switch {
  16262 		case strings.EqualFold("message", t.Name.Local):
  16263 			val, err := decoder.Value()
  16264 			if err != nil {
  16265 				return err
  16266 			}
  16267 			if val == nil {
  16268 				break
  16269 			}
  16270 			{
  16271 				xtv := string(val)
  16272 				sv.Message = ptr.String(xtv)
  16273 			}
  16274 
  16275 		default:
  16276 			// Do nothing and ignore the unexpected tag element
  16277 			err = decoder.Decoder.Skip()
  16278 			if err != nil {
  16279 				return err
  16280 			}
  16281 
  16282 		}
  16283 		decoder = originalDecoder
  16284 	}
  16285 	*v = sv
  16286 	return nil
  16287 }
  16288 
  16289 func awsRestxml_deserializeDocumentDelegationSets(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error {
  16290 	if v == nil {
  16291 		return fmt.Errorf("unexpected nil of type %T", v)
  16292 	}
  16293 	var sv []types.DelegationSet
  16294 	if *v == nil {
  16295 		sv = make([]types.DelegationSet, 0)
  16296 	} else {
  16297 		sv = *v
  16298 	}
  16299 
  16300 	originalDecoder := decoder
  16301 	for {
  16302 		t, done, err := decoder.Token()
  16303 		if err != nil {
  16304 			return err
  16305 		}
  16306 		if done {
  16307 			break
  16308 		}
  16309 		switch {
  16310 		case strings.EqualFold("DelegationSet", t.Name.Local):
  16311 			var col types.DelegationSet
  16312 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16313 			destAddr := &col
  16314 			if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil {
  16315 				return err
  16316 			}
  16317 			col = *destAddr
  16318 			sv = append(sv, col)
  16319 
  16320 		default:
  16321 			err = decoder.Decoder.Skip()
  16322 			if err != nil {
  16323 				return err
  16324 			}
  16325 
  16326 		}
  16327 		decoder = originalDecoder
  16328 	}
  16329 	*v = sv
  16330 	return nil
  16331 }
  16332 
  16333 func awsRestxml_deserializeDocumentDelegationSetsUnwrapped(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error {
  16334 	var sv []types.DelegationSet
  16335 	if *v == nil {
  16336 		sv = make([]types.DelegationSet, 0)
  16337 	} else {
  16338 		sv = *v
  16339 	}
  16340 
  16341 	switch {
  16342 	default:
  16343 		var mv types.DelegationSet
  16344 		t := decoder.StartEl
  16345 		_ = t
  16346 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16347 		destAddr := &mv
  16348 		if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil {
  16349 			return err
  16350 		}
  16351 		mv = *destAddr
  16352 		sv = append(sv, mv)
  16353 	}
  16354 	*v = sv
  16355 	return nil
  16356 }
  16357 func awsRestxml_deserializeDocumentDimension(v **types.Dimension, decoder smithyxml.NodeDecoder) error {
  16358 	if v == nil {
  16359 		return fmt.Errorf("unexpected nil of type %T", v)
  16360 	}
  16361 	var sv *types.Dimension
  16362 	if *v == nil {
  16363 		sv = &types.Dimension{}
  16364 	} else {
  16365 		sv = *v
  16366 	}
  16367 
  16368 	for {
  16369 		t, done, err := decoder.Token()
  16370 		if err != nil {
  16371 			return err
  16372 		}
  16373 		if done {
  16374 			break
  16375 		}
  16376 		originalDecoder := decoder
  16377 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16378 		switch {
  16379 		case strings.EqualFold("Name", t.Name.Local):
  16380 			val, err := decoder.Value()
  16381 			if err != nil {
  16382 				return err
  16383 			}
  16384 			if val == nil {
  16385 				break
  16386 			}
  16387 			{
  16388 				xtv := string(val)
  16389 				sv.Name = ptr.String(xtv)
  16390 			}
  16391 
  16392 		case strings.EqualFold("Value", t.Name.Local):
  16393 			val, err := decoder.Value()
  16394 			if err != nil {
  16395 				return err
  16396 			}
  16397 			if val == nil {
  16398 				break
  16399 			}
  16400 			{
  16401 				xtv := string(val)
  16402 				sv.Value = ptr.String(xtv)
  16403 			}
  16404 
  16405 		default:
  16406 			// Do nothing and ignore the unexpected tag element
  16407 			err = decoder.Decoder.Skip()
  16408 			if err != nil {
  16409 				return err
  16410 			}
  16411 
  16412 		}
  16413 		decoder = originalDecoder
  16414 	}
  16415 	*v = sv
  16416 	return nil
  16417 }
  16418 
  16419 func awsRestxml_deserializeDocumentDimensionList(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error {
  16420 	if v == nil {
  16421 		return fmt.Errorf("unexpected nil of type %T", v)
  16422 	}
  16423 	var sv []types.Dimension
  16424 	if *v == nil {
  16425 		sv = make([]types.Dimension, 0)
  16426 	} else {
  16427 		sv = *v
  16428 	}
  16429 
  16430 	originalDecoder := decoder
  16431 	for {
  16432 		t, done, err := decoder.Token()
  16433 		if err != nil {
  16434 			return err
  16435 		}
  16436 		if done {
  16437 			break
  16438 		}
  16439 		switch {
  16440 		case strings.EqualFold("Dimension", t.Name.Local):
  16441 			var col types.Dimension
  16442 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16443 			destAddr := &col
  16444 			if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil {
  16445 				return err
  16446 			}
  16447 			col = *destAddr
  16448 			sv = append(sv, col)
  16449 
  16450 		default:
  16451 			err = decoder.Decoder.Skip()
  16452 			if err != nil {
  16453 				return err
  16454 			}
  16455 
  16456 		}
  16457 		decoder = originalDecoder
  16458 	}
  16459 	*v = sv
  16460 	return nil
  16461 }
  16462 
  16463 func awsRestxml_deserializeDocumentDimensionListUnwrapped(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error {
  16464 	var sv []types.Dimension
  16465 	if *v == nil {
  16466 		sv = make([]types.Dimension, 0)
  16467 	} else {
  16468 		sv = *v
  16469 	}
  16470 
  16471 	switch {
  16472 	default:
  16473 		var mv types.Dimension
  16474 		t := decoder.StartEl
  16475 		_ = t
  16476 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16477 		destAddr := &mv
  16478 		if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil {
  16479 			return err
  16480 		}
  16481 		mv = *destAddr
  16482 		sv = append(sv, mv)
  16483 	}
  16484 	*v = sv
  16485 	return nil
  16486 }
  16487 func awsRestxml_deserializeDocumentDNSSECNotFound(v **types.DNSSECNotFound, decoder smithyxml.NodeDecoder) error {
  16488 	if v == nil {
  16489 		return fmt.Errorf("unexpected nil of type %T", v)
  16490 	}
  16491 	var sv *types.DNSSECNotFound
  16492 	if *v == nil {
  16493 		sv = &types.DNSSECNotFound{}
  16494 	} else {
  16495 		sv = *v
  16496 	}
  16497 
  16498 	for {
  16499 		t, done, err := decoder.Token()
  16500 		if err != nil {
  16501 			return err
  16502 		}
  16503 		if done {
  16504 			break
  16505 		}
  16506 		originalDecoder := decoder
  16507 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16508 		switch {
  16509 		case strings.EqualFold("message", t.Name.Local):
  16510 			val, err := decoder.Value()
  16511 			if err != nil {
  16512 				return err
  16513 			}
  16514 			if val == nil {
  16515 				break
  16516 			}
  16517 			{
  16518 				xtv := string(val)
  16519 				sv.Message = ptr.String(xtv)
  16520 			}
  16521 
  16522 		default:
  16523 			// Do nothing and ignore the unexpected tag element
  16524 			err = decoder.Decoder.Skip()
  16525 			if err != nil {
  16526 				return err
  16527 			}
  16528 
  16529 		}
  16530 		decoder = originalDecoder
  16531 	}
  16532 	*v = sv
  16533 	return nil
  16534 }
  16535 
  16536 func awsRestxml_deserializeDocumentDNSSECStatus(v **types.DNSSECStatus, decoder smithyxml.NodeDecoder) error {
  16537 	if v == nil {
  16538 		return fmt.Errorf("unexpected nil of type %T", v)
  16539 	}
  16540 	var sv *types.DNSSECStatus
  16541 	if *v == nil {
  16542 		sv = &types.DNSSECStatus{}
  16543 	} else {
  16544 		sv = *v
  16545 	}
  16546 
  16547 	for {
  16548 		t, done, err := decoder.Token()
  16549 		if err != nil {
  16550 			return err
  16551 		}
  16552 		if done {
  16553 			break
  16554 		}
  16555 		originalDecoder := decoder
  16556 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16557 		switch {
  16558 		case strings.EqualFold("ServeSignature", t.Name.Local):
  16559 			val, err := decoder.Value()
  16560 			if err != nil {
  16561 				return err
  16562 			}
  16563 			if val == nil {
  16564 				break
  16565 			}
  16566 			{
  16567 				xtv := string(val)
  16568 				sv.ServeSignature = ptr.String(xtv)
  16569 			}
  16570 
  16571 		case strings.EqualFold("StatusMessage", t.Name.Local):
  16572 			val, err := decoder.Value()
  16573 			if err != nil {
  16574 				return err
  16575 			}
  16576 			if val == nil {
  16577 				break
  16578 			}
  16579 			{
  16580 				xtv := string(val)
  16581 				sv.StatusMessage = ptr.String(xtv)
  16582 			}
  16583 
  16584 		default:
  16585 			// Do nothing and ignore the unexpected tag element
  16586 			err = decoder.Decoder.Skip()
  16587 			if err != nil {
  16588 				return err
  16589 			}
  16590 
  16591 		}
  16592 		decoder = originalDecoder
  16593 	}
  16594 	*v = sv
  16595 	return nil
  16596 }
  16597 
  16598 func awsRestxml_deserializeDocumentErrorMessages(v *[]string, decoder smithyxml.NodeDecoder) error {
  16599 	if v == nil {
  16600 		return fmt.Errorf("unexpected nil of type %T", v)
  16601 	}
  16602 	var sv []string
  16603 	if *v == nil {
  16604 		sv = make([]string, 0)
  16605 	} else {
  16606 		sv = *v
  16607 	}
  16608 
  16609 	originalDecoder := decoder
  16610 	for {
  16611 		t, done, err := decoder.Token()
  16612 		if err != nil {
  16613 			return err
  16614 		}
  16615 		if done {
  16616 			break
  16617 		}
  16618 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16619 		decoder = memberDecoder
  16620 		switch {
  16621 		case strings.EqualFold("Message", t.Name.Local):
  16622 			var col string
  16623 			val, err := decoder.Value()
  16624 			if err != nil {
  16625 				return err
  16626 			}
  16627 			if val == nil {
  16628 				break
  16629 			}
  16630 			{
  16631 				xtv := string(val)
  16632 				col = xtv
  16633 			}
  16634 			sv = append(sv, col)
  16635 
  16636 		default:
  16637 			err = decoder.Decoder.Skip()
  16638 			if err != nil {
  16639 				return err
  16640 			}
  16641 
  16642 		}
  16643 		decoder = originalDecoder
  16644 	}
  16645 	*v = sv
  16646 	return nil
  16647 }
  16648 
  16649 func awsRestxml_deserializeDocumentErrorMessagesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  16650 	var sv []string
  16651 	if *v == nil {
  16652 		sv = make([]string, 0)
  16653 	} else {
  16654 		sv = *v
  16655 	}
  16656 
  16657 	switch {
  16658 	default:
  16659 		var mv string
  16660 		t := decoder.StartEl
  16661 		_ = t
  16662 		val, err := decoder.Value()
  16663 		if err != nil {
  16664 			return err
  16665 		}
  16666 		if val == nil {
  16667 			break
  16668 		}
  16669 		{
  16670 			xtv := string(val)
  16671 			mv = xtv
  16672 		}
  16673 		sv = append(sv, mv)
  16674 	}
  16675 	*v = sv
  16676 	return nil
  16677 }
  16678 func awsRestxml_deserializeDocumentGeoLocation(v **types.GeoLocation, decoder smithyxml.NodeDecoder) error {
  16679 	if v == nil {
  16680 		return fmt.Errorf("unexpected nil of type %T", v)
  16681 	}
  16682 	var sv *types.GeoLocation
  16683 	if *v == nil {
  16684 		sv = &types.GeoLocation{}
  16685 	} else {
  16686 		sv = *v
  16687 	}
  16688 
  16689 	for {
  16690 		t, done, err := decoder.Token()
  16691 		if err != nil {
  16692 			return err
  16693 		}
  16694 		if done {
  16695 			break
  16696 		}
  16697 		originalDecoder := decoder
  16698 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16699 		switch {
  16700 		case strings.EqualFold("ContinentCode", t.Name.Local):
  16701 			val, err := decoder.Value()
  16702 			if err != nil {
  16703 				return err
  16704 			}
  16705 			if val == nil {
  16706 				break
  16707 			}
  16708 			{
  16709 				xtv := string(val)
  16710 				sv.ContinentCode = ptr.String(xtv)
  16711 			}
  16712 
  16713 		case strings.EqualFold("CountryCode", t.Name.Local):
  16714 			val, err := decoder.Value()
  16715 			if err != nil {
  16716 				return err
  16717 			}
  16718 			if val == nil {
  16719 				break
  16720 			}
  16721 			{
  16722 				xtv := string(val)
  16723 				sv.CountryCode = ptr.String(xtv)
  16724 			}
  16725 
  16726 		case strings.EqualFold("SubdivisionCode", t.Name.Local):
  16727 			val, err := decoder.Value()
  16728 			if err != nil {
  16729 				return err
  16730 			}
  16731 			if val == nil {
  16732 				break
  16733 			}
  16734 			{
  16735 				xtv := string(val)
  16736 				sv.SubdivisionCode = ptr.String(xtv)
  16737 			}
  16738 
  16739 		default:
  16740 			// Do nothing and ignore the unexpected tag element
  16741 			err = decoder.Decoder.Skip()
  16742 			if err != nil {
  16743 				return err
  16744 			}
  16745 
  16746 		}
  16747 		decoder = originalDecoder
  16748 	}
  16749 	*v = sv
  16750 	return nil
  16751 }
  16752 
  16753 func awsRestxml_deserializeDocumentGeoLocationDetails(v **types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
  16754 	if v == nil {
  16755 		return fmt.Errorf("unexpected nil of type %T", v)
  16756 	}
  16757 	var sv *types.GeoLocationDetails
  16758 	if *v == nil {
  16759 		sv = &types.GeoLocationDetails{}
  16760 	} else {
  16761 		sv = *v
  16762 	}
  16763 
  16764 	for {
  16765 		t, done, err := decoder.Token()
  16766 		if err != nil {
  16767 			return err
  16768 		}
  16769 		if done {
  16770 			break
  16771 		}
  16772 		originalDecoder := decoder
  16773 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16774 		switch {
  16775 		case strings.EqualFold("ContinentCode", t.Name.Local):
  16776 			val, err := decoder.Value()
  16777 			if err != nil {
  16778 				return err
  16779 			}
  16780 			if val == nil {
  16781 				break
  16782 			}
  16783 			{
  16784 				xtv := string(val)
  16785 				sv.ContinentCode = ptr.String(xtv)
  16786 			}
  16787 
  16788 		case strings.EqualFold("ContinentName", t.Name.Local):
  16789 			val, err := decoder.Value()
  16790 			if err != nil {
  16791 				return err
  16792 			}
  16793 			if val == nil {
  16794 				break
  16795 			}
  16796 			{
  16797 				xtv := string(val)
  16798 				sv.ContinentName = ptr.String(xtv)
  16799 			}
  16800 
  16801 		case strings.EqualFold("CountryCode", t.Name.Local):
  16802 			val, err := decoder.Value()
  16803 			if err != nil {
  16804 				return err
  16805 			}
  16806 			if val == nil {
  16807 				break
  16808 			}
  16809 			{
  16810 				xtv := string(val)
  16811 				sv.CountryCode = ptr.String(xtv)
  16812 			}
  16813 
  16814 		case strings.EqualFold("CountryName", t.Name.Local):
  16815 			val, err := decoder.Value()
  16816 			if err != nil {
  16817 				return err
  16818 			}
  16819 			if val == nil {
  16820 				break
  16821 			}
  16822 			{
  16823 				xtv := string(val)
  16824 				sv.CountryName = ptr.String(xtv)
  16825 			}
  16826 
  16827 		case strings.EqualFold("SubdivisionCode", t.Name.Local):
  16828 			val, err := decoder.Value()
  16829 			if err != nil {
  16830 				return err
  16831 			}
  16832 			if val == nil {
  16833 				break
  16834 			}
  16835 			{
  16836 				xtv := string(val)
  16837 				sv.SubdivisionCode = ptr.String(xtv)
  16838 			}
  16839 
  16840 		case strings.EqualFold("SubdivisionName", t.Name.Local):
  16841 			val, err := decoder.Value()
  16842 			if err != nil {
  16843 				return err
  16844 			}
  16845 			if val == nil {
  16846 				break
  16847 			}
  16848 			{
  16849 				xtv := string(val)
  16850 				sv.SubdivisionName = ptr.String(xtv)
  16851 			}
  16852 
  16853 		default:
  16854 			// Do nothing and ignore the unexpected tag element
  16855 			err = decoder.Decoder.Skip()
  16856 			if err != nil {
  16857 				return err
  16858 			}
  16859 
  16860 		}
  16861 		decoder = originalDecoder
  16862 	}
  16863 	*v = sv
  16864 	return nil
  16865 }
  16866 
  16867 func awsRestxml_deserializeDocumentGeoLocationDetailsList(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
  16868 	if v == nil {
  16869 		return fmt.Errorf("unexpected nil of type %T", v)
  16870 	}
  16871 	var sv []types.GeoLocationDetails
  16872 	if *v == nil {
  16873 		sv = make([]types.GeoLocationDetails, 0)
  16874 	} else {
  16875 		sv = *v
  16876 	}
  16877 
  16878 	originalDecoder := decoder
  16879 	for {
  16880 		t, done, err := decoder.Token()
  16881 		if err != nil {
  16882 			return err
  16883 		}
  16884 		if done {
  16885 			break
  16886 		}
  16887 		switch {
  16888 		case strings.EqualFold("GeoLocationDetails", t.Name.Local):
  16889 			var col types.GeoLocationDetails
  16890 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16891 			destAddr := &col
  16892 			if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil {
  16893 				return err
  16894 			}
  16895 			col = *destAddr
  16896 			sv = append(sv, col)
  16897 
  16898 		default:
  16899 			err = decoder.Decoder.Skip()
  16900 			if err != nil {
  16901 				return err
  16902 			}
  16903 
  16904 		}
  16905 		decoder = originalDecoder
  16906 	}
  16907 	*v = sv
  16908 	return nil
  16909 }
  16910 
  16911 func awsRestxml_deserializeDocumentGeoLocationDetailsListUnwrapped(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
  16912 	var sv []types.GeoLocationDetails
  16913 	if *v == nil {
  16914 		sv = make([]types.GeoLocationDetails, 0)
  16915 	} else {
  16916 		sv = *v
  16917 	}
  16918 
  16919 	switch {
  16920 	default:
  16921 		var mv types.GeoLocationDetails
  16922 		t := decoder.StartEl
  16923 		_ = t
  16924 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16925 		destAddr := &mv
  16926 		if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil {
  16927 			return err
  16928 		}
  16929 		mv = *destAddr
  16930 		sv = append(sv, mv)
  16931 	}
  16932 	*v = sv
  16933 	return nil
  16934 }
  16935 func awsRestxml_deserializeDocumentGeoProximityLocation(v **types.GeoProximityLocation, decoder smithyxml.NodeDecoder) error {
  16936 	if v == nil {
  16937 		return fmt.Errorf("unexpected nil of type %T", v)
  16938 	}
  16939 	var sv *types.GeoProximityLocation
  16940 	if *v == nil {
  16941 		sv = &types.GeoProximityLocation{}
  16942 	} else {
  16943 		sv = *v
  16944 	}
  16945 
  16946 	for {
  16947 		t, done, err := decoder.Token()
  16948 		if err != nil {
  16949 			return err
  16950 		}
  16951 		if done {
  16952 			break
  16953 		}
  16954 		originalDecoder := decoder
  16955 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16956 		switch {
  16957 		case strings.EqualFold("AWSRegion", t.Name.Local):
  16958 			val, err := decoder.Value()
  16959 			if err != nil {
  16960 				return err
  16961 			}
  16962 			if val == nil {
  16963 				break
  16964 			}
  16965 			{
  16966 				xtv := string(val)
  16967 				sv.AWSRegion = ptr.String(xtv)
  16968 			}
  16969 
  16970 		case strings.EqualFold("Bias", t.Name.Local):
  16971 			val, err := decoder.Value()
  16972 			if err != nil {
  16973 				return err
  16974 			}
  16975 			if val == nil {
  16976 				break
  16977 			}
  16978 			{
  16979 				xtv := string(val)
  16980 				i64, err := strconv.ParseInt(xtv, 10, 64)
  16981 				if err != nil {
  16982 					return err
  16983 				}
  16984 				sv.Bias = ptr.Int32(int32(i64))
  16985 			}
  16986 
  16987 		case strings.EqualFold("Coordinates", t.Name.Local):
  16988 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16989 			if err := awsRestxml_deserializeDocumentCoordinates(&sv.Coordinates, nodeDecoder); err != nil {
  16990 				return err
  16991 			}
  16992 
  16993 		case strings.EqualFold("LocalZoneGroup", t.Name.Local):
  16994 			val, err := decoder.Value()
  16995 			if err != nil {
  16996 				return err
  16997 			}
  16998 			if val == nil {
  16999 				break
  17000 			}
  17001 			{
  17002 				xtv := string(val)
  17003 				sv.LocalZoneGroup = ptr.String(xtv)
  17004 			}
  17005 
  17006 		default:
  17007 			// Do nothing and ignore the unexpected tag element
  17008 			err = decoder.Decoder.Skip()
  17009 			if err != nil {
  17010 				return err
  17011 			}
  17012 
  17013 		}
  17014 		decoder = originalDecoder
  17015 	}
  17016 	*v = sv
  17017 	return nil
  17018 }
  17019 
  17020 func awsRestxml_deserializeDocumentHealthCheck(v **types.HealthCheck, decoder smithyxml.NodeDecoder) error {
  17021 	if v == nil {
  17022 		return fmt.Errorf("unexpected nil of type %T", v)
  17023 	}
  17024 	var sv *types.HealthCheck
  17025 	if *v == nil {
  17026 		sv = &types.HealthCheck{}
  17027 	} else {
  17028 		sv = *v
  17029 	}
  17030 
  17031 	for {
  17032 		t, done, err := decoder.Token()
  17033 		if err != nil {
  17034 			return err
  17035 		}
  17036 		if done {
  17037 			break
  17038 		}
  17039 		originalDecoder := decoder
  17040 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17041 		switch {
  17042 		case strings.EqualFold("CallerReference", t.Name.Local):
  17043 			val, err := decoder.Value()
  17044 			if err != nil {
  17045 				return err
  17046 			}
  17047 			if val == nil {
  17048 				break
  17049 			}
  17050 			{
  17051 				xtv := string(val)
  17052 				sv.CallerReference = ptr.String(xtv)
  17053 			}
  17054 
  17055 		case strings.EqualFold("CloudWatchAlarmConfiguration", t.Name.Local):
  17056 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17057 			if err := awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(&sv.CloudWatchAlarmConfiguration, nodeDecoder); err != nil {
  17058 				return err
  17059 			}
  17060 
  17061 		case strings.EqualFold("HealthCheckConfig", t.Name.Local):
  17062 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17063 			if err := awsRestxml_deserializeDocumentHealthCheckConfig(&sv.HealthCheckConfig, nodeDecoder); err != nil {
  17064 				return err
  17065 			}
  17066 
  17067 		case strings.EqualFold("HealthCheckVersion", t.Name.Local):
  17068 			val, err := decoder.Value()
  17069 			if err != nil {
  17070 				return err
  17071 			}
  17072 			if val == nil {
  17073 				break
  17074 			}
  17075 			{
  17076 				xtv := string(val)
  17077 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17078 				if err != nil {
  17079 					return err
  17080 				}
  17081 				sv.HealthCheckVersion = ptr.Int64(i64)
  17082 			}
  17083 
  17084 		case strings.EqualFold("Id", t.Name.Local):
  17085 			val, err := decoder.Value()
  17086 			if err != nil {
  17087 				return err
  17088 			}
  17089 			if val == nil {
  17090 				break
  17091 			}
  17092 			{
  17093 				xtv := string(val)
  17094 				sv.Id = ptr.String(xtv)
  17095 			}
  17096 
  17097 		case strings.EqualFold("LinkedService", t.Name.Local):
  17098 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17099 			if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil {
  17100 				return err
  17101 			}
  17102 
  17103 		default:
  17104 			// Do nothing and ignore the unexpected tag element
  17105 			err = decoder.Decoder.Skip()
  17106 			if err != nil {
  17107 				return err
  17108 			}
  17109 
  17110 		}
  17111 		decoder = originalDecoder
  17112 	}
  17113 	*v = sv
  17114 	return nil
  17115 }
  17116 
  17117 func awsRestxml_deserializeDocumentHealthCheckAlreadyExists(v **types.HealthCheckAlreadyExists, decoder smithyxml.NodeDecoder) error {
  17118 	if v == nil {
  17119 		return fmt.Errorf("unexpected nil of type %T", v)
  17120 	}
  17121 	var sv *types.HealthCheckAlreadyExists
  17122 	if *v == nil {
  17123 		sv = &types.HealthCheckAlreadyExists{}
  17124 	} else {
  17125 		sv = *v
  17126 	}
  17127 
  17128 	for {
  17129 		t, done, err := decoder.Token()
  17130 		if err != nil {
  17131 			return err
  17132 		}
  17133 		if done {
  17134 			break
  17135 		}
  17136 		originalDecoder := decoder
  17137 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17138 		switch {
  17139 		case strings.EqualFold("message", t.Name.Local):
  17140 			val, err := decoder.Value()
  17141 			if err != nil {
  17142 				return err
  17143 			}
  17144 			if val == nil {
  17145 				break
  17146 			}
  17147 			{
  17148 				xtv := string(val)
  17149 				sv.Message = ptr.String(xtv)
  17150 			}
  17151 
  17152 		default:
  17153 			// Do nothing and ignore the unexpected tag element
  17154 			err = decoder.Decoder.Skip()
  17155 			if err != nil {
  17156 				return err
  17157 			}
  17158 
  17159 		}
  17160 		decoder = originalDecoder
  17161 	}
  17162 	*v = sv
  17163 	return nil
  17164 }
  17165 
  17166 func awsRestxml_deserializeDocumentHealthCheckConfig(v **types.HealthCheckConfig, decoder smithyxml.NodeDecoder) error {
  17167 	if v == nil {
  17168 		return fmt.Errorf("unexpected nil of type %T", v)
  17169 	}
  17170 	var sv *types.HealthCheckConfig
  17171 	if *v == nil {
  17172 		sv = &types.HealthCheckConfig{}
  17173 	} else {
  17174 		sv = *v
  17175 	}
  17176 
  17177 	for {
  17178 		t, done, err := decoder.Token()
  17179 		if err != nil {
  17180 			return err
  17181 		}
  17182 		if done {
  17183 			break
  17184 		}
  17185 		originalDecoder := decoder
  17186 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17187 		switch {
  17188 		case strings.EqualFold("AlarmIdentifier", t.Name.Local):
  17189 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17190 			if err := awsRestxml_deserializeDocumentAlarmIdentifier(&sv.AlarmIdentifier, nodeDecoder); err != nil {
  17191 				return err
  17192 			}
  17193 
  17194 		case strings.EqualFold("ChildHealthChecks", t.Name.Local):
  17195 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17196 			if err := awsRestxml_deserializeDocumentChildHealthCheckList(&sv.ChildHealthChecks, nodeDecoder); err != nil {
  17197 				return err
  17198 			}
  17199 
  17200 		case strings.EqualFold("Disabled", t.Name.Local):
  17201 			val, err := decoder.Value()
  17202 			if err != nil {
  17203 				return err
  17204 			}
  17205 			if val == nil {
  17206 				break
  17207 			}
  17208 			{
  17209 				xtv, err := strconv.ParseBool(string(val))
  17210 				if err != nil {
  17211 					return fmt.Errorf("expected Disabled to be of type *bool, got %T instead", val)
  17212 				}
  17213 				sv.Disabled = ptr.Bool(xtv)
  17214 			}
  17215 
  17216 		case strings.EqualFold("EnableSNI", t.Name.Local):
  17217 			val, err := decoder.Value()
  17218 			if err != nil {
  17219 				return err
  17220 			}
  17221 			if val == nil {
  17222 				break
  17223 			}
  17224 			{
  17225 				xtv, err := strconv.ParseBool(string(val))
  17226 				if err != nil {
  17227 					return fmt.Errorf("expected EnableSNI to be of type *bool, got %T instead", val)
  17228 				}
  17229 				sv.EnableSNI = ptr.Bool(xtv)
  17230 			}
  17231 
  17232 		case strings.EqualFold("FailureThreshold", t.Name.Local):
  17233 			val, err := decoder.Value()
  17234 			if err != nil {
  17235 				return err
  17236 			}
  17237 			if val == nil {
  17238 				break
  17239 			}
  17240 			{
  17241 				xtv := string(val)
  17242 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17243 				if err != nil {
  17244 					return err
  17245 				}
  17246 				sv.FailureThreshold = ptr.Int32(int32(i64))
  17247 			}
  17248 
  17249 		case strings.EqualFold("FullyQualifiedDomainName", t.Name.Local):
  17250 			val, err := decoder.Value()
  17251 			if err != nil {
  17252 				return err
  17253 			}
  17254 			if val == nil {
  17255 				break
  17256 			}
  17257 			{
  17258 				xtv := string(val)
  17259 				sv.FullyQualifiedDomainName = ptr.String(xtv)
  17260 			}
  17261 
  17262 		case strings.EqualFold("HealthThreshold", t.Name.Local):
  17263 			val, err := decoder.Value()
  17264 			if err != nil {
  17265 				return err
  17266 			}
  17267 			if val == nil {
  17268 				break
  17269 			}
  17270 			{
  17271 				xtv := string(val)
  17272 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17273 				if err != nil {
  17274 					return err
  17275 				}
  17276 				sv.HealthThreshold = ptr.Int32(int32(i64))
  17277 			}
  17278 
  17279 		case strings.EqualFold("InsufficientDataHealthStatus", t.Name.Local):
  17280 			val, err := decoder.Value()
  17281 			if err != nil {
  17282 				return err
  17283 			}
  17284 			if val == nil {
  17285 				break
  17286 			}
  17287 			{
  17288 				xtv := string(val)
  17289 				sv.InsufficientDataHealthStatus = types.InsufficientDataHealthStatus(xtv)
  17290 			}
  17291 
  17292 		case strings.EqualFold("Inverted", t.Name.Local):
  17293 			val, err := decoder.Value()
  17294 			if err != nil {
  17295 				return err
  17296 			}
  17297 			if val == nil {
  17298 				break
  17299 			}
  17300 			{
  17301 				xtv, err := strconv.ParseBool(string(val))
  17302 				if err != nil {
  17303 					return fmt.Errorf("expected Inverted to be of type *bool, got %T instead", val)
  17304 				}
  17305 				sv.Inverted = ptr.Bool(xtv)
  17306 			}
  17307 
  17308 		case strings.EqualFold("IPAddress", t.Name.Local):
  17309 			val, err := decoder.Value()
  17310 			if err != nil {
  17311 				return err
  17312 			}
  17313 			if val == nil {
  17314 				break
  17315 			}
  17316 			{
  17317 				xtv := string(val)
  17318 				sv.IPAddress = ptr.String(xtv)
  17319 			}
  17320 
  17321 		case strings.EqualFold("MeasureLatency", t.Name.Local):
  17322 			val, err := decoder.Value()
  17323 			if err != nil {
  17324 				return err
  17325 			}
  17326 			if val == nil {
  17327 				break
  17328 			}
  17329 			{
  17330 				xtv, err := strconv.ParseBool(string(val))
  17331 				if err != nil {
  17332 					return fmt.Errorf("expected MeasureLatency to be of type *bool, got %T instead", val)
  17333 				}
  17334 				sv.MeasureLatency = ptr.Bool(xtv)
  17335 			}
  17336 
  17337 		case strings.EqualFold("Port", t.Name.Local):
  17338 			val, err := decoder.Value()
  17339 			if err != nil {
  17340 				return err
  17341 			}
  17342 			if val == nil {
  17343 				break
  17344 			}
  17345 			{
  17346 				xtv := string(val)
  17347 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17348 				if err != nil {
  17349 					return err
  17350 				}
  17351 				sv.Port = ptr.Int32(int32(i64))
  17352 			}
  17353 
  17354 		case strings.EqualFold("Regions", t.Name.Local):
  17355 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17356 			if err := awsRestxml_deserializeDocumentHealthCheckRegionList(&sv.Regions, nodeDecoder); err != nil {
  17357 				return err
  17358 			}
  17359 
  17360 		case strings.EqualFold("RequestInterval", t.Name.Local):
  17361 			val, err := decoder.Value()
  17362 			if err != nil {
  17363 				return err
  17364 			}
  17365 			if val == nil {
  17366 				break
  17367 			}
  17368 			{
  17369 				xtv := string(val)
  17370 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17371 				if err != nil {
  17372 					return err
  17373 				}
  17374 				sv.RequestInterval = ptr.Int32(int32(i64))
  17375 			}
  17376 
  17377 		case strings.EqualFold("ResourcePath", t.Name.Local):
  17378 			val, err := decoder.Value()
  17379 			if err != nil {
  17380 				return err
  17381 			}
  17382 			if val == nil {
  17383 				break
  17384 			}
  17385 			{
  17386 				xtv := string(val)
  17387 				sv.ResourcePath = ptr.String(xtv)
  17388 			}
  17389 
  17390 		case strings.EqualFold("RoutingControlArn", t.Name.Local):
  17391 			val, err := decoder.Value()
  17392 			if err != nil {
  17393 				return err
  17394 			}
  17395 			if val == nil {
  17396 				break
  17397 			}
  17398 			{
  17399 				xtv := string(val)
  17400 				sv.RoutingControlArn = ptr.String(xtv)
  17401 			}
  17402 
  17403 		case strings.EqualFold("SearchString", t.Name.Local):
  17404 			val, err := decoder.Value()
  17405 			if err != nil {
  17406 				return err
  17407 			}
  17408 			if val == nil {
  17409 				break
  17410 			}
  17411 			{
  17412 				xtv := string(val)
  17413 				sv.SearchString = ptr.String(xtv)
  17414 			}
  17415 
  17416 		case strings.EqualFold("Type", t.Name.Local):
  17417 			val, err := decoder.Value()
  17418 			if err != nil {
  17419 				return err
  17420 			}
  17421 			if val == nil {
  17422 				break
  17423 			}
  17424 			{
  17425 				xtv := string(val)
  17426 				sv.Type = types.HealthCheckType(xtv)
  17427 			}
  17428 
  17429 		default:
  17430 			// Do nothing and ignore the unexpected tag element
  17431 			err = decoder.Decoder.Skip()
  17432 			if err != nil {
  17433 				return err
  17434 			}
  17435 
  17436 		}
  17437 		decoder = originalDecoder
  17438 	}
  17439 	*v = sv
  17440 	return nil
  17441 }
  17442 
  17443 func awsRestxml_deserializeDocumentHealthCheckInUse(v **types.HealthCheckInUse, decoder smithyxml.NodeDecoder) error {
  17444 	if v == nil {
  17445 		return fmt.Errorf("unexpected nil of type %T", v)
  17446 	}
  17447 	var sv *types.HealthCheckInUse
  17448 	if *v == nil {
  17449 		sv = &types.HealthCheckInUse{}
  17450 	} else {
  17451 		sv = *v
  17452 	}
  17453 
  17454 	for {
  17455 		t, done, err := decoder.Token()
  17456 		if err != nil {
  17457 			return err
  17458 		}
  17459 		if done {
  17460 			break
  17461 		}
  17462 		originalDecoder := decoder
  17463 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17464 		switch {
  17465 		case strings.EqualFold("message", t.Name.Local):
  17466 			val, err := decoder.Value()
  17467 			if err != nil {
  17468 				return err
  17469 			}
  17470 			if val == nil {
  17471 				break
  17472 			}
  17473 			{
  17474 				xtv := string(val)
  17475 				sv.Message = ptr.String(xtv)
  17476 			}
  17477 
  17478 		default:
  17479 			// Do nothing and ignore the unexpected tag element
  17480 			err = decoder.Decoder.Skip()
  17481 			if err != nil {
  17482 				return err
  17483 			}
  17484 
  17485 		}
  17486 		decoder = originalDecoder
  17487 	}
  17488 	*v = sv
  17489 	return nil
  17490 }
  17491 
  17492 func awsRestxml_deserializeDocumentHealthCheckObservation(v **types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
  17493 	if v == nil {
  17494 		return fmt.Errorf("unexpected nil of type %T", v)
  17495 	}
  17496 	var sv *types.HealthCheckObservation
  17497 	if *v == nil {
  17498 		sv = &types.HealthCheckObservation{}
  17499 	} else {
  17500 		sv = *v
  17501 	}
  17502 
  17503 	for {
  17504 		t, done, err := decoder.Token()
  17505 		if err != nil {
  17506 			return err
  17507 		}
  17508 		if done {
  17509 			break
  17510 		}
  17511 		originalDecoder := decoder
  17512 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17513 		switch {
  17514 		case strings.EqualFold("IPAddress", t.Name.Local):
  17515 			val, err := decoder.Value()
  17516 			if err != nil {
  17517 				return err
  17518 			}
  17519 			if val == nil {
  17520 				break
  17521 			}
  17522 			{
  17523 				xtv := string(val)
  17524 				sv.IPAddress = ptr.String(xtv)
  17525 			}
  17526 
  17527 		case strings.EqualFold("Region", t.Name.Local):
  17528 			val, err := decoder.Value()
  17529 			if err != nil {
  17530 				return err
  17531 			}
  17532 			if val == nil {
  17533 				break
  17534 			}
  17535 			{
  17536 				xtv := string(val)
  17537 				sv.Region = types.HealthCheckRegion(xtv)
  17538 			}
  17539 
  17540 		case strings.EqualFold("StatusReport", t.Name.Local):
  17541 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17542 			if err := awsRestxml_deserializeDocumentStatusReport(&sv.StatusReport, nodeDecoder); err != nil {
  17543 				return err
  17544 			}
  17545 
  17546 		default:
  17547 			// Do nothing and ignore the unexpected tag element
  17548 			err = decoder.Decoder.Skip()
  17549 			if err != nil {
  17550 				return err
  17551 			}
  17552 
  17553 		}
  17554 		decoder = originalDecoder
  17555 	}
  17556 	*v = sv
  17557 	return nil
  17558 }
  17559 
  17560 func awsRestxml_deserializeDocumentHealthCheckObservations(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
  17561 	if v == nil {
  17562 		return fmt.Errorf("unexpected nil of type %T", v)
  17563 	}
  17564 	var sv []types.HealthCheckObservation
  17565 	if *v == nil {
  17566 		sv = make([]types.HealthCheckObservation, 0)
  17567 	} else {
  17568 		sv = *v
  17569 	}
  17570 
  17571 	originalDecoder := decoder
  17572 	for {
  17573 		t, done, err := decoder.Token()
  17574 		if err != nil {
  17575 			return err
  17576 		}
  17577 		if done {
  17578 			break
  17579 		}
  17580 		switch {
  17581 		case strings.EqualFold("HealthCheckObservation", t.Name.Local):
  17582 			var col types.HealthCheckObservation
  17583 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17584 			destAddr := &col
  17585 			if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil {
  17586 				return err
  17587 			}
  17588 			col = *destAddr
  17589 			sv = append(sv, col)
  17590 
  17591 		default:
  17592 			err = decoder.Decoder.Skip()
  17593 			if err != nil {
  17594 				return err
  17595 			}
  17596 
  17597 		}
  17598 		decoder = originalDecoder
  17599 	}
  17600 	*v = sv
  17601 	return nil
  17602 }
  17603 
  17604 func awsRestxml_deserializeDocumentHealthCheckObservationsUnwrapped(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
  17605 	var sv []types.HealthCheckObservation
  17606 	if *v == nil {
  17607 		sv = make([]types.HealthCheckObservation, 0)
  17608 	} else {
  17609 		sv = *v
  17610 	}
  17611 
  17612 	switch {
  17613 	default:
  17614 		var mv types.HealthCheckObservation
  17615 		t := decoder.StartEl
  17616 		_ = t
  17617 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17618 		destAddr := &mv
  17619 		if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil {
  17620 			return err
  17621 		}
  17622 		mv = *destAddr
  17623 		sv = append(sv, mv)
  17624 	}
  17625 	*v = sv
  17626 	return nil
  17627 }
  17628 func awsRestxml_deserializeDocumentHealthCheckRegionList(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error {
  17629 	if v == nil {
  17630 		return fmt.Errorf("unexpected nil of type %T", v)
  17631 	}
  17632 	var sv []types.HealthCheckRegion
  17633 	if *v == nil {
  17634 		sv = make([]types.HealthCheckRegion, 0)
  17635 	} else {
  17636 		sv = *v
  17637 	}
  17638 
  17639 	originalDecoder := decoder
  17640 	for {
  17641 		t, done, err := decoder.Token()
  17642 		if err != nil {
  17643 			return err
  17644 		}
  17645 		if done {
  17646 			break
  17647 		}
  17648 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17649 		decoder = memberDecoder
  17650 		switch {
  17651 		case strings.EqualFold("Region", t.Name.Local):
  17652 			var col types.HealthCheckRegion
  17653 			val, err := decoder.Value()
  17654 			if err != nil {
  17655 				return err
  17656 			}
  17657 			if val == nil {
  17658 				break
  17659 			}
  17660 			{
  17661 				xtv := string(val)
  17662 				col = types.HealthCheckRegion(xtv)
  17663 			}
  17664 			sv = append(sv, col)
  17665 
  17666 		default:
  17667 			err = decoder.Decoder.Skip()
  17668 			if err != nil {
  17669 				return err
  17670 			}
  17671 
  17672 		}
  17673 		decoder = originalDecoder
  17674 	}
  17675 	*v = sv
  17676 	return nil
  17677 }
  17678 
  17679 func awsRestxml_deserializeDocumentHealthCheckRegionListUnwrapped(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error {
  17680 	var sv []types.HealthCheckRegion
  17681 	if *v == nil {
  17682 		sv = make([]types.HealthCheckRegion, 0)
  17683 	} else {
  17684 		sv = *v
  17685 	}
  17686 
  17687 	switch {
  17688 	default:
  17689 		var mv types.HealthCheckRegion
  17690 		t := decoder.StartEl
  17691 		_ = t
  17692 		val, err := decoder.Value()
  17693 		if err != nil {
  17694 			return err
  17695 		}
  17696 		if val == nil {
  17697 			break
  17698 		}
  17699 		{
  17700 			xtv := string(val)
  17701 			mv = types.HealthCheckRegion(xtv)
  17702 		}
  17703 		sv = append(sv, mv)
  17704 	}
  17705 	*v = sv
  17706 	return nil
  17707 }
  17708 func awsRestxml_deserializeDocumentHealthChecks(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error {
  17709 	if v == nil {
  17710 		return fmt.Errorf("unexpected nil of type %T", v)
  17711 	}
  17712 	var sv []types.HealthCheck
  17713 	if *v == nil {
  17714 		sv = make([]types.HealthCheck, 0)
  17715 	} else {
  17716 		sv = *v
  17717 	}
  17718 
  17719 	originalDecoder := decoder
  17720 	for {
  17721 		t, done, err := decoder.Token()
  17722 		if err != nil {
  17723 			return err
  17724 		}
  17725 		if done {
  17726 			break
  17727 		}
  17728 		switch {
  17729 		case strings.EqualFold("HealthCheck", t.Name.Local):
  17730 			var col types.HealthCheck
  17731 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17732 			destAddr := &col
  17733 			if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil {
  17734 				return err
  17735 			}
  17736 			col = *destAddr
  17737 			sv = append(sv, col)
  17738 
  17739 		default:
  17740 			err = decoder.Decoder.Skip()
  17741 			if err != nil {
  17742 				return err
  17743 			}
  17744 
  17745 		}
  17746 		decoder = originalDecoder
  17747 	}
  17748 	*v = sv
  17749 	return nil
  17750 }
  17751 
  17752 func awsRestxml_deserializeDocumentHealthChecksUnwrapped(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error {
  17753 	var sv []types.HealthCheck
  17754 	if *v == nil {
  17755 		sv = make([]types.HealthCheck, 0)
  17756 	} else {
  17757 		sv = *v
  17758 	}
  17759 
  17760 	switch {
  17761 	default:
  17762 		var mv types.HealthCheck
  17763 		t := decoder.StartEl
  17764 		_ = t
  17765 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17766 		destAddr := &mv
  17767 		if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil {
  17768 			return err
  17769 		}
  17770 		mv = *destAddr
  17771 		sv = append(sv, mv)
  17772 	}
  17773 	*v = sv
  17774 	return nil
  17775 }
  17776 func awsRestxml_deserializeDocumentHealthCheckVersionMismatch(v **types.HealthCheckVersionMismatch, decoder smithyxml.NodeDecoder) error {
  17777 	if v == nil {
  17778 		return fmt.Errorf("unexpected nil of type %T", v)
  17779 	}
  17780 	var sv *types.HealthCheckVersionMismatch
  17781 	if *v == nil {
  17782 		sv = &types.HealthCheckVersionMismatch{}
  17783 	} else {
  17784 		sv = *v
  17785 	}
  17786 
  17787 	for {
  17788 		t, done, err := decoder.Token()
  17789 		if err != nil {
  17790 			return err
  17791 		}
  17792 		if done {
  17793 			break
  17794 		}
  17795 		originalDecoder := decoder
  17796 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17797 		switch {
  17798 		case strings.EqualFold("message", t.Name.Local):
  17799 			val, err := decoder.Value()
  17800 			if err != nil {
  17801 				return err
  17802 			}
  17803 			if val == nil {
  17804 				break
  17805 			}
  17806 			{
  17807 				xtv := string(val)
  17808 				sv.Message = ptr.String(xtv)
  17809 			}
  17810 
  17811 		default:
  17812 			// Do nothing and ignore the unexpected tag element
  17813 			err = decoder.Decoder.Skip()
  17814 			if err != nil {
  17815 				return err
  17816 			}
  17817 
  17818 		}
  17819 		decoder = originalDecoder
  17820 	}
  17821 	*v = sv
  17822 	return nil
  17823 }
  17824 
  17825 func awsRestxml_deserializeDocumentHostedZone(v **types.HostedZone, decoder smithyxml.NodeDecoder) error {
  17826 	if v == nil {
  17827 		return fmt.Errorf("unexpected nil of type %T", v)
  17828 	}
  17829 	var sv *types.HostedZone
  17830 	if *v == nil {
  17831 		sv = &types.HostedZone{}
  17832 	} else {
  17833 		sv = *v
  17834 	}
  17835 
  17836 	for {
  17837 		t, done, err := decoder.Token()
  17838 		if err != nil {
  17839 			return err
  17840 		}
  17841 		if done {
  17842 			break
  17843 		}
  17844 		originalDecoder := decoder
  17845 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17846 		switch {
  17847 		case strings.EqualFold("CallerReference", t.Name.Local):
  17848 			val, err := decoder.Value()
  17849 			if err != nil {
  17850 				return err
  17851 			}
  17852 			if val == nil {
  17853 				break
  17854 			}
  17855 			{
  17856 				xtv := string(val)
  17857 				sv.CallerReference = ptr.String(xtv)
  17858 			}
  17859 
  17860 		case strings.EqualFold("Config", t.Name.Local):
  17861 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17862 			if err := awsRestxml_deserializeDocumentHostedZoneConfig(&sv.Config, nodeDecoder); err != nil {
  17863 				return err
  17864 			}
  17865 
  17866 		case strings.EqualFold("Features", t.Name.Local):
  17867 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17868 			if err := awsRestxml_deserializeDocumentHostedZoneFeatures(&sv.Features, nodeDecoder); err != nil {
  17869 				return err
  17870 			}
  17871 
  17872 		case strings.EqualFold("Id", t.Name.Local):
  17873 			val, err := decoder.Value()
  17874 			if err != nil {
  17875 				return err
  17876 			}
  17877 			if val == nil {
  17878 				break
  17879 			}
  17880 			{
  17881 				xtv := string(val)
  17882 				sv.Id = ptr.String(xtv)
  17883 			}
  17884 
  17885 		case strings.EqualFold("LinkedService", t.Name.Local):
  17886 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17887 			if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil {
  17888 				return err
  17889 			}
  17890 
  17891 		case strings.EqualFold("Name", t.Name.Local):
  17892 			val, err := decoder.Value()
  17893 			if err != nil {
  17894 				return err
  17895 			}
  17896 			if val == nil {
  17897 				break
  17898 			}
  17899 			{
  17900 				xtv := string(val)
  17901 				sv.Name = ptr.String(xtv)
  17902 			}
  17903 
  17904 		case strings.EqualFold("ResourceRecordSetCount", t.Name.Local):
  17905 			val, err := decoder.Value()
  17906 			if err != nil {
  17907 				return err
  17908 			}
  17909 			if val == nil {
  17910 				break
  17911 			}
  17912 			{
  17913 				xtv := string(val)
  17914 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17915 				if err != nil {
  17916 					return err
  17917 				}
  17918 				sv.ResourceRecordSetCount = ptr.Int64(i64)
  17919 			}
  17920 
  17921 		default:
  17922 			// Do nothing and ignore the unexpected tag element
  17923 			err = decoder.Decoder.Skip()
  17924 			if err != nil {
  17925 				return err
  17926 			}
  17927 
  17928 		}
  17929 		decoder = originalDecoder
  17930 	}
  17931 	*v = sv
  17932 	return nil
  17933 }
  17934 
  17935 func awsRestxml_deserializeDocumentHostedZoneAlreadyExists(v **types.HostedZoneAlreadyExists, decoder smithyxml.NodeDecoder) error {
  17936 	if v == nil {
  17937 		return fmt.Errorf("unexpected nil of type %T", v)
  17938 	}
  17939 	var sv *types.HostedZoneAlreadyExists
  17940 	if *v == nil {
  17941 		sv = &types.HostedZoneAlreadyExists{}
  17942 	} else {
  17943 		sv = *v
  17944 	}
  17945 
  17946 	for {
  17947 		t, done, err := decoder.Token()
  17948 		if err != nil {
  17949 			return err
  17950 		}
  17951 		if done {
  17952 			break
  17953 		}
  17954 		originalDecoder := decoder
  17955 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17956 		switch {
  17957 		case strings.EqualFold("message", t.Name.Local):
  17958 			val, err := decoder.Value()
  17959 			if err != nil {
  17960 				return err
  17961 			}
  17962 			if val == nil {
  17963 				break
  17964 			}
  17965 			{
  17966 				xtv := string(val)
  17967 				sv.Message = ptr.String(xtv)
  17968 			}
  17969 
  17970 		default:
  17971 			// Do nothing and ignore the unexpected tag element
  17972 			err = decoder.Decoder.Skip()
  17973 			if err != nil {
  17974 				return err
  17975 			}
  17976 
  17977 		}
  17978 		decoder = originalDecoder
  17979 	}
  17980 	*v = sv
  17981 	return nil
  17982 }
  17983 
  17984 func awsRestxml_deserializeDocumentHostedZoneConfig(v **types.HostedZoneConfig, decoder smithyxml.NodeDecoder) error {
  17985 	if v == nil {
  17986 		return fmt.Errorf("unexpected nil of type %T", v)
  17987 	}
  17988 	var sv *types.HostedZoneConfig
  17989 	if *v == nil {
  17990 		sv = &types.HostedZoneConfig{}
  17991 	} else {
  17992 		sv = *v
  17993 	}
  17994 
  17995 	for {
  17996 		t, done, err := decoder.Token()
  17997 		if err != nil {
  17998 			return err
  17999 		}
  18000 		if done {
  18001 			break
  18002 		}
  18003 		originalDecoder := decoder
  18004 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18005 		switch {
  18006 		case strings.EqualFold("Comment", t.Name.Local):
  18007 			val, err := decoder.Value()
  18008 			if err != nil {
  18009 				return err
  18010 			}
  18011 			if val == nil {
  18012 				break
  18013 			}
  18014 			{
  18015 				xtv := string(val)
  18016 				sv.Comment = ptr.String(xtv)
  18017 			}
  18018 
  18019 		case strings.EqualFold("PrivateZone", t.Name.Local):
  18020 			val, err := decoder.Value()
  18021 			if err != nil {
  18022 				return err
  18023 			}
  18024 			if val == nil {
  18025 				break
  18026 			}
  18027 			{
  18028 				xtv, err := strconv.ParseBool(string(val))
  18029 				if err != nil {
  18030 					return fmt.Errorf("expected IsPrivateZone to be of type *bool, got %T instead", val)
  18031 				}
  18032 				sv.PrivateZone = xtv
  18033 			}
  18034 
  18035 		default:
  18036 			// Do nothing and ignore the unexpected tag element
  18037 			err = decoder.Decoder.Skip()
  18038 			if err != nil {
  18039 				return err
  18040 			}
  18041 
  18042 		}
  18043 		decoder = originalDecoder
  18044 	}
  18045 	*v = sv
  18046 	return nil
  18047 }
  18048 
  18049 func awsRestxml_deserializeDocumentHostedZoneFailureReasons(v **types.HostedZoneFailureReasons, decoder smithyxml.NodeDecoder) error {
  18050 	if v == nil {
  18051 		return fmt.Errorf("unexpected nil of type %T", v)
  18052 	}
  18053 	var sv *types.HostedZoneFailureReasons
  18054 	if *v == nil {
  18055 		sv = &types.HostedZoneFailureReasons{}
  18056 	} else {
  18057 		sv = *v
  18058 	}
  18059 
  18060 	for {
  18061 		t, done, err := decoder.Token()
  18062 		if err != nil {
  18063 			return err
  18064 		}
  18065 		if done {
  18066 			break
  18067 		}
  18068 		originalDecoder := decoder
  18069 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18070 		switch {
  18071 		case strings.EqualFold("AcceleratedRecovery", t.Name.Local):
  18072 			val, err := decoder.Value()
  18073 			if err != nil {
  18074 				return err
  18075 			}
  18076 			if val == nil {
  18077 				break
  18078 			}
  18079 			{
  18080 				xtv := string(val)
  18081 				sv.AcceleratedRecovery = ptr.String(xtv)
  18082 			}
  18083 
  18084 		default:
  18085 			// Do nothing and ignore the unexpected tag element
  18086 			err = decoder.Decoder.Skip()
  18087 			if err != nil {
  18088 				return err
  18089 			}
  18090 
  18091 		}
  18092 		decoder = originalDecoder
  18093 	}
  18094 	*v = sv
  18095 	return nil
  18096 }
  18097 
  18098 func awsRestxml_deserializeDocumentHostedZoneFeatures(v **types.HostedZoneFeatures, decoder smithyxml.NodeDecoder) error {
  18099 	if v == nil {
  18100 		return fmt.Errorf("unexpected nil of type %T", v)
  18101 	}
  18102 	var sv *types.HostedZoneFeatures
  18103 	if *v == nil {
  18104 		sv = &types.HostedZoneFeatures{}
  18105 	} else {
  18106 		sv = *v
  18107 	}
  18108 
  18109 	for {
  18110 		t, done, err := decoder.Token()
  18111 		if err != nil {
  18112 			return err
  18113 		}
  18114 		if done {
  18115 			break
  18116 		}
  18117 		originalDecoder := decoder
  18118 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18119 		switch {
  18120 		case strings.EqualFold("AcceleratedRecoveryStatus", t.Name.Local):
  18121 			val, err := decoder.Value()
  18122 			if err != nil {
  18123 				return err
  18124 			}
  18125 			if val == nil {
  18126 				break
  18127 			}
  18128 			{
  18129 				xtv := string(val)
  18130 				sv.AcceleratedRecoveryStatus = types.AcceleratedRecoveryStatus(xtv)
  18131 			}
  18132 
  18133 		case strings.EqualFold("FailureReasons", t.Name.Local):
  18134 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18135 			if err := awsRestxml_deserializeDocumentHostedZoneFailureReasons(&sv.FailureReasons, nodeDecoder); err != nil {
  18136 				return err
  18137 			}
  18138 
  18139 		default:
  18140 			// Do nothing and ignore the unexpected tag element
  18141 			err = decoder.Decoder.Skip()
  18142 			if err != nil {
  18143 				return err
  18144 			}
  18145 
  18146 		}
  18147 		decoder = originalDecoder
  18148 	}
  18149 	*v = sv
  18150 	return nil
  18151 }
  18152 
  18153 func awsRestxml_deserializeDocumentHostedZoneLimit(v **types.HostedZoneLimit, decoder smithyxml.NodeDecoder) error {
  18154 	if v == nil {
  18155 		return fmt.Errorf("unexpected nil of type %T", v)
  18156 	}
  18157 	var sv *types.HostedZoneLimit
  18158 	if *v == nil {
  18159 		sv = &types.HostedZoneLimit{}
  18160 	} else {
  18161 		sv = *v
  18162 	}
  18163 
  18164 	for {
  18165 		t, done, err := decoder.Token()
  18166 		if err != nil {
  18167 			return err
  18168 		}
  18169 		if done {
  18170 			break
  18171 		}
  18172 		originalDecoder := decoder
  18173 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18174 		switch {
  18175 		case strings.EqualFold("Type", t.Name.Local):
  18176 			val, err := decoder.Value()
  18177 			if err != nil {
  18178 				return err
  18179 			}
  18180 			if val == nil {
  18181 				break
  18182 			}
  18183 			{
  18184 				xtv := string(val)
  18185 				sv.Type = types.HostedZoneLimitType(xtv)
  18186 			}
  18187 
  18188 		case strings.EqualFold("Value", t.Name.Local):
  18189 			val, err := decoder.Value()
  18190 			if err != nil {
  18191 				return err
  18192 			}
  18193 			if val == nil {
  18194 				break
  18195 			}
  18196 			{
  18197 				xtv := string(val)
  18198 				i64, err := strconv.ParseInt(xtv, 10, 64)
  18199 				if err != nil {
  18200 					return err
  18201 				}
  18202 				sv.Value = ptr.Int64(i64)
  18203 			}
  18204 
  18205 		default:
  18206 			// Do nothing and ignore the unexpected tag element
  18207 			err = decoder.Decoder.Skip()
  18208 			if err != nil {
  18209 				return err
  18210 			}
  18211 
  18212 		}
  18213 		decoder = originalDecoder
  18214 	}
  18215 	*v = sv
  18216 	return nil
  18217 }
  18218 
  18219 func awsRestxml_deserializeDocumentHostedZoneNotEmpty(v **types.HostedZoneNotEmpty, decoder smithyxml.NodeDecoder) error {
  18220 	if v == nil {
  18221 		return fmt.Errorf("unexpected nil of type %T", v)
  18222 	}
  18223 	var sv *types.HostedZoneNotEmpty
  18224 	if *v == nil {
  18225 		sv = &types.HostedZoneNotEmpty{}
  18226 	} else {
  18227 		sv = *v
  18228 	}
  18229 
  18230 	for {
  18231 		t, done, err := decoder.Token()
  18232 		if err != nil {
  18233 			return err
  18234 		}
  18235 		if done {
  18236 			break
  18237 		}
  18238 		originalDecoder := decoder
  18239 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18240 		switch {
  18241 		case strings.EqualFold("message", t.Name.Local):
  18242 			val, err := decoder.Value()
  18243 			if err != nil {
  18244 				return err
  18245 			}
  18246 			if val == nil {
  18247 				break
  18248 			}
  18249 			{
  18250 				xtv := string(val)
  18251 				sv.Message = ptr.String(xtv)
  18252 			}
  18253 
  18254 		default:
  18255 			// Do nothing and ignore the unexpected tag element
  18256 			err = decoder.Decoder.Skip()
  18257 			if err != nil {
  18258 				return err
  18259 			}
  18260 
  18261 		}
  18262 		decoder = originalDecoder
  18263 	}
  18264 	*v = sv
  18265 	return nil
  18266 }
  18267 
  18268 func awsRestxml_deserializeDocumentHostedZoneNotFound(v **types.HostedZoneNotFound, decoder smithyxml.NodeDecoder) error {
  18269 	if v == nil {
  18270 		return fmt.Errorf("unexpected nil of type %T", v)
  18271 	}
  18272 	var sv *types.HostedZoneNotFound
  18273 	if *v == nil {
  18274 		sv = &types.HostedZoneNotFound{}
  18275 	} else {
  18276 		sv = *v
  18277 	}
  18278 
  18279 	for {
  18280 		t, done, err := decoder.Token()
  18281 		if err != nil {
  18282 			return err
  18283 		}
  18284 		if done {
  18285 			break
  18286 		}
  18287 		originalDecoder := decoder
  18288 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18289 		switch {
  18290 		case strings.EqualFold("message", t.Name.Local):
  18291 			val, err := decoder.Value()
  18292 			if err != nil {
  18293 				return err
  18294 			}
  18295 			if val == nil {
  18296 				break
  18297 			}
  18298 			{
  18299 				xtv := string(val)
  18300 				sv.Message = ptr.String(xtv)
  18301 			}
  18302 
  18303 		default:
  18304 			// Do nothing and ignore the unexpected tag element
  18305 			err = decoder.Decoder.Skip()
  18306 			if err != nil {
  18307 				return err
  18308 			}
  18309 
  18310 		}
  18311 		decoder = originalDecoder
  18312 	}
  18313 	*v = sv
  18314 	return nil
  18315 }
  18316 
  18317 func awsRestxml_deserializeDocumentHostedZoneNotPrivate(v **types.HostedZoneNotPrivate, decoder smithyxml.NodeDecoder) error {
  18318 	if v == nil {
  18319 		return fmt.Errorf("unexpected nil of type %T", v)
  18320 	}
  18321 	var sv *types.HostedZoneNotPrivate
  18322 	if *v == nil {
  18323 		sv = &types.HostedZoneNotPrivate{}
  18324 	} else {
  18325 		sv = *v
  18326 	}
  18327 
  18328 	for {
  18329 		t, done, err := decoder.Token()
  18330 		if err != nil {
  18331 			return err
  18332 		}
  18333 		if done {
  18334 			break
  18335 		}
  18336 		originalDecoder := decoder
  18337 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18338 		switch {
  18339 		case strings.EqualFold("message", t.Name.Local):
  18340 			val, err := decoder.Value()
  18341 			if err != nil {
  18342 				return err
  18343 			}
  18344 			if val == nil {
  18345 				break
  18346 			}
  18347 			{
  18348 				xtv := string(val)
  18349 				sv.Message = ptr.String(xtv)
  18350 			}
  18351 
  18352 		default:
  18353 			// Do nothing and ignore the unexpected tag element
  18354 			err = decoder.Decoder.Skip()
  18355 			if err != nil {
  18356 				return err
  18357 			}
  18358 
  18359 		}
  18360 		decoder = originalDecoder
  18361 	}
  18362 	*v = sv
  18363 	return nil
  18364 }
  18365 
  18366 func awsRestxml_deserializeDocumentHostedZoneOwner(v **types.HostedZoneOwner, decoder smithyxml.NodeDecoder) error {
  18367 	if v == nil {
  18368 		return fmt.Errorf("unexpected nil of type %T", v)
  18369 	}
  18370 	var sv *types.HostedZoneOwner
  18371 	if *v == nil {
  18372 		sv = &types.HostedZoneOwner{}
  18373 	} else {
  18374 		sv = *v
  18375 	}
  18376 
  18377 	for {
  18378 		t, done, err := decoder.Token()
  18379 		if err != nil {
  18380 			return err
  18381 		}
  18382 		if done {
  18383 			break
  18384 		}
  18385 		originalDecoder := decoder
  18386 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18387 		switch {
  18388 		case strings.EqualFold("OwningAccount", t.Name.Local):
  18389 			val, err := decoder.Value()
  18390 			if err != nil {
  18391 				return err
  18392 			}
  18393 			if val == nil {
  18394 				break
  18395 			}
  18396 			{
  18397 				xtv := string(val)
  18398 				sv.OwningAccount = ptr.String(xtv)
  18399 			}
  18400 
  18401 		case strings.EqualFold("OwningService", t.Name.Local):
  18402 			val, err := decoder.Value()
  18403 			if err != nil {
  18404 				return err
  18405 			}
  18406 			if val == nil {
  18407 				break
  18408 			}
  18409 			{
  18410 				xtv := string(val)
  18411 				sv.OwningService = ptr.String(xtv)
  18412 			}
  18413 
  18414 		default:
  18415 			// Do nothing and ignore the unexpected tag element
  18416 			err = decoder.Decoder.Skip()
  18417 			if err != nil {
  18418 				return err
  18419 			}
  18420 
  18421 		}
  18422 		decoder = originalDecoder
  18423 	}
  18424 	*v = sv
  18425 	return nil
  18426 }
  18427 
  18428 func awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(v **types.HostedZonePartiallyDelegated, decoder smithyxml.NodeDecoder) error {
  18429 	if v == nil {
  18430 		return fmt.Errorf("unexpected nil of type %T", v)
  18431 	}
  18432 	var sv *types.HostedZonePartiallyDelegated
  18433 	if *v == nil {
  18434 		sv = &types.HostedZonePartiallyDelegated{}
  18435 	} else {
  18436 		sv = *v
  18437 	}
  18438 
  18439 	for {
  18440 		t, done, err := decoder.Token()
  18441 		if err != nil {
  18442 			return err
  18443 		}
  18444 		if done {
  18445 			break
  18446 		}
  18447 		originalDecoder := decoder
  18448 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18449 		switch {
  18450 		case strings.EqualFold("message", t.Name.Local):
  18451 			val, err := decoder.Value()
  18452 			if err != nil {
  18453 				return err
  18454 			}
  18455 			if val == nil {
  18456 				break
  18457 			}
  18458 			{
  18459 				xtv := string(val)
  18460 				sv.Message = ptr.String(xtv)
  18461 			}
  18462 
  18463 		default:
  18464 			// Do nothing and ignore the unexpected tag element
  18465 			err = decoder.Decoder.Skip()
  18466 			if err != nil {
  18467 				return err
  18468 			}
  18469 
  18470 		}
  18471 		decoder = originalDecoder
  18472 	}
  18473 	*v = sv
  18474 	return nil
  18475 }
  18476 
  18477 func awsRestxml_deserializeDocumentHostedZones(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error {
  18478 	if v == nil {
  18479 		return fmt.Errorf("unexpected nil of type %T", v)
  18480 	}
  18481 	var sv []types.HostedZone
  18482 	if *v == nil {
  18483 		sv = make([]types.HostedZone, 0)
  18484 	} else {
  18485 		sv = *v
  18486 	}
  18487 
  18488 	originalDecoder := decoder
  18489 	for {
  18490 		t, done, err := decoder.Token()
  18491 		if err != nil {
  18492 			return err
  18493 		}
  18494 		if done {
  18495 			break
  18496 		}
  18497 		switch {
  18498 		case strings.EqualFold("HostedZone", t.Name.Local):
  18499 			var col types.HostedZone
  18500 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18501 			destAddr := &col
  18502 			if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil {
  18503 				return err
  18504 			}
  18505 			col = *destAddr
  18506 			sv = append(sv, col)
  18507 
  18508 		default:
  18509 			err = decoder.Decoder.Skip()
  18510 			if err != nil {
  18511 				return err
  18512 			}
  18513 
  18514 		}
  18515 		decoder = originalDecoder
  18516 	}
  18517 	*v = sv
  18518 	return nil
  18519 }
  18520 
  18521 func awsRestxml_deserializeDocumentHostedZonesUnwrapped(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error {
  18522 	var sv []types.HostedZone
  18523 	if *v == nil {
  18524 		sv = make([]types.HostedZone, 0)
  18525 	} else {
  18526 		sv = *v
  18527 	}
  18528 
  18529 	switch {
  18530 	default:
  18531 		var mv types.HostedZone
  18532 		t := decoder.StartEl
  18533 		_ = t
  18534 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18535 		destAddr := &mv
  18536 		if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil {
  18537 			return err
  18538 		}
  18539 		mv = *destAddr
  18540 		sv = append(sv, mv)
  18541 	}
  18542 	*v = sv
  18543 	return nil
  18544 }
  18545 func awsRestxml_deserializeDocumentHostedZoneSummaries(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
  18546 	if v == nil {
  18547 		return fmt.Errorf("unexpected nil of type %T", v)
  18548 	}
  18549 	var sv []types.HostedZoneSummary
  18550 	if *v == nil {
  18551 		sv = make([]types.HostedZoneSummary, 0)
  18552 	} else {
  18553 		sv = *v
  18554 	}
  18555 
  18556 	originalDecoder := decoder
  18557 	for {
  18558 		t, done, err := decoder.Token()
  18559 		if err != nil {
  18560 			return err
  18561 		}
  18562 		if done {
  18563 			break
  18564 		}
  18565 		switch {
  18566 		case strings.EqualFold("HostedZoneSummary", t.Name.Local):
  18567 			var col types.HostedZoneSummary
  18568 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18569 			destAddr := &col
  18570 			if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil {
  18571 				return err
  18572 			}
  18573 			col = *destAddr
  18574 			sv = append(sv, col)
  18575 
  18576 		default:
  18577 			err = decoder.Decoder.Skip()
  18578 			if err != nil {
  18579 				return err
  18580 			}
  18581 
  18582 		}
  18583 		decoder = originalDecoder
  18584 	}
  18585 	*v = sv
  18586 	return nil
  18587 }
  18588 
  18589 func awsRestxml_deserializeDocumentHostedZoneSummariesUnwrapped(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
  18590 	var sv []types.HostedZoneSummary
  18591 	if *v == nil {
  18592 		sv = make([]types.HostedZoneSummary, 0)
  18593 	} else {
  18594 		sv = *v
  18595 	}
  18596 
  18597 	switch {
  18598 	default:
  18599 		var mv types.HostedZoneSummary
  18600 		t := decoder.StartEl
  18601 		_ = t
  18602 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18603 		destAddr := &mv
  18604 		if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil {
  18605 			return err
  18606 		}
  18607 		mv = *destAddr
  18608 		sv = append(sv, mv)
  18609 	}
  18610 	*v = sv
  18611 	return nil
  18612 }
  18613 func awsRestxml_deserializeDocumentHostedZoneSummary(v **types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
  18614 	if v == nil {
  18615 		return fmt.Errorf("unexpected nil of type %T", v)
  18616 	}
  18617 	var sv *types.HostedZoneSummary
  18618 	if *v == nil {
  18619 		sv = &types.HostedZoneSummary{}
  18620 	} else {
  18621 		sv = *v
  18622 	}
  18623 
  18624 	for {
  18625 		t, done, err := decoder.Token()
  18626 		if err != nil {
  18627 			return err
  18628 		}
  18629 		if done {
  18630 			break
  18631 		}
  18632 		originalDecoder := decoder
  18633 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18634 		switch {
  18635 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  18636 			val, err := decoder.Value()
  18637 			if err != nil {
  18638 				return err
  18639 			}
  18640 			if val == nil {
  18641 				break
  18642 			}
  18643 			{
  18644 				xtv := string(val)
  18645 				sv.HostedZoneId = ptr.String(xtv)
  18646 			}
  18647 
  18648 		case strings.EqualFold("Name", t.Name.Local):
  18649 			val, err := decoder.Value()
  18650 			if err != nil {
  18651 				return err
  18652 			}
  18653 			if val == nil {
  18654 				break
  18655 			}
  18656 			{
  18657 				xtv := string(val)
  18658 				sv.Name = ptr.String(xtv)
  18659 			}
  18660 
  18661 		case strings.EqualFold("Owner", t.Name.Local):
  18662 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18663 			if err := awsRestxml_deserializeDocumentHostedZoneOwner(&sv.Owner, nodeDecoder); err != nil {
  18664 				return err
  18665 			}
  18666 
  18667 		default:
  18668 			// Do nothing and ignore the unexpected tag element
  18669 			err = decoder.Decoder.Skip()
  18670 			if err != nil {
  18671 				return err
  18672 			}
  18673 
  18674 		}
  18675 		decoder = originalDecoder
  18676 	}
  18677 	*v = sv
  18678 	return nil
  18679 }
  18680 
  18681 func awsRestxml_deserializeDocumentIncompatibleVersion(v **types.IncompatibleVersion, decoder smithyxml.NodeDecoder) error {
  18682 	if v == nil {
  18683 		return fmt.Errorf("unexpected nil of type %T", v)
  18684 	}
  18685 	var sv *types.IncompatibleVersion
  18686 	if *v == nil {
  18687 		sv = &types.IncompatibleVersion{}
  18688 	} else {
  18689 		sv = *v
  18690 	}
  18691 
  18692 	for {
  18693 		t, done, err := decoder.Token()
  18694 		if err != nil {
  18695 			return err
  18696 		}
  18697 		if done {
  18698 			break
  18699 		}
  18700 		originalDecoder := decoder
  18701 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18702 		switch {
  18703 		case strings.EqualFold("message", t.Name.Local):
  18704 			val, err := decoder.Value()
  18705 			if err != nil {
  18706 				return err
  18707 			}
  18708 			if val == nil {
  18709 				break
  18710 			}
  18711 			{
  18712 				xtv := string(val)
  18713 				sv.Message = ptr.String(xtv)
  18714 			}
  18715 
  18716 		default:
  18717 			// Do nothing and ignore the unexpected tag element
  18718 			err = decoder.Decoder.Skip()
  18719 			if err != nil {
  18720 				return err
  18721 			}
  18722 
  18723 		}
  18724 		decoder = originalDecoder
  18725 	}
  18726 	*v = sv
  18727 	return nil
  18728 }
  18729 
  18730 func awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(v **types.InsufficientCloudWatchLogsResourcePolicy, decoder smithyxml.NodeDecoder) error {
  18731 	if v == nil {
  18732 		return fmt.Errorf("unexpected nil of type %T", v)
  18733 	}
  18734 	var sv *types.InsufficientCloudWatchLogsResourcePolicy
  18735 	if *v == nil {
  18736 		sv = &types.InsufficientCloudWatchLogsResourcePolicy{}
  18737 	} else {
  18738 		sv = *v
  18739 	}
  18740 
  18741 	for {
  18742 		t, done, err := decoder.Token()
  18743 		if err != nil {
  18744 			return err
  18745 		}
  18746 		if done {
  18747 			break
  18748 		}
  18749 		originalDecoder := decoder
  18750 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18751 		switch {
  18752 		case strings.EqualFold("message", t.Name.Local):
  18753 			val, err := decoder.Value()
  18754 			if err != nil {
  18755 				return err
  18756 			}
  18757 			if val == nil {
  18758 				break
  18759 			}
  18760 			{
  18761 				xtv := string(val)
  18762 				sv.Message = ptr.String(xtv)
  18763 			}
  18764 
  18765 		default:
  18766 			// Do nothing and ignore the unexpected tag element
  18767 			err = decoder.Decoder.Skip()
  18768 			if err != nil {
  18769 				return err
  18770 			}
  18771 
  18772 		}
  18773 		decoder = originalDecoder
  18774 	}
  18775 	*v = sv
  18776 	return nil
  18777 }
  18778 
  18779 func awsRestxml_deserializeDocumentInvalidArgument(v **types.InvalidArgument, decoder smithyxml.NodeDecoder) error {
  18780 	if v == nil {
  18781 		return fmt.Errorf("unexpected nil of type %T", v)
  18782 	}
  18783 	var sv *types.InvalidArgument
  18784 	if *v == nil {
  18785 		sv = &types.InvalidArgument{}
  18786 	} else {
  18787 		sv = *v
  18788 	}
  18789 
  18790 	for {
  18791 		t, done, err := decoder.Token()
  18792 		if err != nil {
  18793 			return err
  18794 		}
  18795 		if done {
  18796 			break
  18797 		}
  18798 		originalDecoder := decoder
  18799 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18800 		switch {
  18801 		case strings.EqualFold("message", t.Name.Local):
  18802 			val, err := decoder.Value()
  18803 			if err != nil {
  18804 				return err
  18805 			}
  18806 			if val == nil {
  18807 				break
  18808 			}
  18809 			{
  18810 				xtv := string(val)
  18811 				sv.Message = ptr.String(xtv)
  18812 			}
  18813 
  18814 		default:
  18815 			// Do nothing and ignore the unexpected tag element
  18816 			err = decoder.Decoder.Skip()
  18817 			if err != nil {
  18818 				return err
  18819 			}
  18820 
  18821 		}
  18822 		decoder = originalDecoder
  18823 	}
  18824 	*v = sv
  18825 	return nil
  18826 }
  18827 
  18828 func awsRestxml_deserializeDocumentInvalidChangeBatch(v **types.InvalidChangeBatch, decoder smithyxml.NodeDecoder) error {
  18829 	if v == nil {
  18830 		return fmt.Errorf("unexpected nil of type %T", v)
  18831 	}
  18832 	var sv *types.InvalidChangeBatch
  18833 	if *v == nil {
  18834 		sv = &types.InvalidChangeBatch{}
  18835 	} else {
  18836 		sv = *v
  18837 	}
  18838 
  18839 	for {
  18840 		t, done, err := decoder.Token()
  18841 		if err != nil {
  18842 			return err
  18843 		}
  18844 		if done {
  18845 			break
  18846 		}
  18847 		originalDecoder := decoder
  18848 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18849 		switch {
  18850 		case strings.EqualFold("message", t.Name.Local):
  18851 			val, err := decoder.Value()
  18852 			if err != nil {
  18853 				return err
  18854 			}
  18855 			if val == nil {
  18856 				break
  18857 			}
  18858 			{
  18859 				xtv := string(val)
  18860 				sv.Message = ptr.String(xtv)
  18861 			}
  18862 
  18863 		case strings.EqualFold("messages", t.Name.Local):
  18864 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18865 			if err := awsRestxml_deserializeDocumentErrorMessages(&sv.Messages, nodeDecoder); err != nil {
  18866 				return err
  18867 			}
  18868 
  18869 		default:
  18870 			// Do nothing and ignore the unexpected tag element
  18871 			err = decoder.Decoder.Skip()
  18872 			if err != nil {
  18873 				return err
  18874 			}
  18875 
  18876 		}
  18877 		decoder = originalDecoder
  18878 	}
  18879 	*v = sv
  18880 	return nil
  18881 }
  18882 
  18883 func awsRestxml_deserializeDocumentInvalidDomainName(v **types.InvalidDomainName, decoder smithyxml.NodeDecoder) error {
  18884 	if v == nil {
  18885 		return fmt.Errorf("unexpected nil of type %T", v)
  18886 	}
  18887 	var sv *types.InvalidDomainName
  18888 	if *v == nil {
  18889 		sv = &types.InvalidDomainName{}
  18890 	} else {
  18891 		sv = *v
  18892 	}
  18893 
  18894 	for {
  18895 		t, done, err := decoder.Token()
  18896 		if err != nil {
  18897 			return err
  18898 		}
  18899 		if done {
  18900 			break
  18901 		}
  18902 		originalDecoder := decoder
  18903 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18904 		switch {
  18905 		case strings.EqualFold("message", t.Name.Local):
  18906 			val, err := decoder.Value()
  18907 			if err != nil {
  18908 				return err
  18909 			}
  18910 			if val == nil {
  18911 				break
  18912 			}
  18913 			{
  18914 				xtv := string(val)
  18915 				sv.Message = ptr.String(xtv)
  18916 			}
  18917 
  18918 		default:
  18919 			// Do nothing and ignore the unexpected tag element
  18920 			err = decoder.Decoder.Skip()
  18921 			if err != nil {
  18922 				return err
  18923 			}
  18924 
  18925 		}
  18926 		decoder = originalDecoder
  18927 	}
  18928 	*v = sv
  18929 	return nil
  18930 }
  18931 
  18932 func awsRestxml_deserializeDocumentInvalidInput(v **types.InvalidInput, decoder smithyxml.NodeDecoder) error {
  18933 	if v == nil {
  18934 		return fmt.Errorf("unexpected nil of type %T", v)
  18935 	}
  18936 	var sv *types.InvalidInput
  18937 	if *v == nil {
  18938 		sv = &types.InvalidInput{}
  18939 	} else {
  18940 		sv = *v
  18941 	}
  18942 
  18943 	for {
  18944 		t, done, err := decoder.Token()
  18945 		if err != nil {
  18946 			return err
  18947 		}
  18948 		if done {
  18949 			break
  18950 		}
  18951 		originalDecoder := decoder
  18952 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18953 		switch {
  18954 		case strings.EqualFold("message", t.Name.Local):
  18955 			val, err := decoder.Value()
  18956 			if err != nil {
  18957 				return err
  18958 			}
  18959 			if val == nil {
  18960 				break
  18961 			}
  18962 			{
  18963 				xtv := string(val)
  18964 				sv.Message = ptr.String(xtv)
  18965 			}
  18966 
  18967 		default:
  18968 			// Do nothing and ignore the unexpected tag element
  18969 			err = decoder.Decoder.Skip()
  18970 			if err != nil {
  18971 				return err
  18972 			}
  18973 
  18974 		}
  18975 		decoder = originalDecoder
  18976 	}
  18977 	*v = sv
  18978 	return nil
  18979 }
  18980 
  18981 func awsRestxml_deserializeDocumentInvalidKeySigningKeyName(v **types.InvalidKeySigningKeyName, decoder smithyxml.NodeDecoder) error {
  18982 	if v == nil {
  18983 		return fmt.Errorf("unexpected nil of type %T", v)
  18984 	}
  18985 	var sv *types.InvalidKeySigningKeyName
  18986 	if *v == nil {
  18987 		sv = &types.InvalidKeySigningKeyName{}
  18988 	} else {
  18989 		sv = *v
  18990 	}
  18991 
  18992 	for {
  18993 		t, done, err := decoder.Token()
  18994 		if err != nil {
  18995 			return err
  18996 		}
  18997 		if done {
  18998 			break
  18999 		}
  19000 		originalDecoder := decoder
  19001 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19002 		switch {
  19003 		case strings.EqualFold("message", t.Name.Local):
  19004 			val, err := decoder.Value()
  19005 			if err != nil {
  19006 				return err
  19007 			}
  19008 			if val == nil {
  19009 				break
  19010 			}
  19011 			{
  19012 				xtv := string(val)
  19013 				sv.Message = ptr.String(xtv)
  19014 			}
  19015 
  19016 		default:
  19017 			// Do nothing and ignore the unexpected tag element
  19018 			err = decoder.Decoder.Skip()
  19019 			if err != nil {
  19020 				return err
  19021 			}
  19022 
  19023 		}
  19024 		decoder = originalDecoder
  19025 	}
  19026 	*v = sv
  19027 	return nil
  19028 }
  19029 
  19030 func awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(v **types.InvalidKeySigningKeyStatus, decoder smithyxml.NodeDecoder) error {
  19031 	if v == nil {
  19032 		return fmt.Errorf("unexpected nil of type %T", v)
  19033 	}
  19034 	var sv *types.InvalidKeySigningKeyStatus
  19035 	if *v == nil {
  19036 		sv = &types.InvalidKeySigningKeyStatus{}
  19037 	} else {
  19038 		sv = *v
  19039 	}
  19040 
  19041 	for {
  19042 		t, done, err := decoder.Token()
  19043 		if err != nil {
  19044 			return err
  19045 		}
  19046 		if done {
  19047 			break
  19048 		}
  19049 		originalDecoder := decoder
  19050 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19051 		switch {
  19052 		case strings.EqualFold("message", t.Name.Local):
  19053 			val, err := decoder.Value()
  19054 			if err != nil {
  19055 				return err
  19056 			}
  19057 			if val == nil {
  19058 				break
  19059 			}
  19060 			{
  19061 				xtv := string(val)
  19062 				sv.Message = ptr.String(xtv)
  19063 			}
  19064 
  19065 		default:
  19066 			// Do nothing and ignore the unexpected tag element
  19067 			err = decoder.Decoder.Skip()
  19068 			if err != nil {
  19069 				return err
  19070 			}
  19071 
  19072 		}
  19073 		decoder = originalDecoder
  19074 	}
  19075 	*v = sv
  19076 	return nil
  19077 }
  19078 
  19079 func awsRestxml_deserializeDocumentInvalidKMSArn(v **types.InvalidKMSArn, decoder smithyxml.NodeDecoder) error {
  19080 	if v == nil {
  19081 		return fmt.Errorf("unexpected nil of type %T", v)
  19082 	}
  19083 	var sv *types.InvalidKMSArn
  19084 	if *v == nil {
  19085 		sv = &types.InvalidKMSArn{}
  19086 	} else {
  19087 		sv = *v
  19088 	}
  19089 
  19090 	for {
  19091 		t, done, err := decoder.Token()
  19092 		if err != nil {
  19093 			return err
  19094 		}
  19095 		if done {
  19096 			break
  19097 		}
  19098 		originalDecoder := decoder
  19099 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19100 		switch {
  19101 		case strings.EqualFold("message", t.Name.Local):
  19102 			val, err := decoder.Value()
  19103 			if err != nil {
  19104 				return err
  19105 			}
  19106 			if val == nil {
  19107 				break
  19108 			}
  19109 			{
  19110 				xtv := string(val)
  19111 				sv.Message = ptr.String(xtv)
  19112 			}
  19113 
  19114 		default:
  19115 			// Do nothing and ignore the unexpected tag element
  19116 			err = decoder.Decoder.Skip()
  19117 			if err != nil {
  19118 				return err
  19119 			}
  19120 
  19121 		}
  19122 		decoder = originalDecoder
  19123 	}
  19124 	*v = sv
  19125 	return nil
  19126 }
  19127 
  19128 func awsRestxml_deserializeDocumentInvalidPaginationToken(v **types.InvalidPaginationToken, decoder smithyxml.NodeDecoder) error {
  19129 	if v == nil {
  19130 		return fmt.Errorf("unexpected nil of type %T", v)
  19131 	}
  19132 	var sv *types.InvalidPaginationToken
  19133 	if *v == nil {
  19134 		sv = &types.InvalidPaginationToken{}
  19135 	} else {
  19136 		sv = *v
  19137 	}
  19138 
  19139 	for {
  19140 		t, done, err := decoder.Token()
  19141 		if err != nil {
  19142 			return err
  19143 		}
  19144 		if done {
  19145 			break
  19146 		}
  19147 		originalDecoder := decoder
  19148 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19149 		switch {
  19150 		case strings.EqualFold("message", t.Name.Local):
  19151 			val, err := decoder.Value()
  19152 			if err != nil {
  19153 				return err
  19154 			}
  19155 			if val == nil {
  19156 				break
  19157 			}
  19158 			{
  19159 				xtv := string(val)
  19160 				sv.Message = ptr.String(xtv)
  19161 			}
  19162 
  19163 		default:
  19164 			// Do nothing and ignore the unexpected tag element
  19165 			err = decoder.Decoder.Skip()
  19166 			if err != nil {
  19167 				return err
  19168 			}
  19169 
  19170 		}
  19171 		decoder = originalDecoder
  19172 	}
  19173 	*v = sv
  19174 	return nil
  19175 }
  19176 
  19177 func awsRestxml_deserializeDocumentInvalidSigningStatus(v **types.InvalidSigningStatus, decoder smithyxml.NodeDecoder) error {
  19178 	if v == nil {
  19179 		return fmt.Errorf("unexpected nil of type %T", v)
  19180 	}
  19181 	var sv *types.InvalidSigningStatus
  19182 	if *v == nil {
  19183 		sv = &types.InvalidSigningStatus{}
  19184 	} else {
  19185 		sv = *v
  19186 	}
  19187 
  19188 	for {
  19189 		t, done, err := decoder.Token()
  19190 		if err != nil {
  19191 			return err
  19192 		}
  19193 		if done {
  19194 			break
  19195 		}
  19196 		originalDecoder := decoder
  19197 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19198 		switch {
  19199 		case strings.EqualFold("message", t.Name.Local):
  19200 			val, err := decoder.Value()
  19201 			if err != nil {
  19202 				return err
  19203 			}
  19204 			if val == nil {
  19205 				break
  19206 			}
  19207 			{
  19208 				xtv := string(val)
  19209 				sv.Message = ptr.String(xtv)
  19210 			}
  19211 
  19212 		default:
  19213 			// Do nothing and ignore the unexpected tag element
  19214 			err = decoder.Decoder.Skip()
  19215 			if err != nil {
  19216 				return err
  19217 			}
  19218 
  19219 		}
  19220 		decoder = originalDecoder
  19221 	}
  19222 	*v = sv
  19223 	return nil
  19224 }
  19225 
  19226 func awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(v **types.InvalidTrafficPolicyDocument, decoder smithyxml.NodeDecoder) error {
  19227 	if v == nil {
  19228 		return fmt.Errorf("unexpected nil of type %T", v)
  19229 	}
  19230 	var sv *types.InvalidTrafficPolicyDocument
  19231 	if *v == nil {
  19232 		sv = &types.InvalidTrafficPolicyDocument{}
  19233 	} else {
  19234 		sv = *v
  19235 	}
  19236 
  19237 	for {
  19238 		t, done, err := decoder.Token()
  19239 		if err != nil {
  19240 			return err
  19241 		}
  19242 		if done {
  19243 			break
  19244 		}
  19245 		originalDecoder := decoder
  19246 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19247 		switch {
  19248 		case strings.EqualFold("message", t.Name.Local):
  19249 			val, err := decoder.Value()
  19250 			if err != nil {
  19251 				return err
  19252 			}
  19253 			if val == nil {
  19254 				break
  19255 			}
  19256 			{
  19257 				xtv := string(val)
  19258 				sv.Message = ptr.String(xtv)
  19259 			}
  19260 
  19261 		default:
  19262 			// Do nothing and ignore the unexpected tag element
  19263 			err = decoder.Decoder.Skip()
  19264 			if err != nil {
  19265 				return err
  19266 			}
  19267 
  19268 		}
  19269 		decoder = originalDecoder
  19270 	}
  19271 	*v = sv
  19272 	return nil
  19273 }
  19274 
  19275 func awsRestxml_deserializeDocumentInvalidVPCId(v **types.InvalidVPCId, decoder smithyxml.NodeDecoder) error {
  19276 	if v == nil {
  19277 		return fmt.Errorf("unexpected nil of type %T", v)
  19278 	}
  19279 	var sv *types.InvalidVPCId
  19280 	if *v == nil {
  19281 		sv = &types.InvalidVPCId{}
  19282 	} else {
  19283 		sv = *v
  19284 	}
  19285 
  19286 	for {
  19287 		t, done, err := decoder.Token()
  19288 		if err != nil {
  19289 			return err
  19290 		}
  19291 		if done {
  19292 			break
  19293 		}
  19294 		originalDecoder := decoder
  19295 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19296 		switch {
  19297 		case strings.EqualFold("message", t.Name.Local):
  19298 			val, err := decoder.Value()
  19299 			if err != nil {
  19300 				return err
  19301 			}
  19302 			if val == nil {
  19303 				break
  19304 			}
  19305 			{
  19306 				xtv := string(val)
  19307 				sv.Message = ptr.String(xtv)
  19308 			}
  19309 
  19310 		default:
  19311 			// Do nothing and ignore the unexpected tag element
  19312 			err = decoder.Decoder.Skip()
  19313 			if err != nil {
  19314 				return err
  19315 			}
  19316 
  19317 		}
  19318 		decoder = originalDecoder
  19319 	}
  19320 	*v = sv
  19321 	return nil
  19322 }
  19323 
  19324 func awsRestxml_deserializeDocumentKeySigningKey(v **types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
  19325 	if v == nil {
  19326 		return fmt.Errorf("unexpected nil of type %T", v)
  19327 	}
  19328 	var sv *types.KeySigningKey
  19329 	if *v == nil {
  19330 		sv = &types.KeySigningKey{}
  19331 	} else {
  19332 		sv = *v
  19333 	}
  19334 
  19335 	for {
  19336 		t, done, err := decoder.Token()
  19337 		if err != nil {
  19338 			return err
  19339 		}
  19340 		if done {
  19341 			break
  19342 		}
  19343 		originalDecoder := decoder
  19344 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19345 		switch {
  19346 		case strings.EqualFold("CreatedDate", t.Name.Local):
  19347 			val, err := decoder.Value()
  19348 			if err != nil {
  19349 				return err
  19350 			}
  19351 			if val == nil {
  19352 				break
  19353 			}
  19354 			{
  19355 				xtv := string(val)
  19356 				t, err := smithytime.ParseDateTime(xtv)
  19357 				if err != nil {
  19358 					return err
  19359 				}
  19360 				sv.CreatedDate = ptr.Time(t)
  19361 			}
  19362 
  19363 		case strings.EqualFold("DigestAlgorithmMnemonic", t.Name.Local):
  19364 			val, err := decoder.Value()
  19365 			if err != nil {
  19366 				return err
  19367 			}
  19368 			if val == nil {
  19369 				break
  19370 			}
  19371 			{
  19372 				xtv := string(val)
  19373 				sv.DigestAlgorithmMnemonic = ptr.String(xtv)
  19374 			}
  19375 
  19376 		case strings.EqualFold("DigestAlgorithmType", t.Name.Local):
  19377 			val, err := decoder.Value()
  19378 			if err != nil {
  19379 				return err
  19380 			}
  19381 			if val == nil {
  19382 				break
  19383 			}
  19384 			{
  19385 				xtv := string(val)
  19386 				i64, err := strconv.ParseInt(xtv, 10, 64)
  19387 				if err != nil {
  19388 					return err
  19389 				}
  19390 				sv.DigestAlgorithmType = int32(i64)
  19391 			}
  19392 
  19393 		case strings.EqualFold("DigestValue", t.Name.Local):
  19394 			val, err := decoder.Value()
  19395 			if err != nil {
  19396 				return err
  19397 			}
  19398 			if val == nil {
  19399 				break
  19400 			}
  19401 			{
  19402 				xtv := string(val)
  19403 				sv.DigestValue = ptr.String(xtv)
  19404 			}
  19405 
  19406 		case strings.EqualFold("DNSKEYRecord", t.Name.Local):
  19407 			val, err := decoder.Value()
  19408 			if err != nil {
  19409 				return err
  19410 			}
  19411 			if val == nil {
  19412 				break
  19413 			}
  19414 			{
  19415 				xtv := string(val)
  19416 				sv.DNSKEYRecord = ptr.String(xtv)
  19417 			}
  19418 
  19419 		case strings.EqualFold("DSRecord", t.Name.Local):
  19420 			val, err := decoder.Value()
  19421 			if err != nil {
  19422 				return err
  19423 			}
  19424 			if val == nil {
  19425 				break
  19426 			}
  19427 			{
  19428 				xtv := string(val)
  19429 				sv.DSRecord = ptr.String(xtv)
  19430 			}
  19431 
  19432 		case strings.EqualFold("Flag", t.Name.Local):
  19433 			val, err := decoder.Value()
  19434 			if err != nil {
  19435 				return err
  19436 			}
  19437 			if val == nil {
  19438 				break
  19439 			}
  19440 			{
  19441 				xtv := string(val)
  19442 				i64, err := strconv.ParseInt(xtv, 10, 64)
  19443 				if err != nil {
  19444 					return err
  19445 				}
  19446 				sv.Flag = int32(i64)
  19447 			}
  19448 
  19449 		case strings.EqualFold("KeyTag", 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 				i64, err := strconv.ParseInt(xtv, 10, 64)
  19460 				if err != nil {
  19461 					return err
  19462 				}
  19463 				sv.KeyTag = int32(i64)
  19464 			}
  19465 
  19466 		case strings.EqualFold("KmsArn", t.Name.Local):
  19467 			val, err := decoder.Value()
  19468 			if err != nil {
  19469 				return err
  19470 			}
  19471 			if val == nil {
  19472 				break
  19473 			}
  19474 			{
  19475 				xtv := string(val)
  19476 				sv.KmsArn = ptr.String(xtv)
  19477 			}
  19478 
  19479 		case strings.EqualFold("LastModifiedDate", t.Name.Local):
  19480 			val, err := decoder.Value()
  19481 			if err != nil {
  19482 				return err
  19483 			}
  19484 			if val == nil {
  19485 				break
  19486 			}
  19487 			{
  19488 				xtv := string(val)
  19489 				t, err := smithytime.ParseDateTime(xtv)
  19490 				if err != nil {
  19491 					return err
  19492 				}
  19493 				sv.LastModifiedDate = ptr.Time(t)
  19494 			}
  19495 
  19496 		case strings.EqualFold("Name", t.Name.Local):
  19497 			val, err := decoder.Value()
  19498 			if err != nil {
  19499 				return err
  19500 			}
  19501 			if val == nil {
  19502 				break
  19503 			}
  19504 			{
  19505 				xtv := string(val)
  19506 				sv.Name = ptr.String(xtv)
  19507 			}
  19508 
  19509 		case strings.EqualFold("PublicKey", t.Name.Local):
  19510 			val, err := decoder.Value()
  19511 			if err != nil {
  19512 				return err
  19513 			}
  19514 			if val == nil {
  19515 				break
  19516 			}
  19517 			{
  19518 				xtv := string(val)
  19519 				sv.PublicKey = ptr.String(xtv)
  19520 			}
  19521 
  19522 		case strings.EqualFold("SigningAlgorithmMnemonic", t.Name.Local):
  19523 			val, err := decoder.Value()
  19524 			if err != nil {
  19525 				return err
  19526 			}
  19527 			if val == nil {
  19528 				break
  19529 			}
  19530 			{
  19531 				xtv := string(val)
  19532 				sv.SigningAlgorithmMnemonic = ptr.String(xtv)
  19533 			}
  19534 
  19535 		case strings.EqualFold("SigningAlgorithmType", t.Name.Local):
  19536 			val, err := decoder.Value()
  19537 			if err != nil {
  19538 				return err
  19539 			}
  19540 			if val == nil {
  19541 				break
  19542 			}
  19543 			{
  19544 				xtv := string(val)
  19545 				i64, err := strconv.ParseInt(xtv, 10, 64)
  19546 				if err != nil {
  19547 					return err
  19548 				}
  19549 				sv.SigningAlgorithmType = int32(i64)
  19550 			}
  19551 
  19552 		case strings.EqualFold("Status", t.Name.Local):
  19553 			val, err := decoder.Value()
  19554 			if err != nil {
  19555 				return err
  19556 			}
  19557 			if val == nil {
  19558 				break
  19559 			}
  19560 			{
  19561 				xtv := string(val)
  19562 				sv.Status = ptr.String(xtv)
  19563 			}
  19564 
  19565 		case strings.EqualFold("StatusMessage", t.Name.Local):
  19566 			val, err := decoder.Value()
  19567 			if err != nil {
  19568 				return err
  19569 			}
  19570 			if val == nil {
  19571 				break
  19572 			}
  19573 			{
  19574 				xtv := string(val)
  19575 				sv.StatusMessage = ptr.String(xtv)
  19576 			}
  19577 
  19578 		default:
  19579 			// Do nothing and ignore the unexpected tag element
  19580 			err = decoder.Decoder.Skip()
  19581 			if err != nil {
  19582 				return err
  19583 			}
  19584 
  19585 		}
  19586 		decoder = originalDecoder
  19587 	}
  19588 	*v = sv
  19589 	return nil
  19590 }
  19591 
  19592 func awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(v **types.KeySigningKeyAlreadyExists, decoder smithyxml.NodeDecoder) error {
  19593 	if v == nil {
  19594 		return fmt.Errorf("unexpected nil of type %T", v)
  19595 	}
  19596 	var sv *types.KeySigningKeyAlreadyExists
  19597 	if *v == nil {
  19598 		sv = &types.KeySigningKeyAlreadyExists{}
  19599 	} else {
  19600 		sv = *v
  19601 	}
  19602 
  19603 	for {
  19604 		t, done, err := decoder.Token()
  19605 		if err != nil {
  19606 			return err
  19607 		}
  19608 		if done {
  19609 			break
  19610 		}
  19611 		originalDecoder := decoder
  19612 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19613 		switch {
  19614 		case strings.EqualFold("message", t.Name.Local):
  19615 			val, err := decoder.Value()
  19616 			if err != nil {
  19617 				return err
  19618 			}
  19619 			if val == nil {
  19620 				break
  19621 			}
  19622 			{
  19623 				xtv := string(val)
  19624 				sv.Message = ptr.String(xtv)
  19625 			}
  19626 
  19627 		default:
  19628 			// Do nothing and ignore the unexpected tag element
  19629 			err = decoder.Decoder.Skip()
  19630 			if err != nil {
  19631 				return err
  19632 			}
  19633 
  19634 		}
  19635 		decoder = originalDecoder
  19636 	}
  19637 	*v = sv
  19638 	return nil
  19639 }
  19640 
  19641 func awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(v **types.KeySigningKeyInParentDSRecord, decoder smithyxml.NodeDecoder) error {
  19642 	if v == nil {
  19643 		return fmt.Errorf("unexpected nil of type %T", v)
  19644 	}
  19645 	var sv *types.KeySigningKeyInParentDSRecord
  19646 	if *v == nil {
  19647 		sv = &types.KeySigningKeyInParentDSRecord{}
  19648 	} else {
  19649 		sv = *v
  19650 	}
  19651 
  19652 	for {
  19653 		t, done, err := decoder.Token()
  19654 		if err != nil {
  19655 			return err
  19656 		}
  19657 		if done {
  19658 			break
  19659 		}
  19660 		originalDecoder := decoder
  19661 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19662 		switch {
  19663 		case strings.EqualFold("message", t.Name.Local):
  19664 			val, err := decoder.Value()
  19665 			if err != nil {
  19666 				return err
  19667 			}
  19668 			if val == nil {
  19669 				break
  19670 			}
  19671 			{
  19672 				xtv := string(val)
  19673 				sv.Message = ptr.String(xtv)
  19674 			}
  19675 
  19676 		default:
  19677 			// Do nothing and ignore the unexpected tag element
  19678 			err = decoder.Decoder.Skip()
  19679 			if err != nil {
  19680 				return err
  19681 			}
  19682 
  19683 		}
  19684 		decoder = originalDecoder
  19685 	}
  19686 	*v = sv
  19687 	return nil
  19688 }
  19689 
  19690 func awsRestxml_deserializeDocumentKeySigningKeyInUse(v **types.KeySigningKeyInUse, decoder smithyxml.NodeDecoder) error {
  19691 	if v == nil {
  19692 		return fmt.Errorf("unexpected nil of type %T", v)
  19693 	}
  19694 	var sv *types.KeySigningKeyInUse
  19695 	if *v == nil {
  19696 		sv = &types.KeySigningKeyInUse{}
  19697 	} else {
  19698 		sv = *v
  19699 	}
  19700 
  19701 	for {
  19702 		t, done, err := decoder.Token()
  19703 		if err != nil {
  19704 			return err
  19705 		}
  19706 		if done {
  19707 			break
  19708 		}
  19709 		originalDecoder := decoder
  19710 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19711 		switch {
  19712 		case strings.EqualFold("message", t.Name.Local):
  19713 			val, err := decoder.Value()
  19714 			if err != nil {
  19715 				return err
  19716 			}
  19717 			if val == nil {
  19718 				break
  19719 			}
  19720 			{
  19721 				xtv := string(val)
  19722 				sv.Message = ptr.String(xtv)
  19723 			}
  19724 
  19725 		default:
  19726 			// Do nothing and ignore the unexpected tag element
  19727 			err = decoder.Decoder.Skip()
  19728 			if err != nil {
  19729 				return err
  19730 			}
  19731 
  19732 		}
  19733 		decoder = originalDecoder
  19734 	}
  19735 	*v = sv
  19736 	return nil
  19737 }
  19738 
  19739 func awsRestxml_deserializeDocumentKeySigningKeys(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
  19740 	if v == nil {
  19741 		return fmt.Errorf("unexpected nil of type %T", v)
  19742 	}
  19743 	var sv []types.KeySigningKey
  19744 	if *v == nil {
  19745 		sv = make([]types.KeySigningKey, 0)
  19746 	} else {
  19747 		sv = *v
  19748 	}
  19749 
  19750 	originalDecoder := decoder
  19751 	for {
  19752 		t, done, err := decoder.Token()
  19753 		if err != nil {
  19754 			return err
  19755 		}
  19756 		if done {
  19757 			break
  19758 		}
  19759 		switch {
  19760 		case strings.EqualFold("member", t.Name.Local):
  19761 			var col types.KeySigningKey
  19762 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  19763 			destAddr := &col
  19764 			if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil {
  19765 				return err
  19766 			}
  19767 			col = *destAddr
  19768 			sv = append(sv, col)
  19769 
  19770 		default:
  19771 			err = decoder.Decoder.Skip()
  19772 			if err != nil {
  19773 				return err
  19774 			}
  19775 
  19776 		}
  19777 		decoder = originalDecoder
  19778 	}
  19779 	*v = sv
  19780 	return nil
  19781 }
  19782 
  19783 func awsRestxml_deserializeDocumentKeySigningKeysUnwrapped(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
  19784 	var sv []types.KeySigningKey
  19785 	if *v == nil {
  19786 		sv = make([]types.KeySigningKey, 0)
  19787 	} else {
  19788 		sv = *v
  19789 	}
  19790 
  19791 	switch {
  19792 	default:
  19793 		var mv types.KeySigningKey
  19794 		t := decoder.StartEl
  19795 		_ = t
  19796 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  19797 		destAddr := &mv
  19798 		if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil {
  19799 			return err
  19800 		}
  19801 		mv = *destAddr
  19802 		sv = append(sv, mv)
  19803 	}
  19804 	*v = sv
  19805 	return nil
  19806 }
  19807 func awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(v **types.KeySigningKeyWithActiveStatusNotFound, decoder smithyxml.NodeDecoder) error {
  19808 	if v == nil {
  19809 		return fmt.Errorf("unexpected nil of type %T", v)
  19810 	}
  19811 	var sv *types.KeySigningKeyWithActiveStatusNotFound
  19812 	if *v == nil {
  19813 		sv = &types.KeySigningKeyWithActiveStatusNotFound{}
  19814 	} else {
  19815 		sv = *v
  19816 	}
  19817 
  19818 	for {
  19819 		t, done, err := decoder.Token()
  19820 		if err != nil {
  19821 			return err
  19822 		}
  19823 		if done {
  19824 			break
  19825 		}
  19826 		originalDecoder := decoder
  19827 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19828 		switch {
  19829 		case strings.EqualFold("message", t.Name.Local):
  19830 			val, err := decoder.Value()
  19831 			if err != nil {
  19832 				return err
  19833 			}
  19834 			if val == nil {
  19835 				break
  19836 			}
  19837 			{
  19838 				xtv := string(val)
  19839 				sv.Message = ptr.String(xtv)
  19840 			}
  19841 
  19842 		default:
  19843 			// Do nothing and ignore the unexpected tag element
  19844 			err = decoder.Decoder.Skip()
  19845 			if err != nil {
  19846 				return err
  19847 			}
  19848 
  19849 		}
  19850 		decoder = originalDecoder
  19851 	}
  19852 	*v = sv
  19853 	return nil
  19854 }
  19855 
  19856 func awsRestxml_deserializeDocumentLastVPCAssociation(v **types.LastVPCAssociation, decoder smithyxml.NodeDecoder) error {
  19857 	if v == nil {
  19858 		return fmt.Errorf("unexpected nil of type %T", v)
  19859 	}
  19860 	var sv *types.LastVPCAssociation
  19861 	if *v == nil {
  19862 		sv = &types.LastVPCAssociation{}
  19863 	} else {
  19864 		sv = *v
  19865 	}
  19866 
  19867 	for {
  19868 		t, done, err := decoder.Token()
  19869 		if err != nil {
  19870 			return err
  19871 		}
  19872 		if done {
  19873 			break
  19874 		}
  19875 		originalDecoder := decoder
  19876 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19877 		switch {
  19878 		case strings.EqualFold("message", t.Name.Local):
  19879 			val, err := decoder.Value()
  19880 			if err != nil {
  19881 				return err
  19882 			}
  19883 			if val == nil {
  19884 				break
  19885 			}
  19886 			{
  19887 				xtv := string(val)
  19888 				sv.Message = ptr.String(xtv)
  19889 			}
  19890 
  19891 		default:
  19892 			// Do nothing and ignore the unexpected tag element
  19893 			err = decoder.Decoder.Skip()
  19894 			if err != nil {
  19895 				return err
  19896 			}
  19897 
  19898 		}
  19899 		decoder = originalDecoder
  19900 	}
  19901 	*v = sv
  19902 	return nil
  19903 }
  19904 
  19905 func awsRestxml_deserializeDocumentLimitsExceeded(v **types.LimitsExceeded, decoder smithyxml.NodeDecoder) error {
  19906 	if v == nil {
  19907 		return fmt.Errorf("unexpected nil of type %T", v)
  19908 	}
  19909 	var sv *types.LimitsExceeded
  19910 	if *v == nil {
  19911 		sv = &types.LimitsExceeded{}
  19912 	} else {
  19913 		sv = *v
  19914 	}
  19915 
  19916 	for {
  19917 		t, done, err := decoder.Token()
  19918 		if err != nil {
  19919 			return err
  19920 		}
  19921 		if done {
  19922 			break
  19923 		}
  19924 		originalDecoder := decoder
  19925 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19926 		switch {
  19927 		case strings.EqualFold("message", t.Name.Local):
  19928 			val, err := decoder.Value()
  19929 			if err != nil {
  19930 				return err
  19931 			}
  19932 			if val == nil {
  19933 				break
  19934 			}
  19935 			{
  19936 				xtv := string(val)
  19937 				sv.Message = ptr.String(xtv)
  19938 			}
  19939 
  19940 		default:
  19941 			// Do nothing and ignore the unexpected tag element
  19942 			err = decoder.Decoder.Skip()
  19943 			if err != nil {
  19944 				return err
  19945 			}
  19946 
  19947 		}
  19948 		decoder = originalDecoder
  19949 	}
  19950 	*v = sv
  19951 	return nil
  19952 }
  19953 
  19954 func awsRestxml_deserializeDocumentLinkedService(v **types.LinkedService, decoder smithyxml.NodeDecoder) error {
  19955 	if v == nil {
  19956 		return fmt.Errorf("unexpected nil of type %T", v)
  19957 	}
  19958 	var sv *types.LinkedService
  19959 	if *v == nil {
  19960 		sv = &types.LinkedService{}
  19961 	} else {
  19962 		sv = *v
  19963 	}
  19964 
  19965 	for {
  19966 		t, done, err := decoder.Token()
  19967 		if err != nil {
  19968 			return err
  19969 		}
  19970 		if done {
  19971 			break
  19972 		}
  19973 		originalDecoder := decoder
  19974 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19975 		switch {
  19976 		case strings.EqualFold("Description", t.Name.Local):
  19977 			val, err := decoder.Value()
  19978 			if err != nil {
  19979 				return err
  19980 			}
  19981 			if val == nil {
  19982 				break
  19983 			}
  19984 			{
  19985 				xtv := string(val)
  19986 				sv.Description = ptr.String(xtv)
  19987 			}
  19988 
  19989 		case strings.EqualFold("ServicePrincipal", t.Name.Local):
  19990 			val, err := decoder.Value()
  19991 			if err != nil {
  19992 				return err
  19993 			}
  19994 			if val == nil {
  19995 				break
  19996 			}
  19997 			{
  19998 				xtv := string(val)
  19999 				sv.ServicePrincipal = ptr.String(xtv)
  20000 			}
  20001 
  20002 		default:
  20003 			// Do nothing and ignore the unexpected tag element
  20004 			err = decoder.Decoder.Skip()
  20005 			if err != nil {
  20006 				return err
  20007 			}
  20008 
  20009 		}
  20010 		decoder = originalDecoder
  20011 	}
  20012 	*v = sv
  20013 	return nil
  20014 }
  20015 
  20016 func awsRestxml_deserializeDocumentLocationSummaries(v *[]types.LocationSummary, decoder smithyxml.NodeDecoder) error {
  20017 	if v == nil {
  20018 		return fmt.Errorf("unexpected nil of type %T", v)
  20019 	}
  20020 	var sv []types.LocationSummary
  20021 	if *v == nil {
  20022 		sv = make([]types.LocationSummary, 0)
  20023 	} else {
  20024 		sv = *v
  20025 	}
  20026 
  20027 	originalDecoder := decoder
  20028 	for {
  20029 		t, done, err := decoder.Token()
  20030 		if err != nil {
  20031 			return err
  20032 		}
  20033 		if done {
  20034 			break
  20035 		}
  20036 		switch {
  20037 		case strings.EqualFold("member", t.Name.Local):
  20038 			var col types.LocationSummary
  20039 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20040 			destAddr := &col
  20041 			if err := awsRestxml_deserializeDocumentLocationSummary(&destAddr, nodeDecoder); err != nil {
  20042 				return err
  20043 			}
  20044 			col = *destAddr
  20045 			sv = append(sv, col)
  20046 
  20047 		default:
  20048 			err = decoder.Decoder.Skip()
  20049 			if err != nil {
  20050 				return err
  20051 			}
  20052 
  20053 		}
  20054 		decoder = originalDecoder
  20055 	}
  20056 	*v = sv
  20057 	return nil
  20058 }
  20059 
  20060 func awsRestxml_deserializeDocumentLocationSummariesUnwrapped(v *[]types.LocationSummary, decoder smithyxml.NodeDecoder) error {
  20061 	var sv []types.LocationSummary
  20062 	if *v == nil {
  20063 		sv = make([]types.LocationSummary, 0)
  20064 	} else {
  20065 		sv = *v
  20066 	}
  20067 
  20068 	switch {
  20069 	default:
  20070 		var mv types.LocationSummary
  20071 		t := decoder.StartEl
  20072 		_ = t
  20073 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20074 		destAddr := &mv
  20075 		if err := awsRestxml_deserializeDocumentLocationSummary(&destAddr, nodeDecoder); err != nil {
  20076 			return err
  20077 		}
  20078 		mv = *destAddr
  20079 		sv = append(sv, mv)
  20080 	}
  20081 	*v = sv
  20082 	return nil
  20083 }
  20084 func awsRestxml_deserializeDocumentLocationSummary(v **types.LocationSummary, decoder smithyxml.NodeDecoder) error {
  20085 	if v == nil {
  20086 		return fmt.Errorf("unexpected nil of type %T", v)
  20087 	}
  20088 	var sv *types.LocationSummary
  20089 	if *v == nil {
  20090 		sv = &types.LocationSummary{}
  20091 	} else {
  20092 		sv = *v
  20093 	}
  20094 
  20095 	for {
  20096 		t, done, err := decoder.Token()
  20097 		if err != nil {
  20098 			return err
  20099 		}
  20100 		if done {
  20101 			break
  20102 		}
  20103 		originalDecoder := decoder
  20104 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20105 		switch {
  20106 		case strings.EqualFold("LocationName", t.Name.Local):
  20107 			val, err := decoder.Value()
  20108 			if err != nil {
  20109 				return err
  20110 			}
  20111 			if val == nil {
  20112 				break
  20113 			}
  20114 			{
  20115 				xtv := string(val)
  20116 				sv.LocationName = ptr.String(xtv)
  20117 			}
  20118 
  20119 		default:
  20120 			// Do nothing and ignore the unexpected tag element
  20121 			err = decoder.Decoder.Skip()
  20122 			if err != nil {
  20123 				return err
  20124 			}
  20125 
  20126 		}
  20127 		decoder = originalDecoder
  20128 	}
  20129 	*v = sv
  20130 	return nil
  20131 }
  20132 
  20133 func awsRestxml_deserializeDocumentNoSuchChange(v **types.NoSuchChange, decoder smithyxml.NodeDecoder) error {
  20134 	if v == nil {
  20135 		return fmt.Errorf("unexpected nil of type %T", v)
  20136 	}
  20137 	var sv *types.NoSuchChange
  20138 	if *v == nil {
  20139 		sv = &types.NoSuchChange{}
  20140 	} else {
  20141 		sv = *v
  20142 	}
  20143 
  20144 	for {
  20145 		t, done, err := decoder.Token()
  20146 		if err != nil {
  20147 			return err
  20148 		}
  20149 		if done {
  20150 			break
  20151 		}
  20152 		originalDecoder := decoder
  20153 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20154 		switch {
  20155 		case strings.EqualFold("message", t.Name.Local):
  20156 			val, err := decoder.Value()
  20157 			if err != nil {
  20158 				return err
  20159 			}
  20160 			if val == nil {
  20161 				break
  20162 			}
  20163 			{
  20164 				xtv := string(val)
  20165 				sv.Message = ptr.String(xtv)
  20166 			}
  20167 
  20168 		default:
  20169 			// Do nothing and ignore the unexpected tag element
  20170 			err = decoder.Decoder.Skip()
  20171 			if err != nil {
  20172 				return err
  20173 			}
  20174 
  20175 		}
  20176 		decoder = originalDecoder
  20177 	}
  20178 	*v = sv
  20179 	return nil
  20180 }
  20181 
  20182 func awsRestxml_deserializeDocumentNoSuchCidrCollectionException(v **types.NoSuchCidrCollectionException, decoder smithyxml.NodeDecoder) error {
  20183 	if v == nil {
  20184 		return fmt.Errorf("unexpected nil of type %T", v)
  20185 	}
  20186 	var sv *types.NoSuchCidrCollectionException
  20187 	if *v == nil {
  20188 		sv = &types.NoSuchCidrCollectionException{}
  20189 	} else {
  20190 		sv = *v
  20191 	}
  20192 
  20193 	for {
  20194 		t, done, err := decoder.Token()
  20195 		if err != nil {
  20196 			return err
  20197 		}
  20198 		if done {
  20199 			break
  20200 		}
  20201 		originalDecoder := decoder
  20202 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20203 		switch {
  20204 		case strings.EqualFold("Message", t.Name.Local):
  20205 			val, err := decoder.Value()
  20206 			if err != nil {
  20207 				return err
  20208 			}
  20209 			if val == nil {
  20210 				break
  20211 			}
  20212 			{
  20213 				xtv := string(val)
  20214 				sv.Message = ptr.String(xtv)
  20215 			}
  20216 
  20217 		default:
  20218 			// Do nothing and ignore the unexpected tag element
  20219 			err = decoder.Decoder.Skip()
  20220 			if err != nil {
  20221 				return err
  20222 			}
  20223 
  20224 		}
  20225 		decoder = originalDecoder
  20226 	}
  20227 	*v = sv
  20228 	return nil
  20229 }
  20230 
  20231 func awsRestxml_deserializeDocumentNoSuchCidrLocationException(v **types.NoSuchCidrLocationException, decoder smithyxml.NodeDecoder) error {
  20232 	if v == nil {
  20233 		return fmt.Errorf("unexpected nil of type %T", v)
  20234 	}
  20235 	var sv *types.NoSuchCidrLocationException
  20236 	if *v == nil {
  20237 		sv = &types.NoSuchCidrLocationException{}
  20238 	} else {
  20239 		sv = *v
  20240 	}
  20241 
  20242 	for {
  20243 		t, done, err := decoder.Token()
  20244 		if err != nil {
  20245 			return err
  20246 		}
  20247 		if done {
  20248 			break
  20249 		}
  20250 		originalDecoder := decoder
  20251 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20252 		switch {
  20253 		case strings.EqualFold("Message", t.Name.Local):
  20254 			val, err := decoder.Value()
  20255 			if err != nil {
  20256 				return err
  20257 			}
  20258 			if val == nil {
  20259 				break
  20260 			}
  20261 			{
  20262 				xtv := string(val)
  20263 				sv.Message = ptr.String(xtv)
  20264 			}
  20265 
  20266 		default:
  20267 			// Do nothing and ignore the unexpected tag element
  20268 			err = decoder.Decoder.Skip()
  20269 			if err != nil {
  20270 				return err
  20271 			}
  20272 
  20273 		}
  20274 		decoder = originalDecoder
  20275 	}
  20276 	*v = sv
  20277 	return nil
  20278 }
  20279 
  20280 func awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(v **types.NoSuchCloudWatchLogsLogGroup, decoder smithyxml.NodeDecoder) error {
  20281 	if v == nil {
  20282 		return fmt.Errorf("unexpected nil of type %T", v)
  20283 	}
  20284 	var sv *types.NoSuchCloudWatchLogsLogGroup
  20285 	if *v == nil {
  20286 		sv = &types.NoSuchCloudWatchLogsLogGroup{}
  20287 	} else {
  20288 		sv = *v
  20289 	}
  20290 
  20291 	for {
  20292 		t, done, err := decoder.Token()
  20293 		if err != nil {
  20294 			return err
  20295 		}
  20296 		if done {
  20297 			break
  20298 		}
  20299 		originalDecoder := decoder
  20300 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20301 		switch {
  20302 		case strings.EqualFold("message", t.Name.Local):
  20303 			val, err := decoder.Value()
  20304 			if err != nil {
  20305 				return err
  20306 			}
  20307 			if val == nil {
  20308 				break
  20309 			}
  20310 			{
  20311 				xtv := string(val)
  20312 				sv.Message = ptr.String(xtv)
  20313 			}
  20314 
  20315 		default:
  20316 			// Do nothing and ignore the unexpected tag element
  20317 			err = decoder.Decoder.Skip()
  20318 			if err != nil {
  20319 				return err
  20320 			}
  20321 
  20322 		}
  20323 		decoder = originalDecoder
  20324 	}
  20325 	*v = sv
  20326 	return nil
  20327 }
  20328 
  20329 func awsRestxml_deserializeDocumentNoSuchDelegationSet(v **types.NoSuchDelegationSet, decoder smithyxml.NodeDecoder) error {
  20330 	if v == nil {
  20331 		return fmt.Errorf("unexpected nil of type %T", v)
  20332 	}
  20333 	var sv *types.NoSuchDelegationSet
  20334 	if *v == nil {
  20335 		sv = &types.NoSuchDelegationSet{}
  20336 	} else {
  20337 		sv = *v
  20338 	}
  20339 
  20340 	for {
  20341 		t, done, err := decoder.Token()
  20342 		if err != nil {
  20343 			return err
  20344 		}
  20345 		if done {
  20346 			break
  20347 		}
  20348 		originalDecoder := decoder
  20349 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20350 		switch {
  20351 		case strings.EqualFold("message", t.Name.Local):
  20352 			val, err := decoder.Value()
  20353 			if err != nil {
  20354 				return err
  20355 			}
  20356 			if val == nil {
  20357 				break
  20358 			}
  20359 			{
  20360 				xtv := string(val)
  20361 				sv.Message = ptr.String(xtv)
  20362 			}
  20363 
  20364 		default:
  20365 			// Do nothing and ignore the unexpected tag element
  20366 			err = decoder.Decoder.Skip()
  20367 			if err != nil {
  20368 				return err
  20369 			}
  20370 
  20371 		}
  20372 		decoder = originalDecoder
  20373 	}
  20374 	*v = sv
  20375 	return nil
  20376 }
  20377 
  20378 func awsRestxml_deserializeDocumentNoSuchGeoLocation(v **types.NoSuchGeoLocation, decoder smithyxml.NodeDecoder) error {
  20379 	if v == nil {
  20380 		return fmt.Errorf("unexpected nil of type %T", v)
  20381 	}
  20382 	var sv *types.NoSuchGeoLocation
  20383 	if *v == nil {
  20384 		sv = &types.NoSuchGeoLocation{}
  20385 	} else {
  20386 		sv = *v
  20387 	}
  20388 
  20389 	for {
  20390 		t, done, err := decoder.Token()
  20391 		if err != nil {
  20392 			return err
  20393 		}
  20394 		if done {
  20395 			break
  20396 		}
  20397 		originalDecoder := decoder
  20398 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20399 		switch {
  20400 		case strings.EqualFold("message", t.Name.Local):
  20401 			val, err := decoder.Value()
  20402 			if err != nil {
  20403 				return err
  20404 			}
  20405 			if val == nil {
  20406 				break
  20407 			}
  20408 			{
  20409 				xtv := string(val)
  20410 				sv.Message = ptr.String(xtv)
  20411 			}
  20412 
  20413 		default:
  20414 			// Do nothing and ignore the unexpected tag element
  20415 			err = decoder.Decoder.Skip()
  20416 			if err != nil {
  20417 				return err
  20418 			}
  20419 
  20420 		}
  20421 		decoder = originalDecoder
  20422 	}
  20423 	*v = sv
  20424 	return nil
  20425 }
  20426 
  20427 func awsRestxml_deserializeDocumentNoSuchHealthCheck(v **types.NoSuchHealthCheck, decoder smithyxml.NodeDecoder) error {
  20428 	if v == nil {
  20429 		return fmt.Errorf("unexpected nil of type %T", v)
  20430 	}
  20431 	var sv *types.NoSuchHealthCheck
  20432 	if *v == nil {
  20433 		sv = &types.NoSuchHealthCheck{}
  20434 	} else {
  20435 		sv = *v
  20436 	}
  20437 
  20438 	for {
  20439 		t, done, err := decoder.Token()
  20440 		if err != nil {
  20441 			return err
  20442 		}
  20443 		if done {
  20444 			break
  20445 		}
  20446 		originalDecoder := decoder
  20447 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20448 		switch {
  20449 		case strings.EqualFold("message", t.Name.Local):
  20450 			val, err := decoder.Value()
  20451 			if err != nil {
  20452 				return err
  20453 			}
  20454 			if val == nil {
  20455 				break
  20456 			}
  20457 			{
  20458 				xtv := string(val)
  20459 				sv.Message = ptr.String(xtv)
  20460 			}
  20461 
  20462 		default:
  20463 			// Do nothing and ignore the unexpected tag element
  20464 			err = decoder.Decoder.Skip()
  20465 			if err != nil {
  20466 				return err
  20467 			}
  20468 
  20469 		}
  20470 		decoder = originalDecoder
  20471 	}
  20472 	*v = sv
  20473 	return nil
  20474 }
  20475 
  20476 func awsRestxml_deserializeDocumentNoSuchHostedZone(v **types.NoSuchHostedZone, decoder smithyxml.NodeDecoder) error {
  20477 	if v == nil {
  20478 		return fmt.Errorf("unexpected nil of type %T", v)
  20479 	}
  20480 	var sv *types.NoSuchHostedZone
  20481 	if *v == nil {
  20482 		sv = &types.NoSuchHostedZone{}
  20483 	} else {
  20484 		sv = *v
  20485 	}
  20486 
  20487 	for {
  20488 		t, done, err := decoder.Token()
  20489 		if err != nil {
  20490 			return err
  20491 		}
  20492 		if done {
  20493 			break
  20494 		}
  20495 		originalDecoder := decoder
  20496 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20497 		switch {
  20498 		case strings.EqualFold("message", t.Name.Local):
  20499 			val, err := decoder.Value()
  20500 			if err != nil {
  20501 				return err
  20502 			}
  20503 			if val == nil {
  20504 				break
  20505 			}
  20506 			{
  20507 				xtv := string(val)
  20508 				sv.Message = ptr.String(xtv)
  20509 			}
  20510 
  20511 		default:
  20512 			// Do nothing and ignore the unexpected tag element
  20513 			err = decoder.Decoder.Skip()
  20514 			if err != nil {
  20515 				return err
  20516 			}
  20517 
  20518 		}
  20519 		decoder = originalDecoder
  20520 	}
  20521 	*v = sv
  20522 	return nil
  20523 }
  20524 
  20525 func awsRestxml_deserializeDocumentNoSuchKeySigningKey(v **types.NoSuchKeySigningKey, decoder smithyxml.NodeDecoder) error {
  20526 	if v == nil {
  20527 		return fmt.Errorf("unexpected nil of type %T", v)
  20528 	}
  20529 	var sv *types.NoSuchKeySigningKey
  20530 	if *v == nil {
  20531 		sv = &types.NoSuchKeySigningKey{}
  20532 	} else {
  20533 		sv = *v
  20534 	}
  20535 
  20536 	for {
  20537 		t, done, err := decoder.Token()
  20538 		if err != nil {
  20539 			return err
  20540 		}
  20541 		if done {
  20542 			break
  20543 		}
  20544 		originalDecoder := decoder
  20545 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20546 		switch {
  20547 		case strings.EqualFold("message", t.Name.Local):
  20548 			val, err := decoder.Value()
  20549 			if err != nil {
  20550 				return err
  20551 			}
  20552 			if val == nil {
  20553 				break
  20554 			}
  20555 			{
  20556 				xtv := string(val)
  20557 				sv.Message = ptr.String(xtv)
  20558 			}
  20559 
  20560 		default:
  20561 			// Do nothing and ignore the unexpected tag element
  20562 			err = decoder.Decoder.Skip()
  20563 			if err != nil {
  20564 				return err
  20565 			}
  20566 
  20567 		}
  20568 		decoder = originalDecoder
  20569 	}
  20570 	*v = sv
  20571 	return nil
  20572 }
  20573 
  20574 func awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(v **types.NoSuchQueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  20575 	if v == nil {
  20576 		return fmt.Errorf("unexpected nil of type %T", v)
  20577 	}
  20578 	var sv *types.NoSuchQueryLoggingConfig
  20579 	if *v == nil {
  20580 		sv = &types.NoSuchQueryLoggingConfig{}
  20581 	} else {
  20582 		sv = *v
  20583 	}
  20584 
  20585 	for {
  20586 		t, done, err := decoder.Token()
  20587 		if err != nil {
  20588 			return err
  20589 		}
  20590 		if done {
  20591 			break
  20592 		}
  20593 		originalDecoder := decoder
  20594 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20595 		switch {
  20596 		case strings.EqualFold("message", t.Name.Local):
  20597 			val, err := decoder.Value()
  20598 			if err != nil {
  20599 				return err
  20600 			}
  20601 			if val == nil {
  20602 				break
  20603 			}
  20604 			{
  20605 				xtv := string(val)
  20606 				sv.Message = ptr.String(xtv)
  20607 			}
  20608 
  20609 		default:
  20610 			// Do nothing and ignore the unexpected tag element
  20611 			err = decoder.Decoder.Skip()
  20612 			if err != nil {
  20613 				return err
  20614 			}
  20615 
  20616 		}
  20617 		decoder = originalDecoder
  20618 	}
  20619 	*v = sv
  20620 	return nil
  20621 }
  20622 
  20623 func awsRestxml_deserializeDocumentNoSuchTrafficPolicy(v **types.NoSuchTrafficPolicy, decoder smithyxml.NodeDecoder) error {
  20624 	if v == nil {
  20625 		return fmt.Errorf("unexpected nil of type %T", v)
  20626 	}
  20627 	var sv *types.NoSuchTrafficPolicy
  20628 	if *v == nil {
  20629 		sv = &types.NoSuchTrafficPolicy{}
  20630 	} else {
  20631 		sv = *v
  20632 	}
  20633 
  20634 	for {
  20635 		t, done, err := decoder.Token()
  20636 		if err != nil {
  20637 			return err
  20638 		}
  20639 		if done {
  20640 			break
  20641 		}
  20642 		originalDecoder := decoder
  20643 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20644 		switch {
  20645 		case strings.EqualFold("message", t.Name.Local):
  20646 			val, err := decoder.Value()
  20647 			if err != nil {
  20648 				return err
  20649 			}
  20650 			if val == nil {
  20651 				break
  20652 			}
  20653 			{
  20654 				xtv := string(val)
  20655 				sv.Message = ptr.String(xtv)
  20656 			}
  20657 
  20658 		default:
  20659 			// Do nothing and ignore the unexpected tag element
  20660 			err = decoder.Decoder.Skip()
  20661 			if err != nil {
  20662 				return err
  20663 			}
  20664 
  20665 		}
  20666 		decoder = originalDecoder
  20667 	}
  20668 	*v = sv
  20669 	return nil
  20670 }
  20671 
  20672 func awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(v **types.NoSuchTrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  20673 	if v == nil {
  20674 		return fmt.Errorf("unexpected nil of type %T", v)
  20675 	}
  20676 	var sv *types.NoSuchTrafficPolicyInstance
  20677 	if *v == nil {
  20678 		sv = &types.NoSuchTrafficPolicyInstance{}
  20679 	} else {
  20680 		sv = *v
  20681 	}
  20682 
  20683 	for {
  20684 		t, done, err := decoder.Token()
  20685 		if err != nil {
  20686 			return err
  20687 		}
  20688 		if done {
  20689 			break
  20690 		}
  20691 		originalDecoder := decoder
  20692 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20693 		switch {
  20694 		case strings.EqualFold("message", t.Name.Local):
  20695 			val, err := decoder.Value()
  20696 			if err != nil {
  20697 				return err
  20698 			}
  20699 			if val == nil {
  20700 				break
  20701 			}
  20702 			{
  20703 				xtv := string(val)
  20704 				sv.Message = ptr.String(xtv)
  20705 			}
  20706 
  20707 		default:
  20708 			// Do nothing and ignore the unexpected tag element
  20709 			err = decoder.Decoder.Skip()
  20710 			if err != nil {
  20711 				return err
  20712 			}
  20713 
  20714 		}
  20715 		decoder = originalDecoder
  20716 	}
  20717 	*v = sv
  20718 	return nil
  20719 }
  20720 
  20721 func awsRestxml_deserializeDocumentNotAuthorizedException(v **types.NotAuthorizedException, decoder smithyxml.NodeDecoder) error {
  20722 	if v == nil {
  20723 		return fmt.Errorf("unexpected nil of type %T", v)
  20724 	}
  20725 	var sv *types.NotAuthorizedException
  20726 	if *v == nil {
  20727 		sv = &types.NotAuthorizedException{}
  20728 	} else {
  20729 		sv = *v
  20730 	}
  20731 
  20732 	for {
  20733 		t, done, err := decoder.Token()
  20734 		if err != nil {
  20735 			return err
  20736 		}
  20737 		if done {
  20738 			break
  20739 		}
  20740 		originalDecoder := decoder
  20741 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20742 		switch {
  20743 		case strings.EqualFold("message", t.Name.Local):
  20744 			val, err := decoder.Value()
  20745 			if err != nil {
  20746 				return err
  20747 			}
  20748 			if val == nil {
  20749 				break
  20750 			}
  20751 			{
  20752 				xtv := string(val)
  20753 				sv.Message = ptr.String(xtv)
  20754 			}
  20755 
  20756 		default:
  20757 			// Do nothing and ignore the unexpected tag element
  20758 			err = decoder.Decoder.Skip()
  20759 			if err != nil {
  20760 				return err
  20761 			}
  20762 
  20763 		}
  20764 		decoder = originalDecoder
  20765 	}
  20766 	*v = sv
  20767 	return nil
  20768 }
  20769 
  20770 func awsRestxml_deserializeDocumentPriorRequestNotComplete(v **types.PriorRequestNotComplete, decoder smithyxml.NodeDecoder) error {
  20771 	if v == nil {
  20772 		return fmt.Errorf("unexpected nil of type %T", v)
  20773 	}
  20774 	var sv *types.PriorRequestNotComplete
  20775 	if *v == nil {
  20776 		sv = &types.PriorRequestNotComplete{}
  20777 	} else {
  20778 		sv = *v
  20779 	}
  20780 
  20781 	for {
  20782 		t, done, err := decoder.Token()
  20783 		if err != nil {
  20784 			return err
  20785 		}
  20786 		if done {
  20787 			break
  20788 		}
  20789 		originalDecoder := decoder
  20790 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20791 		switch {
  20792 		case strings.EqualFold("message", t.Name.Local):
  20793 			val, err := decoder.Value()
  20794 			if err != nil {
  20795 				return err
  20796 			}
  20797 			if val == nil {
  20798 				break
  20799 			}
  20800 			{
  20801 				xtv := string(val)
  20802 				sv.Message = ptr.String(xtv)
  20803 			}
  20804 
  20805 		default:
  20806 			// Do nothing and ignore the unexpected tag element
  20807 			err = decoder.Decoder.Skip()
  20808 			if err != nil {
  20809 				return err
  20810 			}
  20811 
  20812 		}
  20813 		decoder = originalDecoder
  20814 	}
  20815 	*v = sv
  20816 	return nil
  20817 }
  20818 
  20819 func awsRestxml_deserializeDocumentPublicZoneVPCAssociation(v **types.PublicZoneVPCAssociation, decoder smithyxml.NodeDecoder) error {
  20820 	if v == nil {
  20821 		return fmt.Errorf("unexpected nil of type %T", v)
  20822 	}
  20823 	var sv *types.PublicZoneVPCAssociation
  20824 	if *v == nil {
  20825 		sv = &types.PublicZoneVPCAssociation{}
  20826 	} else {
  20827 		sv = *v
  20828 	}
  20829 
  20830 	for {
  20831 		t, done, err := decoder.Token()
  20832 		if err != nil {
  20833 			return err
  20834 		}
  20835 		if done {
  20836 			break
  20837 		}
  20838 		originalDecoder := decoder
  20839 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20840 		switch {
  20841 		case strings.EqualFold("message", t.Name.Local):
  20842 			val, err := decoder.Value()
  20843 			if err != nil {
  20844 				return err
  20845 			}
  20846 			if val == nil {
  20847 				break
  20848 			}
  20849 			{
  20850 				xtv := string(val)
  20851 				sv.Message = ptr.String(xtv)
  20852 			}
  20853 
  20854 		default:
  20855 			// Do nothing and ignore the unexpected tag element
  20856 			err = decoder.Decoder.Skip()
  20857 			if err != nil {
  20858 				return err
  20859 			}
  20860 
  20861 		}
  20862 		decoder = originalDecoder
  20863 	}
  20864 	*v = sv
  20865 	return nil
  20866 }
  20867 
  20868 func awsRestxml_deserializeDocumentQueryLoggingConfig(v **types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  20869 	if v == nil {
  20870 		return fmt.Errorf("unexpected nil of type %T", v)
  20871 	}
  20872 	var sv *types.QueryLoggingConfig
  20873 	if *v == nil {
  20874 		sv = &types.QueryLoggingConfig{}
  20875 	} else {
  20876 		sv = *v
  20877 	}
  20878 
  20879 	for {
  20880 		t, done, err := decoder.Token()
  20881 		if err != nil {
  20882 			return err
  20883 		}
  20884 		if done {
  20885 			break
  20886 		}
  20887 		originalDecoder := decoder
  20888 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20889 		switch {
  20890 		case strings.EqualFold("CloudWatchLogsLogGroupArn", t.Name.Local):
  20891 			val, err := decoder.Value()
  20892 			if err != nil {
  20893 				return err
  20894 			}
  20895 			if val == nil {
  20896 				break
  20897 			}
  20898 			{
  20899 				xtv := string(val)
  20900 				sv.CloudWatchLogsLogGroupArn = ptr.String(xtv)
  20901 			}
  20902 
  20903 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  20904 			val, err := decoder.Value()
  20905 			if err != nil {
  20906 				return err
  20907 			}
  20908 			if val == nil {
  20909 				break
  20910 			}
  20911 			{
  20912 				xtv := string(val)
  20913 				sv.HostedZoneId = ptr.String(xtv)
  20914 			}
  20915 
  20916 		case strings.EqualFold("Id", t.Name.Local):
  20917 			val, err := decoder.Value()
  20918 			if err != nil {
  20919 				return err
  20920 			}
  20921 			if val == nil {
  20922 				break
  20923 			}
  20924 			{
  20925 				xtv := string(val)
  20926 				sv.Id = ptr.String(xtv)
  20927 			}
  20928 
  20929 		default:
  20930 			// Do nothing and ignore the unexpected tag element
  20931 			err = decoder.Decoder.Skip()
  20932 			if err != nil {
  20933 				return err
  20934 			}
  20935 
  20936 		}
  20937 		decoder = originalDecoder
  20938 	}
  20939 	*v = sv
  20940 	return nil
  20941 }
  20942 
  20943 func awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(v **types.QueryLoggingConfigAlreadyExists, decoder smithyxml.NodeDecoder) error {
  20944 	if v == nil {
  20945 		return fmt.Errorf("unexpected nil of type %T", v)
  20946 	}
  20947 	var sv *types.QueryLoggingConfigAlreadyExists
  20948 	if *v == nil {
  20949 		sv = &types.QueryLoggingConfigAlreadyExists{}
  20950 	} else {
  20951 		sv = *v
  20952 	}
  20953 
  20954 	for {
  20955 		t, done, err := decoder.Token()
  20956 		if err != nil {
  20957 			return err
  20958 		}
  20959 		if done {
  20960 			break
  20961 		}
  20962 		originalDecoder := decoder
  20963 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20964 		switch {
  20965 		case strings.EqualFold("message", t.Name.Local):
  20966 			val, err := decoder.Value()
  20967 			if err != nil {
  20968 				return err
  20969 			}
  20970 			if val == nil {
  20971 				break
  20972 			}
  20973 			{
  20974 				xtv := string(val)
  20975 				sv.Message = ptr.String(xtv)
  20976 			}
  20977 
  20978 		default:
  20979 			// Do nothing and ignore the unexpected tag element
  20980 			err = decoder.Decoder.Skip()
  20981 			if err != nil {
  20982 				return err
  20983 			}
  20984 
  20985 		}
  20986 		decoder = originalDecoder
  20987 	}
  20988 	*v = sv
  20989 	return nil
  20990 }
  20991 
  20992 func awsRestxml_deserializeDocumentQueryLoggingConfigs(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  20993 	if v == nil {
  20994 		return fmt.Errorf("unexpected nil of type %T", v)
  20995 	}
  20996 	var sv []types.QueryLoggingConfig
  20997 	if *v == nil {
  20998 		sv = make([]types.QueryLoggingConfig, 0)
  20999 	} else {
  21000 		sv = *v
  21001 	}
  21002 
  21003 	originalDecoder := decoder
  21004 	for {
  21005 		t, done, err := decoder.Token()
  21006 		if err != nil {
  21007 			return err
  21008 		}
  21009 		if done {
  21010 			break
  21011 		}
  21012 		switch {
  21013 		case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
  21014 			var col types.QueryLoggingConfig
  21015 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21016 			destAddr := &col
  21017 			if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil {
  21018 				return err
  21019 			}
  21020 			col = *destAddr
  21021 			sv = append(sv, col)
  21022 
  21023 		default:
  21024 			err = decoder.Decoder.Skip()
  21025 			if err != nil {
  21026 				return err
  21027 			}
  21028 
  21029 		}
  21030 		decoder = originalDecoder
  21031 	}
  21032 	*v = sv
  21033 	return nil
  21034 }
  21035 
  21036 func awsRestxml_deserializeDocumentQueryLoggingConfigsUnwrapped(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  21037 	var sv []types.QueryLoggingConfig
  21038 	if *v == nil {
  21039 		sv = make([]types.QueryLoggingConfig, 0)
  21040 	} else {
  21041 		sv = *v
  21042 	}
  21043 
  21044 	switch {
  21045 	default:
  21046 		var mv types.QueryLoggingConfig
  21047 		t := decoder.StartEl
  21048 		_ = t
  21049 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21050 		destAddr := &mv
  21051 		if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil {
  21052 			return err
  21053 		}
  21054 		mv = *destAddr
  21055 		sv = append(sv, mv)
  21056 	}
  21057 	*v = sv
  21058 	return nil
  21059 }
  21060 func awsRestxml_deserializeDocumentRecordData(v *[]string, decoder smithyxml.NodeDecoder) error {
  21061 	if v == nil {
  21062 		return fmt.Errorf("unexpected nil of type %T", v)
  21063 	}
  21064 	var sv []string
  21065 	if *v == nil {
  21066 		sv = make([]string, 0)
  21067 	} else {
  21068 		sv = *v
  21069 	}
  21070 
  21071 	originalDecoder := decoder
  21072 	for {
  21073 		t, done, err := decoder.Token()
  21074 		if err != nil {
  21075 			return err
  21076 		}
  21077 		if done {
  21078 			break
  21079 		}
  21080 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21081 		decoder = memberDecoder
  21082 		switch {
  21083 		case strings.EqualFold("RecordDataEntry", t.Name.Local):
  21084 			var col string
  21085 			val, err := decoder.Value()
  21086 			if err != nil {
  21087 				return err
  21088 			}
  21089 			if val == nil {
  21090 				break
  21091 			}
  21092 			{
  21093 				xtv := string(val)
  21094 				col = xtv
  21095 			}
  21096 			sv = append(sv, col)
  21097 
  21098 		default:
  21099 			err = decoder.Decoder.Skip()
  21100 			if err != nil {
  21101 				return err
  21102 			}
  21103 
  21104 		}
  21105 		decoder = originalDecoder
  21106 	}
  21107 	*v = sv
  21108 	return nil
  21109 }
  21110 
  21111 func awsRestxml_deserializeDocumentRecordDataUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  21112 	var sv []string
  21113 	if *v == nil {
  21114 		sv = make([]string, 0)
  21115 	} else {
  21116 		sv = *v
  21117 	}
  21118 
  21119 	switch {
  21120 	default:
  21121 		var mv string
  21122 		t := decoder.StartEl
  21123 		_ = t
  21124 		val, err := decoder.Value()
  21125 		if err != nil {
  21126 			return err
  21127 		}
  21128 		if val == nil {
  21129 			break
  21130 		}
  21131 		{
  21132 			xtv := string(val)
  21133 			mv = xtv
  21134 		}
  21135 		sv = append(sv, mv)
  21136 	}
  21137 	*v = sv
  21138 	return nil
  21139 }
  21140 func awsRestxml_deserializeDocumentResourceRecord(v **types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
  21141 	if v == nil {
  21142 		return fmt.Errorf("unexpected nil of type %T", v)
  21143 	}
  21144 	var sv *types.ResourceRecord
  21145 	if *v == nil {
  21146 		sv = &types.ResourceRecord{}
  21147 	} else {
  21148 		sv = *v
  21149 	}
  21150 
  21151 	for {
  21152 		t, done, err := decoder.Token()
  21153 		if err != nil {
  21154 			return err
  21155 		}
  21156 		if done {
  21157 			break
  21158 		}
  21159 		originalDecoder := decoder
  21160 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21161 		switch {
  21162 		case strings.EqualFold("Value", t.Name.Local):
  21163 			val, err := decoder.Value()
  21164 			if err != nil {
  21165 				return err
  21166 			}
  21167 			if val == nil {
  21168 				break
  21169 			}
  21170 			{
  21171 				xtv := string(val)
  21172 				sv.Value = ptr.String(xtv)
  21173 			}
  21174 
  21175 		default:
  21176 			// Do nothing and ignore the unexpected tag element
  21177 			err = decoder.Decoder.Skip()
  21178 			if err != nil {
  21179 				return err
  21180 			}
  21181 
  21182 		}
  21183 		decoder = originalDecoder
  21184 	}
  21185 	*v = sv
  21186 	return nil
  21187 }
  21188 
  21189 func awsRestxml_deserializeDocumentResourceRecords(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
  21190 	if v == nil {
  21191 		return fmt.Errorf("unexpected nil of type %T", v)
  21192 	}
  21193 	var sv []types.ResourceRecord
  21194 	if *v == nil {
  21195 		sv = make([]types.ResourceRecord, 0)
  21196 	} else {
  21197 		sv = *v
  21198 	}
  21199 
  21200 	originalDecoder := decoder
  21201 	for {
  21202 		t, done, err := decoder.Token()
  21203 		if err != nil {
  21204 			return err
  21205 		}
  21206 		if done {
  21207 			break
  21208 		}
  21209 		switch {
  21210 		case strings.EqualFold("ResourceRecord", t.Name.Local):
  21211 			var col types.ResourceRecord
  21212 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21213 			destAddr := &col
  21214 			if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil {
  21215 				return err
  21216 			}
  21217 			col = *destAddr
  21218 			sv = append(sv, col)
  21219 
  21220 		default:
  21221 			err = decoder.Decoder.Skip()
  21222 			if err != nil {
  21223 				return err
  21224 			}
  21225 
  21226 		}
  21227 		decoder = originalDecoder
  21228 	}
  21229 	*v = sv
  21230 	return nil
  21231 }
  21232 
  21233 func awsRestxml_deserializeDocumentResourceRecordsUnwrapped(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
  21234 	var sv []types.ResourceRecord
  21235 	if *v == nil {
  21236 		sv = make([]types.ResourceRecord, 0)
  21237 	} else {
  21238 		sv = *v
  21239 	}
  21240 
  21241 	switch {
  21242 	default:
  21243 		var mv types.ResourceRecord
  21244 		t := decoder.StartEl
  21245 		_ = t
  21246 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21247 		destAddr := &mv
  21248 		if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil {
  21249 			return err
  21250 		}
  21251 		mv = *destAddr
  21252 		sv = append(sv, mv)
  21253 	}
  21254 	*v = sv
  21255 	return nil
  21256 }
  21257 func awsRestxml_deserializeDocumentResourceRecordSet(v **types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
  21258 	if v == nil {
  21259 		return fmt.Errorf("unexpected nil of type %T", v)
  21260 	}
  21261 	var sv *types.ResourceRecordSet
  21262 	if *v == nil {
  21263 		sv = &types.ResourceRecordSet{}
  21264 	} else {
  21265 		sv = *v
  21266 	}
  21267 
  21268 	for {
  21269 		t, done, err := decoder.Token()
  21270 		if err != nil {
  21271 			return err
  21272 		}
  21273 		if done {
  21274 			break
  21275 		}
  21276 		originalDecoder := decoder
  21277 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21278 		switch {
  21279 		case strings.EqualFold("AliasTarget", t.Name.Local):
  21280 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21281 			if err := awsRestxml_deserializeDocumentAliasTarget(&sv.AliasTarget, nodeDecoder); err != nil {
  21282 				return err
  21283 			}
  21284 
  21285 		case strings.EqualFold("CidrRoutingConfig", t.Name.Local):
  21286 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21287 			if err := awsRestxml_deserializeDocumentCidrRoutingConfig(&sv.CidrRoutingConfig, nodeDecoder); err != nil {
  21288 				return err
  21289 			}
  21290 
  21291 		case strings.EqualFold("Failover", t.Name.Local):
  21292 			val, err := decoder.Value()
  21293 			if err != nil {
  21294 				return err
  21295 			}
  21296 			if val == nil {
  21297 				break
  21298 			}
  21299 			{
  21300 				xtv := string(val)
  21301 				sv.Failover = types.ResourceRecordSetFailover(xtv)
  21302 			}
  21303 
  21304 		case strings.EqualFold("GeoLocation", t.Name.Local):
  21305 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21306 			if err := awsRestxml_deserializeDocumentGeoLocation(&sv.GeoLocation, nodeDecoder); err != nil {
  21307 				return err
  21308 			}
  21309 
  21310 		case strings.EqualFold("GeoProximityLocation", t.Name.Local):
  21311 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21312 			if err := awsRestxml_deserializeDocumentGeoProximityLocation(&sv.GeoProximityLocation, nodeDecoder); err != nil {
  21313 				return err
  21314 			}
  21315 
  21316 		case strings.EqualFold("HealthCheckId", t.Name.Local):
  21317 			val, err := decoder.Value()
  21318 			if err != nil {
  21319 				return err
  21320 			}
  21321 			if val == nil {
  21322 				break
  21323 			}
  21324 			{
  21325 				xtv := string(val)
  21326 				sv.HealthCheckId = ptr.String(xtv)
  21327 			}
  21328 
  21329 		case strings.EqualFold("MultiValueAnswer", t.Name.Local):
  21330 			val, err := decoder.Value()
  21331 			if err != nil {
  21332 				return err
  21333 			}
  21334 			if val == nil {
  21335 				break
  21336 			}
  21337 			{
  21338 				xtv, err := strconv.ParseBool(string(val))
  21339 				if err != nil {
  21340 					return fmt.Errorf("expected ResourceRecordSetMultiValueAnswer to be of type *bool, got %T instead", val)
  21341 				}
  21342 				sv.MultiValueAnswer = ptr.Bool(xtv)
  21343 			}
  21344 
  21345 		case strings.EqualFold("Name", t.Name.Local):
  21346 			val, err := decoder.Value()
  21347 			if err != nil {
  21348 				return err
  21349 			}
  21350 			if val == nil {
  21351 				break
  21352 			}
  21353 			{
  21354 				xtv := string(val)
  21355 				sv.Name = ptr.String(xtv)
  21356 			}
  21357 
  21358 		case strings.EqualFold("Region", t.Name.Local):
  21359 			val, err := decoder.Value()
  21360 			if err != nil {
  21361 				return err
  21362 			}
  21363 			if val == nil {
  21364 				break
  21365 			}
  21366 			{
  21367 				xtv := string(val)
  21368 				sv.Region = types.ResourceRecordSetRegion(xtv)
  21369 			}
  21370 
  21371 		case strings.EqualFold("ResourceRecords", t.Name.Local):
  21372 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21373 			if err := awsRestxml_deserializeDocumentResourceRecords(&sv.ResourceRecords, nodeDecoder); err != nil {
  21374 				return err
  21375 			}
  21376 
  21377 		case strings.EqualFold("SetIdentifier", t.Name.Local):
  21378 			val, err := decoder.Value()
  21379 			if err != nil {
  21380 				return err
  21381 			}
  21382 			if val == nil {
  21383 				break
  21384 			}
  21385 			{
  21386 				xtv := string(val)
  21387 				sv.SetIdentifier = ptr.String(xtv)
  21388 			}
  21389 
  21390 		case strings.EqualFold("TrafficPolicyInstanceId", t.Name.Local):
  21391 			val, err := decoder.Value()
  21392 			if err != nil {
  21393 				return err
  21394 			}
  21395 			if val == nil {
  21396 				break
  21397 			}
  21398 			{
  21399 				xtv := string(val)
  21400 				sv.TrafficPolicyInstanceId = ptr.String(xtv)
  21401 			}
  21402 
  21403 		case strings.EqualFold("TTL", t.Name.Local):
  21404 			val, err := decoder.Value()
  21405 			if err != nil {
  21406 				return err
  21407 			}
  21408 			if val == nil {
  21409 				break
  21410 			}
  21411 			{
  21412 				xtv := string(val)
  21413 				i64, err := strconv.ParseInt(xtv, 10, 64)
  21414 				if err != nil {
  21415 					return err
  21416 				}
  21417 				sv.TTL = ptr.Int64(i64)
  21418 			}
  21419 
  21420 		case strings.EqualFold("Type", t.Name.Local):
  21421 			val, err := decoder.Value()
  21422 			if err != nil {
  21423 				return err
  21424 			}
  21425 			if val == nil {
  21426 				break
  21427 			}
  21428 			{
  21429 				xtv := string(val)
  21430 				sv.Type = types.RRType(xtv)
  21431 			}
  21432 
  21433 		case strings.EqualFold("Weight", t.Name.Local):
  21434 			val, err := decoder.Value()
  21435 			if err != nil {
  21436 				return err
  21437 			}
  21438 			if val == nil {
  21439 				break
  21440 			}
  21441 			{
  21442 				xtv := string(val)
  21443 				i64, err := strconv.ParseInt(xtv, 10, 64)
  21444 				if err != nil {
  21445 					return err
  21446 				}
  21447 				sv.Weight = ptr.Int64(i64)
  21448 			}
  21449 
  21450 		default:
  21451 			// Do nothing and ignore the unexpected tag element
  21452 			err = decoder.Decoder.Skip()
  21453 			if err != nil {
  21454 				return err
  21455 			}
  21456 
  21457 		}
  21458 		decoder = originalDecoder
  21459 	}
  21460 	*v = sv
  21461 	return nil
  21462 }
  21463 
  21464 func awsRestxml_deserializeDocumentResourceRecordSets(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
  21465 	if v == nil {
  21466 		return fmt.Errorf("unexpected nil of type %T", v)
  21467 	}
  21468 	var sv []types.ResourceRecordSet
  21469 	if *v == nil {
  21470 		sv = make([]types.ResourceRecordSet, 0)
  21471 	} else {
  21472 		sv = *v
  21473 	}
  21474 
  21475 	originalDecoder := decoder
  21476 	for {
  21477 		t, done, err := decoder.Token()
  21478 		if err != nil {
  21479 			return err
  21480 		}
  21481 		if done {
  21482 			break
  21483 		}
  21484 		switch {
  21485 		case strings.EqualFold("ResourceRecordSet", t.Name.Local):
  21486 			var col types.ResourceRecordSet
  21487 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21488 			destAddr := &col
  21489 			if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil {
  21490 				return err
  21491 			}
  21492 			col = *destAddr
  21493 			sv = append(sv, col)
  21494 
  21495 		default:
  21496 			err = decoder.Decoder.Skip()
  21497 			if err != nil {
  21498 				return err
  21499 			}
  21500 
  21501 		}
  21502 		decoder = originalDecoder
  21503 	}
  21504 	*v = sv
  21505 	return nil
  21506 }
  21507 
  21508 func awsRestxml_deserializeDocumentResourceRecordSetsUnwrapped(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
  21509 	var sv []types.ResourceRecordSet
  21510 	if *v == nil {
  21511 		sv = make([]types.ResourceRecordSet, 0)
  21512 	} else {
  21513 		sv = *v
  21514 	}
  21515 
  21516 	switch {
  21517 	default:
  21518 		var mv types.ResourceRecordSet
  21519 		t := decoder.StartEl
  21520 		_ = t
  21521 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21522 		destAddr := &mv
  21523 		if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil {
  21524 			return err
  21525 		}
  21526 		mv = *destAddr
  21527 		sv = append(sv, mv)
  21528 	}
  21529 	*v = sv
  21530 	return nil
  21531 }
  21532 func awsRestxml_deserializeDocumentResourceTagSet(v **types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
  21533 	if v == nil {
  21534 		return fmt.Errorf("unexpected nil of type %T", v)
  21535 	}
  21536 	var sv *types.ResourceTagSet
  21537 	if *v == nil {
  21538 		sv = &types.ResourceTagSet{}
  21539 	} else {
  21540 		sv = *v
  21541 	}
  21542 
  21543 	for {
  21544 		t, done, err := decoder.Token()
  21545 		if err != nil {
  21546 			return err
  21547 		}
  21548 		if done {
  21549 			break
  21550 		}
  21551 		originalDecoder := decoder
  21552 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21553 		switch {
  21554 		case strings.EqualFold("ResourceId", t.Name.Local):
  21555 			val, err := decoder.Value()
  21556 			if err != nil {
  21557 				return err
  21558 			}
  21559 			if val == nil {
  21560 				break
  21561 			}
  21562 			{
  21563 				xtv := string(val)
  21564 				sv.ResourceId = ptr.String(xtv)
  21565 			}
  21566 
  21567 		case strings.EqualFold("ResourceType", t.Name.Local):
  21568 			val, err := decoder.Value()
  21569 			if err != nil {
  21570 				return err
  21571 			}
  21572 			if val == nil {
  21573 				break
  21574 			}
  21575 			{
  21576 				xtv := string(val)
  21577 				sv.ResourceType = types.TagResourceType(xtv)
  21578 			}
  21579 
  21580 		case strings.EqualFold("Tags", t.Name.Local):
  21581 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21582 			if err := awsRestxml_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil {
  21583 				return err
  21584 			}
  21585 
  21586 		default:
  21587 			// Do nothing and ignore the unexpected tag element
  21588 			err = decoder.Decoder.Skip()
  21589 			if err != nil {
  21590 				return err
  21591 			}
  21592 
  21593 		}
  21594 		decoder = originalDecoder
  21595 	}
  21596 	*v = sv
  21597 	return nil
  21598 }
  21599 
  21600 func awsRestxml_deserializeDocumentResourceTagSetList(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
  21601 	if v == nil {
  21602 		return fmt.Errorf("unexpected nil of type %T", v)
  21603 	}
  21604 	var sv []types.ResourceTagSet
  21605 	if *v == nil {
  21606 		sv = make([]types.ResourceTagSet, 0)
  21607 	} else {
  21608 		sv = *v
  21609 	}
  21610 
  21611 	originalDecoder := decoder
  21612 	for {
  21613 		t, done, err := decoder.Token()
  21614 		if err != nil {
  21615 			return err
  21616 		}
  21617 		if done {
  21618 			break
  21619 		}
  21620 		switch {
  21621 		case strings.EqualFold("ResourceTagSet", t.Name.Local):
  21622 			var col types.ResourceTagSet
  21623 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21624 			destAddr := &col
  21625 			if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil {
  21626 				return err
  21627 			}
  21628 			col = *destAddr
  21629 			sv = append(sv, col)
  21630 
  21631 		default:
  21632 			err = decoder.Decoder.Skip()
  21633 			if err != nil {
  21634 				return err
  21635 			}
  21636 
  21637 		}
  21638 		decoder = originalDecoder
  21639 	}
  21640 	*v = sv
  21641 	return nil
  21642 }
  21643 
  21644 func awsRestxml_deserializeDocumentResourceTagSetListUnwrapped(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
  21645 	var sv []types.ResourceTagSet
  21646 	if *v == nil {
  21647 		sv = make([]types.ResourceTagSet, 0)
  21648 	} else {
  21649 		sv = *v
  21650 	}
  21651 
  21652 	switch {
  21653 	default:
  21654 		var mv types.ResourceTagSet
  21655 		t := decoder.StartEl
  21656 		_ = t
  21657 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21658 		destAddr := &mv
  21659 		if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil {
  21660 			return err
  21661 		}
  21662 		mv = *destAddr
  21663 		sv = append(sv, mv)
  21664 	}
  21665 	*v = sv
  21666 	return nil
  21667 }
  21668 func awsRestxml_deserializeDocumentReusableDelegationSetLimit(v **types.ReusableDelegationSetLimit, decoder smithyxml.NodeDecoder) error {
  21669 	if v == nil {
  21670 		return fmt.Errorf("unexpected nil of type %T", v)
  21671 	}
  21672 	var sv *types.ReusableDelegationSetLimit
  21673 	if *v == nil {
  21674 		sv = &types.ReusableDelegationSetLimit{}
  21675 	} else {
  21676 		sv = *v
  21677 	}
  21678 
  21679 	for {
  21680 		t, done, err := decoder.Token()
  21681 		if err != nil {
  21682 			return err
  21683 		}
  21684 		if done {
  21685 			break
  21686 		}
  21687 		originalDecoder := decoder
  21688 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21689 		switch {
  21690 		case strings.EqualFold("Type", t.Name.Local):
  21691 			val, err := decoder.Value()
  21692 			if err != nil {
  21693 				return err
  21694 			}
  21695 			if val == nil {
  21696 				break
  21697 			}
  21698 			{
  21699 				xtv := string(val)
  21700 				sv.Type = types.ReusableDelegationSetLimitType(xtv)
  21701 			}
  21702 
  21703 		case strings.EqualFold("Value", t.Name.Local):
  21704 			val, err := decoder.Value()
  21705 			if err != nil {
  21706 				return err
  21707 			}
  21708 			if val == nil {
  21709 				break
  21710 			}
  21711 			{
  21712 				xtv := string(val)
  21713 				i64, err := strconv.ParseInt(xtv, 10, 64)
  21714 				if err != nil {
  21715 					return err
  21716 				}
  21717 				sv.Value = ptr.Int64(i64)
  21718 			}
  21719 
  21720 		default:
  21721 			// Do nothing and ignore the unexpected tag element
  21722 			err = decoder.Decoder.Skip()
  21723 			if err != nil {
  21724 				return err
  21725 			}
  21726 
  21727 		}
  21728 		decoder = originalDecoder
  21729 	}
  21730 	*v = sv
  21731 	return nil
  21732 }
  21733 
  21734 func awsRestxml_deserializeDocumentStatusReport(v **types.StatusReport, decoder smithyxml.NodeDecoder) error {
  21735 	if v == nil {
  21736 		return fmt.Errorf("unexpected nil of type %T", v)
  21737 	}
  21738 	var sv *types.StatusReport
  21739 	if *v == nil {
  21740 		sv = &types.StatusReport{}
  21741 	} else {
  21742 		sv = *v
  21743 	}
  21744 
  21745 	for {
  21746 		t, done, err := decoder.Token()
  21747 		if err != nil {
  21748 			return err
  21749 		}
  21750 		if done {
  21751 			break
  21752 		}
  21753 		originalDecoder := decoder
  21754 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21755 		switch {
  21756 		case strings.EqualFold("CheckedTime", t.Name.Local):
  21757 			val, err := decoder.Value()
  21758 			if err != nil {
  21759 				return err
  21760 			}
  21761 			if val == nil {
  21762 				break
  21763 			}
  21764 			{
  21765 				xtv := string(val)
  21766 				t, err := smithytime.ParseDateTime(xtv)
  21767 				if err != nil {
  21768 					return err
  21769 				}
  21770 				sv.CheckedTime = ptr.Time(t)
  21771 			}
  21772 
  21773 		case strings.EqualFold("Status", t.Name.Local):
  21774 			val, err := decoder.Value()
  21775 			if err != nil {
  21776 				return err
  21777 			}
  21778 			if val == nil {
  21779 				break
  21780 			}
  21781 			{
  21782 				xtv := string(val)
  21783 				sv.Status = ptr.String(xtv)
  21784 			}
  21785 
  21786 		default:
  21787 			// Do nothing and ignore the unexpected tag element
  21788 			err = decoder.Decoder.Skip()
  21789 			if err != nil {
  21790 				return err
  21791 			}
  21792 
  21793 		}
  21794 		decoder = originalDecoder
  21795 	}
  21796 	*v = sv
  21797 	return nil
  21798 }
  21799 
  21800 func awsRestxml_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error {
  21801 	if v == nil {
  21802 		return fmt.Errorf("unexpected nil of type %T", v)
  21803 	}
  21804 	var sv *types.Tag
  21805 	if *v == nil {
  21806 		sv = &types.Tag{}
  21807 	} else {
  21808 		sv = *v
  21809 	}
  21810 
  21811 	for {
  21812 		t, done, err := decoder.Token()
  21813 		if err != nil {
  21814 			return err
  21815 		}
  21816 		if done {
  21817 			break
  21818 		}
  21819 		originalDecoder := decoder
  21820 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21821 		switch {
  21822 		case strings.EqualFold("Key", t.Name.Local):
  21823 			val, err := decoder.Value()
  21824 			if err != nil {
  21825 				return err
  21826 			}
  21827 			if val == nil {
  21828 				break
  21829 			}
  21830 			{
  21831 				xtv := string(val)
  21832 				sv.Key = ptr.String(xtv)
  21833 			}
  21834 
  21835 		case strings.EqualFold("Value", t.Name.Local):
  21836 			val, err := decoder.Value()
  21837 			if err != nil {
  21838 				return err
  21839 			}
  21840 			if val == nil {
  21841 				break
  21842 			}
  21843 			{
  21844 				xtv := string(val)
  21845 				sv.Value = ptr.String(xtv)
  21846 			}
  21847 
  21848 		default:
  21849 			// Do nothing and ignore the unexpected tag element
  21850 			err = decoder.Decoder.Skip()
  21851 			if err != nil {
  21852 				return err
  21853 			}
  21854 
  21855 		}
  21856 		decoder = originalDecoder
  21857 	}
  21858 	*v = sv
  21859 	return nil
  21860 }
  21861 
  21862 func awsRestxml_deserializeDocumentTagList(v *[]types.Tag, decoder smithyxml.NodeDecoder) error {
  21863 	if v == nil {
  21864 		return fmt.Errorf("unexpected nil of type %T", v)
  21865 	}
  21866 	var sv []types.Tag
  21867 	if *v == nil {
  21868 		sv = make([]types.Tag, 0)
  21869 	} else {
  21870 		sv = *v
  21871 	}
  21872 
  21873 	originalDecoder := decoder
  21874 	for {
  21875 		t, done, err := decoder.Token()
  21876 		if err != nil {
  21877 			return err
  21878 		}
  21879 		if done {
  21880 			break
  21881 		}
  21882 		switch {
  21883 		case strings.EqualFold("Tag", t.Name.Local):
  21884 			var col types.Tag
  21885 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21886 			destAddr := &col
  21887 			if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil {
  21888 				return err
  21889 			}
  21890 			col = *destAddr
  21891 			sv = append(sv, col)
  21892 
  21893 		default:
  21894 			err = decoder.Decoder.Skip()
  21895 			if err != nil {
  21896 				return err
  21897 			}
  21898 
  21899 		}
  21900 		decoder = originalDecoder
  21901 	}
  21902 	*v = sv
  21903 	return nil
  21904 }
  21905 
  21906 func awsRestxml_deserializeDocumentTagListUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error {
  21907 	var sv []types.Tag
  21908 	if *v == nil {
  21909 		sv = make([]types.Tag, 0)
  21910 	} else {
  21911 		sv = *v
  21912 	}
  21913 
  21914 	switch {
  21915 	default:
  21916 		var mv types.Tag
  21917 		t := decoder.StartEl
  21918 		_ = t
  21919 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21920 		destAddr := &mv
  21921 		if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil {
  21922 			return err
  21923 		}
  21924 		mv = *destAddr
  21925 		sv = append(sv, mv)
  21926 	}
  21927 	*v = sv
  21928 	return nil
  21929 }
  21930 func awsRestxml_deserializeDocumentThrottlingException(v **types.ThrottlingException, decoder smithyxml.NodeDecoder) error {
  21931 	if v == nil {
  21932 		return fmt.Errorf("unexpected nil of type %T", v)
  21933 	}
  21934 	var sv *types.ThrottlingException
  21935 	if *v == nil {
  21936 		sv = &types.ThrottlingException{}
  21937 	} else {
  21938 		sv = *v
  21939 	}
  21940 
  21941 	for {
  21942 		t, done, err := decoder.Token()
  21943 		if err != nil {
  21944 			return err
  21945 		}
  21946 		if done {
  21947 			break
  21948 		}
  21949 		originalDecoder := decoder
  21950 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21951 		switch {
  21952 		case strings.EqualFold("message", t.Name.Local):
  21953 			val, err := decoder.Value()
  21954 			if err != nil {
  21955 				return err
  21956 			}
  21957 			if val == nil {
  21958 				break
  21959 			}
  21960 			{
  21961 				xtv := string(val)
  21962 				sv.Message = ptr.String(xtv)
  21963 			}
  21964 
  21965 		default:
  21966 			// Do nothing and ignore the unexpected tag element
  21967 			err = decoder.Decoder.Skip()
  21968 			if err != nil {
  21969 				return err
  21970 			}
  21971 
  21972 		}
  21973 		decoder = originalDecoder
  21974 	}
  21975 	*v = sv
  21976 	return nil
  21977 }
  21978 
  21979 func awsRestxml_deserializeDocumentTooManyHealthChecks(v **types.TooManyHealthChecks, decoder smithyxml.NodeDecoder) error {
  21980 	if v == nil {
  21981 		return fmt.Errorf("unexpected nil of type %T", v)
  21982 	}
  21983 	var sv *types.TooManyHealthChecks
  21984 	if *v == nil {
  21985 		sv = &types.TooManyHealthChecks{}
  21986 	} else {
  21987 		sv = *v
  21988 	}
  21989 
  21990 	for {
  21991 		t, done, err := decoder.Token()
  21992 		if err != nil {
  21993 			return err
  21994 		}
  21995 		if done {
  21996 			break
  21997 		}
  21998 		originalDecoder := decoder
  21999 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22000 		switch {
  22001 		case strings.EqualFold("message", t.Name.Local):
  22002 			val, err := decoder.Value()
  22003 			if err != nil {
  22004 				return err
  22005 			}
  22006 			if val == nil {
  22007 				break
  22008 			}
  22009 			{
  22010 				xtv := string(val)
  22011 				sv.Message = ptr.String(xtv)
  22012 			}
  22013 
  22014 		default:
  22015 			// Do nothing and ignore the unexpected tag element
  22016 			err = decoder.Decoder.Skip()
  22017 			if err != nil {
  22018 				return err
  22019 			}
  22020 
  22021 		}
  22022 		decoder = originalDecoder
  22023 	}
  22024 	*v = sv
  22025 	return nil
  22026 }
  22027 
  22028 func awsRestxml_deserializeDocumentTooManyHostedZones(v **types.TooManyHostedZones, decoder smithyxml.NodeDecoder) error {
  22029 	if v == nil {
  22030 		return fmt.Errorf("unexpected nil of type %T", v)
  22031 	}
  22032 	var sv *types.TooManyHostedZones
  22033 	if *v == nil {
  22034 		sv = &types.TooManyHostedZones{}
  22035 	} else {
  22036 		sv = *v
  22037 	}
  22038 
  22039 	for {
  22040 		t, done, err := decoder.Token()
  22041 		if err != nil {
  22042 			return err
  22043 		}
  22044 		if done {
  22045 			break
  22046 		}
  22047 		originalDecoder := decoder
  22048 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22049 		switch {
  22050 		case strings.EqualFold("message", t.Name.Local):
  22051 			val, err := decoder.Value()
  22052 			if err != nil {
  22053 				return err
  22054 			}
  22055 			if val == nil {
  22056 				break
  22057 			}
  22058 			{
  22059 				xtv := string(val)
  22060 				sv.Message = ptr.String(xtv)
  22061 			}
  22062 
  22063 		default:
  22064 			// Do nothing and ignore the unexpected tag element
  22065 			err = decoder.Decoder.Skip()
  22066 			if err != nil {
  22067 				return err
  22068 			}
  22069 
  22070 		}
  22071 		decoder = originalDecoder
  22072 	}
  22073 	*v = sv
  22074 	return nil
  22075 }
  22076 
  22077 func awsRestxml_deserializeDocumentTooManyKeySigningKeys(v **types.TooManyKeySigningKeys, decoder smithyxml.NodeDecoder) error {
  22078 	if v == nil {
  22079 		return fmt.Errorf("unexpected nil of type %T", v)
  22080 	}
  22081 	var sv *types.TooManyKeySigningKeys
  22082 	if *v == nil {
  22083 		sv = &types.TooManyKeySigningKeys{}
  22084 	} else {
  22085 		sv = *v
  22086 	}
  22087 
  22088 	for {
  22089 		t, done, err := decoder.Token()
  22090 		if err != nil {
  22091 			return err
  22092 		}
  22093 		if done {
  22094 			break
  22095 		}
  22096 		originalDecoder := decoder
  22097 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22098 		switch {
  22099 		case strings.EqualFold("message", t.Name.Local):
  22100 			val, err := decoder.Value()
  22101 			if err != nil {
  22102 				return err
  22103 			}
  22104 			if val == nil {
  22105 				break
  22106 			}
  22107 			{
  22108 				xtv := string(val)
  22109 				sv.Message = ptr.String(xtv)
  22110 			}
  22111 
  22112 		default:
  22113 			// Do nothing and ignore the unexpected tag element
  22114 			err = decoder.Decoder.Skip()
  22115 			if err != nil {
  22116 				return err
  22117 			}
  22118 
  22119 		}
  22120 		decoder = originalDecoder
  22121 	}
  22122 	*v = sv
  22123 	return nil
  22124 }
  22125 
  22126 func awsRestxml_deserializeDocumentTooManyTrafficPolicies(v **types.TooManyTrafficPolicies, decoder smithyxml.NodeDecoder) error {
  22127 	if v == nil {
  22128 		return fmt.Errorf("unexpected nil of type %T", v)
  22129 	}
  22130 	var sv *types.TooManyTrafficPolicies
  22131 	if *v == nil {
  22132 		sv = &types.TooManyTrafficPolicies{}
  22133 	} else {
  22134 		sv = *v
  22135 	}
  22136 
  22137 	for {
  22138 		t, done, err := decoder.Token()
  22139 		if err != nil {
  22140 			return err
  22141 		}
  22142 		if done {
  22143 			break
  22144 		}
  22145 		originalDecoder := decoder
  22146 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22147 		switch {
  22148 		case strings.EqualFold("message", t.Name.Local):
  22149 			val, err := decoder.Value()
  22150 			if err != nil {
  22151 				return err
  22152 			}
  22153 			if val == nil {
  22154 				break
  22155 			}
  22156 			{
  22157 				xtv := string(val)
  22158 				sv.Message = ptr.String(xtv)
  22159 			}
  22160 
  22161 		default:
  22162 			// Do nothing and ignore the unexpected tag element
  22163 			err = decoder.Decoder.Skip()
  22164 			if err != nil {
  22165 				return err
  22166 			}
  22167 
  22168 		}
  22169 		decoder = originalDecoder
  22170 	}
  22171 	*v = sv
  22172 	return nil
  22173 }
  22174 
  22175 func awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(v **types.TooManyTrafficPolicyInstances, decoder smithyxml.NodeDecoder) error {
  22176 	if v == nil {
  22177 		return fmt.Errorf("unexpected nil of type %T", v)
  22178 	}
  22179 	var sv *types.TooManyTrafficPolicyInstances
  22180 	if *v == nil {
  22181 		sv = &types.TooManyTrafficPolicyInstances{}
  22182 	} else {
  22183 		sv = *v
  22184 	}
  22185 
  22186 	for {
  22187 		t, done, err := decoder.Token()
  22188 		if err != nil {
  22189 			return err
  22190 		}
  22191 		if done {
  22192 			break
  22193 		}
  22194 		originalDecoder := decoder
  22195 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22196 		switch {
  22197 		case strings.EqualFold("message", t.Name.Local):
  22198 			val, err := decoder.Value()
  22199 			if err != nil {
  22200 				return err
  22201 			}
  22202 			if val == nil {
  22203 				break
  22204 			}
  22205 			{
  22206 				xtv := string(val)
  22207 				sv.Message = ptr.String(xtv)
  22208 			}
  22209 
  22210 		default:
  22211 			// Do nothing and ignore the unexpected tag element
  22212 			err = decoder.Decoder.Skip()
  22213 			if err != nil {
  22214 				return err
  22215 			}
  22216 
  22217 		}
  22218 		decoder = originalDecoder
  22219 	}
  22220 	*v = sv
  22221 	return nil
  22222 }
  22223 
  22224 func awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(v **types.TooManyTrafficPolicyVersionsForCurrentPolicy, decoder smithyxml.NodeDecoder) error {
  22225 	if v == nil {
  22226 		return fmt.Errorf("unexpected nil of type %T", v)
  22227 	}
  22228 	var sv *types.TooManyTrafficPolicyVersionsForCurrentPolicy
  22229 	if *v == nil {
  22230 		sv = &types.TooManyTrafficPolicyVersionsForCurrentPolicy{}
  22231 	} else {
  22232 		sv = *v
  22233 	}
  22234 
  22235 	for {
  22236 		t, done, err := decoder.Token()
  22237 		if err != nil {
  22238 			return err
  22239 		}
  22240 		if done {
  22241 			break
  22242 		}
  22243 		originalDecoder := decoder
  22244 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22245 		switch {
  22246 		case strings.EqualFold("message", t.Name.Local):
  22247 			val, err := decoder.Value()
  22248 			if err != nil {
  22249 				return err
  22250 			}
  22251 			if val == nil {
  22252 				break
  22253 			}
  22254 			{
  22255 				xtv := string(val)
  22256 				sv.Message = ptr.String(xtv)
  22257 			}
  22258 
  22259 		default:
  22260 			// Do nothing and ignore the unexpected tag element
  22261 			err = decoder.Decoder.Skip()
  22262 			if err != nil {
  22263 				return err
  22264 			}
  22265 
  22266 		}
  22267 		decoder = originalDecoder
  22268 	}
  22269 	*v = sv
  22270 	return nil
  22271 }
  22272 
  22273 func awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(v **types.TooManyVPCAssociationAuthorizations, decoder smithyxml.NodeDecoder) error {
  22274 	if v == nil {
  22275 		return fmt.Errorf("unexpected nil of type %T", v)
  22276 	}
  22277 	var sv *types.TooManyVPCAssociationAuthorizations
  22278 	if *v == nil {
  22279 		sv = &types.TooManyVPCAssociationAuthorizations{}
  22280 	} else {
  22281 		sv = *v
  22282 	}
  22283 
  22284 	for {
  22285 		t, done, err := decoder.Token()
  22286 		if err != nil {
  22287 			return err
  22288 		}
  22289 		if done {
  22290 			break
  22291 		}
  22292 		originalDecoder := decoder
  22293 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22294 		switch {
  22295 		case strings.EqualFold("message", t.Name.Local):
  22296 			val, err := decoder.Value()
  22297 			if err != nil {
  22298 				return err
  22299 			}
  22300 			if val == nil {
  22301 				break
  22302 			}
  22303 			{
  22304 				xtv := string(val)
  22305 				sv.Message = ptr.String(xtv)
  22306 			}
  22307 
  22308 		default:
  22309 			// Do nothing and ignore the unexpected tag element
  22310 			err = decoder.Decoder.Skip()
  22311 			if err != nil {
  22312 				return err
  22313 			}
  22314 
  22315 		}
  22316 		decoder = originalDecoder
  22317 	}
  22318 	*v = sv
  22319 	return nil
  22320 }
  22321 
  22322 func awsRestxml_deserializeDocumentTrafficPolicies(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
  22323 	if v == nil {
  22324 		return fmt.Errorf("unexpected nil of type %T", v)
  22325 	}
  22326 	var sv []types.TrafficPolicy
  22327 	if *v == nil {
  22328 		sv = make([]types.TrafficPolicy, 0)
  22329 	} else {
  22330 		sv = *v
  22331 	}
  22332 
  22333 	originalDecoder := decoder
  22334 	for {
  22335 		t, done, err := decoder.Token()
  22336 		if err != nil {
  22337 			return err
  22338 		}
  22339 		if done {
  22340 			break
  22341 		}
  22342 		switch {
  22343 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
  22344 			var col types.TrafficPolicy
  22345 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22346 			destAddr := &col
  22347 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil {
  22348 				return err
  22349 			}
  22350 			col = *destAddr
  22351 			sv = append(sv, col)
  22352 
  22353 		default:
  22354 			err = decoder.Decoder.Skip()
  22355 			if err != nil {
  22356 				return err
  22357 			}
  22358 
  22359 		}
  22360 		decoder = originalDecoder
  22361 	}
  22362 	*v = sv
  22363 	return nil
  22364 }
  22365 
  22366 func awsRestxml_deserializeDocumentTrafficPoliciesUnwrapped(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
  22367 	var sv []types.TrafficPolicy
  22368 	if *v == nil {
  22369 		sv = make([]types.TrafficPolicy, 0)
  22370 	} else {
  22371 		sv = *v
  22372 	}
  22373 
  22374 	switch {
  22375 	default:
  22376 		var mv types.TrafficPolicy
  22377 		t := decoder.StartEl
  22378 		_ = t
  22379 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22380 		destAddr := &mv
  22381 		if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil {
  22382 			return err
  22383 		}
  22384 		mv = *destAddr
  22385 		sv = append(sv, mv)
  22386 	}
  22387 	*v = sv
  22388 	return nil
  22389 }
  22390 func awsRestxml_deserializeDocumentTrafficPolicy(v **types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
  22391 	if v == nil {
  22392 		return fmt.Errorf("unexpected nil of type %T", v)
  22393 	}
  22394 	var sv *types.TrafficPolicy
  22395 	if *v == nil {
  22396 		sv = &types.TrafficPolicy{}
  22397 	} else {
  22398 		sv = *v
  22399 	}
  22400 
  22401 	for {
  22402 		t, done, err := decoder.Token()
  22403 		if err != nil {
  22404 			return err
  22405 		}
  22406 		if done {
  22407 			break
  22408 		}
  22409 		originalDecoder := decoder
  22410 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22411 		switch {
  22412 		case strings.EqualFold("Comment", t.Name.Local):
  22413 			val, err := decoder.Value()
  22414 			if err != nil {
  22415 				return err
  22416 			}
  22417 			if val == nil {
  22418 				break
  22419 			}
  22420 			{
  22421 				xtv := string(val)
  22422 				sv.Comment = ptr.String(xtv)
  22423 			}
  22424 
  22425 		case strings.EqualFold("Document", t.Name.Local):
  22426 			val, err := decoder.Value()
  22427 			if err != nil {
  22428 				return err
  22429 			}
  22430 			if val == nil {
  22431 				break
  22432 			}
  22433 			{
  22434 				xtv := string(val)
  22435 				sv.Document = ptr.String(xtv)
  22436 			}
  22437 
  22438 		case strings.EqualFold("Id", t.Name.Local):
  22439 			val, err := decoder.Value()
  22440 			if err != nil {
  22441 				return err
  22442 			}
  22443 			if val == nil {
  22444 				break
  22445 			}
  22446 			{
  22447 				xtv := string(val)
  22448 				sv.Id = ptr.String(xtv)
  22449 			}
  22450 
  22451 		case strings.EqualFold("Name", t.Name.Local):
  22452 			val, err := decoder.Value()
  22453 			if err != nil {
  22454 				return err
  22455 			}
  22456 			if val == nil {
  22457 				break
  22458 			}
  22459 			{
  22460 				xtv := string(val)
  22461 				sv.Name = ptr.String(xtv)
  22462 			}
  22463 
  22464 		case strings.EqualFold("Type", t.Name.Local):
  22465 			val, err := decoder.Value()
  22466 			if err != nil {
  22467 				return err
  22468 			}
  22469 			if val == nil {
  22470 				break
  22471 			}
  22472 			{
  22473 				xtv := string(val)
  22474 				sv.Type = types.RRType(xtv)
  22475 			}
  22476 
  22477 		case strings.EqualFold("Version", t.Name.Local):
  22478 			val, err := decoder.Value()
  22479 			if err != nil {
  22480 				return err
  22481 			}
  22482 			if val == nil {
  22483 				break
  22484 			}
  22485 			{
  22486 				xtv := string(val)
  22487 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22488 				if err != nil {
  22489 					return err
  22490 				}
  22491 				sv.Version = ptr.Int32(int32(i64))
  22492 			}
  22493 
  22494 		default:
  22495 			// Do nothing and ignore the unexpected tag element
  22496 			err = decoder.Decoder.Skip()
  22497 			if err != nil {
  22498 				return err
  22499 			}
  22500 
  22501 		}
  22502 		decoder = originalDecoder
  22503 	}
  22504 	*v = sv
  22505 	return nil
  22506 }
  22507 
  22508 func awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(v **types.TrafficPolicyAlreadyExists, decoder smithyxml.NodeDecoder) error {
  22509 	if v == nil {
  22510 		return fmt.Errorf("unexpected nil of type %T", v)
  22511 	}
  22512 	var sv *types.TrafficPolicyAlreadyExists
  22513 	if *v == nil {
  22514 		sv = &types.TrafficPolicyAlreadyExists{}
  22515 	} else {
  22516 		sv = *v
  22517 	}
  22518 
  22519 	for {
  22520 		t, done, err := decoder.Token()
  22521 		if err != nil {
  22522 			return err
  22523 		}
  22524 		if done {
  22525 			break
  22526 		}
  22527 		originalDecoder := decoder
  22528 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22529 		switch {
  22530 		case strings.EqualFold("message", t.Name.Local):
  22531 			val, err := decoder.Value()
  22532 			if err != nil {
  22533 				return err
  22534 			}
  22535 			if val == nil {
  22536 				break
  22537 			}
  22538 			{
  22539 				xtv := string(val)
  22540 				sv.Message = ptr.String(xtv)
  22541 			}
  22542 
  22543 		default:
  22544 			// Do nothing and ignore the unexpected tag element
  22545 			err = decoder.Decoder.Skip()
  22546 			if err != nil {
  22547 				return err
  22548 			}
  22549 
  22550 		}
  22551 		decoder = originalDecoder
  22552 	}
  22553 	*v = sv
  22554 	return nil
  22555 }
  22556 
  22557 func awsRestxml_deserializeDocumentTrafficPolicyInstance(v **types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  22558 	if v == nil {
  22559 		return fmt.Errorf("unexpected nil of type %T", v)
  22560 	}
  22561 	var sv *types.TrafficPolicyInstance
  22562 	if *v == nil {
  22563 		sv = &types.TrafficPolicyInstance{}
  22564 	} else {
  22565 		sv = *v
  22566 	}
  22567 
  22568 	for {
  22569 		t, done, err := decoder.Token()
  22570 		if err != nil {
  22571 			return err
  22572 		}
  22573 		if done {
  22574 			break
  22575 		}
  22576 		originalDecoder := decoder
  22577 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22578 		switch {
  22579 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  22580 			val, err := decoder.Value()
  22581 			if err != nil {
  22582 				return err
  22583 			}
  22584 			if val == nil {
  22585 				break
  22586 			}
  22587 			{
  22588 				xtv := string(val)
  22589 				sv.HostedZoneId = ptr.String(xtv)
  22590 			}
  22591 
  22592 		case strings.EqualFold("Id", t.Name.Local):
  22593 			val, err := decoder.Value()
  22594 			if err != nil {
  22595 				return err
  22596 			}
  22597 			if val == nil {
  22598 				break
  22599 			}
  22600 			{
  22601 				xtv := string(val)
  22602 				sv.Id = ptr.String(xtv)
  22603 			}
  22604 
  22605 		case strings.EqualFold("Message", t.Name.Local):
  22606 			val, err := decoder.Value()
  22607 			if err != nil {
  22608 				return err
  22609 			}
  22610 			if val == nil {
  22611 				break
  22612 			}
  22613 			{
  22614 				xtv := string(val)
  22615 				sv.Message = ptr.String(xtv)
  22616 			}
  22617 
  22618 		case strings.EqualFold("Name", t.Name.Local):
  22619 			val, err := decoder.Value()
  22620 			if err != nil {
  22621 				return err
  22622 			}
  22623 			if val == nil {
  22624 				break
  22625 			}
  22626 			{
  22627 				xtv := string(val)
  22628 				sv.Name = ptr.String(xtv)
  22629 			}
  22630 
  22631 		case strings.EqualFold("State", t.Name.Local):
  22632 			val, err := decoder.Value()
  22633 			if err != nil {
  22634 				return err
  22635 			}
  22636 			if val == nil {
  22637 				break
  22638 			}
  22639 			{
  22640 				xtv := string(val)
  22641 				sv.State = ptr.String(xtv)
  22642 			}
  22643 
  22644 		case strings.EqualFold("TrafficPolicyId", t.Name.Local):
  22645 			val, err := decoder.Value()
  22646 			if err != nil {
  22647 				return err
  22648 			}
  22649 			if val == nil {
  22650 				break
  22651 			}
  22652 			{
  22653 				xtv := string(val)
  22654 				sv.TrafficPolicyId = ptr.String(xtv)
  22655 			}
  22656 
  22657 		case strings.EqualFold("TrafficPolicyType", t.Name.Local):
  22658 			val, err := decoder.Value()
  22659 			if err != nil {
  22660 				return err
  22661 			}
  22662 			if val == nil {
  22663 				break
  22664 			}
  22665 			{
  22666 				xtv := string(val)
  22667 				sv.TrafficPolicyType = types.RRType(xtv)
  22668 			}
  22669 
  22670 		case strings.EqualFold("TrafficPolicyVersion", t.Name.Local):
  22671 			val, err := decoder.Value()
  22672 			if err != nil {
  22673 				return err
  22674 			}
  22675 			if val == nil {
  22676 				break
  22677 			}
  22678 			{
  22679 				xtv := string(val)
  22680 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22681 				if err != nil {
  22682 					return err
  22683 				}
  22684 				sv.TrafficPolicyVersion = ptr.Int32(int32(i64))
  22685 			}
  22686 
  22687 		case strings.EqualFold("TTL", t.Name.Local):
  22688 			val, err := decoder.Value()
  22689 			if err != nil {
  22690 				return err
  22691 			}
  22692 			if val == nil {
  22693 				break
  22694 			}
  22695 			{
  22696 				xtv := string(val)
  22697 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22698 				if err != nil {
  22699 					return err
  22700 				}
  22701 				sv.TTL = ptr.Int64(i64)
  22702 			}
  22703 
  22704 		default:
  22705 			// Do nothing and ignore the unexpected tag element
  22706 			err = decoder.Decoder.Skip()
  22707 			if err != nil {
  22708 				return err
  22709 			}
  22710 
  22711 		}
  22712 		decoder = originalDecoder
  22713 	}
  22714 	*v = sv
  22715 	return nil
  22716 }
  22717 
  22718 func awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(v **types.TrafficPolicyInstanceAlreadyExists, decoder smithyxml.NodeDecoder) error {
  22719 	if v == nil {
  22720 		return fmt.Errorf("unexpected nil of type %T", v)
  22721 	}
  22722 	var sv *types.TrafficPolicyInstanceAlreadyExists
  22723 	if *v == nil {
  22724 		sv = &types.TrafficPolicyInstanceAlreadyExists{}
  22725 	} else {
  22726 		sv = *v
  22727 	}
  22728 
  22729 	for {
  22730 		t, done, err := decoder.Token()
  22731 		if err != nil {
  22732 			return err
  22733 		}
  22734 		if done {
  22735 			break
  22736 		}
  22737 		originalDecoder := decoder
  22738 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22739 		switch {
  22740 		case strings.EqualFold("message", t.Name.Local):
  22741 			val, err := decoder.Value()
  22742 			if err != nil {
  22743 				return err
  22744 			}
  22745 			if val == nil {
  22746 				break
  22747 			}
  22748 			{
  22749 				xtv := string(val)
  22750 				sv.Message = ptr.String(xtv)
  22751 			}
  22752 
  22753 		default:
  22754 			// Do nothing and ignore the unexpected tag element
  22755 			err = decoder.Decoder.Skip()
  22756 			if err != nil {
  22757 				return err
  22758 			}
  22759 
  22760 		}
  22761 		decoder = originalDecoder
  22762 	}
  22763 	*v = sv
  22764 	return nil
  22765 }
  22766 
  22767 func awsRestxml_deserializeDocumentTrafficPolicyInstances(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  22768 	if v == nil {
  22769 		return fmt.Errorf("unexpected nil of type %T", v)
  22770 	}
  22771 	var sv []types.TrafficPolicyInstance
  22772 	if *v == nil {
  22773 		sv = make([]types.TrafficPolicyInstance, 0)
  22774 	} else {
  22775 		sv = *v
  22776 	}
  22777 
  22778 	originalDecoder := decoder
  22779 	for {
  22780 		t, done, err := decoder.Token()
  22781 		if err != nil {
  22782 			return err
  22783 		}
  22784 		if done {
  22785 			break
  22786 		}
  22787 		switch {
  22788 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
  22789 			var col types.TrafficPolicyInstance
  22790 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22791 			destAddr := &col
  22792 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil {
  22793 				return err
  22794 			}
  22795 			col = *destAddr
  22796 			sv = append(sv, col)
  22797 
  22798 		default:
  22799 			err = decoder.Decoder.Skip()
  22800 			if err != nil {
  22801 				return err
  22802 			}
  22803 
  22804 		}
  22805 		decoder = originalDecoder
  22806 	}
  22807 	*v = sv
  22808 	return nil
  22809 }
  22810 
  22811 func awsRestxml_deserializeDocumentTrafficPolicyInstancesUnwrapped(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  22812 	var sv []types.TrafficPolicyInstance
  22813 	if *v == nil {
  22814 		sv = make([]types.TrafficPolicyInstance, 0)
  22815 	} else {
  22816 		sv = *v
  22817 	}
  22818 
  22819 	switch {
  22820 	default:
  22821 		var mv types.TrafficPolicyInstance
  22822 		t := decoder.StartEl
  22823 		_ = t
  22824 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22825 		destAddr := &mv
  22826 		if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil {
  22827 			return err
  22828 		}
  22829 		mv = *destAddr
  22830 		sv = append(sv, mv)
  22831 	}
  22832 	*v = sv
  22833 	return nil
  22834 }
  22835 func awsRestxml_deserializeDocumentTrafficPolicyInUse(v **types.TrafficPolicyInUse, decoder smithyxml.NodeDecoder) error {
  22836 	if v == nil {
  22837 		return fmt.Errorf("unexpected nil of type %T", v)
  22838 	}
  22839 	var sv *types.TrafficPolicyInUse
  22840 	if *v == nil {
  22841 		sv = &types.TrafficPolicyInUse{}
  22842 	} else {
  22843 		sv = *v
  22844 	}
  22845 
  22846 	for {
  22847 		t, done, err := decoder.Token()
  22848 		if err != nil {
  22849 			return err
  22850 		}
  22851 		if done {
  22852 			break
  22853 		}
  22854 		originalDecoder := decoder
  22855 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22856 		switch {
  22857 		case strings.EqualFold("message", t.Name.Local):
  22858 			val, err := decoder.Value()
  22859 			if err != nil {
  22860 				return err
  22861 			}
  22862 			if val == nil {
  22863 				break
  22864 			}
  22865 			{
  22866 				xtv := string(val)
  22867 				sv.Message = ptr.String(xtv)
  22868 			}
  22869 
  22870 		default:
  22871 			// Do nothing and ignore the unexpected tag element
  22872 			err = decoder.Decoder.Skip()
  22873 			if err != nil {
  22874 				return err
  22875 			}
  22876 
  22877 		}
  22878 		decoder = originalDecoder
  22879 	}
  22880 	*v = sv
  22881 	return nil
  22882 }
  22883 
  22884 func awsRestxml_deserializeDocumentTrafficPolicySummaries(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
  22885 	if v == nil {
  22886 		return fmt.Errorf("unexpected nil of type %T", v)
  22887 	}
  22888 	var sv []types.TrafficPolicySummary
  22889 	if *v == nil {
  22890 		sv = make([]types.TrafficPolicySummary, 0)
  22891 	} else {
  22892 		sv = *v
  22893 	}
  22894 
  22895 	originalDecoder := decoder
  22896 	for {
  22897 		t, done, err := decoder.Token()
  22898 		if err != nil {
  22899 			return err
  22900 		}
  22901 		if done {
  22902 			break
  22903 		}
  22904 		switch {
  22905 		case strings.EqualFold("TrafficPolicySummary", t.Name.Local):
  22906 			var col types.TrafficPolicySummary
  22907 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22908 			destAddr := &col
  22909 			if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil {
  22910 				return err
  22911 			}
  22912 			col = *destAddr
  22913 			sv = append(sv, col)
  22914 
  22915 		default:
  22916 			err = decoder.Decoder.Skip()
  22917 			if err != nil {
  22918 				return err
  22919 			}
  22920 
  22921 		}
  22922 		decoder = originalDecoder
  22923 	}
  22924 	*v = sv
  22925 	return nil
  22926 }
  22927 
  22928 func awsRestxml_deserializeDocumentTrafficPolicySummariesUnwrapped(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
  22929 	var sv []types.TrafficPolicySummary
  22930 	if *v == nil {
  22931 		sv = make([]types.TrafficPolicySummary, 0)
  22932 	} else {
  22933 		sv = *v
  22934 	}
  22935 
  22936 	switch {
  22937 	default:
  22938 		var mv types.TrafficPolicySummary
  22939 		t := decoder.StartEl
  22940 		_ = t
  22941 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22942 		destAddr := &mv
  22943 		if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil {
  22944 			return err
  22945 		}
  22946 		mv = *destAddr
  22947 		sv = append(sv, mv)
  22948 	}
  22949 	*v = sv
  22950 	return nil
  22951 }
  22952 func awsRestxml_deserializeDocumentTrafficPolicySummary(v **types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
  22953 	if v == nil {
  22954 		return fmt.Errorf("unexpected nil of type %T", v)
  22955 	}
  22956 	var sv *types.TrafficPolicySummary
  22957 	if *v == nil {
  22958 		sv = &types.TrafficPolicySummary{}
  22959 	} else {
  22960 		sv = *v
  22961 	}
  22962 
  22963 	for {
  22964 		t, done, err := decoder.Token()
  22965 		if err != nil {
  22966 			return err
  22967 		}
  22968 		if done {
  22969 			break
  22970 		}
  22971 		originalDecoder := decoder
  22972 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22973 		switch {
  22974 		case strings.EqualFold("Id", t.Name.Local):
  22975 			val, err := decoder.Value()
  22976 			if err != nil {
  22977 				return err
  22978 			}
  22979 			if val == nil {
  22980 				break
  22981 			}
  22982 			{
  22983 				xtv := string(val)
  22984 				sv.Id = ptr.String(xtv)
  22985 			}
  22986 
  22987 		case strings.EqualFold("LatestVersion", t.Name.Local):
  22988 			val, err := decoder.Value()
  22989 			if err != nil {
  22990 				return err
  22991 			}
  22992 			if val == nil {
  22993 				break
  22994 			}
  22995 			{
  22996 				xtv := string(val)
  22997 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22998 				if err != nil {
  22999 					return err
  23000 				}
  23001 				sv.LatestVersion = ptr.Int32(int32(i64))
  23002 			}
  23003 
  23004 		case strings.EqualFold("Name", t.Name.Local):
  23005 			val, err := decoder.Value()
  23006 			if err != nil {
  23007 				return err
  23008 			}
  23009 			if val == nil {
  23010 				break
  23011 			}
  23012 			{
  23013 				xtv := string(val)
  23014 				sv.Name = ptr.String(xtv)
  23015 			}
  23016 
  23017 		case strings.EqualFold("TrafficPolicyCount", t.Name.Local):
  23018 			val, err := decoder.Value()
  23019 			if err != nil {
  23020 				return err
  23021 			}
  23022 			if val == nil {
  23023 				break
  23024 			}
  23025 			{
  23026 				xtv := string(val)
  23027 				i64, err := strconv.ParseInt(xtv, 10, 64)
  23028 				if err != nil {
  23029 					return err
  23030 				}
  23031 				sv.TrafficPolicyCount = ptr.Int32(int32(i64))
  23032 			}
  23033 
  23034 		case strings.EqualFold("Type", t.Name.Local):
  23035 			val, err := decoder.Value()
  23036 			if err != nil {
  23037 				return err
  23038 			}
  23039 			if val == nil {
  23040 				break
  23041 			}
  23042 			{
  23043 				xtv := string(val)
  23044 				sv.Type = types.RRType(xtv)
  23045 			}
  23046 
  23047 		default:
  23048 			// Do nothing and ignore the unexpected tag element
  23049 			err = decoder.Decoder.Skip()
  23050 			if err != nil {
  23051 				return err
  23052 			}
  23053 
  23054 		}
  23055 		decoder = originalDecoder
  23056 	}
  23057 	*v = sv
  23058 	return nil
  23059 }
  23060 
  23061 func awsRestxml_deserializeDocumentVPC(v **types.VPC, decoder smithyxml.NodeDecoder) error {
  23062 	if v == nil {
  23063 		return fmt.Errorf("unexpected nil of type %T", v)
  23064 	}
  23065 	var sv *types.VPC
  23066 	if *v == nil {
  23067 		sv = &types.VPC{}
  23068 	} else {
  23069 		sv = *v
  23070 	}
  23071 
  23072 	for {
  23073 		t, done, err := decoder.Token()
  23074 		if err != nil {
  23075 			return err
  23076 		}
  23077 		if done {
  23078 			break
  23079 		}
  23080 		originalDecoder := decoder
  23081 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  23082 		switch {
  23083 		case strings.EqualFold("VPCId", t.Name.Local):
  23084 			val, err := decoder.Value()
  23085 			if err != nil {
  23086 				return err
  23087 			}
  23088 			if val == nil {
  23089 				break
  23090 			}
  23091 			{
  23092 				xtv := string(val)
  23093 				sv.VPCId = ptr.String(xtv)
  23094 			}
  23095 
  23096 		case strings.EqualFold("VPCRegion", t.Name.Local):
  23097 			val, err := decoder.Value()
  23098 			if err != nil {
  23099 				return err
  23100 			}
  23101 			if val == nil {
  23102 				break
  23103 			}
  23104 			{
  23105 				xtv := string(val)
  23106 				sv.VPCRegion = types.VPCRegion(xtv)
  23107 			}
  23108 
  23109 		default:
  23110 			// Do nothing and ignore the unexpected tag element
  23111 			err = decoder.Decoder.Skip()
  23112 			if err != nil {
  23113 				return err
  23114 			}
  23115 
  23116 		}
  23117 		decoder = originalDecoder
  23118 	}
  23119 	*v = sv
  23120 	return nil
  23121 }
  23122 
  23123 func awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(v **types.VPCAssociationAuthorizationNotFound, decoder smithyxml.NodeDecoder) error {
  23124 	if v == nil {
  23125 		return fmt.Errorf("unexpected nil of type %T", v)
  23126 	}
  23127 	var sv *types.VPCAssociationAuthorizationNotFound
  23128 	if *v == nil {
  23129 		sv = &types.VPCAssociationAuthorizationNotFound{}
  23130 	} else {
  23131 		sv = *v
  23132 	}
  23133 
  23134 	for {
  23135 		t, done, err := decoder.Token()
  23136 		if err != nil {
  23137 			return err
  23138 		}
  23139 		if done {
  23140 			break
  23141 		}
  23142 		originalDecoder := decoder
  23143 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  23144 		switch {
  23145 		case strings.EqualFold("message", t.Name.Local):
  23146 			val, err := decoder.Value()
  23147 			if err != nil {
  23148 				return err
  23149 			}
  23150 			if val == nil {
  23151 				break
  23152 			}
  23153 			{
  23154 				xtv := string(val)
  23155 				sv.Message = ptr.String(xtv)
  23156 			}
  23157 
  23158 		default:
  23159 			// Do nothing and ignore the unexpected tag element
  23160 			err = decoder.Decoder.Skip()
  23161 			if err != nil {
  23162 				return err
  23163 			}
  23164 
  23165 		}
  23166 		decoder = originalDecoder
  23167 	}
  23168 	*v = sv
  23169 	return nil
  23170 }
  23171 
  23172 func awsRestxml_deserializeDocumentVPCAssociationNotFound(v **types.VPCAssociationNotFound, decoder smithyxml.NodeDecoder) error {
  23173 	if v == nil {
  23174 		return fmt.Errorf("unexpected nil of type %T", v)
  23175 	}
  23176 	var sv *types.VPCAssociationNotFound
  23177 	if *v == nil {
  23178 		sv = &types.VPCAssociationNotFound{}
  23179 	} else {
  23180 		sv = *v
  23181 	}
  23182 
  23183 	for {
  23184 		t, done, err := decoder.Token()
  23185 		if err != nil {
  23186 			return err
  23187 		}
  23188 		if done {
  23189 			break
  23190 		}
  23191 		originalDecoder := decoder
  23192 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  23193 		switch {
  23194 		case strings.EqualFold("message", t.Name.Local):
  23195 			val, err := decoder.Value()
  23196 			if err != nil {
  23197 				return err
  23198 			}
  23199 			if val == nil {
  23200 				break
  23201 			}
  23202 			{
  23203 				xtv := string(val)
  23204 				sv.Message = ptr.String(xtv)
  23205 			}
  23206 
  23207 		default:
  23208 			// Do nothing and ignore the unexpected tag element
  23209 			err = decoder.Decoder.Skip()
  23210 			if err != nil {
  23211 				return err
  23212 			}
  23213 
  23214 		}
  23215 		decoder = originalDecoder
  23216 	}
  23217 	*v = sv
  23218 	return nil
  23219 }
  23220 
  23221 func awsRestxml_deserializeDocumentVPCs(v *[]types.VPC, decoder smithyxml.NodeDecoder) error {
  23222 	if v == nil {
  23223 		return fmt.Errorf("unexpected nil of type %T", v)
  23224 	}
  23225 	var sv []types.VPC
  23226 	if *v == nil {
  23227 		sv = make([]types.VPC, 0)
  23228 	} else {
  23229 		sv = *v
  23230 	}
  23231 
  23232 	originalDecoder := decoder
  23233 	for {
  23234 		t, done, err := decoder.Token()
  23235 		if err != nil {
  23236 			return err
  23237 		}
  23238 		if done {
  23239 			break
  23240 		}
  23241 		switch {
  23242 		case strings.EqualFold("VPC", t.Name.Local):
  23243 			var col types.VPC
  23244 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  23245 			destAddr := &col
  23246 			if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil {
  23247 				return err
  23248 			}
  23249 			col = *destAddr
  23250 			sv = append(sv, col)
  23251 
  23252 		default:
  23253 			err = decoder.Decoder.Skip()
  23254 			if err != nil {
  23255 				return err
  23256 			}
  23257 
  23258 		}
  23259 		decoder = originalDecoder
  23260 	}
  23261 	*v = sv
  23262 	return nil
  23263 }
  23264 
  23265 func awsRestxml_deserializeDocumentVPCsUnwrapped(v *[]types.VPC, decoder smithyxml.NodeDecoder) error {
  23266 	var sv []types.VPC
  23267 	if *v == nil {
  23268 		sv = make([]types.VPC, 0)
  23269 	} else {
  23270 		sv = *v
  23271 	}
  23272 
  23273 	switch {
  23274 	default:
  23275 		var mv types.VPC
  23276 		t := decoder.StartEl
  23277 		_ = t
  23278 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  23279 		destAddr := &mv
  23280 		if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil {
  23281 			return err
  23282 		}
  23283 		mv = *destAddr
  23284 		sv = append(sv, mv)
  23285 	}
  23286 	*v = sv
  23287 	return nil
  23288 }