src

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

deserializers.go (587424B)

      1 // Code generated by smithy-go-codegen DO NOT EDIT.
      2 
      3 package route53
      4 
      5 import (
      6 	"bytes"
      7 	"context"
      8 	"encoding/xml"
      9 	"fmt"
     10 	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
     11 	awsxml "github.com/aws/aws-sdk-go-v2/aws/protocol/xml"
     12 	"github.com/aws/aws-sdk-go-v2/service/route53/types"
     13 	smithy "github.com/aws/smithy-go"
     14 	smithyxml "github.com/aws/smithy-go/encoding/xml"
     15 	smithyio "github.com/aws/smithy-go/io"
     16 	"github.com/aws/smithy-go/middleware"
     17 	"github.com/aws/smithy-go/ptr"
     18 	smithytime "github.com/aws/smithy-go/time"
     19 	"github.com/aws/smithy-go/tracing"
     20 	smithyhttp "github.com/aws/smithy-go/transport/http"
     21 	"io"
     22 	"strconv"
     23 	"strings"
     24 )
     25 
     26 type awsRestxml_deserializeOpActivateKeySigningKey struct {
     27 }
     28 
     29 func (*awsRestxml_deserializeOpActivateKeySigningKey) ID() string {
     30 	return "OperationDeserializer"
     31 }
     32 
     33 func (m *awsRestxml_deserializeOpActivateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
     34 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
     35 ) {
     36 	out, metadata, err = next.HandleDeserialize(ctx, in)
     37 	if err != nil {
     38 		return out, metadata, err
     39 	}
     40 
     41 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
     42 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
     43 	defer endTimer()
     44 	defer span.End()
     45 	response, ok := out.RawResponse.(*smithyhttp.Response)
     46 	if !ok {
     47 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
     48 	}
     49 
     50 	if response.StatusCode < 200 || response.StatusCode >= 300 {
     51 		return out, metadata, awsRestxml_deserializeOpErrorActivateKeySigningKey(response, &metadata)
     52 	}
     53 	output := &ActivateKeySigningKeyOutput{}
     54 	out.Result = output
     55 
     56 	var buff [1024]byte
     57 	ringBuffer := smithyio.NewRingBuffer(buff[:])
     58 	body := io.TeeReader(response.Body, ringBuffer)
     59 	rootDecoder := xml.NewDecoder(body)
     60 	t, err := smithyxml.FetchRootElement(rootDecoder)
     61 	if err == io.EOF {
     62 		return out, metadata, nil
     63 	}
     64 	if err != nil {
     65 		var snapshot bytes.Buffer
     66 		io.Copy(&snapshot, ringBuffer)
     67 		return out, metadata, &smithy.DeserializationError{
     68 			Err:      fmt.Errorf("failed to decode response body, %w", err),
     69 			Snapshot: snapshot.Bytes(),
     70 		}
     71 	}
     72 
     73 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
     74 	err = awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(&output, decoder)
     75 	if err != nil {
     76 		var snapshot bytes.Buffer
     77 		io.Copy(&snapshot, ringBuffer)
     78 		return out, metadata, &smithy.DeserializationError{
     79 			Err:      fmt.Errorf("failed to decode response body, %w", err),
     80 			Snapshot: snapshot.Bytes(),
     81 		}
     82 	}
     83 
     84 	span.End()
     85 	return out, metadata, err
     86 }
     87 
     88 func awsRestxml_deserializeOpErrorActivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
     89 	var errorBuffer bytes.Buffer
     90 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
     91 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
     92 	}
     93 	errorBody := bytes.NewReader(errorBuffer.Bytes())
     94 
     95 	errorCode := "UnknownError"
     96 	errorMessage := errorCode
     97 
     98 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
     99 	if err != nil {
    100 		return err
    101 	}
    102 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    103 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    104 	}
    105 	if len(errorComponents.Code) != 0 {
    106 		errorCode = errorComponents.Code
    107 	}
    108 	if len(errorComponents.Message) != 0 {
    109 		errorMessage = errorComponents.Message
    110 	}
    111 	errorBody.Seek(0, io.SeekStart)
    112 	switch {
    113 	case strings.EqualFold("ConcurrentModification", errorCode):
    114 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
    115 
    116 	case strings.EqualFold("InvalidInput", errorCode):
    117 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    118 
    119 	case strings.EqualFold("InvalidKMSArn", errorCode):
    120 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
    121 
    122 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
    123 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
    124 
    125 	case strings.EqualFold("InvalidSigningStatus", errorCode):
    126 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
    127 
    128 	case strings.EqualFold("NoSuchKeySigningKey", errorCode):
    129 		return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
    130 
    131 	default:
    132 		genericError := &smithy.GenericAPIError{
    133 			Code:    errorCode,
    134 			Message: errorMessage,
    135 		}
    136 		return genericError
    137 
    138 	}
    139 }
    140 
    141 func awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(v **ActivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
    142 	if v == nil {
    143 		return fmt.Errorf("unexpected nil of type %T", v)
    144 	}
    145 	var sv *ActivateKeySigningKeyOutput
    146 	if *v == nil {
    147 		sv = &ActivateKeySigningKeyOutput{}
    148 	} else {
    149 		sv = *v
    150 	}
    151 
    152 	for {
    153 		t, done, err := decoder.Token()
    154 		if err != nil {
    155 			return err
    156 		}
    157 		if done {
    158 			break
    159 		}
    160 		originalDecoder := decoder
    161 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    162 		switch {
    163 		case strings.EqualFold("ChangeInfo", t.Name.Local):
    164 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    165 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
    166 				return err
    167 			}
    168 
    169 		default:
    170 			// Do nothing and ignore the unexpected tag element
    171 			err = decoder.Decoder.Skip()
    172 			if err != nil {
    173 				return err
    174 			}
    175 
    176 		}
    177 		decoder = originalDecoder
    178 	}
    179 	*v = sv
    180 	return nil
    181 }
    182 
    183 type awsRestxml_deserializeOpAssociateVPCWithHostedZone struct {
    184 }
    185 
    186 func (*awsRestxml_deserializeOpAssociateVPCWithHostedZone) ID() string {
    187 	return "OperationDeserializer"
    188 }
    189 
    190 func (m *awsRestxml_deserializeOpAssociateVPCWithHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    191 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    192 ) {
    193 	out, metadata, err = next.HandleDeserialize(ctx, in)
    194 	if err != nil {
    195 		return out, metadata, err
    196 	}
    197 
    198 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    199 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    200 	defer endTimer()
    201 	defer span.End()
    202 	response, ok := out.RawResponse.(*smithyhttp.Response)
    203 	if !ok {
    204 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    205 	}
    206 
    207 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    208 		return out, metadata, awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response, &metadata)
    209 	}
    210 	output := &AssociateVPCWithHostedZoneOutput{}
    211 	out.Result = output
    212 
    213 	var buff [1024]byte
    214 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    215 	body := io.TeeReader(response.Body, ringBuffer)
    216 	rootDecoder := xml.NewDecoder(body)
    217 	t, err := smithyxml.FetchRootElement(rootDecoder)
    218 	if err == io.EOF {
    219 		return out, metadata, nil
    220 	}
    221 	if err != nil {
    222 		var snapshot bytes.Buffer
    223 		io.Copy(&snapshot, ringBuffer)
    224 		return out, metadata, &smithy.DeserializationError{
    225 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    226 			Snapshot: snapshot.Bytes(),
    227 		}
    228 	}
    229 
    230 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    231 	err = awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(&output, decoder)
    232 	if err != nil {
    233 		var snapshot bytes.Buffer
    234 		io.Copy(&snapshot, ringBuffer)
    235 		return out, metadata, &smithy.DeserializationError{
    236 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    237 			Snapshot: snapshot.Bytes(),
    238 		}
    239 	}
    240 
    241 	span.End()
    242 	return out, metadata, err
    243 }
    244 
    245 func awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    246 	var errorBuffer bytes.Buffer
    247 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    248 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    249 	}
    250 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    251 
    252 	errorCode := "UnknownError"
    253 	errorMessage := errorCode
    254 
    255 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    256 	if err != nil {
    257 		return err
    258 	}
    259 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    260 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    261 	}
    262 	if len(errorComponents.Code) != 0 {
    263 		errorCode = errorComponents.Code
    264 	}
    265 	if len(errorComponents.Message) != 0 {
    266 		errorMessage = errorComponents.Message
    267 	}
    268 	errorBody.Seek(0, io.SeekStart)
    269 	switch {
    270 	case strings.EqualFold("ConflictingDomainExists", errorCode):
    271 		return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody)
    272 
    273 	case strings.EqualFold("InvalidInput", errorCode):
    274 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    275 
    276 	case strings.EqualFold("InvalidVPCId", errorCode):
    277 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
    278 
    279 	case strings.EqualFold("LimitsExceeded", errorCode):
    280 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
    281 
    282 	case strings.EqualFold("NoSuchHostedZone", errorCode):
    283 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
    284 
    285 	case strings.EqualFold("NotAuthorizedException", errorCode):
    286 		return awsRestxml_deserializeErrorNotAuthorizedException(response, errorBody)
    287 
    288 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
    289 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
    290 
    291 	case strings.EqualFold("PublicZoneVPCAssociation", errorCode):
    292 		return awsRestxml_deserializeErrorPublicZoneVPCAssociation(response, errorBody)
    293 
    294 	default:
    295 		genericError := &smithy.GenericAPIError{
    296 			Code:    errorCode,
    297 			Message: errorMessage,
    298 		}
    299 		return genericError
    300 
    301 	}
    302 }
    303 
    304 func awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(v **AssociateVPCWithHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
    305 	if v == nil {
    306 		return fmt.Errorf("unexpected nil of type %T", v)
    307 	}
    308 	var sv *AssociateVPCWithHostedZoneOutput
    309 	if *v == nil {
    310 		sv = &AssociateVPCWithHostedZoneOutput{}
    311 	} else {
    312 		sv = *v
    313 	}
    314 
    315 	for {
    316 		t, done, err := decoder.Token()
    317 		if err != nil {
    318 			return err
    319 		}
    320 		if done {
    321 			break
    322 		}
    323 		originalDecoder := decoder
    324 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    325 		switch {
    326 		case strings.EqualFold("ChangeInfo", t.Name.Local):
    327 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    328 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
    329 				return err
    330 			}
    331 
    332 		default:
    333 			// Do nothing and ignore the unexpected tag element
    334 			err = decoder.Decoder.Skip()
    335 			if err != nil {
    336 				return err
    337 			}
    338 
    339 		}
    340 		decoder = originalDecoder
    341 	}
    342 	*v = sv
    343 	return nil
    344 }
    345 
    346 type awsRestxml_deserializeOpChangeCidrCollection struct {
    347 }
    348 
    349 func (*awsRestxml_deserializeOpChangeCidrCollection) ID() string {
    350 	return "OperationDeserializer"
    351 }
    352 
    353 func (m *awsRestxml_deserializeOpChangeCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    354 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    355 ) {
    356 	out, metadata, err = next.HandleDeserialize(ctx, in)
    357 	if err != nil {
    358 		return out, metadata, err
    359 	}
    360 
    361 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    362 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    363 	defer endTimer()
    364 	defer span.End()
    365 	response, ok := out.RawResponse.(*smithyhttp.Response)
    366 	if !ok {
    367 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    368 	}
    369 
    370 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    371 		return out, metadata, awsRestxml_deserializeOpErrorChangeCidrCollection(response, &metadata)
    372 	}
    373 	output := &ChangeCidrCollectionOutput{}
    374 	out.Result = output
    375 
    376 	var buff [1024]byte
    377 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    378 	body := io.TeeReader(response.Body, ringBuffer)
    379 	rootDecoder := xml.NewDecoder(body)
    380 	t, err := smithyxml.FetchRootElement(rootDecoder)
    381 	if err == io.EOF {
    382 		return out, metadata, nil
    383 	}
    384 	if err != nil {
    385 		var snapshot bytes.Buffer
    386 		io.Copy(&snapshot, ringBuffer)
    387 		return out, metadata, &smithy.DeserializationError{
    388 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    389 			Snapshot: snapshot.Bytes(),
    390 		}
    391 	}
    392 
    393 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    394 	err = awsRestxml_deserializeOpDocumentChangeCidrCollectionOutput(&output, decoder)
    395 	if err != nil {
    396 		var snapshot bytes.Buffer
    397 		io.Copy(&snapshot, ringBuffer)
    398 		return out, metadata, &smithy.DeserializationError{
    399 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    400 			Snapshot: snapshot.Bytes(),
    401 		}
    402 	}
    403 
    404 	span.End()
    405 	return out, metadata, err
    406 }
    407 
    408 func awsRestxml_deserializeOpErrorChangeCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    409 	var errorBuffer bytes.Buffer
    410 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    411 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    412 	}
    413 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    414 
    415 	errorCode := "UnknownError"
    416 	errorMessage := errorCode
    417 
    418 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    419 	if err != nil {
    420 		return err
    421 	}
    422 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    423 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    424 	}
    425 	if len(errorComponents.Code) != 0 {
    426 		errorCode = errorComponents.Code
    427 	}
    428 	if len(errorComponents.Message) != 0 {
    429 		errorMessage = errorComponents.Message
    430 	}
    431 	errorBody.Seek(0, io.SeekStart)
    432 	switch {
    433 	case strings.EqualFold("CidrBlockInUseException", errorCode):
    434 		return awsRestxml_deserializeErrorCidrBlockInUseException(response, errorBody)
    435 
    436 	case strings.EqualFold("CidrCollectionVersionMismatchException", errorCode):
    437 		return awsRestxml_deserializeErrorCidrCollectionVersionMismatchException(response, errorBody)
    438 
    439 	case strings.EqualFold("ConcurrentModification", errorCode):
    440 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
    441 
    442 	case strings.EqualFold("InvalidInput", errorCode):
    443 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    444 
    445 	case strings.EqualFold("LimitsExceeded", errorCode):
    446 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
    447 
    448 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
    449 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
    450 
    451 	default:
    452 		genericError := &smithy.GenericAPIError{
    453 			Code:    errorCode,
    454 			Message: errorMessage,
    455 		}
    456 		return genericError
    457 
    458 	}
    459 }
    460 
    461 func awsRestxml_deserializeOpDocumentChangeCidrCollectionOutput(v **ChangeCidrCollectionOutput, decoder smithyxml.NodeDecoder) error {
    462 	if v == nil {
    463 		return fmt.Errorf("unexpected nil of type %T", v)
    464 	}
    465 	var sv *ChangeCidrCollectionOutput
    466 	if *v == nil {
    467 		sv = &ChangeCidrCollectionOutput{}
    468 	} else {
    469 		sv = *v
    470 	}
    471 
    472 	for {
    473 		t, done, err := decoder.Token()
    474 		if err != nil {
    475 			return err
    476 		}
    477 		if done {
    478 			break
    479 		}
    480 		originalDecoder := decoder
    481 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    482 		switch {
    483 		case strings.EqualFold("Id", t.Name.Local):
    484 			val, err := decoder.Value()
    485 			if err != nil {
    486 				return err
    487 			}
    488 			if val == nil {
    489 				break
    490 			}
    491 			{
    492 				xtv := string(val)
    493 				sv.Id = ptr.String(xtv)
    494 			}
    495 
    496 		default:
    497 			// Do nothing and ignore the unexpected tag element
    498 			err = decoder.Decoder.Skip()
    499 			if err != nil {
    500 				return err
    501 			}
    502 
    503 		}
    504 		decoder = originalDecoder
    505 	}
    506 	*v = sv
    507 	return nil
    508 }
    509 
    510 type awsRestxml_deserializeOpChangeResourceRecordSets struct {
    511 }
    512 
    513 func (*awsRestxml_deserializeOpChangeResourceRecordSets) ID() string {
    514 	return "OperationDeserializer"
    515 }
    516 
    517 func (m *awsRestxml_deserializeOpChangeResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    518 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    519 ) {
    520 	out, metadata, err = next.HandleDeserialize(ctx, in)
    521 	if err != nil {
    522 		return out, metadata, err
    523 	}
    524 
    525 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    526 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    527 	defer endTimer()
    528 	defer span.End()
    529 	response, ok := out.RawResponse.(*smithyhttp.Response)
    530 	if !ok {
    531 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    532 	}
    533 
    534 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    535 		return out, metadata, awsRestxml_deserializeOpErrorChangeResourceRecordSets(response, &metadata)
    536 	}
    537 	output := &ChangeResourceRecordSetsOutput{}
    538 	out.Result = output
    539 
    540 	var buff [1024]byte
    541 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    542 	body := io.TeeReader(response.Body, ringBuffer)
    543 	rootDecoder := xml.NewDecoder(body)
    544 	t, err := smithyxml.FetchRootElement(rootDecoder)
    545 	if err == io.EOF {
    546 		return out, metadata, nil
    547 	}
    548 	if err != nil {
    549 		var snapshot bytes.Buffer
    550 		io.Copy(&snapshot, ringBuffer)
    551 		return out, metadata, &smithy.DeserializationError{
    552 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    553 			Snapshot: snapshot.Bytes(),
    554 		}
    555 	}
    556 
    557 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    558 	err = awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(&output, decoder)
    559 	if err != nil {
    560 		var snapshot bytes.Buffer
    561 		io.Copy(&snapshot, ringBuffer)
    562 		return out, metadata, &smithy.DeserializationError{
    563 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    564 			Snapshot: snapshot.Bytes(),
    565 		}
    566 	}
    567 
    568 	span.End()
    569 	return out, metadata, err
    570 }
    571 
    572 func awsRestxml_deserializeOpErrorChangeResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    573 	var errorBuffer bytes.Buffer
    574 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    575 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    576 	}
    577 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    578 
    579 	errorCode := "UnknownError"
    580 	errorMessage := errorCode
    581 
    582 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    583 	if err != nil {
    584 		return err
    585 	}
    586 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    587 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    588 	}
    589 	if len(errorComponents.Code) != 0 {
    590 		errorCode = errorComponents.Code
    591 	}
    592 	if len(errorComponents.Message) != 0 {
    593 		errorMessage = errorComponents.Message
    594 	}
    595 	errorBody.Seek(0, io.SeekStart)
    596 	switch {
    597 	case strings.EqualFold("InvalidChangeBatch", errorCode):
    598 		return awsRestxml_deserializeErrorInvalidChangeBatch(response, errorBody)
    599 
    600 	case strings.EqualFold("InvalidInput", errorCode):
    601 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    602 
    603 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
    604 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
    605 
    606 	case strings.EqualFold("NoSuchHostedZone", errorCode):
    607 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
    608 
    609 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
    610 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
    611 
    612 	default:
    613 		genericError := &smithy.GenericAPIError{
    614 			Code:    errorCode,
    615 			Message: errorMessage,
    616 		}
    617 		return genericError
    618 
    619 	}
    620 }
    621 
    622 func awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(v **ChangeResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error {
    623 	if v == nil {
    624 		return fmt.Errorf("unexpected nil of type %T", v)
    625 	}
    626 	var sv *ChangeResourceRecordSetsOutput
    627 	if *v == nil {
    628 		sv = &ChangeResourceRecordSetsOutput{}
    629 	} else {
    630 		sv = *v
    631 	}
    632 
    633 	for {
    634 		t, done, err := decoder.Token()
    635 		if err != nil {
    636 			return err
    637 		}
    638 		if done {
    639 			break
    640 		}
    641 		originalDecoder := decoder
    642 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    643 		switch {
    644 		case strings.EqualFold("ChangeInfo", t.Name.Local):
    645 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    646 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
    647 				return err
    648 			}
    649 
    650 		default:
    651 			// Do nothing and ignore the unexpected tag element
    652 			err = decoder.Decoder.Skip()
    653 			if err != nil {
    654 				return err
    655 			}
    656 
    657 		}
    658 		decoder = originalDecoder
    659 	}
    660 	*v = sv
    661 	return nil
    662 }
    663 
    664 type awsRestxml_deserializeOpChangeTagsForResource struct {
    665 }
    666 
    667 func (*awsRestxml_deserializeOpChangeTagsForResource) ID() string {
    668 	return "OperationDeserializer"
    669 }
    670 
    671 func (m *awsRestxml_deserializeOpChangeTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    672 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    673 ) {
    674 	out, metadata, err = next.HandleDeserialize(ctx, in)
    675 	if err != nil {
    676 		return out, metadata, err
    677 	}
    678 
    679 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    680 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    681 	defer endTimer()
    682 	defer span.End()
    683 	response, ok := out.RawResponse.(*smithyhttp.Response)
    684 	if !ok {
    685 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    686 	}
    687 
    688 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    689 		return out, metadata, awsRestxml_deserializeOpErrorChangeTagsForResource(response, &metadata)
    690 	}
    691 	output := &ChangeTagsForResourceOutput{}
    692 	out.Result = output
    693 
    694 	span.End()
    695 	return out, metadata, err
    696 }
    697 
    698 func awsRestxml_deserializeOpErrorChangeTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    699 	var errorBuffer bytes.Buffer
    700 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    701 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    702 	}
    703 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    704 
    705 	errorCode := "UnknownError"
    706 	errorMessage := errorCode
    707 
    708 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    709 	if err != nil {
    710 		return err
    711 	}
    712 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    713 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    714 	}
    715 	if len(errorComponents.Code) != 0 {
    716 		errorCode = errorComponents.Code
    717 	}
    718 	if len(errorComponents.Message) != 0 {
    719 		errorMessage = errorComponents.Message
    720 	}
    721 	errorBody.Seek(0, io.SeekStart)
    722 	switch {
    723 	case strings.EqualFold("InvalidInput", errorCode):
    724 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    725 
    726 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
    727 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
    728 
    729 	case strings.EqualFold("NoSuchHostedZone", errorCode):
    730 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
    731 
    732 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
    733 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
    734 
    735 	case strings.EqualFold("ThrottlingException", errorCode):
    736 		return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
    737 
    738 	default:
    739 		genericError := &smithy.GenericAPIError{
    740 			Code:    errorCode,
    741 			Message: errorMessage,
    742 		}
    743 		return genericError
    744 
    745 	}
    746 }
    747 
    748 type awsRestxml_deserializeOpCreateCidrCollection struct {
    749 }
    750 
    751 func (*awsRestxml_deserializeOpCreateCidrCollection) ID() string {
    752 	return "OperationDeserializer"
    753 }
    754 
    755 func (m *awsRestxml_deserializeOpCreateCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    756 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    757 ) {
    758 	out, metadata, err = next.HandleDeserialize(ctx, in)
    759 	if err != nil {
    760 		return out, metadata, err
    761 	}
    762 
    763 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    764 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    765 	defer endTimer()
    766 	defer span.End()
    767 	response, ok := out.RawResponse.(*smithyhttp.Response)
    768 	if !ok {
    769 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    770 	}
    771 
    772 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    773 		return out, metadata, awsRestxml_deserializeOpErrorCreateCidrCollection(response, &metadata)
    774 	}
    775 	output := &CreateCidrCollectionOutput{}
    776 	out.Result = output
    777 
    778 	err = awsRestxml_deserializeOpHttpBindingsCreateCidrCollectionOutput(output, response)
    779 	if err != nil {
    780 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
    781 	}
    782 
    783 	var buff [1024]byte
    784 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    785 	body := io.TeeReader(response.Body, ringBuffer)
    786 	rootDecoder := xml.NewDecoder(body)
    787 	t, err := smithyxml.FetchRootElement(rootDecoder)
    788 	if err == io.EOF {
    789 		return out, metadata, nil
    790 	}
    791 	if err != nil {
    792 		var snapshot bytes.Buffer
    793 		io.Copy(&snapshot, ringBuffer)
    794 		return out, metadata, &smithy.DeserializationError{
    795 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    796 			Snapshot: snapshot.Bytes(),
    797 		}
    798 	}
    799 
    800 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    801 	err = awsRestxml_deserializeOpDocumentCreateCidrCollectionOutput(&output, decoder)
    802 	if err != nil {
    803 		var snapshot bytes.Buffer
    804 		io.Copy(&snapshot, ringBuffer)
    805 		return out, metadata, &smithy.DeserializationError{
    806 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    807 			Snapshot: snapshot.Bytes(),
    808 		}
    809 	}
    810 
    811 	span.End()
    812 	return out, metadata, err
    813 }
    814 
    815 func awsRestxml_deserializeOpErrorCreateCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    816 	var errorBuffer bytes.Buffer
    817 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    818 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    819 	}
    820 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    821 
    822 	errorCode := "UnknownError"
    823 	errorMessage := errorCode
    824 
    825 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    826 	if err != nil {
    827 		return err
    828 	}
    829 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    830 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    831 	}
    832 	if len(errorComponents.Code) != 0 {
    833 		errorCode = errorComponents.Code
    834 	}
    835 	if len(errorComponents.Message) != 0 {
    836 		errorMessage = errorComponents.Message
    837 	}
    838 	errorBody.Seek(0, io.SeekStart)
    839 	switch {
    840 	case strings.EqualFold("CidrCollectionAlreadyExistsException", errorCode):
    841 		return awsRestxml_deserializeErrorCidrCollectionAlreadyExistsException(response, errorBody)
    842 
    843 	case strings.EqualFold("ConcurrentModification", errorCode):
    844 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
    845 
    846 	case strings.EqualFold("InvalidInput", errorCode):
    847 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    848 
    849 	case strings.EqualFold("LimitsExceeded", errorCode):
    850 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
    851 
    852 	default:
    853 		genericError := &smithy.GenericAPIError{
    854 			Code:    errorCode,
    855 			Message: errorMessage,
    856 		}
    857 		return genericError
    858 
    859 	}
    860 }
    861 
    862 func awsRestxml_deserializeOpHttpBindingsCreateCidrCollectionOutput(v *CreateCidrCollectionOutput, response *smithyhttp.Response) error {
    863 	if v == nil {
    864 		return fmt.Errorf("unsupported deserialization for nil %T", v)
    865 	}
    866 
    867 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
    868 		headerValues[0] = strings.TrimSpace(headerValues[0])
    869 		v.Location = ptr.String(headerValues[0])
    870 	}
    871 
    872 	return nil
    873 }
    874 func awsRestxml_deserializeOpDocumentCreateCidrCollectionOutput(v **CreateCidrCollectionOutput, decoder smithyxml.NodeDecoder) error {
    875 	if v == nil {
    876 		return fmt.Errorf("unexpected nil of type %T", v)
    877 	}
    878 	var sv *CreateCidrCollectionOutput
    879 	if *v == nil {
    880 		sv = &CreateCidrCollectionOutput{}
    881 	} else {
    882 		sv = *v
    883 	}
    884 
    885 	for {
    886 		t, done, err := decoder.Token()
    887 		if err != nil {
    888 			return err
    889 		}
    890 		if done {
    891 			break
    892 		}
    893 		originalDecoder := decoder
    894 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    895 		switch {
    896 		case strings.EqualFold("Collection", t.Name.Local):
    897 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    898 			if err := awsRestxml_deserializeDocumentCidrCollection(&sv.Collection, nodeDecoder); err != nil {
    899 				return err
    900 			}
    901 
    902 		default:
    903 			// Do nothing and ignore the unexpected tag element
    904 			err = decoder.Decoder.Skip()
    905 			if err != nil {
    906 				return err
    907 			}
    908 
    909 		}
    910 		decoder = originalDecoder
    911 	}
    912 	*v = sv
    913 	return nil
    914 }
    915 
    916 type awsRestxml_deserializeOpCreateHealthCheck struct {
    917 }
    918 
    919 func (*awsRestxml_deserializeOpCreateHealthCheck) ID() string {
    920 	return "OperationDeserializer"
    921 }
    922 
    923 func (m *awsRestxml_deserializeOpCreateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    924 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    925 ) {
    926 	out, metadata, err = next.HandleDeserialize(ctx, in)
    927 	if err != nil {
    928 		return out, metadata, err
    929 	}
    930 
    931 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    932 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    933 	defer endTimer()
    934 	defer span.End()
    935 	response, ok := out.RawResponse.(*smithyhttp.Response)
    936 	if !ok {
    937 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    938 	}
    939 
    940 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    941 		return out, metadata, awsRestxml_deserializeOpErrorCreateHealthCheck(response, &metadata)
    942 	}
    943 	output := &CreateHealthCheckOutput{}
    944 	out.Result = output
    945 
    946 	err = awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(output, response)
    947 	if err != nil {
    948 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
    949 	}
    950 
    951 	var buff [1024]byte
    952 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    953 	body := io.TeeReader(response.Body, ringBuffer)
    954 	rootDecoder := xml.NewDecoder(body)
    955 	t, err := smithyxml.FetchRootElement(rootDecoder)
    956 	if err == io.EOF {
    957 		return out, metadata, nil
    958 	}
    959 	if err != nil {
    960 		var snapshot bytes.Buffer
    961 		io.Copy(&snapshot, ringBuffer)
    962 		return out, metadata, &smithy.DeserializationError{
    963 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    964 			Snapshot: snapshot.Bytes(),
    965 		}
    966 	}
    967 
    968 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    969 	err = awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(&output, decoder)
    970 	if err != nil {
    971 		var snapshot bytes.Buffer
    972 		io.Copy(&snapshot, ringBuffer)
    973 		return out, metadata, &smithy.DeserializationError{
    974 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    975 			Snapshot: snapshot.Bytes(),
    976 		}
    977 	}
    978 
    979 	span.End()
    980 	return out, metadata, err
    981 }
    982 
    983 func awsRestxml_deserializeOpErrorCreateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    984 	var errorBuffer bytes.Buffer
    985 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    986 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    987 	}
    988 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    989 
    990 	errorCode := "UnknownError"
    991 	errorMessage := errorCode
    992 
    993 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    994 	if err != nil {
    995 		return err
    996 	}
    997 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    998 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    999 	}
   1000 	if len(errorComponents.Code) != 0 {
   1001 		errorCode = errorComponents.Code
   1002 	}
   1003 	if len(errorComponents.Message) != 0 {
   1004 		errorMessage = errorComponents.Message
   1005 	}
   1006 	errorBody.Seek(0, io.SeekStart)
   1007 	switch {
   1008 	case strings.EqualFold("HealthCheckAlreadyExists", errorCode):
   1009 		return awsRestxml_deserializeErrorHealthCheckAlreadyExists(response, errorBody)
   1010 
   1011 	case strings.EqualFold("InvalidInput", errorCode):
   1012 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1013 
   1014 	case strings.EqualFold("TooManyHealthChecks", errorCode):
   1015 		return awsRestxml_deserializeErrorTooManyHealthChecks(response, errorBody)
   1016 
   1017 	default:
   1018 		genericError := &smithy.GenericAPIError{
   1019 			Code:    errorCode,
   1020 			Message: errorMessage,
   1021 		}
   1022 		return genericError
   1023 
   1024 	}
   1025 }
   1026 
   1027 func awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(v *CreateHealthCheckOutput, response *smithyhttp.Response) error {
   1028 	if v == nil {
   1029 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1030 	}
   1031 
   1032 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1033 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1034 		v.Location = ptr.String(headerValues[0])
   1035 	}
   1036 
   1037 	return nil
   1038 }
   1039 func awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(v **CreateHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
   1040 	if v == nil {
   1041 		return fmt.Errorf("unexpected nil of type %T", v)
   1042 	}
   1043 	var sv *CreateHealthCheckOutput
   1044 	if *v == nil {
   1045 		sv = &CreateHealthCheckOutput{}
   1046 	} else {
   1047 		sv = *v
   1048 	}
   1049 
   1050 	for {
   1051 		t, done, err := decoder.Token()
   1052 		if err != nil {
   1053 			return err
   1054 		}
   1055 		if done {
   1056 			break
   1057 		}
   1058 		originalDecoder := decoder
   1059 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1060 		switch {
   1061 		case strings.EqualFold("HealthCheck", t.Name.Local):
   1062 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1063 			if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
   1064 				return err
   1065 			}
   1066 
   1067 		default:
   1068 			// Do nothing and ignore the unexpected tag element
   1069 			err = decoder.Decoder.Skip()
   1070 			if err != nil {
   1071 				return err
   1072 			}
   1073 
   1074 		}
   1075 		decoder = originalDecoder
   1076 	}
   1077 	*v = sv
   1078 	return nil
   1079 }
   1080 
   1081 type awsRestxml_deserializeOpCreateHostedZone struct {
   1082 }
   1083 
   1084 func (*awsRestxml_deserializeOpCreateHostedZone) ID() string {
   1085 	return "OperationDeserializer"
   1086 }
   1087 
   1088 func (m *awsRestxml_deserializeOpCreateHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1089 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1090 ) {
   1091 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1092 	if err != nil {
   1093 		return out, metadata, err
   1094 	}
   1095 
   1096 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1097 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1098 	defer endTimer()
   1099 	defer span.End()
   1100 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1101 	if !ok {
   1102 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1103 	}
   1104 
   1105 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1106 		return out, metadata, awsRestxml_deserializeOpErrorCreateHostedZone(response, &metadata)
   1107 	}
   1108 	output := &CreateHostedZoneOutput{}
   1109 	out.Result = output
   1110 
   1111 	err = awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(output, response)
   1112 	if err != nil {
   1113 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1114 	}
   1115 
   1116 	var buff [1024]byte
   1117 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1118 	body := io.TeeReader(response.Body, ringBuffer)
   1119 	rootDecoder := xml.NewDecoder(body)
   1120 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1121 	if err == io.EOF {
   1122 		return out, metadata, nil
   1123 	}
   1124 	if err != nil {
   1125 		var snapshot bytes.Buffer
   1126 		io.Copy(&snapshot, ringBuffer)
   1127 		return out, metadata, &smithy.DeserializationError{
   1128 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1129 			Snapshot: snapshot.Bytes(),
   1130 		}
   1131 	}
   1132 
   1133 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1134 	err = awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(&output, decoder)
   1135 	if err != nil {
   1136 		var snapshot bytes.Buffer
   1137 		io.Copy(&snapshot, ringBuffer)
   1138 		return out, metadata, &smithy.DeserializationError{
   1139 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1140 			Snapshot: snapshot.Bytes(),
   1141 		}
   1142 	}
   1143 
   1144 	span.End()
   1145 	return out, metadata, err
   1146 }
   1147 
   1148 func awsRestxml_deserializeOpErrorCreateHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1149 	var errorBuffer bytes.Buffer
   1150 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1151 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1152 	}
   1153 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1154 
   1155 	errorCode := "UnknownError"
   1156 	errorMessage := errorCode
   1157 
   1158 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1159 	if err != nil {
   1160 		return err
   1161 	}
   1162 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1163 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1164 	}
   1165 	if len(errorComponents.Code) != 0 {
   1166 		errorCode = errorComponents.Code
   1167 	}
   1168 	if len(errorComponents.Message) != 0 {
   1169 		errorMessage = errorComponents.Message
   1170 	}
   1171 	errorBody.Seek(0, io.SeekStart)
   1172 	switch {
   1173 	case strings.EqualFold("ConflictingDomainExists", errorCode):
   1174 		return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody)
   1175 
   1176 	case strings.EqualFold("DelegationSetNotAvailable", errorCode):
   1177 		return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody)
   1178 
   1179 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   1180 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   1181 
   1182 	case strings.EqualFold("HostedZoneAlreadyExists", errorCode):
   1183 		return awsRestxml_deserializeErrorHostedZoneAlreadyExists(response, errorBody)
   1184 
   1185 	case strings.EqualFold("InvalidDomainName", errorCode):
   1186 		return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
   1187 
   1188 	case strings.EqualFold("InvalidInput", errorCode):
   1189 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1190 
   1191 	case strings.EqualFold("InvalidVPCId", errorCode):
   1192 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   1193 
   1194 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   1195 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   1196 
   1197 	case strings.EqualFold("TooManyHostedZones", errorCode):
   1198 		return awsRestxml_deserializeErrorTooManyHostedZones(response, errorBody)
   1199 
   1200 	default:
   1201 		genericError := &smithy.GenericAPIError{
   1202 			Code:    errorCode,
   1203 			Message: errorMessage,
   1204 		}
   1205 		return genericError
   1206 
   1207 	}
   1208 }
   1209 
   1210 func awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(v *CreateHostedZoneOutput, response *smithyhttp.Response) error {
   1211 	if v == nil {
   1212 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1213 	}
   1214 
   1215 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1216 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1217 		v.Location = ptr.String(headerValues[0])
   1218 	}
   1219 
   1220 	return nil
   1221 }
   1222 func awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(v **CreateHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   1223 	if v == nil {
   1224 		return fmt.Errorf("unexpected nil of type %T", v)
   1225 	}
   1226 	var sv *CreateHostedZoneOutput
   1227 	if *v == nil {
   1228 		sv = &CreateHostedZoneOutput{}
   1229 	} else {
   1230 		sv = *v
   1231 	}
   1232 
   1233 	for {
   1234 		t, done, err := decoder.Token()
   1235 		if err != nil {
   1236 			return err
   1237 		}
   1238 		if done {
   1239 			break
   1240 		}
   1241 		originalDecoder := decoder
   1242 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1243 		switch {
   1244 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   1245 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1246 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   1247 				return err
   1248 			}
   1249 
   1250 		case strings.EqualFold("DelegationSet", t.Name.Local):
   1251 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1252 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   1253 				return err
   1254 			}
   1255 
   1256 		case strings.EqualFold("HostedZone", t.Name.Local):
   1257 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1258 			if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
   1259 				return err
   1260 			}
   1261 
   1262 		case strings.EqualFold("VPC", t.Name.Local):
   1263 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1264 			if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil {
   1265 				return err
   1266 			}
   1267 
   1268 		default:
   1269 			// Do nothing and ignore the unexpected tag element
   1270 			err = decoder.Decoder.Skip()
   1271 			if err != nil {
   1272 				return err
   1273 			}
   1274 
   1275 		}
   1276 		decoder = originalDecoder
   1277 	}
   1278 	*v = sv
   1279 	return nil
   1280 }
   1281 
   1282 type awsRestxml_deserializeOpCreateKeySigningKey struct {
   1283 }
   1284 
   1285 func (*awsRestxml_deserializeOpCreateKeySigningKey) ID() string {
   1286 	return "OperationDeserializer"
   1287 }
   1288 
   1289 func (m *awsRestxml_deserializeOpCreateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1290 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1291 ) {
   1292 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1293 	if err != nil {
   1294 		return out, metadata, err
   1295 	}
   1296 
   1297 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1298 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1299 	defer endTimer()
   1300 	defer span.End()
   1301 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1302 	if !ok {
   1303 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1304 	}
   1305 
   1306 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1307 		return out, metadata, awsRestxml_deserializeOpErrorCreateKeySigningKey(response, &metadata)
   1308 	}
   1309 	output := &CreateKeySigningKeyOutput{}
   1310 	out.Result = output
   1311 
   1312 	err = awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(output, response)
   1313 	if err != nil {
   1314 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1315 	}
   1316 
   1317 	var buff [1024]byte
   1318 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1319 	body := io.TeeReader(response.Body, ringBuffer)
   1320 	rootDecoder := xml.NewDecoder(body)
   1321 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1322 	if err == io.EOF {
   1323 		return out, metadata, nil
   1324 	}
   1325 	if err != nil {
   1326 		var snapshot bytes.Buffer
   1327 		io.Copy(&snapshot, ringBuffer)
   1328 		return out, metadata, &smithy.DeserializationError{
   1329 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1330 			Snapshot: snapshot.Bytes(),
   1331 		}
   1332 	}
   1333 
   1334 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1335 	err = awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(&output, decoder)
   1336 	if err != nil {
   1337 		var snapshot bytes.Buffer
   1338 		io.Copy(&snapshot, ringBuffer)
   1339 		return out, metadata, &smithy.DeserializationError{
   1340 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1341 			Snapshot: snapshot.Bytes(),
   1342 		}
   1343 	}
   1344 
   1345 	span.End()
   1346 	return out, metadata, err
   1347 }
   1348 
   1349 func awsRestxml_deserializeOpErrorCreateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1350 	var errorBuffer bytes.Buffer
   1351 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1352 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1353 	}
   1354 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1355 
   1356 	errorCode := "UnknownError"
   1357 	errorMessage := errorCode
   1358 
   1359 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1360 	if err != nil {
   1361 		return err
   1362 	}
   1363 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1364 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1365 	}
   1366 	if len(errorComponents.Code) != 0 {
   1367 		errorCode = errorComponents.Code
   1368 	}
   1369 	if len(errorComponents.Message) != 0 {
   1370 		errorMessage = errorComponents.Message
   1371 	}
   1372 	errorBody.Seek(0, io.SeekStart)
   1373 	switch {
   1374 	case strings.EqualFold("ConcurrentModification", errorCode):
   1375 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   1376 
   1377 	case strings.EqualFold("InvalidArgument", errorCode):
   1378 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   1379 
   1380 	case strings.EqualFold("InvalidInput", errorCode):
   1381 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1382 
   1383 	case strings.EqualFold("InvalidKMSArn", errorCode):
   1384 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   1385 
   1386 	case strings.EqualFold("InvalidKeySigningKeyName", errorCode):
   1387 		return awsRestxml_deserializeErrorInvalidKeySigningKeyName(response, errorBody)
   1388 
   1389 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   1390 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   1391 
   1392 	case strings.EqualFold("InvalidSigningStatus", errorCode):
   1393 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
   1394 
   1395 	case strings.EqualFold("KeySigningKeyAlreadyExists", errorCode):
   1396 		return awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response, errorBody)
   1397 
   1398 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   1399 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   1400 
   1401 	case strings.EqualFold("TooManyKeySigningKeys", errorCode):
   1402 		return awsRestxml_deserializeErrorTooManyKeySigningKeys(response, errorBody)
   1403 
   1404 	default:
   1405 		genericError := &smithy.GenericAPIError{
   1406 			Code:    errorCode,
   1407 			Message: errorMessage,
   1408 		}
   1409 		return genericError
   1410 
   1411 	}
   1412 }
   1413 
   1414 func awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(v *CreateKeySigningKeyOutput, response *smithyhttp.Response) error {
   1415 	if v == nil {
   1416 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1417 	}
   1418 
   1419 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1420 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1421 		v.Location = ptr.String(headerValues[0])
   1422 	}
   1423 
   1424 	return nil
   1425 }
   1426 func awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(v **CreateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
   1427 	if v == nil {
   1428 		return fmt.Errorf("unexpected nil of type %T", v)
   1429 	}
   1430 	var sv *CreateKeySigningKeyOutput
   1431 	if *v == nil {
   1432 		sv = &CreateKeySigningKeyOutput{}
   1433 	} else {
   1434 		sv = *v
   1435 	}
   1436 
   1437 	for {
   1438 		t, done, err := decoder.Token()
   1439 		if err != nil {
   1440 			return err
   1441 		}
   1442 		if done {
   1443 			break
   1444 		}
   1445 		originalDecoder := decoder
   1446 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1447 		switch {
   1448 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   1449 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1450 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   1451 				return err
   1452 			}
   1453 
   1454 		case strings.EqualFold("KeySigningKey", t.Name.Local):
   1455 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1456 			if err := awsRestxml_deserializeDocumentKeySigningKey(&sv.KeySigningKey, nodeDecoder); err != nil {
   1457 				return err
   1458 			}
   1459 
   1460 		default:
   1461 			// Do nothing and ignore the unexpected tag element
   1462 			err = decoder.Decoder.Skip()
   1463 			if err != nil {
   1464 				return err
   1465 			}
   1466 
   1467 		}
   1468 		decoder = originalDecoder
   1469 	}
   1470 	*v = sv
   1471 	return nil
   1472 }
   1473 
   1474 type awsRestxml_deserializeOpCreateQueryLoggingConfig struct {
   1475 }
   1476 
   1477 func (*awsRestxml_deserializeOpCreateQueryLoggingConfig) ID() string {
   1478 	return "OperationDeserializer"
   1479 }
   1480 
   1481 func (m *awsRestxml_deserializeOpCreateQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1482 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1483 ) {
   1484 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1485 	if err != nil {
   1486 		return out, metadata, err
   1487 	}
   1488 
   1489 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1490 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1491 	defer endTimer()
   1492 	defer span.End()
   1493 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1494 	if !ok {
   1495 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1496 	}
   1497 
   1498 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1499 		return out, metadata, awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response, &metadata)
   1500 	}
   1501 	output := &CreateQueryLoggingConfigOutput{}
   1502 	out.Result = output
   1503 
   1504 	err = awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(output, response)
   1505 	if err != nil {
   1506 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1507 	}
   1508 
   1509 	var buff [1024]byte
   1510 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1511 	body := io.TeeReader(response.Body, ringBuffer)
   1512 	rootDecoder := xml.NewDecoder(body)
   1513 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1514 	if err == io.EOF {
   1515 		return out, metadata, nil
   1516 	}
   1517 	if err != nil {
   1518 		var snapshot bytes.Buffer
   1519 		io.Copy(&snapshot, ringBuffer)
   1520 		return out, metadata, &smithy.DeserializationError{
   1521 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1522 			Snapshot: snapshot.Bytes(),
   1523 		}
   1524 	}
   1525 
   1526 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1527 	err = awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(&output, decoder)
   1528 	if err != nil {
   1529 		var snapshot bytes.Buffer
   1530 		io.Copy(&snapshot, ringBuffer)
   1531 		return out, metadata, &smithy.DeserializationError{
   1532 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1533 			Snapshot: snapshot.Bytes(),
   1534 		}
   1535 	}
   1536 
   1537 	span.End()
   1538 	return out, metadata, err
   1539 }
   1540 
   1541 func awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1542 	var errorBuffer bytes.Buffer
   1543 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1544 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1545 	}
   1546 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1547 
   1548 	errorCode := "UnknownError"
   1549 	errorMessage := errorCode
   1550 
   1551 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1552 	if err != nil {
   1553 		return err
   1554 	}
   1555 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1556 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1557 	}
   1558 	if len(errorComponents.Code) != 0 {
   1559 		errorCode = errorComponents.Code
   1560 	}
   1561 	if len(errorComponents.Message) != 0 {
   1562 		errorMessage = errorComponents.Message
   1563 	}
   1564 	errorBody.Seek(0, io.SeekStart)
   1565 	switch {
   1566 	case strings.EqualFold("ConcurrentModification", errorCode):
   1567 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   1568 
   1569 	case strings.EqualFold("InsufficientCloudWatchLogsResourcePolicy", errorCode):
   1570 		return awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response, errorBody)
   1571 
   1572 	case strings.EqualFold("InvalidInput", errorCode):
   1573 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1574 
   1575 	case strings.EqualFold("NoSuchCloudWatchLogsLogGroup", errorCode):
   1576 		return awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response, errorBody)
   1577 
   1578 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   1579 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   1580 
   1581 	case strings.EqualFold("QueryLoggingConfigAlreadyExists", errorCode):
   1582 		return awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response, errorBody)
   1583 
   1584 	default:
   1585 		genericError := &smithy.GenericAPIError{
   1586 			Code:    errorCode,
   1587 			Message: errorMessage,
   1588 		}
   1589 		return genericError
   1590 
   1591 	}
   1592 }
   1593 
   1594 func awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(v *CreateQueryLoggingConfigOutput, response *smithyhttp.Response) error {
   1595 	if v == nil {
   1596 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1597 	}
   1598 
   1599 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1600 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1601 		v.Location = ptr.String(headerValues[0])
   1602 	}
   1603 
   1604 	return nil
   1605 }
   1606 func awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(v **CreateQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error {
   1607 	if v == nil {
   1608 		return fmt.Errorf("unexpected nil of type %T", v)
   1609 	}
   1610 	var sv *CreateQueryLoggingConfigOutput
   1611 	if *v == nil {
   1612 		sv = &CreateQueryLoggingConfigOutput{}
   1613 	} else {
   1614 		sv = *v
   1615 	}
   1616 
   1617 	for {
   1618 		t, done, err := decoder.Token()
   1619 		if err != nil {
   1620 			return err
   1621 		}
   1622 		if done {
   1623 			break
   1624 		}
   1625 		originalDecoder := decoder
   1626 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1627 		switch {
   1628 		case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
   1629 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1630 			if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil {
   1631 				return err
   1632 			}
   1633 
   1634 		default:
   1635 			// Do nothing and ignore the unexpected tag element
   1636 			err = decoder.Decoder.Skip()
   1637 			if err != nil {
   1638 				return err
   1639 			}
   1640 
   1641 		}
   1642 		decoder = originalDecoder
   1643 	}
   1644 	*v = sv
   1645 	return nil
   1646 }
   1647 
   1648 type awsRestxml_deserializeOpCreateReusableDelegationSet struct {
   1649 }
   1650 
   1651 func (*awsRestxml_deserializeOpCreateReusableDelegationSet) ID() string {
   1652 	return "OperationDeserializer"
   1653 }
   1654 
   1655 func (m *awsRestxml_deserializeOpCreateReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1656 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1657 ) {
   1658 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1659 	if err != nil {
   1660 		return out, metadata, err
   1661 	}
   1662 
   1663 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1664 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1665 	defer endTimer()
   1666 	defer span.End()
   1667 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1668 	if !ok {
   1669 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1670 	}
   1671 
   1672 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1673 		return out, metadata, awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response, &metadata)
   1674 	}
   1675 	output := &CreateReusableDelegationSetOutput{}
   1676 	out.Result = output
   1677 
   1678 	err = awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(output, response)
   1679 	if err != nil {
   1680 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1681 	}
   1682 
   1683 	var buff [1024]byte
   1684 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1685 	body := io.TeeReader(response.Body, ringBuffer)
   1686 	rootDecoder := xml.NewDecoder(body)
   1687 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1688 	if err == io.EOF {
   1689 		return out, metadata, nil
   1690 	}
   1691 	if err != nil {
   1692 		var snapshot bytes.Buffer
   1693 		io.Copy(&snapshot, ringBuffer)
   1694 		return out, metadata, &smithy.DeserializationError{
   1695 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1696 			Snapshot: snapshot.Bytes(),
   1697 		}
   1698 	}
   1699 
   1700 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1701 	err = awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(&output, decoder)
   1702 	if err != nil {
   1703 		var snapshot bytes.Buffer
   1704 		io.Copy(&snapshot, ringBuffer)
   1705 		return out, metadata, &smithy.DeserializationError{
   1706 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1707 			Snapshot: snapshot.Bytes(),
   1708 		}
   1709 	}
   1710 
   1711 	span.End()
   1712 	return out, metadata, err
   1713 }
   1714 
   1715 func awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1716 	var errorBuffer bytes.Buffer
   1717 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1718 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1719 	}
   1720 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1721 
   1722 	errorCode := "UnknownError"
   1723 	errorMessage := errorCode
   1724 
   1725 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1726 	if err != nil {
   1727 		return err
   1728 	}
   1729 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1730 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1731 	}
   1732 	if len(errorComponents.Code) != 0 {
   1733 		errorCode = errorComponents.Code
   1734 	}
   1735 	if len(errorComponents.Message) != 0 {
   1736 		errorMessage = errorComponents.Message
   1737 	}
   1738 	errorBody.Seek(0, io.SeekStart)
   1739 	switch {
   1740 	case strings.EqualFold("DelegationSetAlreadyCreated", errorCode):
   1741 		return awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response, errorBody)
   1742 
   1743 	case strings.EqualFold("DelegationSetAlreadyReusable", errorCode):
   1744 		return awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response, errorBody)
   1745 
   1746 	case strings.EqualFold("DelegationSetNotAvailable", errorCode):
   1747 		return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody)
   1748 
   1749 	case strings.EqualFold("HostedZoneNotFound", errorCode):
   1750 		return awsRestxml_deserializeErrorHostedZoneNotFound(response, errorBody)
   1751 
   1752 	case strings.EqualFold("InvalidArgument", errorCode):
   1753 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   1754 
   1755 	case strings.EqualFold("InvalidInput", errorCode):
   1756 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1757 
   1758 	case strings.EqualFold("LimitsExceeded", errorCode):
   1759 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
   1760 
   1761 	default:
   1762 		genericError := &smithy.GenericAPIError{
   1763 			Code:    errorCode,
   1764 			Message: errorMessage,
   1765 		}
   1766 		return genericError
   1767 
   1768 	}
   1769 }
   1770 
   1771 func awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(v *CreateReusableDelegationSetOutput, response *smithyhttp.Response) error {
   1772 	if v == nil {
   1773 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1774 	}
   1775 
   1776 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1777 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1778 		v.Location = ptr.String(headerValues[0])
   1779 	}
   1780 
   1781 	return nil
   1782 }
   1783 func awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(v **CreateReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error {
   1784 	if v == nil {
   1785 		return fmt.Errorf("unexpected nil of type %T", v)
   1786 	}
   1787 	var sv *CreateReusableDelegationSetOutput
   1788 	if *v == nil {
   1789 		sv = &CreateReusableDelegationSetOutput{}
   1790 	} else {
   1791 		sv = *v
   1792 	}
   1793 
   1794 	for {
   1795 		t, done, err := decoder.Token()
   1796 		if err != nil {
   1797 			return err
   1798 		}
   1799 		if done {
   1800 			break
   1801 		}
   1802 		originalDecoder := decoder
   1803 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1804 		switch {
   1805 		case strings.EqualFold("DelegationSet", t.Name.Local):
   1806 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1807 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   1808 				return err
   1809 			}
   1810 
   1811 		default:
   1812 			// Do nothing and ignore the unexpected tag element
   1813 			err = decoder.Decoder.Skip()
   1814 			if err != nil {
   1815 				return err
   1816 			}
   1817 
   1818 		}
   1819 		decoder = originalDecoder
   1820 	}
   1821 	*v = sv
   1822 	return nil
   1823 }
   1824 
   1825 type awsRestxml_deserializeOpCreateTrafficPolicy struct {
   1826 }
   1827 
   1828 func (*awsRestxml_deserializeOpCreateTrafficPolicy) ID() string {
   1829 	return "OperationDeserializer"
   1830 }
   1831 
   1832 func (m *awsRestxml_deserializeOpCreateTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1833 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1834 ) {
   1835 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1836 	if err != nil {
   1837 		return out, metadata, err
   1838 	}
   1839 
   1840 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1841 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1842 	defer endTimer()
   1843 	defer span.End()
   1844 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1845 	if !ok {
   1846 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1847 	}
   1848 
   1849 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1850 		return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicy(response, &metadata)
   1851 	}
   1852 	output := &CreateTrafficPolicyOutput{}
   1853 	out.Result = output
   1854 
   1855 	err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(output, response)
   1856 	if err != nil {
   1857 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1858 	}
   1859 
   1860 	var buff [1024]byte
   1861 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1862 	body := io.TeeReader(response.Body, ringBuffer)
   1863 	rootDecoder := xml.NewDecoder(body)
   1864 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1865 	if err == io.EOF {
   1866 		return out, metadata, nil
   1867 	}
   1868 	if err != nil {
   1869 		var snapshot bytes.Buffer
   1870 		io.Copy(&snapshot, ringBuffer)
   1871 		return out, metadata, &smithy.DeserializationError{
   1872 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1873 			Snapshot: snapshot.Bytes(),
   1874 		}
   1875 	}
   1876 
   1877 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1878 	err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(&output, decoder)
   1879 	if err != nil {
   1880 		var snapshot bytes.Buffer
   1881 		io.Copy(&snapshot, ringBuffer)
   1882 		return out, metadata, &smithy.DeserializationError{
   1883 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1884 			Snapshot: snapshot.Bytes(),
   1885 		}
   1886 	}
   1887 
   1888 	span.End()
   1889 	return out, metadata, err
   1890 }
   1891 
   1892 func awsRestxml_deserializeOpErrorCreateTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1893 	var errorBuffer bytes.Buffer
   1894 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1895 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1896 	}
   1897 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1898 
   1899 	errorCode := "UnknownError"
   1900 	errorMessage := errorCode
   1901 
   1902 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1903 	if err != nil {
   1904 		return err
   1905 	}
   1906 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1907 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1908 	}
   1909 	if len(errorComponents.Code) != 0 {
   1910 		errorCode = errorComponents.Code
   1911 	}
   1912 	if len(errorComponents.Message) != 0 {
   1913 		errorMessage = errorComponents.Message
   1914 	}
   1915 	errorBody.Seek(0, io.SeekStart)
   1916 	switch {
   1917 	case strings.EqualFold("InvalidInput", errorCode):
   1918 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1919 
   1920 	case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode):
   1921 		return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody)
   1922 
   1923 	case strings.EqualFold("TooManyTrafficPolicies", errorCode):
   1924 		return awsRestxml_deserializeErrorTooManyTrafficPolicies(response, errorBody)
   1925 
   1926 	case strings.EqualFold("TrafficPolicyAlreadyExists", errorCode):
   1927 		return awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response, errorBody)
   1928 
   1929 	default:
   1930 		genericError := &smithy.GenericAPIError{
   1931 			Code:    errorCode,
   1932 			Message: errorMessage,
   1933 		}
   1934 		return genericError
   1935 
   1936 	}
   1937 }
   1938 
   1939 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(v *CreateTrafficPolicyOutput, response *smithyhttp.Response) error {
   1940 	if v == nil {
   1941 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1942 	}
   1943 
   1944 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1945 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1946 		v.Location = ptr.String(headerValues[0])
   1947 	}
   1948 
   1949 	return nil
   1950 }
   1951 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(v **CreateTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error {
   1952 	if v == nil {
   1953 		return fmt.Errorf("unexpected nil of type %T", v)
   1954 	}
   1955 	var sv *CreateTrafficPolicyOutput
   1956 	if *v == nil {
   1957 		sv = &CreateTrafficPolicyOutput{}
   1958 	} else {
   1959 		sv = *v
   1960 	}
   1961 
   1962 	for {
   1963 		t, done, err := decoder.Token()
   1964 		if err != nil {
   1965 			return err
   1966 		}
   1967 		if done {
   1968 			break
   1969 		}
   1970 		originalDecoder := decoder
   1971 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1972 		switch {
   1973 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
   1974 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1975 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
   1976 				return err
   1977 			}
   1978 
   1979 		default:
   1980 			// Do nothing and ignore the unexpected tag element
   1981 			err = decoder.Decoder.Skip()
   1982 			if err != nil {
   1983 				return err
   1984 			}
   1985 
   1986 		}
   1987 		decoder = originalDecoder
   1988 	}
   1989 	*v = sv
   1990 	return nil
   1991 }
   1992 
   1993 type awsRestxml_deserializeOpCreateTrafficPolicyInstance struct {
   1994 }
   1995 
   1996 func (*awsRestxml_deserializeOpCreateTrafficPolicyInstance) ID() string {
   1997 	return "OperationDeserializer"
   1998 }
   1999 
   2000 func (m *awsRestxml_deserializeOpCreateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2001 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2002 ) {
   2003 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2004 	if err != nil {
   2005 		return out, metadata, err
   2006 	}
   2007 
   2008 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2009 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2010 	defer endTimer()
   2011 	defer span.End()
   2012 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2013 	if !ok {
   2014 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2015 	}
   2016 
   2017 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2018 		return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response, &metadata)
   2019 	}
   2020 	output := &CreateTrafficPolicyInstanceOutput{}
   2021 	out.Result = output
   2022 
   2023 	err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(output, response)
   2024 	if err != nil {
   2025 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   2026 	}
   2027 
   2028 	var buff [1024]byte
   2029 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2030 	body := io.TeeReader(response.Body, ringBuffer)
   2031 	rootDecoder := xml.NewDecoder(body)
   2032 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2033 	if err == io.EOF {
   2034 		return out, metadata, nil
   2035 	}
   2036 	if err != nil {
   2037 		var snapshot bytes.Buffer
   2038 		io.Copy(&snapshot, ringBuffer)
   2039 		return out, metadata, &smithy.DeserializationError{
   2040 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2041 			Snapshot: snapshot.Bytes(),
   2042 		}
   2043 	}
   2044 
   2045 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2046 	err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(&output, decoder)
   2047 	if err != nil {
   2048 		var snapshot bytes.Buffer
   2049 		io.Copy(&snapshot, ringBuffer)
   2050 		return out, metadata, &smithy.DeserializationError{
   2051 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2052 			Snapshot: snapshot.Bytes(),
   2053 		}
   2054 	}
   2055 
   2056 	span.End()
   2057 	return out, metadata, err
   2058 }
   2059 
   2060 func awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2061 	var errorBuffer bytes.Buffer
   2062 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2063 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2064 	}
   2065 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2066 
   2067 	errorCode := "UnknownError"
   2068 	errorMessage := errorCode
   2069 
   2070 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2071 	if err != nil {
   2072 		return err
   2073 	}
   2074 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2075 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2076 	}
   2077 	if len(errorComponents.Code) != 0 {
   2078 		errorCode = errorComponents.Code
   2079 	}
   2080 	if len(errorComponents.Message) != 0 {
   2081 		errorMessage = errorComponents.Message
   2082 	}
   2083 	errorBody.Seek(0, io.SeekStart)
   2084 	switch {
   2085 	case strings.EqualFold("InvalidInput", errorCode):
   2086 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2087 
   2088 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   2089 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   2090 
   2091 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   2092 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   2093 
   2094 	case strings.EqualFold("TooManyTrafficPolicyInstances", errorCode):
   2095 		return awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response, errorBody)
   2096 
   2097 	case strings.EqualFold("TrafficPolicyInstanceAlreadyExists", errorCode):
   2098 		return awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response, errorBody)
   2099 
   2100 	default:
   2101 		genericError := &smithy.GenericAPIError{
   2102 			Code:    errorCode,
   2103 			Message: errorMessage,
   2104 		}
   2105 		return genericError
   2106 
   2107 	}
   2108 }
   2109 
   2110 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(v *CreateTrafficPolicyInstanceOutput, response *smithyhttp.Response) error {
   2111 	if v == nil {
   2112 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   2113 	}
   2114 
   2115 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   2116 		headerValues[0] = strings.TrimSpace(headerValues[0])
   2117 		v.Location = ptr.String(headerValues[0])
   2118 	}
   2119 
   2120 	return nil
   2121 }
   2122 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(v **CreateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
   2123 	if v == nil {
   2124 		return fmt.Errorf("unexpected nil of type %T", v)
   2125 	}
   2126 	var sv *CreateTrafficPolicyInstanceOutput
   2127 	if *v == nil {
   2128 		sv = &CreateTrafficPolicyInstanceOutput{}
   2129 	} else {
   2130 		sv = *v
   2131 	}
   2132 
   2133 	for {
   2134 		t, done, err := decoder.Token()
   2135 		if err != nil {
   2136 			return err
   2137 		}
   2138 		if done {
   2139 			break
   2140 		}
   2141 		originalDecoder := decoder
   2142 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2143 		switch {
   2144 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
   2145 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2146 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
   2147 				return err
   2148 			}
   2149 
   2150 		default:
   2151 			// Do nothing and ignore the unexpected tag element
   2152 			err = decoder.Decoder.Skip()
   2153 			if err != nil {
   2154 				return err
   2155 			}
   2156 
   2157 		}
   2158 		decoder = originalDecoder
   2159 	}
   2160 	*v = sv
   2161 	return nil
   2162 }
   2163 
   2164 type awsRestxml_deserializeOpCreateTrafficPolicyVersion struct {
   2165 }
   2166 
   2167 func (*awsRestxml_deserializeOpCreateTrafficPolicyVersion) ID() string {
   2168 	return "OperationDeserializer"
   2169 }
   2170 
   2171 func (m *awsRestxml_deserializeOpCreateTrafficPolicyVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2172 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2173 ) {
   2174 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2175 	if err != nil {
   2176 		return out, metadata, err
   2177 	}
   2178 
   2179 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2180 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2181 	defer endTimer()
   2182 	defer span.End()
   2183 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2184 	if !ok {
   2185 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2186 	}
   2187 
   2188 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2189 		return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response, &metadata)
   2190 	}
   2191 	output := &CreateTrafficPolicyVersionOutput{}
   2192 	out.Result = output
   2193 
   2194 	err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(output, response)
   2195 	if err != nil {
   2196 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   2197 	}
   2198 
   2199 	var buff [1024]byte
   2200 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2201 	body := io.TeeReader(response.Body, ringBuffer)
   2202 	rootDecoder := xml.NewDecoder(body)
   2203 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2204 	if err == io.EOF {
   2205 		return out, metadata, nil
   2206 	}
   2207 	if err != nil {
   2208 		var snapshot bytes.Buffer
   2209 		io.Copy(&snapshot, ringBuffer)
   2210 		return out, metadata, &smithy.DeserializationError{
   2211 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2212 			Snapshot: snapshot.Bytes(),
   2213 		}
   2214 	}
   2215 
   2216 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2217 	err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(&output, decoder)
   2218 	if err != nil {
   2219 		var snapshot bytes.Buffer
   2220 		io.Copy(&snapshot, ringBuffer)
   2221 		return out, metadata, &smithy.DeserializationError{
   2222 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2223 			Snapshot: snapshot.Bytes(),
   2224 		}
   2225 	}
   2226 
   2227 	span.End()
   2228 	return out, metadata, err
   2229 }
   2230 
   2231 func awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2232 	var errorBuffer bytes.Buffer
   2233 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2234 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2235 	}
   2236 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2237 
   2238 	errorCode := "UnknownError"
   2239 	errorMessage := errorCode
   2240 
   2241 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2242 	if err != nil {
   2243 		return err
   2244 	}
   2245 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2246 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2247 	}
   2248 	if len(errorComponents.Code) != 0 {
   2249 		errorCode = errorComponents.Code
   2250 	}
   2251 	if len(errorComponents.Message) != 0 {
   2252 		errorMessage = errorComponents.Message
   2253 	}
   2254 	errorBody.Seek(0, io.SeekStart)
   2255 	switch {
   2256 	case strings.EqualFold("ConcurrentModification", errorCode):
   2257 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2258 
   2259 	case strings.EqualFold("InvalidInput", errorCode):
   2260 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2261 
   2262 	case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode):
   2263 		return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody)
   2264 
   2265 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   2266 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   2267 
   2268 	case strings.EqualFold("TooManyTrafficPolicyVersionsForCurrentPolicy", errorCode):
   2269 		return awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response, errorBody)
   2270 
   2271 	default:
   2272 		genericError := &smithy.GenericAPIError{
   2273 			Code:    errorCode,
   2274 			Message: errorMessage,
   2275 		}
   2276 		return genericError
   2277 
   2278 	}
   2279 }
   2280 
   2281 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(v *CreateTrafficPolicyVersionOutput, response *smithyhttp.Response) error {
   2282 	if v == nil {
   2283 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   2284 	}
   2285 
   2286 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   2287 		headerValues[0] = strings.TrimSpace(headerValues[0])
   2288 		v.Location = ptr.String(headerValues[0])
   2289 	}
   2290 
   2291 	return nil
   2292 }
   2293 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(v **CreateTrafficPolicyVersionOutput, decoder smithyxml.NodeDecoder) error {
   2294 	if v == nil {
   2295 		return fmt.Errorf("unexpected nil of type %T", v)
   2296 	}
   2297 	var sv *CreateTrafficPolicyVersionOutput
   2298 	if *v == nil {
   2299 		sv = &CreateTrafficPolicyVersionOutput{}
   2300 	} else {
   2301 		sv = *v
   2302 	}
   2303 
   2304 	for {
   2305 		t, done, err := decoder.Token()
   2306 		if err != nil {
   2307 			return err
   2308 		}
   2309 		if done {
   2310 			break
   2311 		}
   2312 		originalDecoder := decoder
   2313 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2314 		switch {
   2315 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
   2316 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2317 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
   2318 				return err
   2319 			}
   2320 
   2321 		default:
   2322 			// Do nothing and ignore the unexpected tag element
   2323 			err = decoder.Decoder.Skip()
   2324 			if err != nil {
   2325 				return err
   2326 			}
   2327 
   2328 		}
   2329 		decoder = originalDecoder
   2330 	}
   2331 	*v = sv
   2332 	return nil
   2333 }
   2334 
   2335 type awsRestxml_deserializeOpCreateVPCAssociationAuthorization struct {
   2336 }
   2337 
   2338 func (*awsRestxml_deserializeOpCreateVPCAssociationAuthorization) ID() string {
   2339 	return "OperationDeserializer"
   2340 }
   2341 
   2342 func (m *awsRestxml_deserializeOpCreateVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2343 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2344 ) {
   2345 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2346 	if err != nil {
   2347 		return out, metadata, err
   2348 	}
   2349 
   2350 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2351 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2352 	defer endTimer()
   2353 	defer span.End()
   2354 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2355 	if !ok {
   2356 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2357 	}
   2358 
   2359 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2360 		return out, metadata, awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response, &metadata)
   2361 	}
   2362 	output := &CreateVPCAssociationAuthorizationOutput{}
   2363 	out.Result = output
   2364 
   2365 	var buff [1024]byte
   2366 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2367 	body := io.TeeReader(response.Body, ringBuffer)
   2368 	rootDecoder := xml.NewDecoder(body)
   2369 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2370 	if err == io.EOF {
   2371 		return out, metadata, nil
   2372 	}
   2373 	if err != nil {
   2374 		var snapshot bytes.Buffer
   2375 		io.Copy(&snapshot, ringBuffer)
   2376 		return out, metadata, &smithy.DeserializationError{
   2377 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2378 			Snapshot: snapshot.Bytes(),
   2379 		}
   2380 	}
   2381 
   2382 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2383 	err = awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(&output, decoder)
   2384 	if err != nil {
   2385 		var snapshot bytes.Buffer
   2386 		io.Copy(&snapshot, ringBuffer)
   2387 		return out, metadata, &smithy.DeserializationError{
   2388 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2389 			Snapshot: snapshot.Bytes(),
   2390 		}
   2391 	}
   2392 
   2393 	span.End()
   2394 	return out, metadata, err
   2395 }
   2396 
   2397 func awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2398 	var errorBuffer bytes.Buffer
   2399 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2400 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2401 	}
   2402 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2403 
   2404 	errorCode := "UnknownError"
   2405 	errorMessage := errorCode
   2406 
   2407 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2408 	if err != nil {
   2409 		return err
   2410 	}
   2411 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2412 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2413 	}
   2414 	if len(errorComponents.Code) != 0 {
   2415 		errorCode = errorComponents.Code
   2416 	}
   2417 	if len(errorComponents.Message) != 0 {
   2418 		errorMessage = errorComponents.Message
   2419 	}
   2420 	errorBody.Seek(0, io.SeekStart)
   2421 	switch {
   2422 	case strings.EqualFold("ConcurrentModification", errorCode):
   2423 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2424 
   2425 	case strings.EqualFold("InvalidInput", errorCode):
   2426 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2427 
   2428 	case strings.EqualFold("InvalidVPCId", errorCode):
   2429 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   2430 
   2431 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   2432 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   2433 
   2434 	case strings.EqualFold("TooManyVPCAssociationAuthorizations", errorCode):
   2435 		return awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response, errorBody)
   2436 
   2437 	default:
   2438 		genericError := &smithy.GenericAPIError{
   2439 			Code:    errorCode,
   2440 			Message: errorMessage,
   2441 		}
   2442 		return genericError
   2443 
   2444 	}
   2445 }
   2446 
   2447 func awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(v **CreateVPCAssociationAuthorizationOutput, decoder smithyxml.NodeDecoder) error {
   2448 	if v == nil {
   2449 		return fmt.Errorf("unexpected nil of type %T", v)
   2450 	}
   2451 	var sv *CreateVPCAssociationAuthorizationOutput
   2452 	if *v == nil {
   2453 		sv = &CreateVPCAssociationAuthorizationOutput{}
   2454 	} else {
   2455 		sv = *v
   2456 	}
   2457 
   2458 	for {
   2459 		t, done, err := decoder.Token()
   2460 		if err != nil {
   2461 			return err
   2462 		}
   2463 		if done {
   2464 			break
   2465 		}
   2466 		originalDecoder := decoder
   2467 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2468 		switch {
   2469 		case strings.EqualFold("HostedZoneId", t.Name.Local):
   2470 			val, err := decoder.Value()
   2471 			if err != nil {
   2472 				return err
   2473 			}
   2474 			if val == nil {
   2475 				break
   2476 			}
   2477 			{
   2478 				xtv := string(val)
   2479 				sv.HostedZoneId = ptr.String(xtv)
   2480 			}
   2481 
   2482 		case strings.EqualFold("VPC", t.Name.Local):
   2483 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2484 			if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil {
   2485 				return err
   2486 			}
   2487 
   2488 		default:
   2489 			// Do nothing and ignore the unexpected tag element
   2490 			err = decoder.Decoder.Skip()
   2491 			if err != nil {
   2492 				return err
   2493 			}
   2494 
   2495 		}
   2496 		decoder = originalDecoder
   2497 	}
   2498 	*v = sv
   2499 	return nil
   2500 }
   2501 
   2502 type awsRestxml_deserializeOpDeactivateKeySigningKey struct {
   2503 }
   2504 
   2505 func (*awsRestxml_deserializeOpDeactivateKeySigningKey) ID() string {
   2506 	return "OperationDeserializer"
   2507 }
   2508 
   2509 func (m *awsRestxml_deserializeOpDeactivateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2510 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2511 ) {
   2512 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2513 	if err != nil {
   2514 		return out, metadata, err
   2515 	}
   2516 
   2517 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2518 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2519 	defer endTimer()
   2520 	defer span.End()
   2521 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2522 	if !ok {
   2523 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2524 	}
   2525 
   2526 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2527 		return out, metadata, awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response, &metadata)
   2528 	}
   2529 	output := &DeactivateKeySigningKeyOutput{}
   2530 	out.Result = output
   2531 
   2532 	var buff [1024]byte
   2533 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2534 	body := io.TeeReader(response.Body, ringBuffer)
   2535 	rootDecoder := xml.NewDecoder(body)
   2536 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2537 	if err == io.EOF {
   2538 		return out, metadata, nil
   2539 	}
   2540 	if err != nil {
   2541 		var snapshot bytes.Buffer
   2542 		io.Copy(&snapshot, ringBuffer)
   2543 		return out, metadata, &smithy.DeserializationError{
   2544 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2545 			Snapshot: snapshot.Bytes(),
   2546 		}
   2547 	}
   2548 
   2549 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2550 	err = awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(&output, decoder)
   2551 	if err != nil {
   2552 		var snapshot bytes.Buffer
   2553 		io.Copy(&snapshot, ringBuffer)
   2554 		return out, metadata, &smithy.DeserializationError{
   2555 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2556 			Snapshot: snapshot.Bytes(),
   2557 		}
   2558 	}
   2559 
   2560 	span.End()
   2561 	return out, metadata, err
   2562 }
   2563 
   2564 func awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2565 	var errorBuffer bytes.Buffer
   2566 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2567 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2568 	}
   2569 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2570 
   2571 	errorCode := "UnknownError"
   2572 	errorMessage := errorCode
   2573 
   2574 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2575 	if err != nil {
   2576 		return err
   2577 	}
   2578 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2579 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2580 	}
   2581 	if len(errorComponents.Code) != 0 {
   2582 		errorCode = errorComponents.Code
   2583 	}
   2584 	if len(errorComponents.Message) != 0 {
   2585 		errorMessage = errorComponents.Message
   2586 	}
   2587 	errorBody.Seek(0, io.SeekStart)
   2588 	switch {
   2589 	case strings.EqualFold("ConcurrentModification", errorCode):
   2590 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2591 
   2592 	case strings.EqualFold("InvalidInput", errorCode):
   2593 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2594 
   2595 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   2596 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   2597 
   2598 	case strings.EqualFold("InvalidSigningStatus", errorCode):
   2599 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
   2600 
   2601 	case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode):
   2602 		return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody)
   2603 
   2604 	case strings.EqualFold("KeySigningKeyInUse", errorCode):
   2605 		return awsRestxml_deserializeErrorKeySigningKeyInUse(response, errorBody)
   2606 
   2607 	case strings.EqualFold("NoSuchKeySigningKey", errorCode):
   2608 		return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
   2609 
   2610 	default:
   2611 		genericError := &smithy.GenericAPIError{
   2612 			Code:    errorCode,
   2613 			Message: errorMessage,
   2614 		}
   2615 		return genericError
   2616 
   2617 	}
   2618 }
   2619 
   2620 func awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(v **DeactivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
   2621 	if v == nil {
   2622 		return fmt.Errorf("unexpected nil of type %T", v)
   2623 	}
   2624 	var sv *DeactivateKeySigningKeyOutput
   2625 	if *v == nil {
   2626 		sv = &DeactivateKeySigningKeyOutput{}
   2627 	} else {
   2628 		sv = *v
   2629 	}
   2630 
   2631 	for {
   2632 		t, done, err := decoder.Token()
   2633 		if err != nil {
   2634 			return err
   2635 		}
   2636 		if done {
   2637 			break
   2638 		}
   2639 		originalDecoder := decoder
   2640 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2641 		switch {
   2642 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   2643 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2644 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   2645 				return err
   2646 			}
   2647 
   2648 		default:
   2649 			// Do nothing and ignore the unexpected tag element
   2650 			err = decoder.Decoder.Skip()
   2651 			if err != nil {
   2652 				return err
   2653 			}
   2654 
   2655 		}
   2656 		decoder = originalDecoder
   2657 	}
   2658 	*v = sv
   2659 	return nil
   2660 }
   2661 
   2662 type awsRestxml_deserializeOpDeleteCidrCollection struct {
   2663 }
   2664 
   2665 func (*awsRestxml_deserializeOpDeleteCidrCollection) ID() string {
   2666 	return "OperationDeserializer"
   2667 }
   2668 
   2669 func (m *awsRestxml_deserializeOpDeleteCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2670 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2671 ) {
   2672 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2673 	if err != nil {
   2674 		return out, metadata, err
   2675 	}
   2676 
   2677 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2678 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2679 	defer endTimer()
   2680 	defer span.End()
   2681 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2682 	if !ok {
   2683 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2684 	}
   2685 
   2686 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2687 		return out, metadata, awsRestxml_deserializeOpErrorDeleteCidrCollection(response, &metadata)
   2688 	}
   2689 	output := &DeleteCidrCollectionOutput{}
   2690 	out.Result = output
   2691 
   2692 	span.End()
   2693 	return out, metadata, err
   2694 }
   2695 
   2696 func awsRestxml_deserializeOpErrorDeleteCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2697 	var errorBuffer bytes.Buffer
   2698 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2699 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2700 	}
   2701 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2702 
   2703 	errorCode := "UnknownError"
   2704 	errorMessage := errorCode
   2705 
   2706 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2707 	if err != nil {
   2708 		return err
   2709 	}
   2710 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2711 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2712 	}
   2713 	if len(errorComponents.Code) != 0 {
   2714 		errorCode = errorComponents.Code
   2715 	}
   2716 	if len(errorComponents.Message) != 0 {
   2717 		errorMessage = errorComponents.Message
   2718 	}
   2719 	errorBody.Seek(0, io.SeekStart)
   2720 	switch {
   2721 	case strings.EqualFold("CidrCollectionInUseException", errorCode):
   2722 		return awsRestxml_deserializeErrorCidrCollectionInUseException(response, errorBody)
   2723 
   2724 	case strings.EqualFold("ConcurrentModification", errorCode):
   2725 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2726 
   2727 	case strings.EqualFold("InvalidInput", errorCode):
   2728 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2729 
   2730 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
   2731 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
   2732 
   2733 	default:
   2734 		genericError := &smithy.GenericAPIError{
   2735 			Code:    errorCode,
   2736 			Message: errorMessage,
   2737 		}
   2738 		return genericError
   2739 
   2740 	}
   2741 }
   2742 
   2743 type awsRestxml_deserializeOpDeleteHealthCheck struct {
   2744 }
   2745 
   2746 func (*awsRestxml_deserializeOpDeleteHealthCheck) ID() string {
   2747 	return "OperationDeserializer"
   2748 }
   2749 
   2750 func (m *awsRestxml_deserializeOpDeleteHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2751 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2752 ) {
   2753 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2754 	if err != nil {
   2755 		return out, metadata, err
   2756 	}
   2757 
   2758 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2759 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2760 	defer endTimer()
   2761 	defer span.End()
   2762 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2763 	if !ok {
   2764 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2765 	}
   2766 
   2767 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2768 		return out, metadata, awsRestxml_deserializeOpErrorDeleteHealthCheck(response, &metadata)
   2769 	}
   2770 	output := &DeleteHealthCheckOutput{}
   2771 	out.Result = output
   2772 
   2773 	span.End()
   2774 	return out, metadata, err
   2775 }
   2776 
   2777 func awsRestxml_deserializeOpErrorDeleteHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2778 	var errorBuffer bytes.Buffer
   2779 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2780 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2781 	}
   2782 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2783 
   2784 	errorCode := "UnknownError"
   2785 	errorMessage := errorCode
   2786 
   2787 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2788 	if err != nil {
   2789 		return err
   2790 	}
   2791 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2792 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2793 	}
   2794 	if len(errorComponents.Code) != 0 {
   2795 		errorCode = errorComponents.Code
   2796 	}
   2797 	if len(errorComponents.Message) != 0 {
   2798 		errorMessage = errorComponents.Message
   2799 	}
   2800 	errorBody.Seek(0, io.SeekStart)
   2801 	switch {
   2802 	case strings.EqualFold("HealthCheckInUse", errorCode):
   2803 		return awsRestxml_deserializeErrorHealthCheckInUse(response, errorBody)
   2804 
   2805 	case strings.EqualFold("InvalidInput", errorCode):
   2806 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2807 
   2808 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   2809 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   2810 
   2811 	default:
   2812 		genericError := &smithy.GenericAPIError{
   2813 			Code:    errorCode,
   2814 			Message: errorMessage,
   2815 		}
   2816 		return genericError
   2817 
   2818 	}
   2819 }
   2820 
   2821 type awsRestxml_deserializeOpDeleteHostedZone struct {
   2822 }
   2823 
   2824 func (*awsRestxml_deserializeOpDeleteHostedZone) ID() string {
   2825 	return "OperationDeserializer"
   2826 }
   2827 
   2828 func (m *awsRestxml_deserializeOpDeleteHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2829 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2830 ) {
   2831 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2832 	if err != nil {
   2833 		return out, metadata, err
   2834 	}
   2835 
   2836 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2837 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2838 	defer endTimer()
   2839 	defer span.End()
   2840 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2841 	if !ok {
   2842 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2843 	}
   2844 
   2845 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2846 		return out, metadata, awsRestxml_deserializeOpErrorDeleteHostedZone(response, &metadata)
   2847 	}
   2848 	output := &DeleteHostedZoneOutput{}
   2849 	out.Result = output
   2850 
   2851 	var buff [1024]byte
   2852 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2853 	body := io.TeeReader(response.Body, ringBuffer)
   2854 	rootDecoder := xml.NewDecoder(body)
   2855 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2856 	if err == io.EOF {
   2857 		return out, metadata, nil
   2858 	}
   2859 	if err != nil {
   2860 		var snapshot bytes.Buffer
   2861 		io.Copy(&snapshot, ringBuffer)
   2862 		return out, metadata, &smithy.DeserializationError{
   2863 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2864 			Snapshot: snapshot.Bytes(),
   2865 		}
   2866 	}
   2867 
   2868 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2869 	err = awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(&output, decoder)
   2870 	if err != nil {
   2871 		var snapshot bytes.Buffer
   2872 		io.Copy(&snapshot, ringBuffer)
   2873 		return out, metadata, &smithy.DeserializationError{
   2874 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2875 			Snapshot: snapshot.Bytes(),
   2876 		}
   2877 	}
   2878 
   2879 	span.End()
   2880 	return out, metadata, err
   2881 }
   2882 
   2883 func awsRestxml_deserializeOpErrorDeleteHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2884 	var errorBuffer bytes.Buffer
   2885 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2886 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2887 	}
   2888 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2889 
   2890 	errorCode := "UnknownError"
   2891 	errorMessage := errorCode
   2892 
   2893 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2894 	if err != nil {
   2895 		return err
   2896 	}
   2897 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2898 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2899 	}
   2900 	if len(errorComponents.Code) != 0 {
   2901 		errorCode = errorComponents.Code
   2902 	}
   2903 	if len(errorComponents.Message) != 0 {
   2904 		errorMessage = errorComponents.Message
   2905 	}
   2906 	errorBody.Seek(0, io.SeekStart)
   2907 	switch {
   2908 	case strings.EqualFold("HostedZoneNotEmpty", errorCode):
   2909 		return awsRestxml_deserializeErrorHostedZoneNotEmpty(response, errorBody)
   2910 
   2911 	case strings.EqualFold("InvalidDomainName", errorCode):
   2912 		return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
   2913 
   2914 	case strings.EqualFold("InvalidInput", errorCode):
   2915 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2916 
   2917 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   2918 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   2919 
   2920 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   2921 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   2922 
   2923 	default:
   2924 		genericError := &smithy.GenericAPIError{
   2925 			Code:    errorCode,
   2926 			Message: errorMessage,
   2927 		}
   2928 		return genericError
   2929 
   2930 	}
   2931 }
   2932 
   2933 func awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(v **DeleteHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   2934 	if v == nil {
   2935 		return fmt.Errorf("unexpected nil of type %T", v)
   2936 	}
   2937 	var sv *DeleteHostedZoneOutput
   2938 	if *v == nil {
   2939 		sv = &DeleteHostedZoneOutput{}
   2940 	} else {
   2941 		sv = *v
   2942 	}
   2943 
   2944 	for {
   2945 		t, done, err := decoder.Token()
   2946 		if err != nil {
   2947 			return err
   2948 		}
   2949 		if done {
   2950 			break
   2951 		}
   2952 		originalDecoder := decoder
   2953 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2954 		switch {
   2955 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   2956 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2957 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   2958 				return err
   2959 			}
   2960 
   2961 		default:
   2962 			// Do nothing and ignore the unexpected tag element
   2963 			err = decoder.Decoder.Skip()
   2964 			if err != nil {
   2965 				return err
   2966 			}
   2967 
   2968 		}
   2969 		decoder = originalDecoder
   2970 	}
   2971 	*v = sv
   2972 	return nil
   2973 }
   2974 
   2975 type awsRestxml_deserializeOpDeleteKeySigningKey struct {
   2976 }
   2977 
   2978 func (*awsRestxml_deserializeOpDeleteKeySigningKey) ID() string {
   2979 	return "OperationDeserializer"
   2980 }
   2981 
   2982 func (m *awsRestxml_deserializeOpDeleteKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2983 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2984 ) {
   2985 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2986 	if err != nil {
   2987 		return out, metadata, err
   2988 	}
   2989 
   2990 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   2991 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   2992 	defer endTimer()
   2993 	defer span.End()
   2994 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2995 	if !ok {
   2996 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2997 	}
   2998 
   2999 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3000 		return out, metadata, awsRestxml_deserializeOpErrorDeleteKeySigningKey(response, &metadata)
   3001 	}
   3002 	output := &DeleteKeySigningKeyOutput{}
   3003 	out.Result = output
   3004 
   3005 	var buff [1024]byte
   3006 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3007 	body := io.TeeReader(response.Body, ringBuffer)
   3008 	rootDecoder := xml.NewDecoder(body)
   3009 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3010 	if err == io.EOF {
   3011 		return out, metadata, nil
   3012 	}
   3013 	if err != nil {
   3014 		var snapshot bytes.Buffer
   3015 		io.Copy(&snapshot, ringBuffer)
   3016 		return out, metadata, &smithy.DeserializationError{
   3017 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3018 			Snapshot: snapshot.Bytes(),
   3019 		}
   3020 	}
   3021 
   3022 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3023 	err = awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(&output, decoder)
   3024 	if err != nil {
   3025 		var snapshot bytes.Buffer
   3026 		io.Copy(&snapshot, ringBuffer)
   3027 		return out, metadata, &smithy.DeserializationError{
   3028 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3029 			Snapshot: snapshot.Bytes(),
   3030 		}
   3031 	}
   3032 
   3033 	span.End()
   3034 	return out, metadata, err
   3035 }
   3036 
   3037 func awsRestxml_deserializeOpErrorDeleteKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3038 	var errorBuffer bytes.Buffer
   3039 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3040 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3041 	}
   3042 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3043 
   3044 	errorCode := "UnknownError"
   3045 	errorMessage := errorCode
   3046 
   3047 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3048 	if err != nil {
   3049 		return err
   3050 	}
   3051 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3052 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3053 	}
   3054 	if len(errorComponents.Code) != 0 {
   3055 		errorCode = errorComponents.Code
   3056 	}
   3057 	if len(errorComponents.Message) != 0 {
   3058 		errorMessage = errorComponents.Message
   3059 	}
   3060 	errorBody.Seek(0, io.SeekStart)
   3061 	switch {
   3062 	case strings.EqualFold("ConcurrentModification", errorCode):
   3063 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3064 
   3065 	case strings.EqualFold("InvalidInput", errorCode):
   3066 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3067 
   3068 	case strings.EqualFold("InvalidKMSArn", errorCode):
   3069 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   3070 
   3071 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   3072 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   3073 
   3074 	case strings.EqualFold("InvalidSigningStatus", errorCode):
   3075 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
   3076 
   3077 	case strings.EqualFold("NoSuchKeySigningKey", errorCode):
   3078 		return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
   3079 
   3080 	default:
   3081 		genericError := &smithy.GenericAPIError{
   3082 			Code:    errorCode,
   3083 			Message: errorMessage,
   3084 		}
   3085 		return genericError
   3086 
   3087 	}
   3088 }
   3089 
   3090 func awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(v **DeleteKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
   3091 	if v == nil {
   3092 		return fmt.Errorf("unexpected nil of type %T", v)
   3093 	}
   3094 	var sv *DeleteKeySigningKeyOutput
   3095 	if *v == nil {
   3096 		sv = &DeleteKeySigningKeyOutput{}
   3097 	} else {
   3098 		sv = *v
   3099 	}
   3100 
   3101 	for {
   3102 		t, done, err := decoder.Token()
   3103 		if err != nil {
   3104 			return err
   3105 		}
   3106 		if done {
   3107 			break
   3108 		}
   3109 		originalDecoder := decoder
   3110 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3111 		switch {
   3112 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3113 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3114 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3115 				return err
   3116 			}
   3117 
   3118 		default:
   3119 			// Do nothing and ignore the unexpected tag element
   3120 			err = decoder.Decoder.Skip()
   3121 			if err != nil {
   3122 				return err
   3123 			}
   3124 
   3125 		}
   3126 		decoder = originalDecoder
   3127 	}
   3128 	*v = sv
   3129 	return nil
   3130 }
   3131 
   3132 type awsRestxml_deserializeOpDeleteQueryLoggingConfig struct {
   3133 }
   3134 
   3135 func (*awsRestxml_deserializeOpDeleteQueryLoggingConfig) ID() string {
   3136 	return "OperationDeserializer"
   3137 }
   3138 
   3139 func (m *awsRestxml_deserializeOpDeleteQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3140 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3141 ) {
   3142 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3143 	if err != nil {
   3144 		return out, metadata, err
   3145 	}
   3146 
   3147 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3148 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3149 	defer endTimer()
   3150 	defer span.End()
   3151 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3152 	if !ok {
   3153 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3154 	}
   3155 
   3156 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3157 		return out, metadata, awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response, &metadata)
   3158 	}
   3159 	output := &DeleteQueryLoggingConfigOutput{}
   3160 	out.Result = output
   3161 
   3162 	span.End()
   3163 	return out, metadata, err
   3164 }
   3165 
   3166 func awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3167 	var errorBuffer bytes.Buffer
   3168 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3169 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3170 	}
   3171 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3172 
   3173 	errorCode := "UnknownError"
   3174 	errorMessage := errorCode
   3175 
   3176 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3177 	if err != nil {
   3178 		return err
   3179 	}
   3180 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3181 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3182 	}
   3183 	if len(errorComponents.Code) != 0 {
   3184 		errorCode = errorComponents.Code
   3185 	}
   3186 	if len(errorComponents.Message) != 0 {
   3187 		errorMessage = errorComponents.Message
   3188 	}
   3189 	errorBody.Seek(0, io.SeekStart)
   3190 	switch {
   3191 	case strings.EqualFold("ConcurrentModification", errorCode):
   3192 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3193 
   3194 	case strings.EqualFold("InvalidInput", errorCode):
   3195 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3196 
   3197 	case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode):
   3198 		return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody)
   3199 
   3200 	default:
   3201 		genericError := &smithy.GenericAPIError{
   3202 			Code:    errorCode,
   3203 			Message: errorMessage,
   3204 		}
   3205 		return genericError
   3206 
   3207 	}
   3208 }
   3209 
   3210 type awsRestxml_deserializeOpDeleteReusableDelegationSet struct {
   3211 }
   3212 
   3213 func (*awsRestxml_deserializeOpDeleteReusableDelegationSet) ID() string {
   3214 	return "OperationDeserializer"
   3215 }
   3216 
   3217 func (m *awsRestxml_deserializeOpDeleteReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3218 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3219 ) {
   3220 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3221 	if err != nil {
   3222 		return out, metadata, err
   3223 	}
   3224 
   3225 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3226 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3227 	defer endTimer()
   3228 	defer span.End()
   3229 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3230 	if !ok {
   3231 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3232 	}
   3233 
   3234 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3235 		return out, metadata, awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response, &metadata)
   3236 	}
   3237 	output := &DeleteReusableDelegationSetOutput{}
   3238 	out.Result = output
   3239 
   3240 	span.End()
   3241 	return out, metadata, err
   3242 }
   3243 
   3244 func awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3245 	var errorBuffer bytes.Buffer
   3246 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3247 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3248 	}
   3249 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3250 
   3251 	errorCode := "UnknownError"
   3252 	errorMessage := errorCode
   3253 
   3254 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3255 	if err != nil {
   3256 		return err
   3257 	}
   3258 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3259 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3260 	}
   3261 	if len(errorComponents.Code) != 0 {
   3262 		errorCode = errorComponents.Code
   3263 	}
   3264 	if len(errorComponents.Message) != 0 {
   3265 		errorMessage = errorComponents.Message
   3266 	}
   3267 	errorBody.Seek(0, io.SeekStart)
   3268 	switch {
   3269 	case strings.EqualFold("DelegationSetInUse", errorCode):
   3270 		return awsRestxml_deserializeErrorDelegationSetInUse(response, errorBody)
   3271 
   3272 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   3273 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   3274 
   3275 	case strings.EqualFold("InvalidInput", errorCode):
   3276 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3277 
   3278 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   3279 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   3280 
   3281 	default:
   3282 		genericError := &smithy.GenericAPIError{
   3283 			Code:    errorCode,
   3284 			Message: errorMessage,
   3285 		}
   3286 		return genericError
   3287 
   3288 	}
   3289 }
   3290 
   3291 type awsRestxml_deserializeOpDeleteTrafficPolicy struct {
   3292 }
   3293 
   3294 func (*awsRestxml_deserializeOpDeleteTrafficPolicy) ID() string {
   3295 	return "OperationDeserializer"
   3296 }
   3297 
   3298 func (m *awsRestxml_deserializeOpDeleteTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3299 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3300 ) {
   3301 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3302 	if err != nil {
   3303 		return out, metadata, err
   3304 	}
   3305 
   3306 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3307 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3308 	defer endTimer()
   3309 	defer span.End()
   3310 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3311 	if !ok {
   3312 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3313 	}
   3314 
   3315 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3316 		return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response, &metadata)
   3317 	}
   3318 	output := &DeleteTrafficPolicyOutput{}
   3319 	out.Result = output
   3320 
   3321 	span.End()
   3322 	return out, metadata, err
   3323 }
   3324 
   3325 func awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3326 	var errorBuffer bytes.Buffer
   3327 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3328 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3329 	}
   3330 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3331 
   3332 	errorCode := "UnknownError"
   3333 	errorMessage := errorCode
   3334 
   3335 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3336 	if err != nil {
   3337 		return err
   3338 	}
   3339 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3340 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3341 	}
   3342 	if len(errorComponents.Code) != 0 {
   3343 		errorCode = errorComponents.Code
   3344 	}
   3345 	if len(errorComponents.Message) != 0 {
   3346 		errorMessage = errorComponents.Message
   3347 	}
   3348 	errorBody.Seek(0, io.SeekStart)
   3349 	switch {
   3350 	case strings.EqualFold("ConcurrentModification", errorCode):
   3351 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3352 
   3353 	case strings.EqualFold("InvalidInput", errorCode):
   3354 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3355 
   3356 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   3357 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   3358 
   3359 	case strings.EqualFold("TrafficPolicyInUse", errorCode):
   3360 		return awsRestxml_deserializeErrorTrafficPolicyInUse(response, errorBody)
   3361 
   3362 	default:
   3363 		genericError := &smithy.GenericAPIError{
   3364 			Code:    errorCode,
   3365 			Message: errorMessage,
   3366 		}
   3367 		return genericError
   3368 
   3369 	}
   3370 }
   3371 
   3372 type awsRestxml_deserializeOpDeleteTrafficPolicyInstance struct {
   3373 }
   3374 
   3375 func (*awsRestxml_deserializeOpDeleteTrafficPolicyInstance) ID() string {
   3376 	return "OperationDeserializer"
   3377 }
   3378 
   3379 func (m *awsRestxml_deserializeOpDeleteTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3380 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3381 ) {
   3382 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3383 	if err != nil {
   3384 		return out, metadata, err
   3385 	}
   3386 
   3387 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3388 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3389 	defer endTimer()
   3390 	defer span.End()
   3391 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3392 	if !ok {
   3393 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3394 	}
   3395 
   3396 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3397 		return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response, &metadata)
   3398 	}
   3399 	output := &DeleteTrafficPolicyInstanceOutput{}
   3400 	out.Result = output
   3401 
   3402 	span.End()
   3403 	return out, metadata, err
   3404 }
   3405 
   3406 func awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3407 	var errorBuffer bytes.Buffer
   3408 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3409 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3410 	}
   3411 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3412 
   3413 	errorCode := "UnknownError"
   3414 	errorMessage := errorCode
   3415 
   3416 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3417 	if err != nil {
   3418 		return err
   3419 	}
   3420 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3421 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3422 	}
   3423 	if len(errorComponents.Code) != 0 {
   3424 		errorCode = errorComponents.Code
   3425 	}
   3426 	if len(errorComponents.Message) != 0 {
   3427 		errorMessage = errorComponents.Message
   3428 	}
   3429 	errorBody.Seek(0, io.SeekStart)
   3430 	switch {
   3431 	case strings.EqualFold("InvalidInput", errorCode):
   3432 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3433 
   3434 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   3435 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   3436 
   3437 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   3438 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   3439 
   3440 	default:
   3441 		genericError := &smithy.GenericAPIError{
   3442 			Code:    errorCode,
   3443 			Message: errorMessage,
   3444 		}
   3445 		return genericError
   3446 
   3447 	}
   3448 }
   3449 
   3450 type awsRestxml_deserializeOpDeleteVPCAssociationAuthorization struct {
   3451 }
   3452 
   3453 func (*awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) ID() string {
   3454 	return "OperationDeserializer"
   3455 }
   3456 
   3457 func (m *awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3458 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3459 ) {
   3460 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3461 	if err != nil {
   3462 		return out, metadata, err
   3463 	}
   3464 
   3465 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3466 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3467 	defer endTimer()
   3468 	defer span.End()
   3469 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3470 	if !ok {
   3471 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3472 	}
   3473 
   3474 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3475 		return out, metadata, awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response, &metadata)
   3476 	}
   3477 	output := &DeleteVPCAssociationAuthorizationOutput{}
   3478 	out.Result = output
   3479 
   3480 	span.End()
   3481 	return out, metadata, err
   3482 }
   3483 
   3484 func awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3485 	var errorBuffer bytes.Buffer
   3486 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3487 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3488 	}
   3489 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3490 
   3491 	errorCode := "UnknownError"
   3492 	errorMessage := errorCode
   3493 
   3494 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3495 	if err != nil {
   3496 		return err
   3497 	}
   3498 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3499 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3500 	}
   3501 	if len(errorComponents.Code) != 0 {
   3502 		errorCode = errorComponents.Code
   3503 	}
   3504 	if len(errorComponents.Message) != 0 {
   3505 		errorMessage = errorComponents.Message
   3506 	}
   3507 	errorBody.Seek(0, io.SeekStart)
   3508 	switch {
   3509 	case strings.EqualFold("ConcurrentModification", errorCode):
   3510 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3511 
   3512 	case strings.EqualFold("InvalidInput", errorCode):
   3513 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3514 
   3515 	case strings.EqualFold("InvalidVPCId", errorCode):
   3516 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   3517 
   3518 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3519 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3520 
   3521 	case strings.EqualFold("VPCAssociationAuthorizationNotFound", errorCode):
   3522 		return awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response, errorBody)
   3523 
   3524 	default:
   3525 		genericError := &smithy.GenericAPIError{
   3526 			Code:    errorCode,
   3527 			Message: errorMessage,
   3528 		}
   3529 		return genericError
   3530 
   3531 	}
   3532 }
   3533 
   3534 type awsRestxml_deserializeOpDisableHostedZoneDNSSEC struct {
   3535 }
   3536 
   3537 func (*awsRestxml_deserializeOpDisableHostedZoneDNSSEC) ID() string {
   3538 	return "OperationDeserializer"
   3539 }
   3540 
   3541 func (m *awsRestxml_deserializeOpDisableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3542 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3543 ) {
   3544 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3545 	if err != nil {
   3546 		return out, metadata, err
   3547 	}
   3548 
   3549 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3550 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3551 	defer endTimer()
   3552 	defer span.End()
   3553 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3554 	if !ok {
   3555 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3556 	}
   3557 
   3558 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3559 		return out, metadata, awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response, &metadata)
   3560 	}
   3561 	output := &DisableHostedZoneDNSSECOutput{}
   3562 	out.Result = output
   3563 
   3564 	var buff [1024]byte
   3565 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3566 	body := io.TeeReader(response.Body, ringBuffer)
   3567 	rootDecoder := xml.NewDecoder(body)
   3568 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3569 	if err == io.EOF {
   3570 		return out, metadata, nil
   3571 	}
   3572 	if err != nil {
   3573 		var snapshot bytes.Buffer
   3574 		io.Copy(&snapshot, ringBuffer)
   3575 		return out, metadata, &smithy.DeserializationError{
   3576 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3577 			Snapshot: snapshot.Bytes(),
   3578 		}
   3579 	}
   3580 
   3581 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3582 	err = awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(&output, decoder)
   3583 	if err != nil {
   3584 		var snapshot bytes.Buffer
   3585 		io.Copy(&snapshot, ringBuffer)
   3586 		return out, metadata, &smithy.DeserializationError{
   3587 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3588 			Snapshot: snapshot.Bytes(),
   3589 		}
   3590 	}
   3591 
   3592 	span.End()
   3593 	return out, metadata, err
   3594 }
   3595 
   3596 func awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3597 	var errorBuffer bytes.Buffer
   3598 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3599 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3600 	}
   3601 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3602 
   3603 	errorCode := "UnknownError"
   3604 	errorMessage := errorCode
   3605 
   3606 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3607 	if err != nil {
   3608 		return err
   3609 	}
   3610 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3611 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3612 	}
   3613 	if len(errorComponents.Code) != 0 {
   3614 		errorCode = errorComponents.Code
   3615 	}
   3616 	if len(errorComponents.Message) != 0 {
   3617 		errorMessage = errorComponents.Message
   3618 	}
   3619 	errorBody.Seek(0, io.SeekStart)
   3620 	switch {
   3621 	case strings.EqualFold("ConcurrentModification", errorCode):
   3622 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3623 
   3624 	case strings.EqualFold("DNSSECNotFound", errorCode):
   3625 		return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody)
   3626 
   3627 	case strings.EqualFold("InvalidArgument", errorCode):
   3628 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   3629 
   3630 	case strings.EqualFold("InvalidInput", errorCode):
   3631 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3632 
   3633 	case strings.EqualFold("InvalidKMSArn", errorCode):
   3634 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   3635 
   3636 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   3637 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   3638 
   3639 	case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode):
   3640 		return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody)
   3641 
   3642 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3643 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3644 
   3645 	default:
   3646 		genericError := &smithy.GenericAPIError{
   3647 			Code:    errorCode,
   3648 			Message: errorMessage,
   3649 		}
   3650 		return genericError
   3651 
   3652 	}
   3653 }
   3654 
   3655 func awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(v **DisableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error {
   3656 	if v == nil {
   3657 		return fmt.Errorf("unexpected nil of type %T", v)
   3658 	}
   3659 	var sv *DisableHostedZoneDNSSECOutput
   3660 	if *v == nil {
   3661 		sv = &DisableHostedZoneDNSSECOutput{}
   3662 	} else {
   3663 		sv = *v
   3664 	}
   3665 
   3666 	for {
   3667 		t, done, err := decoder.Token()
   3668 		if err != nil {
   3669 			return err
   3670 		}
   3671 		if done {
   3672 			break
   3673 		}
   3674 		originalDecoder := decoder
   3675 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3676 		switch {
   3677 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3678 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3679 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3680 				return err
   3681 			}
   3682 
   3683 		default:
   3684 			// Do nothing and ignore the unexpected tag element
   3685 			err = decoder.Decoder.Skip()
   3686 			if err != nil {
   3687 				return err
   3688 			}
   3689 
   3690 		}
   3691 		decoder = originalDecoder
   3692 	}
   3693 	*v = sv
   3694 	return nil
   3695 }
   3696 
   3697 type awsRestxml_deserializeOpDisassociateVPCFromHostedZone struct {
   3698 }
   3699 
   3700 func (*awsRestxml_deserializeOpDisassociateVPCFromHostedZone) ID() string {
   3701 	return "OperationDeserializer"
   3702 }
   3703 
   3704 func (m *awsRestxml_deserializeOpDisassociateVPCFromHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3705 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3706 ) {
   3707 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3708 	if err != nil {
   3709 		return out, metadata, err
   3710 	}
   3711 
   3712 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3713 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3714 	defer endTimer()
   3715 	defer span.End()
   3716 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3717 	if !ok {
   3718 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3719 	}
   3720 
   3721 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3722 		return out, metadata, awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response, &metadata)
   3723 	}
   3724 	output := &DisassociateVPCFromHostedZoneOutput{}
   3725 	out.Result = output
   3726 
   3727 	var buff [1024]byte
   3728 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3729 	body := io.TeeReader(response.Body, ringBuffer)
   3730 	rootDecoder := xml.NewDecoder(body)
   3731 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3732 	if err == io.EOF {
   3733 		return out, metadata, nil
   3734 	}
   3735 	if err != nil {
   3736 		var snapshot bytes.Buffer
   3737 		io.Copy(&snapshot, ringBuffer)
   3738 		return out, metadata, &smithy.DeserializationError{
   3739 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3740 			Snapshot: snapshot.Bytes(),
   3741 		}
   3742 	}
   3743 
   3744 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3745 	err = awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(&output, decoder)
   3746 	if err != nil {
   3747 		var snapshot bytes.Buffer
   3748 		io.Copy(&snapshot, ringBuffer)
   3749 		return out, metadata, &smithy.DeserializationError{
   3750 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3751 			Snapshot: snapshot.Bytes(),
   3752 		}
   3753 	}
   3754 
   3755 	span.End()
   3756 	return out, metadata, err
   3757 }
   3758 
   3759 func awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3760 	var errorBuffer bytes.Buffer
   3761 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3762 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3763 	}
   3764 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3765 
   3766 	errorCode := "UnknownError"
   3767 	errorMessage := errorCode
   3768 
   3769 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3770 	if err != nil {
   3771 		return err
   3772 	}
   3773 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3774 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3775 	}
   3776 	if len(errorComponents.Code) != 0 {
   3777 		errorCode = errorComponents.Code
   3778 	}
   3779 	if len(errorComponents.Message) != 0 {
   3780 		errorMessage = errorComponents.Message
   3781 	}
   3782 	errorBody.Seek(0, io.SeekStart)
   3783 	switch {
   3784 	case strings.EqualFold("InvalidInput", errorCode):
   3785 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3786 
   3787 	case strings.EqualFold("InvalidVPCId", errorCode):
   3788 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   3789 
   3790 	case strings.EqualFold("LastVPCAssociation", errorCode):
   3791 		return awsRestxml_deserializeErrorLastVPCAssociation(response, errorBody)
   3792 
   3793 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3794 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3795 
   3796 	case strings.EqualFold("VPCAssociationNotFound", errorCode):
   3797 		return awsRestxml_deserializeErrorVPCAssociationNotFound(response, errorBody)
   3798 
   3799 	default:
   3800 		genericError := &smithy.GenericAPIError{
   3801 			Code:    errorCode,
   3802 			Message: errorMessage,
   3803 		}
   3804 		return genericError
   3805 
   3806 	}
   3807 }
   3808 
   3809 func awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(v **DisassociateVPCFromHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   3810 	if v == nil {
   3811 		return fmt.Errorf("unexpected nil of type %T", v)
   3812 	}
   3813 	var sv *DisassociateVPCFromHostedZoneOutput
   3814 	if *v == nil {
   3815 		sv = &DisassociateVPCFromHostedZoneOutput{}
   3816 	} else {
   3817 		sv = *v
   3818 	}
   3819 
   3820 	for {
   3821 		t, done, err := decoder.Token()
   3822 		if err != nil {
   3823 			return err
   3824 		}
   3825 		if done {
   3826 			break
   3827 		}
   3828 		originalDecoder := decoder
   3829 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3830 		switch {
   3831 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3832 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3833 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3834 				return err
   3835 			}
   3836 
   3837 		default:
   3838 			// Do nothing and ignore the unexpected tag element
   3839 			err = decoder.Decoder.Skip()
   3840 			if err != nil {
   3841 				return err
   3842 			}
   3843 
   3844 		}
   3845 		decoder = originalDecoder
   3846 	}
   3847 	*v = sv
   3848 	return nil
   3849 }
   3850 
   3851 type awsRestxml_deserializeOpEnableHostedZoneDNSSEC struct {
   3852 }
   3853 
   3854 func (*awsRestxml_deserializeOpEnableHostedZoneDNSSEC) ID() string {
   3855 	return "OperationDeserializer"
   3856 }
   3857 
   3858 func (m *awsRestxml_deserializeOpEnableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3859 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3860 ) {
   3861 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3862 	if err != nil {
   3863 		return out, metadata, err
   3864 	}
   3865 
   3866 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   3867 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   3868 	defer endTimer()
   3869 	defer span.End()
   3870 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3871 	if !ok {
   3872 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3873 	}
   3874 
   3875 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3876 		return out, metadata, awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response, &metadata)
   3877 	}
   3878 	output := &EnableHostedZoneDNSSECOutput{}
   3879 	out.Result = output
   3880 
   3881 	var buff [1024]byte
   3882 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3883 	body := io.TeeReader(response.Body, ringBuffer)
   3884 	rootDecoder := xml.NewDecoder(body)
   3885 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3886 	if err == io.EOF {
   3887 		return out, metadata, nil
   3888 	}
   3889 	if err != nil {
   3890 		var snapshot bytes.Buffer
   3891 		io.Copy(&snapshot, ringBuffer)
   3892 		return out, metadata, &smithy.DeserializationError{
   3893 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3894 			Snapshot: snapshot.Bytes(),
   3895 		}
   3896 	}
   3897 
   3898 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3899 	err = awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(&output, decoder)
   3900 	if err != nil {
   3901 		var snapshot bytes.Buffer
   3902 		io.Copy(&snapshot, ringBuffer)
   3903 		return out, metadata, &smithy.DeserializationError{
   3904 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3905 			Snapshot: snapshot.Bytes(),
   3906 		}
   3907 	}
   3908 
   3909 	span.End()
   3910 	return out, metadata, err
   3911 }
   3912 
   3913 func awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3914 	var errorBuffer bytes.Buffer
   3915 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3916 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3917 	}
   3918 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3919 
   3920 	errorCode := "UnknownError"
   3921 	errorMessage := errorCode
   3922 
   3923 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3924 	if err != nil {
   3925 		return err
   3926 	}
   3927 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3928 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3929 	}
   3930 	if len(errorComponents.Code) != 0 {
   3931 		errorCode = errorComponents.Code
   3932 	}
   3933 	if len(errorComponents.Message) != 0 {
   3934 		errorMessage = errorComponents.Message
   3935 	}
   3936 	errorBody.Seek(0, io.SeekStart)
   3937 	switch {
   3938 	case strings.EqualFold("ConcurrentModification", errorCode):
   3939 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3940 
   3941 	case strings.EqualFold("DNSSECNotFound", errorCode):
   3942 		return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody)
   3943 
   3944 	case strings.EqualFold("HostedZonePartiallyDelegated", errorCode):
   3945 		return awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response, errorBody)
   3946 
   3947 	case strings.EqualFold("InvalidArgument", errorCode):
   3948 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   3949 
   3950 	case strings.EqualFold("InvalidInput", errorCode):
   3951 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3952 
   3953 	case strings.EqualFold("InvalidKMSArn", errorCode):
   3954 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   3955 
   3956 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   3957 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   3958 
   3959 	case strings.EqualFold("KeySigningKeyWithActiveStatusNotFound", errorCode):
   3960 		return awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response, errorBody)
   3961 
   3962 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3963 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3964 
   3965 	default:
   3966 		genericError := &smithy.GenericAPIError{
   3967 			Code:    errorCode,
   3968 			Message: errorMessage,
   3969 		}
   3970 		return genericError
   3971 
   3972 	}
   3973 }
   3974 
   3975 func awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(v **EnableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error {
   3976 	if v == nil {
   3977 		return fmt.Errorf("unexpected nil of type %T", v)
   3978 	}
   3979 	var sv *EnableHostedZoneDNSSECOutput
   3980 	if *v == nil {
   3981 		sv = &EnableHostedZoneDNSSECOutput{}
   3982 	} else {
   3983 		sv = *v
   3984 	}
   3985 
   3986 	for {
   3987 		t, done, err := decoder.Token()
   3988 		if err != nil {
   3989 			return err
   3990 		}
   3991 		if done {
   3992 			break
   3993 		}
   3994 		originalDecoder := decoder
   3995 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3996 		switch {
   3997 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3998 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3999 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   4000 				return err
   4001 			}
   4002 
   4003 		default:
   4004 			// Do nothing and ignore the unexpected tag element
   4005 			err = decoder.Decoder.Skip()
   4006 			if err != nil {
   4007 				return err
   4008 			}
   4009 
   4010 		}
   4011 		decoder = originalDecoder
   4012 	}
   4013 	*v = sv
   4014 	return nil
   4015 }
   4016 
   4017 type awsRestxml_deserializeOpGetAccountLimit struct {
   4018 }
   4019 
   4020 func (*awsRestxml_deserializeOpGetAccountLimit) ID() string {
   4021 	return "OperationDeserializer"
   4022 }
   4023 
   4024 func (m *awsRestxml_deserializeOpGetAccountLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4025 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4026 ) {
   4027 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4028 	if err != nil {
   4029 		return out, metadata, err
   4030 	}
   4031 
   4032 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4033 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4034 	defer endTimer()
   4035 	defer span.End()
   4036 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4037 	if !ok {
   4038 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4039 	}
   4040 
   4041 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4042 		return out, metadata, awsRestxml_deserializeOpErrorGetAccountLimit(response, &metadata)
   4043 	}
   4044 	output := &GetAccountLimitOutput{}
   4045 	out.Result = output
   4046 
   4047 	var buff [1024]byte
   4048 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4049 	body := io.TeeReader(response.Body, ringBuffer)
   4050 	rootDecoder := xml.NewDecoder(body)
   4051 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4052 	if err == io.EOF {
   4053 		return out, metadata, nil
   4054 	}
   4055 	if err != nil {
   4056 		var snapshot bytes.Buffer
   4057 		io.Copy(&snapshot, ringBuffer)
   4058 		return out, metadata, &smithy.DeserializationError{
   4059 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4060 			Snapshot: snapshot.Bytes(),
   4061 		}
   4062 	}
   4063 
   4064 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4065 	err = awsRestxml_deserializeOpDocumentGetAccountLimitOutput(&output, decoder)
   4066 	if err != nil {
   4067 		var snapshot bytes.Buffer
   4068 		io.Copy(&snapshot, ringBuffer)
   4069 		return out, metadata, &smithy.DeserializationError{
   4070 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4071 			Snapshot: snapshot.Bytes(),
   4072 		}
   4073 	}
   4074 
   4075 	span.End()
   4076 	return out, metadata, err
   4077 }
   4078 
   4079 func awsRestxml_deserializeOpErrorGetAccountLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4080 	var errorBuffer bytes.Buffer
   4081 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4082 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4083 	}
   4084 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4085 
   4086 	errorCode := "UnknownError"
   4087 	errorMessage := errorCode
   4088 
   4089 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4090 	if err != nil {
   4091 		return err
   4092 	}
   4093 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4094 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4095 	}
   4096 	if len(errorComponents.Code) != 0 {
   4097 		errorCode = errorComponents.Code
   4098 	}
   4099 	if len(errorComponents.Message) != 0 {
   4100 		errorMessage = errorComponents.Message
   4101 	}
   4102 	errorBody.Seek(0, io.SeekStart)
   4103 	switch {
   4104 	case strings.EqualFold("InvalidInput", errorCode):
   4105 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4106 
   4107 	default:
   4108 		genericError := &smithy.GenericAPIError{
   4109 			Code:    errorCode,
   4110 			Message: errorMessage,
   4111 		}
   4112 		return genericError
   4113 
   4114 	}
   4115 }
   4116 
   4117 func awsRestxml_deserializeOpDocumentGetAccountLimitOutput(v **GetAccountLimitOutput, decoder smithyxml.NodeDecoder) error {
   4118 	if v == nil {
   4119 		return fmt.Errorf("unexpected nil of type %T", v)
   4120 	}
   4121 	var sv *GetAccountLimitOutput
   4122 	if *v == nil {
   4123 		sv = &GetAccountLimitOutput{}
   4124 	} else {
   4125 		sv = *v
   4126 	}
   4127 
   4128 	for {
   4129 		t, done, err := decoder.Token()
   4130 		if err != nil {
   4131 			return err
   4132 		}
   4133 		if done {
   4134 			break
   4135 		}
   4136 		originalDecoder := decoder
   4137 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4138 		switch {
   4139 		case strings.EqualFold("Count", t.Name.Local):
   4140 			val, err := decoder.Value()
   4141 			if err != nil {
   4142 				return err
   4143 			}
   4144 			if val == nil {
   4145 				break
   4146 			}
   4147 			{
   4148 				xtv := string(val)
   4149 				i64, err := strconv.ParseInt(xtv, 10, 64)
   4150 				if err != nil {
   4151 					return err
   4152 				}
   4153 				sv.Count = i64
   4154 			}
   4155 
   4156 		case strings.EqualFold("Limit", t.Name.Local):
   4157 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4158 			if err := awsRestxml_deserializeDocumentAccountLimit(&sv.Limit, nodeDecoder); err != nil {
   4159 				return err
   4160 			}
   4161 
   4162 		default:
   4163 			// Do nothing and ignore the unexpected tag element
   4164 			err = decoder.Decoder.Skip()
   4165 			if err != nil {
   4166 				return err
   4167 			}
   4168 
   4169 		}
   4170 		decoder = originalDecoder
   4171 	}
   4172 	*v = sv
   4173 	return nil
   4174 }
   4175 
   4176 type awsRestxml_deserializeOpGetChange struct {
   4177 }
   4178 
   4179 func (*awsRestxml_deserializeOpGetChange) ID() string {
   4180 	return "OperationDeserializer"
   4181 }
   4182 
   4183 func (m *awsRestxml_deserializeOpGetChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4184 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4185 ) {
   4186 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4187 	if err != nil {
   4188 		return out, metadata, err
   4189 	}
   4190 
   4191 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4192 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4193 	defer endTimer()
   4194 	defer span.End()
   4195 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4196 	if !ok {
   4197 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4198 	}
   4199 
   4200 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4201 		return out, metadata, awsRestxml_deserializeOpErrorGetChange(response, &metadata)
   4202 	}
   4203 	output := &GetChangeOutput{}
   4204 	out.Result = output
   4205 
   4206 	var buff [1024]byte
   4207 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4208 	body := io.TeeReader(response.Body, ringBuffer)
   4209 	rootDecoder := xml.NewDecoder(body)
   4210 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4211 	if err == io.EOF {
   4212 		return out, metadata, nil
   4213 	}
   4214 	if err != nil {
   4215 		var snapshot bytes.Buffer
   4216 		io.Copy(&snapshot, ringBuffer)
   4217 		return out, metadata, &smithy.DeserializationError{
   4218 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4219 			Snapshot: snapshot.Bytes(),
   4220 		}
   4221 	}
   4222 
   4223 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4224 	err = awsRestxml_deserializeOpDocumentGetChangeOutput(&output, decoder)
   4225 	if err != nil {
   4226 		var snapshot bytes.Buffer
   4227 		io.Copy(&snapshot, ringBuffer)
   4228 		return out, metadata, &smithy.DeserializationError{
   4229 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4230 			Snapshot: snapshot.Bytes(),
   4231 		}
   4232 	}
   4233 
   4234 	span.End()
   4235 	return out, metadata, err
   4236 }
   4237 
   4238 func awsRestxml_deserializeOpErrorGetChange(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4239 	var errorBuffer bytes.Buffer
   4240 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4241 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4242 	}
   4243 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4244 
   4245 	errorCode := "UnknownError"
   4246 	errorMessage := errorCode
   4247 
   4248 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4249 	if err != nil {
   4250 		return err
   4251 	}
   4252 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4253 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4254 	}
   4255 	if len(errorComponents.Code) != 0 {
   4256 		errorCode = errorComponents.Code
   4257 	}
   4258 	if len(errorComponents.Message) != 0 {
   4259 		errorMessage = errorComponents.Message
   4260 	}
   4261 	errorBody.Seek(0, io.SeekStart)
   4262 	switch {
   4263 	case strings.EqualFold("InvalidInput", errorCode):
   4264 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4265 
   4266 	case strings.EqualFold("NoSuchChange", errorCode):
   4267 		return awsRestxml_deserializeErrorNoSuchChange(response, errorBody)
   4268 
   4269 	default:
   4270 		genericError := &smithy.GenericAPIError{
   4271 			Code:    errorCode,
   4272 			Message: errorMessage,
   4273 		}
   4274 		return genericError
   4275 
   4276 	}
   4277 }
   4278 
   4279 func awsRestxml_deserializeOpDocumentGetChangeOutput(v **GetChangeOutput, decoder smithyxml.NodeDecoder) error {
   4280 	if v == nil {
   4281 		return fmt.Errorf("unexpected nil of type %T", v)
   4282 	}
   4283 	var sv *GetChangeOutput
   4284 	if *v == nil {
   4285 		sv = &GetChangeOutput{}
   4286 	} else {
   4287 		sv = *v
   4288 	}
   4289 
   4290 	for {
   4291 		t, done, err := decoder.Token()
   4292 		if err != nil {
   4293 			return err
   4294 		}
   4295 		if done {
   4296 			break
   4297 		}
   4298 		originalDecoder := decoder
   4299 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4300 		switch {
   4301 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   4302 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4303 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   4304 				return err
   4305 			}
   4306 
   4307 		default:
   4308 			// Do nothing and ignore the unexpected tag element
   4309 			err = decoder.Decoder.Skip()
   4310 			if err != nil {
   4311 				return err
   4312 			}
   4313 
   4314 		}
   4315 		decoder = originalDecoder
   4316 	}
   4317 	*v = sv
   4318 	return nil
   4319 }
   4320 
   4321 type awsRestxml_deserializeOpGetCheckerIpRanges struct {
   4322 }
   4323 
   4324 func (*awsRestxml_deserializeOpGetCheckerIpRanges) ID() string {
   4325 	return "OperationDeserializer"
   4326 }
   4327 
   4328 func (m *awsRestxml_deserializeOpGetCheckerIpRanges) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4329 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4330 ) {
   4331 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4332 	if err != nil {
   4333 		return out, metadata, err
   4334 	}
   4335 
   4336 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4337 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4338 	defer endTimer()
   4339 	defer span.End()
   4340 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4341 	if !ok {
   4342 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4343 	}
   4344 
   4345 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4346 		return out, metadata, awsRestxml_deserializeOpErrorGetCheckerIpRanges(response, &metadata)
   4347 	}
   4348 	output := &GetCheckerIpRangesOutput{}
   4349 	out.Result = output
   4350 
   4351 	var buff [1024]byte
   4352 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4353 	body := io.TeeReader(response.Body, ringBuffer)
   4354 	rootDecoder := xml.NewDecoder(body)
   4355 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4356 	if err == io.EOF {
   4357 		return out, metadata, nil
   4358 	}
   4359 	if err != nil {
   4360 		var snapshot bytes.Buffer
   4361 		io.Copy(&snapshot, ringBuffer)
   4362 		return out, metadata, &smithy.DeserializationError{
   4363 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4364 			Snapshot: snapshot.Bytes(),
   4365 		}
   4366 	}
   4367 
   4368 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4369 	err = awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(&output, decoder)
   4370 	if err != nil {
   4371 		var snapshot bytes.Buffer
   4372 		io.Copy(&snapshot, ringBuffer)
   4373 		return out, metadata, &smithy.DeserializationError{
   4374 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4375 			Snapshot: snapshot.Bytes(),
   4376 		}
   4377 	}
   4378 
   4379 	span.End()
   4380 	return out, metadata, err
   4381 }
   4382 
   4383 func awsRestxml_deserializeOpErrorGetCheckerIpRanges(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4384 	var errorBuffer bytes.Buffer
   4385 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4386 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4387 	}
   4388 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4389 
   4390 	errorCode := "UnknownError"
   4391 	errorMessage := errorCode
   4392 
   4393 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4394 	if err != nil {
   4395 		return err
   4396 	}
   4397 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4398 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4399 	}
   4400 	if len(errorComponents.Code) != 0 {
   4401 		errorCode = errorComponents.Code
   4402 	}
   4403 	if len(errorComponents.Message) != 0 {
   4404 		errorMessage = errorComponents.Message
   4405 	}
   4406 	errorBody.Seek(0, io.SeekStart)
   4407 	switch {
   4408 	default:
   4409 		genericError := &smithy.GenericAPIError{
   4410 			Code:    errorCode,
   4411 			Message: errorMessage,
   4412 		}
   4413 		return genericError
   4414 
   4415 	}
   4416 }
   4417 
   4418 func awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(v **GetCheckerIpRangesOutput, decoder smithyxml.NodeDecoder) error {
   4419 	if v == nil {
   4420 		return fmt.Errorf("unexpected nil of type %T", v)
   4421 	}
   4422 	var sv *GetCheckerIpRangesOutput
   4423 	if *v == nil {
   4424 		sv = &GetCheckerIpRangesOutput{}
   4425 	} else {
   4426 		sv = *v
   4427 	}
   4428 
   4429 	for {
   4430 		t, done, err := decoder.Token()
   4431 		if err != nil {
   4432 			return err
   4433 		}
   4434 		if done {
   4435 			break
   4436 		}
   4437 		originalDecoder := decoder
   4438 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4439 		switch {
   4440 		case strings.EqualFold("CheckerIpRanges", t.Name.Local):
   4441 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4442 			if err := awsRestxml_deserializeDocumentCheckerIpRanges(&sv.CheckerIpRanges, nodeDecoder); err != nil {
   4443 				return err
   4444 			}
   4445 
   4446 		default:
   4447 			// Do nothing and ignore the unexpected tag element
   4448 			err = decoder.Decoder.Skip()
   4449 			if err != nil {
   4450 				return err
   4451 			}
   4452 
   4453 		}
   4454 		decoder = originalDecoder
   4455 	}
   4456 	*v = sv
   4457 	return nil
   4458 }
   4459 
   4460 type awsRestxml_deserializeOpGetDNSSEC struct {
   4461 }
   4462 
   4463 func (*awsRestxml_deserializeOpGetDNSSEC) ID() string {
   4464 	return "OperationDeserializer"
   4465 }
   4466 
   4467 func (m *awsRestxml_deserializeOpGetDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4468 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4469 ) {
   4470 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4471 	if err != nil {
   4472 		return out, metadata, err
   4473 	}
   4474 
   4475 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4476 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4477 	defer endTimer()
   4478 	defer span.End()
   4479 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4480 	if !ok {
   4481 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4482 	}
   4483 
   4484 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4485 		return out, metadata, awsRestxml_deserializeOpErrorGetDNSSEC(response, &metadata)
   4486 	}
   4487 	output := &GetDNSSECOutput{}
   4488 	out.Result = output
   4489 
   4490 	var buff [1024]byte
   4491 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4492 	body := io.TeeReader(response.Body, ringBuffer)
   4493 	rootDecoder := xml.NewDecoder(body)
   4494 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4495 	if err == io.EOF {
   4496 		return out, metadata, nil
   4497 	}
   4498 	if err != nil {
   4499 		var snapshot bytes.Buffer
   4500 		io.Copy(&snapshot, ringBuffer)
   4501 		return out, metadata, &smithy.DeserializationError{
   4502 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4503 			Snapshot: snapshot.Bytes(),
   4504 		}
   4505 	}
   4506 
   4507 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4508 	err = awsRestxml_deserializeOpDocumentGetDNSSECOutput(&output, decoder)
   4509 	if err != nil {
   4510 		var snapshot bytes.Buffer
   4511 		io.Copy(&snapshot, ringBuffer)
   4512 		return out, metadata, &smithy.DeserializationError{
   4513 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4514 			Snapshot: snapshot.Bytes(),
   4515 		}
   4516 	}
   4517 
   4518 	span.End()
   4519 	return out, metadata, err
   4520 }
   4521 
   4522 func awsRestxml_deserializeOpErrorGetDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4523 	var errorBuffer bytes.Buffer
   4524 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4525 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4526 	}
   4527 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4528 
   4529 	errorCode := "UnknownError"
   4530 	errorMessage := errorCode
   4531 
   4532 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4533 	if err != nil {
   4534 		return err
   4535 	}
   4536 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4537 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4538 	}
   4539 	if len(errorComponents.Code) != 0 {
   4540 		errorCode = errorComponents.Code
   4541 	}
   4542 	if len(errorComponents.Message) != 0 {
   4543 		errorMessage = errorComponents.Message
   4544 	}
   4545 	errorBody.Seek(0, io.SeekStart)
   4546 	switch {
   4547 	case strings.EqualFold("InvalidArgument", errorCode):
   4548 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   4549 
   4550 	case strings.EqualFold("InvalidInput", errorCode):
   4551 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4552 
   4553 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   4554 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   4555 
   4556 	default:
   4557 		genericError := &smithy.GenericAPIError{
   4558 			Code:    errorCode,
   4559 			Message: errorMessage,
   4560 		}
   4561 		return genericError
   4562 
   4563 	}
   4564 }
   4565 
   4566 func awsRestxml_deserializeOpDocumentGetDNSSECOutput(v **GetDNSSECOutput, decoder smithyxml.NodeDecoder) error {
   4567 	if v == nil {
   4568 		return fmt.Errorf("unexpected nil of type %T", v)
   4569 	}
   4570 	var sv *GetDNSSECOutput
   4571 	if *v == nil {
   4572 		sv = &GetDNSSECOutput{}
   4573 	} else {
   4574 		sv = *v
   4575 	}
   4576 
   4577 	for {
   4578 		t, done, err := decoder.Token()
   4579 		if err != nil {
   4580 			return err
   4581 		}
   4582 		if done {
   4583 			break
   4584 		}
   4585 		originalDecoder := decoder
   4586 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4587 		switch {
   4588 		case strings.EqualFold("KeySigningKeys", t.Name.Local):
   4589 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4590 			if err := awsRestxml_deserializeDocumentKeySigningKeys(&sv.KeySigningKeys, nodeDecoder); err != nil {
   4591 				return err
   4592 			}
   4593 
   4594 		case strings.EqualFold("Status", t.Name.Local):
   4595 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4596 			if err := awsRestxml_deserializeDocumentDNSSECStatus(&sv.Status, nodeDecoder); err != nil {
   4597 				return err
   4598 			}
   4599 
   4600 		default:
   4601 			// Do nothing and ignore the unexpected tag element
   4602 			err = decoder.Decoder.Skip()
   4603 			if err != nil {
   4604 				return err
   4605 			}
   4606 
   4607 		}
   4608 		decoder = originalDecoder
   4609 	}
   4610 	*v = sv
   4611 	return nil
   4612 }
   4613 
   4614 type awsRestxml_deserializeOpGetGeoLocation struct {
   4615 }
   4616 
   4617 func (*awsRestxml_deserializeOpGetGeoLocation) ID() string {
   4618 	return "OperationDeserializer"
   4619 }
   4620 
   4621 func (m *awsRestxml_deserializeOpGetGeoLocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4622 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4623 ) {
   4624 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4625 	if err != nil {
   4626 		return out, metadata, err
   4627 	}
   4628 
   4629 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4630 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4631 	defer endTimer()
   4632 	defer span.End()
   4633 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4634 	if !ok {
   4635 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4636 	}
   4637 
   4638 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4639 		return out, metadata, awsRestxml_deserializeOpErrorGetGeoLocation(response, &metadata)
   4640 	}
   4641 	output := &GetGeoLocationOutput{}
   4642 	out.Result = output
   4643 
   4644 	var buff [1024]byte
   4645 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4646 	body := io.TeeReader(response.Body, ringBuffer)
   4647 	rootDecoder := xml.NewDecoder(body)
   4648 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4649 	if err == io.EOF {
   4650 		return out, metadata, nil
   4651 	}
   4652 	if err != nil {
   4653 		var snapshot bytes.Buffer
   4654 		io.Copy(&snapshot, ringBuffer)
   4655 		return out, metadata, &smithy.DeserializationError{
   4656 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4657 			Snapshot: snapshot.Bytes(),
   4658 		}
   4659 	}
   4660 
   4661 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4662 	err = awsRestxml_deserializeOpDocumentGetGeoLocationOutput(&output, decoder)
   4663 	if err != nil {
   4664 		var snapshot bytes.Buffer
   4665 		io.Copy(&snapshot, ringBuffer)
   4666 		return out, metadata, &smithy.DeserializationError{
   4667 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4668 			Snapshot: snapshot.Bytes(),
   4669 		}
   4670 	}
   4671 
   4672 	span.End()
   4673 	return out, metadata, err
   4674 }
   4675 
   4676 func awsRestxml_deserializeOpErrorGetGeoLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4677 	var errorBuffer bytes.Buffer
   4678 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4679 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4680 	}
   4681 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4682 
   4683 	errorCode := "UnknownError"
   4684 	errorMessage := errorCode
   4685 
   4686 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4687 	if err != nil {
   4688 		return err
   4689 	}
   4690 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4691 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4692 	}
   4693 	if len(errorComponents.Code) != 0 {
   4694 		errorCode = errorComponents.Code
   4695 	}
   4696 	if len(errorComponents.Message) != 0 {
   4697 		errorMessage = errorComponents.Message
   4698 	}
   4699 	errorBody.Seek(0, io.SeekStart)
   4700 	switch {
   4701 	case strings.EqualFold("InvalidInput", errorCode):
   4702 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4703 
   4704 	case strings.EqualFold("NoSuchGeoLocation", errorCode):
   4705 		return awsRestxml_deserializeErrorNoSuchGeoLocation(response, errorBody)
   4706 
   4707 	default:
   4708 		genericError := &smithy.GenericAPIError{
   4709 			Code:    errorCode,
   4710 			Message: errorMessage,
   4711 		}
   4712 		return genericError
   4713 
   4714 	}
   4715 }
   4716 
   4717 func awsRestxml_deserializeOpDocumentGetGeoLocationOutput(v **GetGeoLocationOutput, decoder smithyxml.NodeDecoder) error {
   4718 	if v == nil {
   4719 		return fmt.Errorf("unexpected nil of type %T", v)
   4720 	}
   4721 	var sv *GetGeoLocationOutput
   4722 	if *v == nil {
   4723 		sv = &GetGeoLocationOutput{}
   4724 	} else {
   4725 		sv = *v
   4726 	}
   4727 
   4728 	for {
   4729 		t, done, err := decoder.Token()
   4730 		if err != nil {
   4731 			return err
   4732 		}
   4733 		if done {
   4734 			break
   4735 		}
   4736 		originalDecoder := decoder
   4737 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4738 		switch {
   4739 		case strings.EqualFold("GeoLocationDetails", t.Name.Local):
   4740 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4741 			if err := awsRestxml_deserializeDocumentGeoLocationDetails(&sv.GeoLocationDetails, nodeDecoder); err != nil {
   4742 				return err
   4743 			}
   4744 
   4745 		default:
   4746 			// Do nothing and ignore the unexpected tag element
   4747 			err = decoder.Decoder.Skip()
   4748 			if err != nil {
   4749 				return err
   4750 			}
   4751 
   4752 		}
   4753 		decoder = originalDecoder
   4754 	}
   4755 	*v = sv
   4756 	return nil
   4757 }
   4758 
   4759 type awsRestxml_deserializeOpGetHealthCheck struct {
   4760 }
   4761 
   4762 func (*awsRestxml_deserializeOpGetHealthCheck) ID() string {
   4763 	return "OperationDeserializer"
   4764 }
   4765 
   4766 func (m *awsRestxml_deserializeOpGetHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4767 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4768 ) {
   4769 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4770 	if err != nil {
   4771 		return out, metadata, err
   4772 	}
   4773 
   4774 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4775 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4776 	defer endTimer()
   4777 	defer span.End()
   4778 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4779 	if !ok {
   4780 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4781 	}
   4782 
   4783 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4784 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheck(response, &metadata)
   4785 	}
   4786 	output := &GetHealthCheckOutput{}
   4787 	out.Result = output
   4788 
   4789 	var buff [1024]byte
   4790 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4791 	body := io.TeeReader(response.Body, ringBuffer)
   4792 	rootDecoder := xml.NewDecoder(body)
   4793 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4794 	if err == io.EOF {
   4795 		return out, metadata, nil
   4796 	}
   4797 	if err != nil {
   4798 		var snapshot bytes.Buffer
   4799 		io.Copy(&snapshot, ringBuffer)
   4800 		return out, metadata, &smithy.DeserializationError{
   4801 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4802 			Snapshot: snapshot.Bytes(),
   4803 		}
   4804 	}
   4805 
   4806 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4807 	err = awsRestxml_deserializeOpDocumentGetHealthCheckOutput(&output, decoder)
   4808 	if err != nil {
   4809 		var snapshot bytes.Buffer
   4810 		io.Copy(&snapshot, ringBuffer)
   4811 		return out, metadata, &smithy.DeserializationError{
   4812 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4813 			Snapshot: snapshot.Bytes(),
   4814 		}
   4815 	}
   4816 
   4817 	span.End()
   4818 	return out, metadata, err
   4819 }
   4820 
   4821 func awsRestxml_deserializeOpErrorGetHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4822 	var errorBuffer bytes.Buffer
   4823 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4824 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4825 	}
   4826 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4827 
   4828 	errorCode := "UnknownError"
   4829 	errorMessage := errorCode
   4830 
   4831 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4832 	if err != nil {
   4833 		return err
   4834 	}
   4835 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4836 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4837 	}
   4838 	if len(errorComponents.Code) != 0 {
   4839 		errorCode = errorComponents.Code
   4840 	}
   4841 	if len(errorComponents.Message) != 0 {
   4842 		errorMessage = errorComponents.Message
   4843 	}
   4844 	errorBody.Seek(0, io.SeekStart)
   4845 	switch {
   4846 	case strings.EqualFold("IncompatibleVersion", errorCode):
   4847 		return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody)
   4848 
   4849 	case strings.EqualFold("InvalidInput", errorCode):
   4850 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4851 
   4852 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   4853 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   4854 
   4855 	default:
   4856 		genericError := &smithy.GenericAPIError{
   4857 			Code:    errorCode,
   4858 			Message: errorMessage,
   4859 		}
   4860 		return genericError
   4861 
   4862 	}
   4863 }
   4864 
   4865 func awsRestxml_deserializeOpDocumentGetHealthCheckOutput(v **GetHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
   4866 	if v == nil {
   4867 		return fmt.Errorf("unexpected nil of type %T", v)
   4868 	}
   4869 	var sv *GetHealthCheckOutput
   4870 	if *v == nil {
   4871 		sv = &GetHealthCheckOutput{}
   4872 	} else {
   4873 		sv = *v
   4874 	}
   4875 
   4876 	for {
   4877 		t, done, err := decoder.Token()
   4878 		if err != nil {
   4879 			return err
   4880 		}
   4881 		if done {
   4882 			break
   4883 		}
   4884 		originalDecoder := decoder
   4885 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4886 		switch {
   4887 		case strings.EqualFold("HealthCheck", t.Name.Local):
   4888 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4889 			if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
   4890 				return err
   4891 			}
   4892 
   4893 		default:
   4894 			// Do nothing and ignore the unexpected tag element
   4895 			err = decoder.Decoder.Skip()
   4896 			if err != nil {
   4897 				return err
   4898 			}
   4899 
   4900 		}
   4901 		decoder = originalDecoder
   4902 	}
   4903 	*v = sv
   4904 	return nil
   4905 }
   4906 
   4907 type awsRestxml_deserializeOpGetHealthCheckCount struct {
   4908 }
   4909 
   4910 func (*awsRestxml_deserializeOpGetHealthCheckCount) ID() string {
   4911 	return "OperationDeserializer"
   4912 }
   4913 
   4914 func (m *awsRestxml_deserializeOpGetHealthCheckCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4915 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4916 ) {
   4917 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4918 	if err != nil {
   4919 		return out, metadata, err
   4920 	}
   4921 
   4922 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   4923 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   4924 	defer endTimer()
   4925 	defer span.End()
   4926 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4927 	if !ok {
   4928 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4929 	}
   4930 
   4931 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4932 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckCount(response, &metadata)
   4933 	}
   4934 	output := &GetHealthCheckCountOutput{}
   4935 	out.Result = output
   4936 
   4937 	var buff [1024]byte
   4938 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4939 	body := io.TeeReader(response.Body, ringBuffer)
   4940 	rootDecoder := xml.NewDecoder(body)
   4941 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4942 	if err == io.EOF {
   4943 		return out, metadata, nil
   4944 	}
   4945 	if err != nil {
   4946 		var snapshot bytes.Buffer
   4947 		io.Copy(&snapshot, ringBuffer)
   4948 		return out, metadata, &smithy.DeserializationError{
   4949 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4950 			Snapshot: snapshot.Bytes(),
   4951 		}
   4952 	}
   4953 
   4954 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4955 	err = awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(&output, decoder)
   4956 	if err != nil {
   4957 		var snapshot bytes.Buffer
   4958 		io.Copy(&snapshot, ringBuffer)
   4959 		return out, metadata, &smithy.DeserializationError{
   4960 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4961 			Snapshot: snapshot.Bytes(),
   4962 		}
   4963 	}
   4964 
   4965 	span.End()
   4966 	return out, metadata, err
   4967 }
   4968 
   4969 func awsRestxml_deserializeOpErrorGetHealthCheckCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4970 	var errorBuffer bytes.Buffer
   4971 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4972 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4973 	}
   4974 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4975 
   4976 	errorCode := "UnknownError"
   4977 	errorMessage := errorCode
   4978 
   4979 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4980 	if err != nil {
   4981 		return err
   4982 	}
   4983 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4984 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4985 	}
   4986 	if len(errorComponents.Code) != 0 {
   4987 		errorCode = errorComponents.Code
   4988 	}
   4989 	if len(errorComponents.Message) != 0 {
   4990 		errorMessage = errorComponents.Message
   4991 	}
   4992 	errorBody.Seek(0, io.SeekStart)
   4993 	switch {
   4994 	default:
   4995 		genericError := &smithy.GenericAPIError{
   4996 			Code:    errorCode,
   4997 			Message: errorMessage,
   4998 		}
   4999 		return genericError
   5000 
   5001 	}
   5002 }
   5003 
   5004 func awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(v **GetHealthCheckCountOutput, decoder smithyxml.NodeDecoder) error {
   5005 	if v == nil {
   5006 		return fmt.Errorf("unexpected nil of type %T", v)
   5007 	}
   5008 	var sv *GetHealthCheckCountOutput
   5009 	if *v == nil {
   5010 		sv = &GetHealthCheckCountOutput{}
   5011 	} else {
   5012 		sv = *v
   5013 	}
   5014 
   5015 	for {
   5016 		t, done, err := decoder.Token()
   5017 		if err != nil {
   5018 			return err
   5019 		}
   5020 		if done {
   5021 			break
   5022 		}
   5023 		originalDecoder := decoder
   5024 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5025 		switch {
   5026 		case strings.EqualFold("HealthCheckCount", t.Name.Local):
   5027 			val, err := decoder.Value()
   5028 			if err != nil {
   5029 				return err
   5030 			}
   5031 			if val == nil {
   5032 				break
   5033 			}
   5034 			{
   5035 				xtv := string(val)
   5036 				i64, err := strconv.ParseInt(xtv, 10, 64)
   5037 				if err != nil {
   5038 					return err
   5039 				}
   5040 				sv.HealthCheckCount = ptr.Int64(i64)
   5041 			}
   5042 
   5043 		default:
   5044 			// Do nothing and ignore the unexpected tag element
   5045 			err = decoder.Decoder.Skip()
   5046 			if err != nil {
   5047 				return err
   5048 			}
   5049 
   5050 		}
   5051 		decoder = originalDecoder
   5052 	}
   5053 	*v = sv
   5054 	return nil
   5055 }
   5056 
   5057 type awsRestxml_deserializeOpGetHealthCheckLastFailureReason struct {
   5058 }
   5059 
   5060 func (*awsRestxml_deserializeOpGetHealthCheckLastFailureReason) ID() string {
   5061 	return "OperationDeserializer"
   5062 }
   5063 
   5064 func (m *awsRestxml_deserializeOpGetHealthCheckLastFailureReason) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5065 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5066 ) {
   5067 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5068 	if err != nil {
   5069 		return out, metadata, err
   5070 	}
   5071 
   5072 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5073 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5074 	defer endTimer()
   5075 	defer span.End()
   5076 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5077 	if !ok {
   5078 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5079 	}
   5080 
   5081 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5082 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response, &metadata)
   5083 	}
   5084 	output := &GetHealthCheckLastFailureReasonOutput{}
   5085 	out.Result = output
   5086 
   5087 	var buff [1024]byte
   5088 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5089 	body := io.TeeReader(response.Body, ringBuffer)
   5090 	rootDecoder := xml.NewDecoder(body)
   5091 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5092 	if err == io.EOF {
   5093 		return out, metadata, nil
   5094 	}
   5095 	if err != nil {
   5096 		var snapshot bytes.Buffer
   5097 		io.Copy(&snapshot, ringBuffer)
   5098 		return out, metadata, &smithy.DeserializationError{
   5099 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5100 			Snapshot: snapshot.Bytes(),
   5101 		}
   5102 	}
   5103 
   5104 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5105 	err = awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(&output, decoder)
   5106 	if err != nil {
   5107 		var snapshot bytes.Buffer
   5108 		io.Copy(&snapshot, ringBuffer)
   5109 		return out, metadata, &smithy.DeserializationError{
   5110 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5111 			Snapshot: snapshot.Bytes(),
   5112 		}
   5113 	}
   5114 
   5115 	span.End()
   5116 	return out, metadata, err
   5117 }
   5118 
   5119 func awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5120 	var errorBuffer bytes.Buffer
   5121 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5122 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5123 	}
   5124 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5125 
   5126 	errorCode := "UnknownError"
   5127 	errorMessage := errorCode
   5128 
   5129 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5130 	if err != nil {
   5131 		return err
   5132 	}
   5133 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5134 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5135 	}
   5136 	if len(errorComponents.Code) != 0 {
   5137 		errorCode = errorComponents.Code
   5138 	}
   5139 	if len(errorComponents.Message) != 0 {
   5140 		errorMessage = errorComponents.Message
   5141 	}
   5142 	errorBody.Seek(0, io.SeekStart)
   5143 	switch {
   5144 	case strings.EqualFold("InvalidInput", errorCode):
   5145 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5146 
   5147 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   5148 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   5149 
   5150 	default:
   5151 		genericError := &smithy.GenericAPIError{
   5152 			Code:    errorCode,
   5153 			Message: errorMessage,
   5154 		}
   5155 		return genericError
   5156 
   5157 	}
   5158 }
   5159 
   5160 func awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(v **GetHealthCheckLastFailureReasonOutput, decoder smithyxml.NodeDecoder) error {
   5161 	if v == nil {
   5162 		return fmt.Errorf("unexpected nil of type %T", v)
   5163 	}
   5164 	var sv *GetHealthCheckLastFailureReasonOutput
   5165 	if *v == nil {
   5166 		sv = &GetHealthCheckLastFailureReasonOutput{}
   5167 	} else {
   5168 		sv = *v
   5169 	}
   5170 
   5171 	for {
   5172 		t, done, err := decoder.Token()
   5173 		if err != nil {
   5174 			return err
   5175 		}
   5176 		if done {
   5177 			break
   5178 		}
   5179 		originalDecoder := decoder
   5180 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5181 		switch {
   5182 		case strings.EqualFold("HealthCheckObservations", t.Name.Local):
   5183 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5184 			if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil {
   5185 				return err
   5186 			}
   5187 
   5188 		default:
   5189 			// Do nothing and ignore the unexpected tag element
   5190 			err = decoder.Decoder.Skip()
   5191 			if err != nil {
   5192 				return err
   5193 			}
   5194 
   5195 		}
   5196 		decoder = originalDecoder
   5197 	}
   5198 	*v = sv
   5199 	return nil
   5200 }
   5201 
   5202 type awsRestxml_deserializeOpGetHealthCheckStatus struct {
   5203 }
   5204 
   5205 func (*awsRestxml_deserializeOpGetHealthCheckStatus) ID() string {
   5206 	return "OperationDeserializer"
   5207 }
   5208 
   5209 func (m *awsRestxml_deserializeOpGetHealthCheckStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5210 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5211 ) {
   5212 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5213 	if err != nil {
   5214 		return out, metadata, err
   5215 	}
   5216 
   5217 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5218 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5219 	defer endTimer()
   5220 	defer span.End()
   5221 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5222 	if !ok {
   5223 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5224 	}
   5225 
   5226 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5227 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckStatus(response, &metadata)
   5228 	}
   5229 	output := &GetHealthCheckStatusOutput{}
   5230 	out.Result = output
   5231 
   5232 	var buff [1024]byte
   5233 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5234 	body := io.TeeReader(response.Body, ringBuffer)
   5235 	rootDecoder := xml.NewDecoder(body)
   5236 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5237 	if err == io.EOF {
   5238 		return out, metadata, nil
   5239 	}
   5240 	if err != nil {
   5241 		var snapshot bytes.Buffer
   5242 		io.Copy(&snapshot, ringBuffer)
   5243 		return out, metadata, &smithy.DeserializationError{
   5244 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5245 			Snapshot: snapshot.Bytes(),
   5246 		}
   5247 	}
   5248 
   5249 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5250 	err = awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(&output, decoder)
   5251 	if err != nil {
   5252 		var snapshot bytes.Buffer
   5253 		io.Copy(&snapshot, ringBuffer)
   5254 		return out, metadata, &smithy.DeserializationError{
   5255 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5256 			Snapshot: snapshot.Bytes(),
   5257 		}
   5258 	}
   5259 
   5260 	span.End()
   5261 	return out, metadata, err
   5262 }
   5263 
   5264 func awsRestxml_deserializeOpErrorGetHealthCheckStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5265 	var errorBuffer bytes.Buffer
   5266 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5267 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5268 	}
   5269 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5270 
   5271 	errorCode := "UnknownError"
   5272 	errorMessage := errorCode
   5273 
   5274 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5275 	if err != nil {
   5276 		return err
   5277 	}
   5278 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5279 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5280 	}
   5281 	if len(errorComponents.Code) != 0 {
   5282 		errorCode = errorComponents.Code
   5283 	}
   5284 	if len(errorComponents.Message) != 0 {
   5285 		errorMessage = errorComponents.Message
   5286 	}
   5287 	errorBody.Seek(0, io.SeekStart)
   5288 	switch {
   5289 	case strings.EqualFold("InvalidInput", errorCode):
   5290 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5291 
   5292 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   5293 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   5294 
   5295 	default:
   5296 		genericError := &smithy.GenericAPIError{
   5297 			Code:    errorCode,
   5298 			Message: errorMessage,
   5299 		}
   5300 		return genericError
   5301 
   5302 	}
   5303 }
   5304 
   5305 func awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(v **GetHealthCheckStatusOutput, decoder smithyxml.NodeDecoder) error {
   5306 	if v == nil {
   5307 		return fmt.Errorf("unexpected nil of type %T", v)
   5308 	}
   5309 	var sv *GetHealthCheckStatusOutput
   5310 	if *v == nil {
   5311 		sv = &GetHealthCheckStatusOutput{}
   5312 	} else {
   5313 		sv = *v
   5314 	}
   5315 
   5316 	for {
   5317 		t, done, err := decoder.Token()
   5318 		if err != nil {
   5319 			return err
   5320 		}
   5321 		if done {
   5322 			break
   5323 		}
   5324 		originalDecoder := decoder
   5325 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5326 		switch {
   5327 		case strings.EqualFold("HealthCheckObservations", t.Name.Local):
   5328 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5329 			if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil {
   5330 				return err
   5331 			}
   5332 
   5333 		default:
   5334 			// Do nothing and ignore the unexpected tag element
   5335 			err = decoder.Decoder.Skip()
   5336 			if err != nil {
   5337 				return err
   5338 			}
   5339 
   5340 		}
   5341 		decoder = originalDecoder
   5342 	}
   5343 	*v = sv
   5344 	return nil
   5345 }
   5346 
   5347 type awsRestxml_deserializeOpGetHostedZone struct {
   5348 }
   5349 
   5350 func (*awsRestxml_deserializeOpGetHostedZone) ID() string {
   5351 	return "OperationDeserializer"
   5352 }
   5353 
   5354 func (m *awsRestxml_deserializeOpGetHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5355 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5356 ) {
   5357 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5358 	if err != nil {
   5359 		return out, metadata, err
   5360 	}
   5361 
   5362 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5363 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5364 	defer endTimer()
   5365 	defer span.End()
   5366 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5367 	if !ok {
   5368 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5369 	}
   5370 
   5371 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5372 		return out, metadata, awsRestxml_deserializeOpErrorGetHostedZone(response, &metadata)
   5373 	}
   5374 	output := &GetHostedZoneOutput{}
   5375 	out.Result = output
   5376 
   5377 	var buff [1024]byte
   5378 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5379 	body := io.TeeReader(response.Body, ringBuffer)
   5380 	rootDecoder := xml.NewDecoder(body)
   5381 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5382 	if err == io.EOF {
   5383 		return out, metadata, nil
   5384 	}
   5385 	if err != nil {
   5386 		var snapshot bytes.Buffer
   5387 		io.Copy(&snapshot, ringBuffer)
   5388 		return out, metadata, &smithy.DeserializationError{
   5389 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5390 			Snapshot: snapshot.Bytes(),
   5391 		}
   5392 	}
   5393 
   5394 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5395 	err = awsRestxml_deserializeOpDocumentGetHostedZoneOutput(&output, decoder)
   5396 	if err != nil {
   5397 		var snapshot bytes.Buffer
   5398 		io.Copy(&snapshot, ringBuffer)
   5399 		return out, metadata, &smithy.DeserializationError{
   5400 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5401 			Snapshot: snapshot.Bytes(),
   5402 		}
   5403 	}
   5404 
   5405 	span.End()
   5406 	return out, metadata, err
   5407 }
   5408 
   5409 func awsRestxml_deserializeOpErrorGetHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5410 	var errorBuffer bytes.Buffer
   5411 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5412 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5413 	}
   5414 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5415 
   5416 	errorCode := "UnknownError"
   5417 	errorMessage := errorCode
   5418 
   5419 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5420 	if err != nil {
   5421 		return err
   5422 	}
   5423 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5424 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5425 	}
   5426 	if len(errorComponents.Code) != 0 {
   5427 		errorCode = errorComponents.Code
   5428 	}
   5429 	if len(errorComponents.Message) != 0 {
   5430 		errorMessage = errorComponents.Message
   5431 	}
   5432 	errorBody.Seek(0, io.SeekStart)
   5433 	switch {
   5434 	case strings.EqualFold("InvalidInput", errorCode):
   5435 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5436 
   5437 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   5438 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   5439 
   5440 	default:
   5441 		genericError := &smithy.GenericAPIError{
   5442 			Code:    errorCode,
   5443 			Message: errorMessage,
   5444 		}
   5445 		return genericError
   5446 
   5447 	}
   5448 }
   5449 
   5450 func awsRestxml_deserializeOpDocumentGetHostedZoneOutput(v **GetHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   5451 	if v == nil {
   5452 		return fmt.Errorf("unexpected nil of type %T", v)
   5453 	}
   5454 	var sv *GetHostedZoneOutput
   5455 	if *v == nil {
   5456 		sv = &GetHostedZoneOutput{}
   5457 	} else {
   5458 		sv = *v
   5459 	}
   5460 
   5461 	for {
   5462 		t, done, err := decoder.Token()
   5463 		if err != nil {
   5464 			return err
   5465 		}
   5466 		if done {
   5467 			break
   5468 		}
   5469 		originalDecoder := decoder
   5470 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5471 		switch {
   5472 		case strings.EqualFold("DelegationSet", t.Name.Local):
   5473 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5474 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   5475 				return err
   5476 			}
   5477 
   5478 		case strings.EqualFold("HostedZone", t.Name.Local):
   5479 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5480 			if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
   5481 				return err
   5482 			}
   5483 
   5484 		case strings.EqualFold("VPCs", t.Name.Local):
   5485 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5486 			if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil {
   5487 				return err
   5488 			}
   5489 
   5490 		default:
   5491 			// Do nothing and ignore the unexpected tag element
   5492 			err = decoder.Decoder.Skip()
   5493 			if err != nil {
   5494 				return err
   5495 			}
   5496 
   5497 		}
   5498 		decoder = originalDecoder
   5499 	}
   5500 	*v = sv
   5501 	return nil
   5502 }
   5503 
   5504 type awsRestxml_deserializeOpGetHostedZoneCount struct {
   5505 }
   5506 
   5507 func (*awsRestxml_deserializeOpGetHostedZoneCount) ID() string {
   5508 	return "OperationDeserializer"
   5509 }
   5510 
   5511 func (m *awsRestxml_deserializeOpGetHostedZoneCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5512 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5513 ) {
   5514 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5515 	if err != nil {
   5516 		return out, metadata, err
   5517 	}
   5518 
   5519 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5520 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5521 	defer endTimer()
   5522 	defer span.End()
   5523 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5524 	if !ok {
   5525 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5526 	}
   5527 
   5528 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5529 		return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneCount(response, &metadata)
   5530 	}
   5531 	output := &GetHostedZoneCountOutput{}
   5532 	out.Result = output
   5533 
   5534 	var buff [1024]byte
   5535 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5536 	body := io.TeeReader(response.Body, ringBuffer)
   5537 	rootDecoder := xml.NewDecoder(body)
   5538 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5539 	if err == io.EOF {
   5540 		return out, metadata, nil
   5541 	}
   5542 	if err != nil {
   5543 		var snapshot bytes.Buffer
   5544 		io.Copy(&snapshot, ringBuffer)
   5545 		return out, metadata, &smithy.DeserializationError{
   5546 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5547 			Snapshot: snapshot.Bytes(),
   5548 		}
   5549 	}
   5550 
   5551 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5552 	err = awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(&output, decoder)
   5553 	if err != nil {
   5554 		var snapshot bytes.Buffer
   5555 		io.Copy(&snapshot, ringBuffer)
   5556 		return out, metadata, &smithy.DeserializationError{
   5557 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5558 			Snapshot: snapshot.Bytes(),
   5559 		}
   5560 	}
   5561 
   5562 	span.End()
   5563 	return out, metadata, err
   5564 }
   5565 
   5566 func awsRestxml_deserializeOpErrorGetHostedZoneCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5567 	var errorBuffer bytes.Buffer
   5568 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5569 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5570 	}
   5571 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5572 
   5573 	errorCode := "UnknownError"
   5574 	errorMessage := errorCode
   5575 
   5576 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5577 	if err != nil {
   5578 		return err
   5579 	}
   5580 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5581 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5582 	}
   5583 	if len(errorComponents.Code) != 0 {
   5584 		errorCode = errorComponents.Code
   5585 	}
   5586 	if len(errorComponents.Message) != 0 {
   5587 		errorMessage = errorComponents.Message
   5588 	}
   5589 	errorBody.Seek(0, io.SeekStart)
   5590 	switch {
   5591 	case strings.EqualFold("InvalidInput", errorCode):
   5592 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5593 
   5594 	default:
   5595 		genericError := &smithy.GenericAPIError{
   5596 			Code:    errorCode,
   5597 			Message: errorMessage,
   5598 		}
   5599 		return genericError
   5600 
   5601 	}
   5602 }
   5603 
   5604 func awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(v **GetHostedZoneCountOutput, decoder smithyxml.NodeDecoder) error {
   5605 	if v == nil {
   5606 		return fmt.Errorf("unexpected nil of type %T", v)
   5607 	}
   5608 	var sv *GetHostedZoneCountOutput
   5609 	if *v == nil {
   5610 		sv = &GetHostedZoneCountOutput{}
   5611 	} else {
   5612 		sv = *v
   5613 	}
   5614 
   5615 	for {
   5616 		t, done, err := decoder.Token()
   5617 		if err != nil {
   5618 			return err
   5619 		}
   5620 		if done {
   5621 			break
   5622 		}
   5623 		originalDecoder := decoder
   5624 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5625 		switch {
   5626 		case strings.EqualFold("HostedZoneCount", t.Name.Local):
   5627 			val, err := decoder.Value()
   5628 			if err != nil {
   5629 				return err
   5630 			}
   5631 			if val == nil {
   5632 				break
   5633 			}
   5634 			{
   5635 				xtv := string(val)
   5636 				i64, err := strconv.ParseInt(xtv, 10, 64)
   5637 				if err != nil {
   5638 					return err
   5639 				}
   5640 				sv.HostedZoneCount = ptr.Int64(i64)
   5641 			}
   5642 
   5643 		default:
   5644 			// Do nothing and ignore the unexpected tag element
   5645 			err = decoder.Decoder.Skip()
   5646 			if err != nil {
   5647 				return err
   5648 			}
   5649 
   5650 		}
   5651 		decoder = originalDecoder
   5652 	}
   5653 	*v = sv
   5654 	return nil
   5655 }
   5656 
   5657 type awsRestxml_deserializeOpGetHostedZoneLimit struct {
   5658 }
   5659 
   5660 func (*awsRestxml_deserializeOpGetHostedZoneLimit) ID() string {
   5661 	return "OperationDeserializer"
   5662 }
   5663 
   5664 func (m *awsRestxml_deserializeOpGetHostedZoneLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5665 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5666 ) {
   5667 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5668 	if err != nil {
   5669 		return out, metadata, err
   5670 	}
   5671 
   5672 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5673 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5674 	defer endTimer()
   5675 	defer span.End()
   5676 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5677 	if !ok {
   5678 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5679 	}
   5680 
   5681 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5682 		return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneLimit(response, &metadata)
   5683 	}
   5684 	output := &GetHostedZoneLimitOutput{}
   5685 	out.Result = output
   5686 
   5687 	var buff [1024]byte
   5688 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5689 	body := io.TeeReader(response.Body, ringBuffer)
   5690 	rootDecoder := xml.NewDecoder(body)
   5691 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5692 	if err == io.EOF {
   5693 		return out, metadata, nil
   5694 	}
   5695 	if err != nil {
   5696 		var snapshot bytes.Buffer
   5697 		io.Copy(&snapshot, ringBuffer)
   5698 		return out, metadata, &smithy.DeserializationError{
   5699 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5700 			Snapshot: snapshot.Bytes(),
   5701 		}
   5702 	}
   5703 
   5704 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5705 	err = awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(&output, decoder)
   5706 	if err != nil {
   5707 		var snapshot bytes.Buffer
   5708 		io.Copy(&snapshot, ringBuffer)
   5709 		return out, metadata, &smithy.DeserializationError{
   5710 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5711 			Snapshot: snapshot.Bytes(),
   5712 		}
   5713 	}
   5714 
   5715 	span.End()
   5716 	return out, metadata, err
   5717 }
   5718 
   5719 func awsRestxml_deserializeOpErrorGetHostedZoneLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5720 	var errorBuffer bytes.Buffer
   5721 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5722 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5723 	}
   5724 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5725 
   5726 	errorCode := "UnknownError"
   5727 	errorMessage := errorCode
   5728 
   5729 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5730 	if err != nil {
   5731 		return err
   5732 	}
   5733 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5734 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5735 	}
   5736 	if len(errorComponents.Code) != 0 {
   5737 		errorCode = errorComponents.Code
   5738 	}
   5739 	if len(errorComponents.Message) != 0 {
   5740 		errorMessage = errorComponents.Message
   5741 	}
   5742 	errorBody.Seek(0, io.SeekStart)
   5743 	switch {
   5744 	case strings.EqualFold("HostedZoneNotPrivate", errorCode):
   5745 		return awsRestxml_deserializeErrorHostedZoneNotPrivate(response, errorBody)
   5746 
   5747 	case strings.EqualFold("InvalidInput", errorCode):
   5748 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5749 
   5750 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   5751 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   5752 
   5753 	default:
   5754 		genericError := &smithy.GenericAPIError{
   5755 			Code:    errorCode,
   5756 			Message: errorMessage,
   5757 		}
   5758 		return genericError
   5759 
   5760 	}
   5761 }
   5762 
   5763 func awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(v **GetHostedZoneLimitOutput, decoder smithyxml.NodeDecoder) error {
   5764 	if v == nil {
   5765 		return fmt.Errorf("unexpected nil of type %T", v)
   5766 	}
   5767 	var sv *GetHostedZoneLimitOutput
   5768 	if *v == nil {
   5769 		sv = &GetHostedZoneLimitOutput{}
   5770 	} else {
   5771 		sv = *v
   5772 	}
   5773 
   5774 	for {
   5775 		t, done, err := decoder.Token()
   5776 		if err != nil {
   5777 			return err
   5778 		}
   5779 		if done {
   5780 			break
   5781 		}
   5782 		originalDecoder := decoder
   5783 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5784 		switch {
   5785 		case strings.EqualFold("Count", t.Name.Local):
   5786 			val, err := decoder.Value()
   5787 			if err != nil {
   5788 				return err
   5789 			}
   5790 			if val == nil {
   5791 				break
   5792 			}
   5793 			{
   5794 				xtv := string(val)
   5795 				i64, err := strconv.ParseInt(xtv, 10, 64)
   5796 				if err != nil {
   5797 					return err
   5798 				}
   5799 				sv.Count = i64
   5800 			}
   5801 
   5802 		case strings.EqualFold("Limit", t.Name.Local):
   5803 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5804 			if err := awsRestxml_deserializeDocumentHostedZoneLimit(&sv.Limit, nodeDecoder); err != nil {
   5805 				return err
   5806 			}
   5807 
   5808 		default:
   5809 			// Do nothing and ignore the unexpected tag element
   5810 			err = decoder.Decoder.Skip()
   5811 			if err != nil {
   5812 				return err
   5813 			}
   5814 
   5815 		}
   5816 		decoder = originalDecoder
   5817 	}
   5818 	*v = sv
   5819 	return nil
   5820 }
   5821 
   5822 type awsRestxml_deserializeOpGetQueryLoggingConfig struct {
   5823 }
   5824 
   5825 func (*awsRestxml_deserializeOpGetQueryLoggingConfig) ID() string {
   5826 	return "OperationDeserializer"
   5827 }
   5828 
   5829 func (m *awsRestxml_deserializeOpGetQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5830 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5831 ) {
   5832 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5833 	if err != nil {
   5834 		return out, metadata, err
   5835 	}
   5836 
   5837 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5838 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5839 	defer endTimer()
   5840 	defer span.End()
   5841 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5842 	if !ok {
   5843 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5844 	}
   5845 
   5846 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5847 		return out, metadata, awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response, &metadata)
   5848 	}
   5849 	output := &GetQueryLoggingConfigOutput{}
   5850 	out.Result = output
   5851 
   5852 	var buff [1024]byte
   5853 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5854 	body := io.TeeReader(response.Body, ringBuffer)
   5855 	rootDecoder := xml.NewDecoder(body)
   5856 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5857 	if err == io.EOF {
   5858 		return out, metadata, nil
   5859 	}
   5860 	if err != nil {
   5861 		var snapshot bytes.Buffer
   5862 		io.Copy(&snapshot, ringBuffer)
   5863 		return out, metadata, &smithy.DeserializationError{
   5864 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5865 			Snapshot: snapshot.Bytes(),
   5866 		}
   5867 	}
   5868 
   5869 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5870 	err = awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(&output, decoder)
   5871 	if err != nil {
   5872 		var snapshot bytes.Buffer
   5873 		io.Copy(&snapshot, ringBuffer)
   5874 		return out, metadata, &smithy.DeserializationError{
   5875 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5876 			Snapshot: snapshot.Bytes(),
   5877 		}
   5878 	}
   5879 
   5880 	span.End()
   5881 	return out, metadata, err
   5882 }
   5883 
   5884 func awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5885 	var errorBuffer bytes.Buffer
   5886 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5887 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5888 	}
   5889 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5890 
   5891 	errorCode := "UnknownError"
   5892 	errorMessage := errorCode
   5893 
   5894 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5895 	if err != nil {
   5896 		return err
   5897 	}
   5898 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5899 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5900 	}
   5901 	if len(errorComponents.Code) != 0 {
   5902 		errorCode = errorComponents.Code
   5903 	}
   5904 	if len(errorComponents.Message) != 0 {
   5905 		errorMessage = errorComponents.Message
   5906 	}
   5907 	errorBody.Seek(0, io.SeekStart)
   5908 	switch {
   5909 	case strings.EqualFold("InvalidInput", errorCode):
   5910 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5911 
   5912 	case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode):
   5913 		return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody)
   5914 
   5915 	default:
   5916 		genericError := &smithy.GenericAPIError{
   5917 			Code:    errorCode,
   5918 			Message: errorMessage,
   5919 		}
   5920 		return genericError
   5921 
   5922 	}
   5923 }
   5924 
   5925 func awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(v **GetQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error {
   5926 	if v == nil {
   5927 		return fmt.Errorf("unexpected nil of type %T", v)
   5928 	}
   5929 	var sv *GetQueryLoggingConfigOutput
   5930 	if *v == nil {
   5931 		sv = &GetQueryLoggingConfigOutput{}
   5932 	} else {
   5933 		sv = *v
   5934 	}
   5935 
   5936 	for {
   5937 		t, done, err := decoder.Token()
   5938 		if err != nil {
   5939 			return err
   5940 		}
   5941 		if done {
   5942 			break
   5943 		}
   5944 		originalDecoder := decoder
   5945 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5946 		switch {
   5947 		case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
   5948 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5949 			if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil {
   5950 				return err
   5951 			}
   5952 
   5953 		default:
   5954 			// Do nothing and ignore the unexpected tag element
   5955 			err = decoder.Decoder.Skip()
   5956 			if err != nil {
   5957 				return err
   5958 			}
   5959 
   5960 		}
   5961 		decoder = originalDecoder
   5962 	}
   5963 	*v = sv
   5964 	return nil
   5965 }
   5966 
   5967 type awsRestxml_deserializeOpGetReusableDelegationSet struct {
   5968 }
   5969 
   5970 func (*awsRestxml_deserializeOpGetReusableDelegationSet) ID() string {
   5971 	return "OperationDeserializer"
   5972 }
   5973 
   5974 func (m *awsRestxml_deserializeOpGetReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5975 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5976 ) {
   5977 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5978 	if err != nil {
   5979 		return out, metadata, err
   5980 	}
   5981 
   5982 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   5983 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   5984 	defer endTimer()
   5985 	defer span.End()
   5986 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5987 	if !ok {
   5988 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5989 	}
   5990 
   5991 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5992 		return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSet(response, &metadata)
   5993 	}
   5994 	output := &GetReusableDelegationSetOutput{}
   5995 	out.Result = output
   5996 
   5997 	var buff [1024]byte
   5998 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5999 	body := io.TeeReader(response.Body, ringBuffer)
   6000 	rootDecoder := xml.NewDecoder(body)
   6001 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6002 	if err == io.EOF {
   6003 		return out, metadata, nil
   6004 	}
   6005 	if err != nil {
   6006 		var snapshot bytes.Buffer
   6007 		io.Copy(&snapshot, ringBuffer)
   6008 		return out, metadata, &smithy.DeserializationError{
   6009 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6010 			Snapshot: snapshot.Bytes(),
   6011 		}
   6012 	}
   6013 
   6014 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6015 	err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(&output, decoder)
   6016 	if err != nil {
   6017 		var snapshot bytes.Buffer
   6018 		io.Copy(&snapshot, ringBuffer)
   6019 		return out, metadata, &smithy.DeserializationError{
   6020 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6021 			Snapshot: snapshot.Bytes(),
   6022 		}
   6023 	}
   6024 
   6025 	span.End()
   6026 	return out, metadata, err
   6027 }
   6028 
   6029 func awsRestxml_deserializeOpErrorGetReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6030 	var errorBuffer bytes.Buffer
   6031 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6032 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6033 	}
   6034 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6035 
   6036 	errorCode := "UnknownError"
   6037 	errorMessage := errorCode
   6038 
   6039 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6040 	if err != nil {
   6041 		return err
   6042 	}
   6043 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6044 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6045 	}
   6046 	if len(errorComponents.Code) != 0 {
   6047 		errorCode = errorComponents.Code
   6048 	}
   6049 	if len(errorComponents.Message) != 0 {
   6050 		errorMessage = errorComponents.Message
   6051 	}
   6052 	errorBody.Seek(0, io.SeekStart)
   6053 	switch {
   6054 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   6055 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   6056 
   6057 	case strings.EqualFold("InvalidInput", errorCode):
   6058 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6059 
   6060 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   6061 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   6062 
   6063 	default:
   6064 		genericError := &smithy.GenericAPIError{
   6065 			Code:    errorCode,
   6066 			Message: errorMessage,
   6067 		}
   6068 		return genericError
   6069 
   6070 	}
   6071 }
   6072 
   6073 func awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(v **GetReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error {
   6074 	if v == nil {
   6075 		return fmt.Errorf("unexpected nil of type %T", v)
   6076 	}
   6077 	var sv *GetReusableDelegationSetOutput
   6078 	if *v == nil {
   6079 		sv = &GetReusableDelegationSetOutput{}
   6080 	} else {
   6081 		sv = *v
   6082 	}
   6083 
   6084 	for {
   6085 		t, done, err := decoder.Token()
   6086 		if err != nil {
   6087 			return err
   6088 		}
   6089 		if done {
   6090 			break
   6091 		}
   6092 		originalDecoder := decoder
   6093 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6094 		switch {
   6095 		case strings.EqualFold("DelegationSet", t.Name.Local):
   6096 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6097 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   6098 				return err
   6099 			}
   6100 
   6101 		default:
   6102 			// Do nothing and ignore the unexpected tag element
   6103 			err = decoder.Decoder.Skip()
   6104 			if err != nil {
   6105 				return err
   6106 			}
   6107 
   6108 		}
   6109 		decoder = originalDecoder
   6110 	}
   6111 	*v = sv
   6112 	return nil
   6113 }
   6114 
   6115 type awsRestxml_deserializeOpGetReusableDelegationSetLimit struct {
   6116 }
   6117 
   6118 func (*awsRestxml_deserializeOpGetReusableDelegationSetLimit) ID() string {
   6119 	return "OperationDeserializer"
   6120 }
   6121 
   6122 func (m *awsRestxml_deserializeOpGetReusableDelegationSetLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6123 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6124 ) {
   6125 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6126 	if err != nil {
   6127 		return out, metadata, err
   6128 	}
   6129 
   6130 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6131 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6132 	defer endTimer()
   6133 	defer span.End()
   6134 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6135 	if !ok {
   6136 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6137 	}
   6138 
   6139 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6140 		return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response, &metadata)
   6141 	}
   6142 	output := &GetReusableDelegationSetLimitOutput{}
   6143 	out.Result = output
   6144 
   6145 	var buff [1024]byte
   6146 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6147 	body := io.TeeReader(response.Body, ringBuffer)
   6148 	rootDecoder := xml.NewDecoder(body)
   6149 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6150 	if err == io.EOF {
   6151 		return out, metadata, nil
   6152 	}
   6153 	if err != nil {
   6154 		var snapshot bytes.Buffer
   6155 		io.Copy(&snapshot, ringBuffer)
   6156 		return out, metadata, &smithy.DeserializationError{
   6157 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6158 			Snapshot: snapshot.Bytes(),
   6159 		}
   6160 	}
   6161 
   6162 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6163 	err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(&output, decoder)
   6164 	if err != nil {
   6165 		var snapshot bytes.Buffer
   6166 		io.Copy(&snapshot, ringBuffer)
   6167 		return out, metadata, &smithy.DeserializationError{
   6168 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6169 			Snapshot: snapshot.Bytes(),
   6170 		}
   6171 	}
   6172 
   6173 	span.End()
   6174 	return out, metadata, err
   6175 }
   6176 
   6177 func awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6178 	var errorBuffer bytes.Buffer
   6179 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6180 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6181 	}
   6182 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6183 
   6184 	errorCode := "UnknownError"
   6185 	errorMessage := errorCode
   6186 
   6187 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6188 	if err != nil {
   6189 		return err
   6190 	}
   6191 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6192 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6193 	}
   6194 	if len(errorComponents.Code) != 0 {
   6195 		errorCode = errorComponents.Code
   6196 	}
   6197 	if len(errorComponents.Message) != 0 {
   6198 		errorMessage = errorComponents.Message
   6199 	}
   6200 	errorBody.Seek(0, io.SeekStart)
   6201 	switch {
   6202 	case strings.EqualFold("InvalidInput", errorCode):
   6203 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6204 
   6205 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   6206 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   6207 
   6208 	default:
   6209 		genericError := &smithy.GenericAPIError{
   6210 			Code:    errorCode,
   6211 			Message: errorMessage,
   6212 		}
   6213 		return genericError
   6214 
   6215 	}
   6216 }
   6217 
   6218 func awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(v **GetReusableDelegationSetLimitOutput, decoder smithyxml.NodeDecoder) error {
   6219 	if v == nil {
   6220 		return fmt.Errorf("unexpected nil of type %T", v)
   6221 	}
   6222 	var sv *GetReusableDelegationSetLimitOutput
   6223 	if *v == nil {
   6224 		sv = &GetReusableDelegationSetLimitOutput{}
   6225 	} else {
   6226 		sv = *v
   6227 	}
   6228 
   6229 	for {
   6230 		t, done, err := decoder.Token()
   6231 		if err != nil {
   6232 			return err
   6233 		}
   6234 		if done {
   6235 			break
   6236 		}
   6237 		originalDecoder := decoder
   6238 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6239 		switch {
   6240 		case strings.EqualFold("Count", t.Name.Local):
   6241 			val, err := decoder.Value()
   6242 			if err != nil {
   6243 				return err
   6244 			}
   6245 			if val == nil {
   6246 				break
   6247 			}
   6248 			{
   6249 				xtv := string(val)
   6250 				i64, err := strconv.ParseInt(xtv, 10, 64)
   6251 				if err != nil {
   6252 					return err
   6253 				}
   6254 				sv.Count = i64
   6255 			}
   6256 
   6257 		case strings.EqualFold("Limit", t.Name.Local):
   6258 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6259 			if err := awsRestxml_deserializeDocumentReusableDelegationSetLimit(&sv.Limit, nodeDecoder); err != nil {
   6260 				return err
   6261 			}
   6262 
   6263 		default:
   6264 			// Do nothing and ignore the unexpected tag element
   6265 			err = decoder.Decoder.Skip()
   6266 			if err != nil {
   6267 				return err
   6268 			}
   6269 
   6270 		}
   6271 		decoder = originalDecoder
   6272 	}
   6273 	*v = sv
   6274 	return nil
   6275 }
   6276 
   6277 type awsRestxml_deserializeOpGetTrafficPolicy struct {
   6278 }
   6279 
   6280 func (*awsRestxml_deserializeOpGetTrafficPolicy) ID() string {
   6281 	return "OperationDeserializer"
   6282 }
   6283 
   6284 func (m *awsRestxml_deserializeOpGetTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6285 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6286 ) {
   6287 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6288 	if err != nil {
   6289 		return out, metadata, err
   6290 	}
   6291 
   6292 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6293 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6294 	defer endTimer()
   6295 	defer span.End()
   6296 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6297 	if !ok {
   6298 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6299 	}
   6300 
   6301 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6302 		return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicy(response, &metadata)
   6303 	}
   6304 	output := &GetTrafficPolicyOutput{}
   6305 	out.Result = output
   6306 
   6307 	var buff [1024]byte
   6308 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6309 	body := io.TeeReader(response.Body, ringBuffer)
   6310 	rootDecoder := xml.NewDecoder(body)
   6311 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6312 	if err == io.EOF {
   6313 		return out, metadata, nil
   6314 	}
   6315 	if err != nil {
   6316 		var snapshot bytes.Buffer
   6317 		io.Copy(&snapshot, ringBuffer)
   6318 		return out, metadata, &smithy.DeserializationError{
   6319 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6320 			Snapshot: snapshot.Bytes(),
   6321 		}
   6322 	}
   6323 
   6324 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6325 	err = awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(&output, decoder)
   6326 	if err != nil {
   6327 		var snapshot bytes.Buffer
   6328 		io.Copy(&snapshot, ringBuffer)
   6329 		return out, metadata, &smithy.DeserializationError{
   6330 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6331 			Snapshot: snapshot.Bytes(),
   6332 		}
   6333 	}
   6334 
   6335 	span.End()
   6336 	return out, metadata, err
   6337 }
   6338 
   6339 func awsRestxml_deserializeOpErrorGetTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6340 	var errorBuffer bytes.Buffer
   6341 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6342 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6343 	}
   6344 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6345 
   6346 	errorCode := "UnknownError"
   6347 	errorMessage := errorCode
   6348 
   6349 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6350 	if err != nil {
   6351 		return err
   6352 	}
   6353 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6354 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6355 	}
   6356 	if len(errorComponents.Code) != 0 {
   6357 		errorCode = errorComponents.Code
   6358 	}
   6359 	if len(errorComponents.Message) != 0 {
   6360 		errorMessage = errorComponents.Message
   6361 	}
   6362 	errorBody.Seek(0, io.SeekStart)
   6363 	switch {
   6364 	case strings.EqualFold("InvalidInput", errorCode):
   6365 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6366 
   6367 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   6368 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   6369 
   6370 	default:
   6371 		genericError := &smithy.GenericAPIError{
   6372 			Code:    errorCode,
   6373 			Message: errorMessage,
   6374 		}
   6375 		return genericError
   6376 
   6377 	}
   6378 }
   6379 
   6380 func awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(v **GetTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error {
   6381 	if v == nil {
   6382 		return fmt.Errorf("unexpected nil of type %T", v)
   6383 	}
   6384 	var sv *GetTrafficPolicyOutput
   6385 	if *v == nil {
   6386 		sv = &GetTrafficPolicyOutput{}
   6387 	} else {
   6388 		sv = *v
   6389 	}
   6390 
   6391 	for {
   6392 		t, done, err := decoder.Token()
   6393 		if err != nil {
   6394 			return err
   6395 		}
   6396 		if done {
   6397 			break
   6398 		}
   6399 		originalDecoder := decoder
   6400 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6401 		switch {
   6402 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
   6403 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6404 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
   6405 				return err
   6406 			}
   6407 
   6408 		default:
   6409 			// Do nothing and ignore the unexpected tag element
   6410 			err = decoder.Decoder.Skip()
   6411 			if err != nil {
   6412 				return err
   6413 			}
   6414 
   6415 		}
   6416 		decoder = originalDecoder
   6417 	}
   6418 	*v = sv
   6419 	return nil
   6420 }
   6421 
   6422 type awsRestxml_deserializeOpGetTrafficPolicyInstance struct {
   6423 }
   6424 
   6425 func (*awsRestxml_deserializeOpGetTrafficPolicyInstance) ID() string {
   6426 	return "OperationDeserializer"
   6427 }
   6428 
   6429 func (m *awsRestxml_deserializeOpGetTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6430 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6431 ) {
   6432 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6433 	if err != nil {
   6434 		return out, metadata, err
   6435 	}
   6436 
   6437 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6438 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6439 	defer endTimer()
   6440 	defer span.End()
   6441 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6442 	if !ok {
   6443 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6444 	}
   6445 
   6446 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6447 		return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response, &metadata)
   6448 	}
   6449 	output := &GetTrafficPolicyInstanceOutput{}
   6450 	out.Result = output
   6451 
   6452 	var buff [1024]byte
   6453 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6454 	body := io.TeeReader(response.Body, ringBuffer)
   6455 	rootDecoder := xml.NewDecoder(body)
   6456 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6457 	if err == io.EOF {
   6458 		return out, metadata, nil
   6459 	}
   6460 	if err != nil {
   6461 		var snapshot bytes.Buffer
   6462 		io.Copy(&snapshot, ringBuffer)
   6463 		return out, metadata, &smithy.DeserializationError{
   6464 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6465 			Snapshot: snapshot.Bytes(),
   6466 		}
   6467 	}
   6468 
   6469 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6470 	err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(&output, decoder)
   6471 	if err != nil {
   6472 		var snapshot bytes.Buffer
   6473 		io.Copy(&snapshot, ringBuffer)
   6474 		return out, metadata, &smithy.DeserializationError{
   6475 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6476 			Snapshot: snapshot.Bytes(),
   6477 		}
   6478 	}
   6479 
   6480 	span.End()
   6481 	return out, metadata, err
   6482 }
   6483 
   6484 func awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6485 	var errorBuffer bytes.Buffer
   6486 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6487 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6488 	}
   6489 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6490 
   6491 	errorCode := "UnknownError"
   6492 	errorMessage := errorCode
   6493 
   6494 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6495 	if err != nil {
   6496 		return err
   6497 	}
   6498 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6499 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6500 	}
   6501 	if len(errorComponents.Code) != 0 {
   6502 		errorCode = errorComponents.Code
   6503 	}
   6504 	if len(errorComponents.Message) != 0 {
   6505 		errorMessage = errorComponents.Message
   6506 	}
   6507 	errorBody.Seek(0, io.SeekStart)
   6508 	switch {
   6509 	case strings.EqualFold("InvalidInput", errorCode):
   6510 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6511 
   6512 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   6513 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   6514 
   6515 	default:
   6516 		genericError := &smithy.GenericAPIError{
   6517 			Code:    errorCode,
   6518 			Message: errorMessage,
   6519 		}
   6520 		return genericError
   6521 
   6522 	}
   6523 }
   6524 
   6525 func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(v **GetTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
   6526 	if v == nil {
   6527 		return fmt.Errorf("unexpected nil of type %T", v)
   6528 	}
   6529 	var sv *GetTrafficPolicyInstanceOutput
   6530 	if *v == nil {
   6531 		sv = &GetTrafficPolicyInstanceOutput{}
   6532 	} else {
   6533 		sv = *v
   6534 	}
   6535 
   6536 	for {
   6537 		t, done, err := decoder.Token()
   6538 		if err != nil {
   6539 			return err
   6540 		}
   6541 		if done {
   6542 			break
   6543 		}
   6544 		originalDecoder := decoder
   6545 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6546 		switch {
   6547 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
   6548 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6549 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
   6550 				return err
   6551 			}
   6552 
   6553 		default:
   6554 			// Do nothing and ignore the unexpected tag element
   6555 			err = decoder.Decoder.Skip()
   6556 			if err != nil {
   6557 				return err
   6558 			}
   6559 
   6560 		}
   6561 		decoder = originalDecoder
   6562 	}
   6563 	*v = sv
   6564 	return nil
   6565 }
   6566 
   6567 type awsRestxml_deserializeOpGetTrafficPolicyInstanceCount struct {
   6568 }
   6569 
   6570 func (*awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) ID() string {
   6571 	return "OperationDeserializer"
   6572 }
   6573 
   6574 func (m *awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6575 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6576 ) {
   6577 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6578 	if err != nil {
   6579 		return out, metadata, err
   6580 	}
   6581 
   6582 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6583 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6584 	defer endTimer()
   6585 	defer span.End()
   6586 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6587 	if !ok {
   6588 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6589 	}
   6590 
   6591 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6592 		return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response, &metadata)
   6593 	}
   6594 	output := &GetTrafficPolicyInstanceCountOutput{}
   6595 	out.Result = output
   6596 
   6597 	var buff [1024]byte
   6598 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6599 	body := io.TeeReader(response.Body, ringBuffer)
   6600 	rootDecoder := xml.NewDecoder(body)
   6601 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6602 	if err == io.EOF {
   6603 		return out, metadata, nil
   6604 	}
   6605 	if err != nil {
   6606 		var snapshot bytes.Buffer
   6607 		io.Copy(&snapshot, ringBuffer)
   6608 		return out, metadata, &smithy.DeserializationError{
   6609 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6610 			Snapshot: snapshot.Bytes(),
   6611 		}
   6612 	}
   6613 
   6614 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6615 	err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(&output, decoder)
   6616 	if err != nil {
   6617 		var snapshot bytes.Buffer
   6618 		io.Copy(&snapshot, ringBuffer)
   6619 		return out, metadata, &smithy.DeserializationError{
   6620 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6621 			Snapshot: snapshot.Bytes(),
   6622 		}
   6623 	}
   6624 
   6625 	span.End()
   6626 	return out, metadata, err
   6627 }
   6628 
   6629 func awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6630 	var errorBuffer bytes.Buffer
   6631 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6632 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6633 	}
   6634 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6635 
   6636 	errorCode := "UnknownError"
   6637 	errorMessage := errorCode
   6638 
   6639 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6640 	if err != nil {
   6641 		return err
   6642 	}
   6643 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6644 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6645 	}
   6646 	if len(errorComponents.Code) != 0 {
   6647 		errorCode = errorComponents.Code
   6648 	}
   6649 	if len(errorComponents.Message) != 0 {
   6650 		errorMessage = errorComponents.Message
   6651 	}
   6652 	errorBody.Seek(0, io.SeekStart)
   6653 	switch {
   6654 	default:
   6655 		genericError := &smithy.GenericAPIError{
   6656 			Code:    errorCode,
   6657 			Message: errorMessage,
   6658 		}
   6659 		return genericError
   6660 
   6661 	}
   6662 }
   6663 
   6664 func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(v **GetTrafficPolicyInstanceCountOutput, decoder smithyxml.NodeDecoder) error {
   6665 	if v == nil {
   6666 		return fmt.Errorf("unexpected nil of type %T", v)
   6667 	}
   6668 	var sv *GetTrafficPolicyInstanceCountOutput
   6669 	if *v == nil {
   6670 		sv = &GetTrafficPolicyInstanceCountOutput{}
   6671 	} else {
   6672 		sv = *v
   6673 	}
   6674 
   6675 	for {
   6676 		t, done, err := decoder.Token()
   6677 		if err != nil {
   6678 			return err
   6679 		}
   6680 		if done {
   6681 			break
   6682 		}
   6683 		originalDecoder := decoder
   6684 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6685 		switch {
   6686 		case strings.EqualFold("TrafficPolicyInstanceCount", t.Name.Local):
   6687 			val, err := decoder.Value()
   6688 			if err != nil {
   6689 				return err
   6690 			}
   6691 			if val == nil {
   6692 				break
   6693 			}
   6694 			{
   6695 				xtv := string(val)
   6696 				i64, err := strconv.ParseInt(xtv, 10, 64)
   6697 				if err != nil {
   6698 					return err
   6699 				}
   6700 				sv.TrafficPolicyInstanceCount = ptr.Int32(int32(i64))
   6701 			}
   6702 
   6703 		default:
   6704 			// Do nothing and ignore the unexpected tag element
   6705 			err = decoder.Decoder.Skip()
   6706 			if err != nil {
   6707 				return err
   6708 			}
   6709 
   6710 		}
   6711 		decoder = originalDecoder
   6712 	}
   6713 	*v = sv
   6714 	return nil
   6715 }
   6716 
   6717 type awsRestxml_deserializeOpListCidrBlocks struct {
   6718 }
   6719 
   6720 func (*awsRestxml_deserializeOpListCidrBlocks) ID() string {
   6721 	return "OperationDeserializer"
   6722 }
   6723 
   6724 func (m *awsRestxml_deserializeOpListCidrBlocks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6725 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6726 ) {
   6727 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6728 	if err != nil {
   6729 		return out, metadata, err
   6730 	}
   6731 
   6732 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6733 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6734 	defer endTimer()
   6735 	defer span.End()
   6736 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6737 	if !ok {
   6738 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6739 	}
   6740 
   6741 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6742 		return out, metadata, awsRestxml_deserializeOpErrorListCidrBlocks(response, &metadata)
   6743 	}
   6744 	output := &ListCidrBlocksOutput{}
   6745 	out.Result = output
   6746 
   6747 	var buff [1024]byte
   6748 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6749 	body := io.TeeReader(response.Body, ringBuffer)
   6750 	rootDecoder := xml.NewDecoder(body)
   6751 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6752 	if err == io.EOF {
   6753 		return out, metadata, nil
   6754 	}
   6755 	if err != nil {
   6756 		var snapshot bytes.Buffer
   6757 		io.Copy(&snapshot, ringBuffer)
   6758 		return out, metadata, &smithy.DeserializationError{
   6759 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6760 			Snapshot: snapshot.Bytes(),
   6761 		}
   6762 	}
   6763 
   6764 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6765 	err = awsRestxml_deserializeOpDocumentListCidrBlocksOutput(&output, decoder)
   6766 	if err != nil {
   6767 		var snapshot bytes.Buffer
   6768 		io.Copy(&snapshot, ringBuffer)
   6769 		return out, metadata, &smithy.DeserializationError{
   6770 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6771 			Snapshot: snapshot.Bytes(),
   6772 		}
   6773 	}
   6774 
   6775 	span.End()
   6776 	return out, metadata, err
   6777 }
   6778 
   6779 func awsRestxml_deserializeOpErrorListCidrBlocks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6780 	var errorBuffer bytes.Buffer
   6781 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6782 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6783 	}
   6784 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6785 
   6786 	errorCode := "UnknownError"
   6787 	errorMessage := errorCode
   6788 
   6789 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6790 	if err != nil {
   6791 		return err
   6792 	}
   6793 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6794 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6795 	}
   6796 	if len(errorComponents.Code) != 0 {
   6797 		errorCode = errorComponents.Code
   6798 	}
   6799 	if len(errorComponents.Message) != 0 {
   6800 		errorMessage = errorComponents.Message
   6801 	}
   6802 	errorBody.Seek(0, io.SeekStart)
   6803 	switch {
   6804 	case strings.EqualFold("InvalidInput", errorCode):
   6805 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6806 
   6807 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
   6808 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
   6809 
   6810 	case strings.EqualFold("NoSuchCidrLocationException", errorCode):
   6811 		return awsRestxml_deserializeErrorNoSuchCidrLocationException(response, errorBody)
   6812 
   6813 	default:
   6814 		genericError := &smithy.GenericAPIError{
   6815 			Code:    errorCode,
   6816 			Message: errorMessage,
   6817 		}
   6818 		return genericError
   6819 
   6820 	}
   6821 }
   6822 
   6823 func awsRestxml_deserializeOpDocumentListCidrBlocksOutput(v **ListCidrBlocksOutput, decoder smithyxml.NodeDecoder) error {
   6824 	if v == nil {
   6825 		return fmt.Errorf("unexpected nil of type %T", v)
   6826 	}
   6827 	var sv *ListCidrBlocksOutput
   6828 	if *v == nil {
   6829 		sv = &ListCidrBlocksOutput{}
   6830 	} else {
   6831 		sv = *v
   6832 	}
   6833 
   6834 	for {
   6835 		t, done, err := decoder.Token()
   6836 		if err != nil {
   6837 			return err
   6838 		}
   6839 		if done {
   6840 			break
   6841 		}
   6842 		originalDecoder := decoder
   6843 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6844 		switch {
   6845 		case strings.EqualFold("CidrBlocks", t.Name.Local):
   6846 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6847 			if err := awsRestxml_deserializeDocumentCidrBlockSummaries(&sv.CidrBlocks, nodeDecoder); err != nil {
   6848 				return err
   6849 			}
   6850 
   6851 		case strings.EqualFold("NextToken", t.Name.Local):
   6852 			val, err := decoder.Value()
   6853 			if err != nil {
   6854 				return err
   6855 			}
   6856 			if val == nil {
   6857 				break
   6858 			}
   6859 			{
   6860 				xtv := string(val)
   6861 				sv.NextToken = ptr.String(xtv)
   6862 			}
   6863 
   6864 		default:
   6865 			// Do nothing and ignore the unexpected tag element
   6866 			err = decoder.Decoder.Skip()
   6867 			if err != nil {
   6868 				return err
   6869 			}
   6870 
   6871 		}
   6872 		decoder = originalDecoder
   6873 	}
   6874 	*v = sv
   6875 	return nil
   6876 }
   6877 
   6878 type awsRestxml_deserializeOpListCidrCollections struct {
   6879 }
   6880 
   6881 func (*awsRestxml_deserializeOpListCidrCollections) ID() string {
   6882 	return "OperationDeserializer"
   6883 }
   6884 
   6885 func (m *awsRestxml_deserializeOpListCidrCollections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6886 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6887 ) {
   6888 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6889 	if err != nil {
   6890 		return out, metadata, err
   6891 	}
   6892 
   6893 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   6894 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   6895 	defer endTimer()
   6896 	defer span.End()
   6897 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6898 	if !ok {
   6899 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6900 	}
   6901 
   6902 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6903 		return out, metadata, awsRestxml_deserializeOpErrorListCidrCollections(response, &metadata)
   6904 	}
   6905 	output := &ListCidrCollectionsOutput{}
   6906 	out.Result = output
   6907 
   6908 	var buff [1024]byte
   6909 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6910 	body := io.TeeReader(response.Body, ringBuffer)
   6911 	rootDecoder := xml.NewDecoder(body)
   6912 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6913 	if err == io.EOF {
   6914 		return out, metadata, nil
   6915 	}
   6916 	if err != nil {
   6917 		var snapshot bytes.Buffer
   6918 		io.Copy(&snapshot, ringBuffer)
   6919 		return out, metadata, &smithy.DeserializationError{
   6920 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6921 			Snapshot: snapshot.Bytes(),
   6922 		}
   6923 	}
   6924 
   6925 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6926 	err = awsRestxml_deserializeOpDocumentListCidrCollectionsOutput(&output, decoder)
   6927 	if err != nil {
   6928 		var snapshot bytes.Buffer
   6929 		io.Copy(&snapshot, ringBuffer)
   6930 		return out, metadata, &smithy.DeserializationError{
   6931 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6932 			Snapshot: snapshot.Bytes(),
   6933 		}
   6934 	}
   6935 
   6936 	span.End()
   6937 	return out, metadata, err
   6938 }
   6939 
   6940 func awsRestxml_deserializeOpErrorListCidrCollections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6941 	var errorBuffer bytes.Buffer
   6942 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6943 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6944 	}
   6945 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6946 
   6947 	errorCode := "UnknownError"
   6948 	errorMessage := errorCode
   6949 
   6950 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6951 	if err != nil {
   6952 		return err
   6953 	}
   6954 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6955 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6956 	}
   6957 	if len(errorComponents.Code) != 0 {
   6958 		errorCode = errorComponents.Code
   6959 	}
   6960 	if len(errorComponents.Message) != 0 {
   6961 		errorMessage = errorComponents.Message
   6962 	}
   6963 	errorBody.Seek(0, io.SeekStart)
   6964 	switch {
   6965 	case strings.EqualFold("InvalidInput", errorCode):
   6966 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6967 
   6968 	default:
   6969 		genericError := &smithy.GenericAPIError{
   6970 			Code:    errorCode,
   6971 			Message: errorMessage,
   6972 		}
   6973 		return genericError
   6974 
   6975 	}
   6976 }
   6977 
   6978 func awsRestxml_deserializeOpDocumentListCidrCollectionsOutput(v **ListCidrCollectionsOutput, decoder smithyxml.NodeDecoder) error {
   6979 	if v == nil {
   6980 		return fmt.Errorf("unexpected nil of type %T", v)
   6981 	}
   6982 	var sv *ListCidrCollectionsOutput
   6983 	if *v == nil {
   6984 		sv = &ListCidrCollectionsOutput{}
   6985 	} else {
   6986 		sv = *v
   6987 	}
   6988 
   6989 	for {
   6990 		t, done, err := decoder.Token()
   6991 		if err != nil {
   6992 			return err
   6993 		}
   6994 		if done {
   6995 			break
   6996 		}
   6997 		originalDecoder := decoder
   6998 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6999 		switch {
   7000 		case strings.EqualFold("CidrCollections", t.Name.Local):
   7001 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7002 			if err := awsRestxml_deserializeDocumentCollectionSummaries(&sv.CidrCollections, nodeDecoder); err != nil {
   7003 				return err
   7004 			}
   7005 
   7006 		case strings.EqualFold("NextToken", t.Name.Local):
   7007 			val, err := decoder.Value()
   7008 			if err != nil {
   7009 				return err
   7010 			}
   7011 			if val == nil {
   7012 				break
   7013 			}
   7014 			{
   7015 				xtv := string(val)
   7016 				sv.NextToken = ptr.String(xtv)
   7017 			}
   7018 
   7019 		default:
   7020 			// Do nothing and ignore the unexpected tag element
   7021 			err = decoder.Decoder.Skip()
   7022 			if err != nil {
   7023 				return err
   7024 			}
   7025 
   7026 		}
   7027 		decoder = originalDecoder
   7028 	}
   7029 	*v = sv
   7030 	return nil
   7031 }
   7032 
   7033 type awsRestxml_deserializeOpListCidrLocations struct {
   7034 }
   7035 
   7036 func (*awsRestxml_deserializeOpListCidrLocations) ID() string {
   7037 	return "OperationDeserializer"
   7038 }
   7039 
   7040 func (m *awsRestxml_deserializeOpListCidrLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7041 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7042 ) {
   7043 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7044 	if err != nil {
   7045 		return out, metadata, err
   7046 	}
   7047 
   7048 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7049 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7050 	defer endTimer()
   7051 	defer span.End()
   7052 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7053 	if !ok {
   7054 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7055 	}
   7056 
   7057 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7058 		return out, metadata, awsRestxml_deserializeOpErrorListCidrLocations(response, &metadata)
   7059 	}
   7060 	output := &ListCidrLocationsOutput{}
   7061 	out.Result = output
   7062 
   7063 	var buff [1024]byte
   7064 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7065 	body := io.TeeReader(response.Body, ringBuffer)
   7066 	rootDecoder := xml.NewDecoder(body)
   7067 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7068 	if err == io.EOF {
   7069 		return out, metadata, nil
   7070 	}
   7071 	if err != nil {
   7072 		var snapshot bytes.Buffer
   7073 		io.Copy(&snapshot, ringBuffer)
   7074 		return out, metadata, &smithy.DeserializationError{
   7075 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7076 			Snapshot: snapshot.Bytes(),
   7077 		}
   7078 	}
   7079 
   7080 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7081 	err = awsRestxml_deserializeOpDocumentListCidrLocationsOutput(&output, decoder)
   7082 	if err != nil {
   7083 		var snapshot bytes.Buffer
   7084 		io.Copy(&snapshot, ringBuffer)
   7085 		return out, metadata, &smithy.DeserializationError{
   7086 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7087 			Snapshot: snapshot.Bytes(),
   7088 		}
   7089 	}
   7090 
   7091 	span.End()
   7092 	return out, metadata, err
   7093 }
   7094 
   7095 func awsRestxml_deserializeOpErrorListCidrLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7096 	var errorBuffer bytes.Buffer
   7097 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7098 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7099 	}
   7100 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7101 
   7102 	errorCode := "UnknownError"
   7103 	errorMessage := errorCode
   7104 
   7105 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7106 	if err != nil {
   7107 		return err
   7108 	}
   7109 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7110 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7111 	}
   7112 	if len(errorComponents.Code) != 0 {
   7113 		errorCode = errorComponents.Code
   7114 	}
   7115 	if len(errorComponents.Message) != 0 {
   7116 		errorMessage = errorComponents.Message
   7117 	}
   7118 	errorBody.Seek(0, io.SeekStart)
   7119 	switch {
   7120 	case strings.EqualFold("InvalidInput", errorCode):
   7121 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7122 
   7123 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
   7124 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
   7125 
   7126 	default:
   7127 		genericError := &smithy.GenericAPIError{
   7128 			Code:    errorCode,
   7129 			Message: errorMessage,
   7130 		}
   7131 		return genericError
   7132 
   7133 	}
   7134 }
   7135 
   7136 func awsRestxml_deserializeOpDocumentListCidrLocationsOutput(v **ListCidrLocationsOutput, decoder smithyxml.NodeDecoder) error {
   7137 	if v == nil {
   7138 		return fmt.Errorf("unexpected nil of type %T", v)
   7139 	}
   7140 	var sv *ListCidrLocationsOutput
   7141 	if *v == nil {
   7142 		sv = &ListCidrLocationsOutput{}
   7143 	} else {
   7144 		sv = *v
   7145 	}
   7146 
   7147 	for {
   7148 		t, done, err := decoder.Token()
   7149 		if err != nil {
   7150 			return err
   7151 		}
   7152 		if done {
   7153 			break
   7154 		}
   7155 		originalDecoder := decoder
   7156 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7157 		switch {
   7158 		case strings.EqualFold("CidrLocations", t.Name.Local):
   7159 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7160 			if err := awsRestxml_deserializeDocumentLocationSummaries(&sv.CidrLocations, nodeDecoder); err != nil {
   7161 				return err
   7162 			}
   7163 
   7164 		case strings.EqualFold("NextToken", t.Name.Local):
   7165 			val, err := decoder.Value()
   7166 			if err != nil {
   7167 				return err
   7168 			}
   7169 			if val == nil {
   7170 				break
   7171 			}
   7172 			{
   7173 				xtv := string(val)
   7174 				sv.NextToken = ptr.String(xtv)
   7175 			}
   7176 
   7177 		default:
   7178 			// Do nothing and ignore the unexpected tag element
   7179 			err = decoder.Decoder.Skip()
   7180 			if err != nil {
   7181 				return err
   7182 			}
   7183 
   7184 		}
   7185 		decoder = originalDecoder
   7186 	}
   7187 	*v = sv
   7188 	return nil
   7189 }
   7190 
   7191 type awsRestxml_deserializeOpListGeoLocations struct {
   7192 }
   7193 
   7194 func (*awsRestxml_deserializeOpListGeoLocations) ID() string {
   7195 	return "OperationDeserializer"
   7196 }
   7197 
   7198 func (m *awsRestxml_deserializeOpListGeoLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7199 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7200 ) {
   7201 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7202 	if err != nil {
   7203 		return out, metadata, err
   7204 	}
   7205 
   7206 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7207 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7208 	defer endTimer()
   7209 	defer span.End()
   7210 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7211 	if !ok {
   7212 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7213 	}
   7214 
   7215 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7216 		return out, metadata, awsRestxml_deserializeOpErrorListGeoLocations(response, &metadata)
   7217 	}
   7218 	output := &ListGeoLocationsOutput{}
   7219 	out.Result = output
   7220 
   7221 	var buff [1024]byte
   7222 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7223 	body := io.TeeReader(response.Body, ringBuffer)
   7224 	rootDecoder := xml.NewDecoder(body)
   7225 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7226 	if err == io.EOF {
   7227 		return out, metadata, nil
   7228 	}
   7229 	if err != nil {
   7230 		var snapshot bytes.Buffer
   7231 		io.Copy(&snapshot, ringBuffer)
   7232 		return out, metadata, &smithy.DeserializationError{
   7233 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7234 			Snapshot: snapshot.Bytes(),
   7235 		}
   7236 	}
   7237 
   7238 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7239 	err = awsRestxml_deserializeOpDocumentListGeoLocationsOutput(&output, decoder)
   7240 	if err != nil {
   7241 		var snapshot bytes.Buffer
   7242 		io.Copy(&snapshot, ringBuffer)
   7243 		return out, metadata, &smithy.DeserializationError{
   7244 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7245 			Snapshot: snapshot.Bytes(),
   7246 		}
   7247 	}
   7248 
   7249 	span.End()
   7250 	return out, metadata, err
   7251 }
   7252 
   7253 func awsRestxml_deserializeOpErrorListGeoLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7254 	var errorBuffer bytes.Buffer
   7255 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7256 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7257 	}
   7258 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7259 
   7260 	errorCode := "UnknownError"
   7261 	errorMessage := errorCode
   7262 
   7263 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7264 	if err != nil {
   7265 		return err
   7266 	}
   7267 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7268 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7269 	}
   7270 	if len(errorComponents.Code) != 0 {
   7271 		errorCode = errorComponents.Code
   7272 	}
   7273 	if len(errorComponents.Message) != 0 {
   7274 		errorMessage = errorComponents.Message
   7275 	}
   7276 	errorBody.Seek(0, io.SeekStart)
   7277 	switch {
   7278 	case strings.EqualFold("InvalidInput", errorCode):
   7279 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7280 
   7281 	default:
   7282 		genericError := &smithy.GenericAPIError{
   7283 			Code:    errorCode,
   7284 			Message: errorMessage,
   7285 		}
   7286 		return genericError
   7287 
   7288 	}
   7289 }
   7290 
   7291 func awsRestxml_deserializeOpDocumentListGeoLocationsOutput(v **ListGeoLocationsOutput, decoder smithyxml.NodeDecoder) error {
   7292 	if v == nil {
   7293 		return fmt.Errorf("unexpected nil of type %T", v)
   7294 	}
   7295 	var sv *ListGeoLocationsOutput
   7296 	if *v == nil {
   7297 		sv = &ListGeoLocationsOutput{}
   7298 	} else {
   7299 		sv = *v
   7300 	}
   7301 
   7302 	for {
   7303 		t, done, err := decoder.Token()
   7304 		if err != nil {
   7305 			return err
   7306 		}
   7307 		if done {
   7308 			break
   7309 		}
   7310 		originalDecoder := decoder
   7311 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7312 		switch {
   7313 		case strings.EqualFold("GeoLocationDetailsList", t.Name.Local):
   7314 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7315 			if err := awsRestxml_deserializeDocumentGeoLocationDetailsList(&sv.GeoLocationDetailsList, nodeDecoder); err != nil {
   7316 				return err
   7317 			}
   7318 
   7319 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7320 			val, err := decoder.Value()
   7321 			if err != nil {
   7322 				return err
   7323 			}
   7324 			if val == nil {
   7325 				break
   7326 			}
   7327 			{
   7328 				xtv, err := strconv.ParseBool(string(val))
   7329 				if err != nil {
   7330 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7331 				}
   7332 				sv.IsTruncated = xtv
   7333 			}
   7334 
   7335 		case strings.EqualFold("MaxItems", t.Name.Local):
   7336 			val, err := decoder.Value()
   7337 			if err != nil {
   7338 				return err
   7339 			}
   7340 			if val == nil {
   7341 				break
   7342 			}
   7343 			{
   7344 				xtv := string(val)
   7345 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7346 				if err != nil {
   7347 					return err
   7348 				}
   7349 				sv.MaxItems = ptr.Int32(int32(i64))
   7350 			}
   7351 
   7352 		case strings.EqualFold("NextContinentCode", t.Name.Local):
   7353 			val, err := decoder.Value()
   7354 			if err != nil {
   7355 				return err
   7356 			}
   7357 			if val == nil {
   7358 				break
   7359 			}
   7360 			{
   7361 				xtv := string(val)
   7362 				sv.NextContinentCode = ptr.String(xtv)
   7363 			}
   7364 
   7365 		case strings.EqualFold("NextCountryCode", t.Name.Local):
   7366 			val, err := decoder.Value()
   7367 			if err != nil {
   7368 				return err
   7369 			}
   7370 			if val == nil {
   7371 				break
   7372 			}
   7373 			{
   7374 				xtv := string(val)
   7375 				sv.NextCountryCode = ptr.String(xtv)
   7376 			}
   7377 
   7378 		case strings.EqualFold("NextSubdivisionCode", t.Name.Local):
   7379 			val, err := decoder.Value()
   7380 			if err != nil {
   7381 				return err
   7382 			}
   7383 			if val == nil {
   7384 				break
   7385 			}
   7386 			{
   7387 				xtv := string(val)
   7388 				sv.NextSubdivisionCode = ptr.String(xtv)
   7389 			}
   7390 
   7391 		default:
   7392 			// Do nothing and ignore the unexpected tag element
   7393 			err = decoder.Decoder.Skip()
   7394 			if err != nil {
   7395 				return err
   7396 			}
   7397 
   7398 		}
   7399 		decoder = originalDecoder
   7400 	}
   7401 	*v = sv
   7402 	return nil
   7403 }
   7404 
   7405 type awsRestxml_deserializeOpListHealthChecks struct {
   7406 }
   7407 
   7408 func (*awsRestxml_deserializeOpListHealthChecks) ID() string {
   7409 	return "OperationDeserializer"
   7410 }
   7411 
   7412 func (m *awsRestxml_deserializeOpListHealthChecks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7413 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7414 ) {
   7415 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7416 	if err != nil {
   7417 		return out, metadata, err
   7418 	}
   7419 
   7420 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7421 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7422 	defer endTimer()
   7423 	defer span.End()
   7424 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7425 	if !ok {
   7426 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7427 	}
   7428 
   7429 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7430 		return out, metadata, awsRestxml_deserializeOpErrorListHealthChecks(response, &metadata)
   7431 	}
   7432 	output := &ListHealthChecksOutput{}
   7433 	out.Result = output
   7434 
   7435 	var buff [1024]byte
   7436 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7437 	body := io.TeeReader(response.Body, ringBuffer)
   7438 	rootDecoder := xml.NewDecoder(body)
   7439 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7440 	if err == io.EOF {
   7441 		return out, metadata, nil
   7442 	}
   7443 	if err != nil {
   7444 		var snapshot bytes.Buffer
   7445 		io.Copy(&snapshot, ringBuffer)
   7446 		return out, metadata, &smithy.DeserializationError{
   7447 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7448 			Snapshot: snapshot.Bytes(),
   7449 		}
   7450 	}
   7451 
   7452 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7453 	err = awsRestxml_deserializeOpDocumentListHealthChecksOutput(&output, decoder)
   7454 	if err != nil {
   7455 		var snapshot bytes.Buffer
   7456 		io.Copy(&snapshot, ringBuffer)
   7457 		return out, metadata, &smithy.DeserializationError{
   7458 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7459 			Snapshot: snapshot.Bytes(),
   7460 		}
   7461 	}
   7462 
   7463 	span.End()
   7464 	return out, metadata, err
   7465 }
   7466 
   7467 func awsRestxml_deserializeOpErrorListHealthChecks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7468 	var errorBuffer bytes.Buffer
   7469 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7470 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7471 	}
   7472 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7473 
   7474 	errorCode := "UnknownError"
   7475 	errorMessage := errorCode
   7476 
   7477 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7478 	if err != nil {
   7479 		return err
   7480 	}
   7481 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7482 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7483 	}
   7484 	if len(errorComponents.Code) != 0 {
   7485 		errorCode = errorComponents.Code
   7486 	}
   7487 	if len(errorComponents.Message) != 0 {
   7488 		errorMessage = errorComponents.Message
   7489 	}
   7490 	errorBody.Seek(0, io.SeekStart)
   7491 	switch {
   7492 	case strings.EqualFold("IncompatibleVersion", errorCode):
   7493 		return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody)
   7494 
   7495 	case strings.EqualFold("InvalidInput", errorCode):
   7496 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7497 
   7498 	default:
   7499 		genericError := &smithy.GenericAPIError{
   7500 			Code:    errorCode,
   7501 			Message: errorMessage,
   7502 		}
   7503 		return genericError
   7504 
   7505 	}
   7506 }
   7507 
   7508 func awsRestxml_deserializeOpDocumentListHealthChecksOutput(v **ListHealthChecksOutput, decoder smithyxml.NodeDecoder) error {
   7509 	if v == nil {
   7510 		return fmt.Errorf("unexpected nil of type %T", v)
   7511 	}
   7512 	var sv *ListHealthChecksOutput
   7513 	if *v == nil {
   7514 		sv = &ListHealthChecksOutput{}
   7515 	} else {
   7516 		sv = *v
   7517 	}
   7518 
   7519 	for {
   7520 		t, done, err := decoder.Token()
   7521 		if err != nil {
   7522 			return err
   7523 		}
   7524 		if done {
   7525 			break
   7526 		}
   7527 		originalDecoder := decoder
   7528 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7529 		switch {
   7530 		case strings.EqualFold("HealthChecks", t.Name.Local):
   7531 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7532 			if err := awsRestxml_deserializeDocumentHealthChecks(&sv.HealthChecks, nodeDecoder); err != nil {
   7533 				return err
   7534 			}
   7535 
   7536 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7537 			val, err := decoder.Value()
   7538 			if err != nil {
   7539 				return err
   7540 			}
   7541 			if val == nil {
   7542 				break
   7543 			}
   7544 			{
   7545 				xtv, err := strconv.ParseBool(string(val))
   7546 				if err != nil {
   7547 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7548 				}
   7549 				sv.IsTruncated = xtv
   7550 			}
   7551 
   7552 		case strings.EqualFold("Marker", t.Name.Local):
   7553 			val, err := decoder.Value()
   7554 			if err != nil {
   7555 				return err
   7556 			}
   7557 			if val == nil {
   7558 				break
   7559 			}
   7560 			{
   7561 				xtv := string(val)
   7562 				sv.Marker = ptr.String(xtv)
   7563 			}
   7564 
   7565 		case strings.EqualFold("MaxItems", t.Name.Local):
   7566 			val, err := decoder.Value()
   7567 			if err != nil {
   7568 				return err
   7569 			}
   7570 			if val == nil {
   7571 				break
   7572 			}
   7573 			{
   7574 				xtv := string(val)
   7575 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7576 				if err != nil {
   7577 					return err
   7578 				}
   7579 				sv.MaxItems = ptr.Int32(int32(i64))
   7580 			}
   7581 
   7582 		case strings.EqualFold("NextMarker", t.Name.Local):
   7583 			val, err := decoder.Value()
   7584 			if err != nil {
   7585 				return err
   7586 			}
   7587 			if val == nil {
   7588 				break
   7589 			}
   7590 			{
   7591 				xtv := string(val)
   7592 				sv.NextMarker = ptr.String(xtv)
   7593 			}
   7594 
   7595 		default:
   7596 			// Do nothing and ignore the unexpected tag element
   7597 			err = decoder.Decoder.Skip()
   7598 			if err != nil {
   7599 				return err
   7600 			}
   7601 
   7602 		}
   7603 		decoder = originalDecoder
   7604 	}
   7605 	*v = sv
   7606 	return nil
   7607 }
   7608 
   7609 type awsRestxml_deserializeOpListHostedZones struct {
   7610 }
   7611 
   7612 func (*awsRestxml_deserializeOpListHostedZones) ID() string {
   7613 	return "OperationDeserializer"
   7614 }
   7615 
   7616 func (m *awsRestxml_deserializeOpListHostedZones) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7617 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7618 ) {
   7619 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7620 	if err != nil {
   7621 		return out, metadata, err
   7622 	}
   7623 
   7624 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7625 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7626 	defer endTimer()
   7627 	defer span.End()
   7628 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7629 	if !ok {
   7630 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7631 	}
   7632 
   7633 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7634 		return out, metadata, awsRestxml_deserializeOpErrorListHostedZones(response, &metadata)
   7635 	}
   7636 	output := &ListHostedZonesOutput{}
   7637 	out.Result = output
   7638 
   7639 	var buff [1024]byte
   7640 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7641 	body := io.TeeReader(response.Body, ringBuffer)
   7642 	rootDecoder := xml.NewDecoder(body)
   7643 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7644 	if err == io.EOF {
   7645 		return out, metadata, nil
   7646 	}
   7647 	if err != nil {
   7648 		var snapshot bytes.Buffer
   7649 		io.Copy(&snapshot, ringBuffer)
   7650 		return out, metadata, &smithy.DeserializationError{
   7651 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7652 			Snapshot: snapshot.Bytes(),
   7653 		}
   7654 	}
   7655 
   7656 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7657 	err = awsRestxml_deserializeOpDocumentListHostedZonesOutput(&output, decoder)
   7658 	if err != nil {
   7659 		var snapshot bytes.Buffer
   7660 		io.Copy(&snapshot, ringBuffer)
   7661 		return out, metadata, &smithy.DeserializationError{
   7662 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7663 			Snapshot: snapshot.Bytes(),
   7664 		}
   7665 	}
   7666 
   7667 	span.End()
   7668 	return out, metadata, err
   7669 }
   7670 
   7671 func awsRestxml_deserializeOpErrorListHostedZones(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7672 	var errorBuffer bytes.Buffer
   7673 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7674 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7675 	}
   7676 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7677 
   7678 	errorCode := "UnknownError"
   7679 	errorMessage := errorCode
   7680 
   7681 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7682 	if err != nil {
   7683 		return err
   7684 	}
   7685 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7686 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7687 	}
   7688 	if len(errorComponents.Code) != 0 {
   7689 		errorCode = errorComponents.Code
   7690 	}
   7691 	if len(errorComponents.Message) != 0 {
   7692 		errorMessage = errorComponents.Message
   7693 	}
   7694 	errorBody.Seek(0, io.SeekStart)
   7695 	switch {
   7696 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   7697 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   7698 
   7699 	case strings.EqualFold("InvalidInput", errorCode):
   7700 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7701 
   7702 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   7703 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   7704 
   7705 	default:
   7706 		genericError := &smithy.GenericAPIError{
   7707 			Code:    errorCode,
   7708 			Message: errorMessage,
   7709 		}
   7710 		return genericError
   7711 
   7712 	}
   7713 }
   7714 
   7715 func awsRestxml_deserializeOpDocumentListHostedZonesOutput(v **ListHostedZonesOutput, decoder smithyxml.NodeDecoder) error {
   7716 	if v == nil {
   7717 		return fmt.Errorf("unexpected nil of type %T", v)
   7718 	}
   7719 	var sv *ListHostedZonesOutput
   7720 	if *v == nil {
   7721 		sv = &ListHostedZonesOutput{}
   7722 	} else {
   7723 		sv = *v
   7724 	}
   7725 
   7726 	for {
   7727 		t, done, err := decoder.Token()
   7728 		if err != nil {
   7729 			return err
   7730 		}
   7731 		if done {
   7732 			break
   7733 		}
   7734 		originalDecoder := decoder
   7735 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7736 		switch {
   7737 		case strings.EqualFold("HostedZones", t.Name.Local):
   7738 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7739 			if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil {
   7740 				return err
   7741 			}
   7742 
   7743 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7744 			val, err := decoder.Value()
   7745 			if err != nil {
   7746 				return err
   7747 			}
   7748 			if val == nil {
   7749 				break
   7750 			}
   7751 			{
   7752 				xtv, err := strconv.ParseBool(string(val))
   7753 				if err != nil {
   7754 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7755 				}
   7756 				sv.IsTruncated = xtv
   7757 			}
   7758 
   7759 		case strings.EqualFold("Marker", t.Name.Local):
   7760 			val, err := decoder.Value()
   7761 			if err != nil {
   7762 				return err
   7763 			}
   7764 			if val == nil {
   7765 				break
   7766 			}
   7767 			{
   7768 				xtv := string(val)
   7769 				sv.Marker = ptr.String(xtv)
   7770 			}
   7771 
   7772 		case strings.EqualFold("MaxItems", t.Name.Local):
   7773 			val, err := decoder.Value()
   7774 			if err != nil {
   7775 				return err
   7776 			}
   7777 			if val == nil {
   7778 				break
   7779 			}
   7780 			{
   7781 				xtv := string(val)
   7782 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7783 				if err != nil {
   7784 					return err
   7785 				}
   7786 				sv.MaxItems = ptr.Int32(int32(i64))
   7787 			}
   7788 
   7789 		case strings.EqualFold("NextMarker", t.Name.Local):
   7790 			val, err := decoder.Value()
   7791 			if err != nil {
   7792 				return err
   7793 			}
   7794 			if val == nil {
   7795 				break
   7796 			}
   7797 			{
   7798 				xtv := string(val)
   7799 				sv.NextMarker = ptr.String(xtv)
   7800 			}
   7801 
   7802 		default:
   7803 			// Do nothing and ignore the unexpected tag element
   7804 			err = decoder.Decoder.Skip()
   7805 			if err != nil {
   7806 				return err
   7807 			}
   7808 
   7809 		}
   7810 		decoder = originalDecoder
   7811 	}
   7812 	*v = sv
   7813 	return nil
   7814 }
   7815 
   7816 type awsRestxml_deserializeOpListHostedZonesByName struct {
   7817 }
   7818 
   7819 func (*awsRestxml_deserializeOpListHostedZonesByName) ID() string {
   7820 	return "OperationDeserializer"
   7821 }
   7822 
   7823 func (m *awsRestxml_deserializeOpListHostedZonesByName) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7824 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7825 ) {
   7826 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7827 	if err != nil {
   7828 		return out, metadata, err
   7829 	}
   7830 
   7831 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   7832 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   7833 	defer endTimer()
   7834 	defer span.End()
   7835 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7836 	if !ok {
   7837 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7838 	}
   7839 
   7840 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7841 		return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByName(response, &metadata)
   7842 	}
   7843 	output := &ListHostedZonesByNameOutput{}
   7844 	out.Result = output
   7845 
   7846 	var buff [1024]byte
   7847 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7848 	body := io.TeeReader(response.Body, ringBuffer)
   7849 	rootDecoder := xml.NewDecoder(body)
   7850 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7851 	if err == io.EOF {
   7852 		return out, metadata, nil
   7853 	}
   7854 	if err != nil {
   7855 		var snapshot bytes.Buffer
   7856 		io.Copy(&snapshot, ringBuffer)
   7857 		return out, metadata, &smithy.DeserializationError{
   7858 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7859 			Snapshot: snapshot.Bytes(),
   7860 		}
   7861 	}
   7862 
   7863 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7864 	err = awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(&output, decoder)
   7865 	if err != nil {
   7866 		var snapshot bytes.Buffer
   7867 		io.Copy(&snapshot, ringBuffer)
   7868 		return out, metadata, &smithy.DeserializationError{
   7869 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7870 			Snapshot: snapshot.Bytes(),
   7871 		}
   7872 	}
   7873 
   7874 	span.End()
   7875 	return out, metadata, err
   7876 }
   7877 
   7878 func awsRestxml_deserializeOpErrorListHostedZonesByName(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7879 	var errorBuffer bytes.Buffer
   7880 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7881 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7882 	}
   7883 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7884 
   7885 	errorCode := "UnknownError"
   7886 	errorMessage := errorCode
   7887 
   7888 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7889 	if err != nil {
   7890 		return err
   7891 	}
   7892 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7893 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7894 	}
   7895 	if len(errorComponents.Code) != 0 {
   7896 		errorCode = errorComponents.Code
   7897 	}
   7898 	if len(errorComponents.Message) != 0 {
   7899 		errorMessage = errorComponents.Message
   7900 	}
   7901 	errorBody.Seek(0, io.SeekStart)
   7902 	switch {
   7903 	case strings.EqualFold("InvalidDomainName", errorCode):
   7904 		return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
   7905 
   7906 	case strings.EqualFold("InvalidInput", errorCode):
   7907 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7908 
   7909 	default:
   7910 		genericError := &smithy.GenericAPIError{
   7911 			Code:    errorCode,
   7912 			Message: errorMessage,
   7913 		}
   7914 		return genericError
   7915 
   7916 	}
   7917 }
   7918 
   7919 func awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(v **ListHostedZonesByNameOutput, decoder smithyxml.NodeDecoder) error {
   7920 	if v == nil {
   7921 		return fmt.Errorf("unexpected nil of type %T", v)
   7922 	}
   7923 	var sv *ListHostedZonesByNameOutput
   7924 	if *v == nil {
   7925 		sv = &ListHostedZonesByNameOutput{}
   7926 	} else {
   7927 		sv = *v
   7928 	}
   7929 
   7930 	for {
   7931 		t, done, err := decoder.Token()
   7932 		if err != nil {
   7933 			return err
   7934 		}
   7935 		if done {
   7936 			break
   7937 		}
   7938 		originalDecoder := decoder
   7939 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7940 		switch {
   7941 		case strings.EqualFold("DNSName", t.Name.Local):
   7942 			val, err := decoder.Value()
   7943 			if err != nil {
   7944 				return err
   7945 			}
   7946 			if val == nil {
   7947 				break
   7948 			}
   7949 			{
   7950 				xtv := string(val)
   7951 				sv.DNSName = ptr.String(xtv)
   7952 			}
   7953 
   7954 		case strings.EqualFold("HostedZoneId", t.Name.Local):
   7955 			val, err := decoder.Value()
   7956 			if err != nil {
   7957 				return err
   7958 			}
   7959 			if val == nil {
   7960 				break
   7961 			}
   7962 			{
   7963 				xtv := string(val)
   7964 				sv.HostedZoneId = ptr.String(xtv)
   7965 			}
   7966 
   7967 		case strings.EqualFold("HostedZones", t.Name.Local):
   7968 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7969 			if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil {
   7970 				return err
   7971 			}
   7972 
   7973 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7974 			val, err := decoder.Value()
   7975 			if err != nil {
   7976 				return err
   7977 			}
   7978 			if val == nil {
   7979 				break
   7980 			}
   7981 			{
   7982 				xtv, err := strconv.ParseBool(string(val))
   7983 				if err != nil {
   7984 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7985 				}
   7986 				sv.IsTruncated = xtv
   7987 			}
   7988 
   7989 		case strings.EqualFold("MaxItems", t.Name.Local):
   7990 			val, err := decoder.Value()
   7991 			if err != nil {
   7992 				return err
   7993 			}
   7994 			if val == nil {
   7995 				break
   7996 			}
   7997 			{
   7998 				xtv := string(val)
   7999 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8000 				if err != nil {
   8001 					return err
   8002 				}
   8003 				sv.MaxItems = ptr.Int32(int32(i64))
   8004 			}
   8005 
   8006 		case strings.EqualFold("NextDNSName", t.Name.Local):
   8007 			val, err := decoder.Value()
   8008 			if err != nil {
   8009 				return err
   8010 			}
   8011 			if val == nil {
   8012 				break
   8013 			}
   8014 			{
   8015 				xtv := string(val)
   8016 				sv.NextDNSName = ptr.String(xtv)
   8017 			}
   8018 
   8019 		case strings.EqualFold("NextHostedZoneId", t.Name.Local):
   8020 			val, err := decoder.Value()
   8021 			if err != nil {
   8022 				return err
   8023 			}
   8024 			if val == nil {
   8025 				break
   8026 			}
   8027 			{
   8028 				xtv := string(val)
   8029 				sv.NextHostedZoneId = ptr.String(xtv)
   8030 			}
   8031 
   8032 		default:
   8033 			// Do nothing and ignore the unexpected tag element
   8034 			err = decoder.Decoder.Skip()
   8035 			if err != nil {
   8036 				return err
   8037 			}
   8038 
   8039 		}
   8040 		decoder = originalDecoder
   8041 	}
   8042 	*v = sv
   8043 	return nil
   8044 }
   8045 
   8046 type awsRestxml_deserializeOpListHostedZonesByVPC struct {
   8047 }
   8048 
   8049 func (*awsRestxml_deserializeOpListHostedZonesByVPC) ID() string {
   8050 	return "OperationDeserializer"
   8051 }
   8052 
   8053 func (m *awsRestxml_deserializeOpListHostedZonesByVPC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8054 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8055 ) {
   8056 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8057 	if err != nil {
   8058 		return out, metadata, err
   8059 	}
   8060 
   8061 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8062 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8063 	defer endTimer()
   8064 	defer span.End()
   8065 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8066 	if !ok {
   8067 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8068 	}
   8069 
   8070 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8071 		return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByVPC(response, &metadata)
   8072 	}
   8073 	output := &ListHostedZonesByVPCOutput{}
   8074 	out.Result = output
   8075 
   8076 	var buff [1024]byte
   8077 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8078 	body := io.TeeReader(response.Body, ringBuffer)
   8079 	rootDecoder := xml.NewDecoder(body)
   8080 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8081 	if err == io.EOF {
   8082 		return out, metadata, nil
   8083 	}
   8084 	if err != nil {
   8085 		var snapshot bytes.Buffer
   8086 		io.Copy(&snapshot, ringBuffer)
   8087 		return out, metadata, &smithy.DeserializationError{
   8088 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8089 			Snapshot: snapshot.Bytes(),
   8090 		}
   8091 	}
   8092 
   8093 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8094 	err = awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(&output, decoder)
   8095 	if err != nil {
   8096 		var snapshot bytes.Buffer
   8097 		io.Copy(&snapshot, ringBuffer)
   8098 		return out, metadata, &smithy.DeserializationError{
   8099 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8100 			Snapshot: snapshot.Bytes(),
   8101 		}
   8102 	}
   8103 
   8104 	span.End()
   8105 	return out, metadata, err
   8106 }
   8107 
   8108 func awsRestxml_deserializeOpErrorListHostedZonesByVPC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8109 	var errorBuffer bytes.Buffer
   8110 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8111 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8112 	}
   8113 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8114 
   8115 	errorCode := "UnknownError"
   8116 	errorMessage := errorCode
   8117 
   8118 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8119 	if err != nil {
   8120 		return err
   8121 	}
   8122 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8123 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8124 	}
   8125 	if len(errorComponents.Code) != 0 {
   8126 		errorCode = errorComponents.Code
   8127 	}
   8128 	if len(errorComponents.Message) != 0 {
   8129 		errorMessage = errorComponents.Message
   8130 	}
   8131 	errorBody.Seek(0, io.SeekStart)
   8132 	switch {
   8133 	case strings.EqualFold("InvalidInput", errorCode):
   8134 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8135 
   8136 	case strings.EqualFold("InvalidPaginationToken", errorCode):
   8137 		return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
   8138 
   8139 	default:
   8140 		genericError := &smithy.GenericAPIError{
   8141 			Code:    errorCode,
   8142 			Message: errorMessage,
   8143 		}
   8144 		return genericError
   8145 
   8146 	}
   8147 }
   8148 
   8149 func awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(v **ListHostedZonesByVPCOutput, decoder smithyxml.NodeDecoder) error {
   8150 	if v == nil {
   8151 		return fmt.Errorf("unexpected nil of type %T", v)
   8152 	}
   8153 	var sv *ListHostedZonesByVPCOutput
   8154 	if *v == nil {
   8155 		sv = &ListHostedZonesByVPCOutput{}
   8156 	} else {
   8157 		sv = *v
   8158 	}
   8159 
   8160 	for {
   8161 		t, done, err := decoder.Token()
   8162 		if err != nil {
   8163 			return err
   8164 		}
   8165 		if done {
   8166 			break
   8167 		}
   8168 		originalDecoder := decoder
   8169 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8170 		switch {
   8171 		case strings.EqualFold("HostedZoneSummaries", t.Name.Local):
   8172 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8173 			if err := awsRestxml_deserializeDocumentHostedZoneSummaries(&sv.HostedZoneSummaries, nodeDecoder); err != nil {
   8174 				return err
   8175 			}
   8176 
   8177 		case strings.EqualFold("MaxItems", t.Name.Local):
   8178 			val, err := decoder.Value()
   8179 			if err != nil {
   8180 				return err
   8181 			}
   8182 			if val == nil {
   8183 				break
   8184 			}
   8185 			{
   8186 				xtv := string(val)
   8187 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8188 				if err != nil {
   8189 					return err
   8190 				}
   8191 				sv.MaxItems = ptr.Int32(int32(i64))
   8192 			}
   8193 
   8194 		case strings.EqualFold("NextToken", t.Name.Local):
   8195 			val, err := decoder.Value()
   8196 			if err != nil {
   8197 				return err
   8198 			}
   8199 			if val == nil {
   8200 				break
   8201 			}
   8202 			{
   8203 				xtv := string(val)
   8204 				sv.NextToken = ptr.String(xtv)
   8205 			}
   8206 
   8207 		default:
   8208 			// Do nothing and ignore the unexpected tag element
   8209 			err = decoder.Decoder.Skip()
   8210 			if err != nil {
   8211 				return err
   8212 			}
   8213 
   8214 		}
   8215 		decoder = originalDecoder
   8216 	}
   8217 	*v = sv
   8218 	return nil
   8219 }
   8220 
   8221 type awsRestxml_deserializeOpListQueryLoggingConfigs struct {
   8222 }
   8223 
   8224 func (*awsRestxml_deserializeOpListQueryLoggingConfigs) ID() string {
   8225 	return "OperationDeserializer"
   8226 }
   8227 
   8228 func (m *awsRestxml_deserializeOpListQueryLoggingConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8229 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8230 ) {
   8231 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8232 	if err != nil {
   8233 		return out, metadata, err
   8234 	}
   8235 
   8236 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8237 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8238 	defer endTimer()
   8239 	defer span.End()
   8240 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8241 	if !ok {
   8242 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8243 	}
   8244 
   8245 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8246 		return out, metadata, awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response, &metadata)
   8247 	}
   8248 	output := &ListQueryLoggingConfigsOutput{}
   8249 	out.Result = output
   8250 
   8251 	var buff [1024]byte
   8252 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8253 	body := io.TeeReader(response.Body, ringBuffer)
   8254 	rootDecoder := xml.NewDecoder(body)
   8255 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8256 	if err == io.EOF {
   8257 		return out, metadata, nil
   8258 	}
   8259 	if err != nil {
   8260 		var snapshot bytes.Buffer
   8261 		io.Copy(&snapshot, ringBuffer)
   8262 		return out, metadata, &smithy.DeserializationError{
   8263 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8264 			Snapshot: snapshot.Bytes(),
   8265 		}
   8266 	}
   8267 
   8268 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8269 	err = awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(&output, decoder)
   8270 	if err != nil {
   8271 		var snapshot bytes.Buffer
   8272 		io.Copy(&snapshot, ringBuffer)
   8273 		return out, metadata, &smithy.DeserializationError{
   8274 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8275 			Snapshot: snapshot.Bytes(),
   8276 		}
   8277 	}
   8278 
   8279 	span.End()
   8280 	return out, metadata, err
   8281 }
   8282 
   8283 func awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8284 	var errorBuffer bytes.Buffer
   8285 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8286 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8287 	}
   8288 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8289 
   8290 	errorCode := "UnknownError"
   8291 	errorMessage := errorCode
   8292 
   8293 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8294 	if err != nil {
   8295 		return err
   8296 	}
   8297 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8298 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8299 	}
   8300 	if len(errorComponents.Code) != 0 {
   8301 		errorCode = errorComponents.Code
   8302 	}
   8303 	if len(errorComponents.Message) != 0 {
   8304 		errorMessage = errorComponents.Message
   8305 	}
   8306 	errorBody.Seek(0, io.SeekStart)
   8307 	switch {
   8308 	case strings.EqualFold("InvalidInput", errorCode):
   8309 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8310 
   8311 	case strings.EqualFold("InvalidPaginationToken", errorCode):
   8312 		return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
   8313 
   8314 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   8315 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   8316 
   8317 	default:
   8318 		genericError := &smithy.GenericAPIError{
   8319 			Code:    errorCode,
   8320 			Message: errorMessage,
   8321 		}
   8322 		return genericError
   8323 
   8324 	}
   8325 }
   8326 
   8327 func awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(v **ListQueryLoggingConfigsOutput, decoder smithyxml.NodeDecoder) error {
   8328 	if v == nil {
   8329 		return fmt.Errorf("unexpected nil of type %T", v)
   8330 	}
   8331 	var sv *ListQueryLoggingConfigsOutput
   8332 	if *v == nil {
   8333 		sv = &ListQueryLoggingConfigsOutput{}
   8334 	} else {
   8335 		sv = *v
   8336 	}
   8337 
   8338 	for {
   8339 		t, done, err := decoder.Token()
   8340 		if err != nil {
   8341 			return err
   8342 		}
   8343 		if done {
   8344 			break
   8345 		}
   8346 		originalDecoder := decoder
   8347 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8348 		switch {
   8349 		case strings.EqualFold("NextToken", t.Name.Local):
   8350 			val, err := decoder.Value()
   8351 			if err != nil {
   8352 				return err
   8353 			}
   8354 			if val == nil {
   8355 				break
   8356 			}
   8357 			{
   8358 				xtv := string(val)
   8359 				sv.NextToken = ptr.String(xtv)
   8360 			}
   8361 
   8362 		case strings.EqualFold("QueryLoggingConfigs", t.Name.Local):
   8363 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8364 			if err := awsRestxml_deserializeDocumentQueryLoggingConfigs(&sv.QueryLoggingConfigs, nodeDecoder); err != nil {
   8365 				return err
   8366 			}
   8367 
   8368 		default:
   8369 			// Do nothing and ignore the unexpected tag element
   8370 			err = decoder.Decoder.Skip()
   8371 			if err != nil {
   8372 				return err
   8373 			}
   8374 
   8375 		}
   8376 		decoder = originalDecoder
   8377 	}
   8378 	*v = sv
   8379 	return nil
   8380 }
   8381 
   8382 type awsRestxml_deserializeOpListResourceRecordSets struct {
   8383 }
   8384 
   8385 func (*awsRestxml_deserializeOpListResourceRecordSets) ID() string {
   8386 	return "OperationDeserializer"
   8387 }
   8388 
   8389 func (m *awsRestxml_deserializeOpListResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8390 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8391 ) {
   8392 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8393 	if err != nil {
   8394 		return out, metadata, err
   8395 	}
   8396 
   8397 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8398 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8399 	defer endTimer()
   8400 	defer span.End()
   8401 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8402 	if !ok {
   8403 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8404 	}
   8405 
   8406 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8407 		return out, metadata, awsRestxml_deserializeOpErrorListResourceRecordSets(response, &metadata)
   8408 	}
   8409 	output := &ListResourceRecordSetsOutput{}
   8410 	out.Result = output
   8411 
   8412 	var buff [1024]byte
   8413 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8414 	body := io.TeeReader(response.Body, ringBuffer)
   8415 	rootDecoder := xml.NewDecoder(body)
   8416 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8417 	if err == io.EOF {
   8418 		return out, metadata, nil
   8419 	}
   8420 	if err != nil {
   8421 		var snapshot bytes.Buffer
   8422 		io.Copy(&snapshot, ringBuffer)
   8423 		return out, metadata, &smithy.DeserializationError{
   8424 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8425 			Snapshot: snapshot.Bytes(),
   8426 		}
   8427 	}
   8428 
   8429 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8430 	err = awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(&output, decoder)
   8431 	if err != nil {
   8432 		var snapshot bytes.Buffer
   8433 		io.Copy(&snapshot, ringBuffer)
   8434 		return out, metadata, &smithy.DeserializationError{
   8435 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8436 			Snapshot: snapshot.Bytes(),
   8437 		}
   8438 	}
   8439 
   8440 	span.End()
   8441 	return out, metadata, err
   8442 }
   8443 
   8444 func awsRestxml_deserializeOpErrorListResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8445 	var errorBuffer bytes.Buffer
   8446 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8447 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8448 	}
   8449 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8450 
   8451 	errorCode := "UnknownError"
   8452 	errorMessage := errorCode
   8453 
   8454 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8455 	if err != nil {
   8456 		return err
   8457 	}
   8458 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8459 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8460 	}
   8461 	if len(errorComponents.Code) != 0 {
   8462 		errorCode = errorComponents.Code
   8463 	}
   8464 	if len(errorComponents.Message) != 0 {
   8465 		errorMessage = errorComponents.Message
   8466 	}
   8467 	errorBody.Seek(0, io.SeekStart)
   8468 	switch {
   8469 	case strings.EqualFold("InvalidInput", errorCode):
   8470 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8471 
   8472 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   8473 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   8474 
   8475 	default:
   8476 		genericError := &smithy.GenericAPIError{
   8477 			Code:    errorCode,
   8478 			Message: errorMessage,
   8479 		}
   8480 		return genericError
   8481 
   8482 	}
   8483 }
   8484 
   8485 func awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(v **ListResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error {
   8486 	if v == nil {
   8487 		return fmt.Errorf("unexpected nil of type %T", v)
   8488 	}
   8489 	var sv *ListResourceRecordSetsOutput
   8490 	if *v == nil {
   8491 		sv = &ListResourceRecordSetsOutput{}
   8492 	} else {
   8493 		sv = *v
   8494 	}
   8495 
   8496 	for {
   8497 		t, done, err := decoder.Token()
   8498 		if err != nil {
   8499 			return err
   8500 		}
   8501 		if done {
   8502 			break
   8503 		}
   8504 		originalDecoder := decoder
   8505 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8506 		switch {
   8507 		case strings.EqualFold("IsTruncated", t.Name.Local):
   8508 			val, err := decoder.Value()
   8509 			if err != nil {
   8510 				return err
   8511 			}
   8512 			if val == nil {
   8513 				break
   8514 			}
   8515 			{
   8516 				xtv, err := strconv.ParseBool(string(val))
   8517 				if err != nil {
   8518 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   8519 				}
   8520 				sv.IsTruncated = xtv
   8521 			}
   8522 
   8523 		case strings.EqualFold("MaxItems", t.Name.Local):
   8524 			val, err := decoder.Value()
   8525 			if err != nil {
   8526 				return err
   8527 			}
   8528 			if val == nil {
   8529 				break
   8530 			}
   8531 			{
   8532 				xtv := string(val)
   8533 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8534 				if err != nil {
   8535 					return err
   8536 				}
   8537 				sv.MaxItems = ptr.Int32(int32(i64))
   8538 			}
   8539 
   8540 		case strings.EqualFold("NextRecordIdentifier", t.Name.Local):
   8541 			val, err := decoder.Value()
   8542 			if err != nil {
   8543 				return err
   8544 			}
   8545 			if val == nil {
   8546 				break
   8547 			}
   8548 			{
   8549 				xtv := string(val)
   8550 				sv.NextRecordIdentifier = ptr.String(xtv)
   8551 			}
   8552 
   8553 		case strings.EqualFold("NextRecordName", t.Name.Local):
   8554 			val, err := decoder.Value()
   8555 			if err != nil {
   8556 				return err
   8557 			}
   8558 			if val == nil {
   8559 				break
   8560 			}
   8561 			{
   8562 				xtv := string(val)
   8563 				sv.NextRecordName = ptr.String(xtv)
   8564 			}
   8565 
   8566 		case strings.EqualFold("NextRecordType", t.Name.Local):
   8567 			val, err := decoder.Value()
   8568 			if err != nil {
   8569 				return err
   8570 			}
   8571 			if val == nil {
   8572 				break
   8573 			}
   8574 			{
   8575 				xtv := string(val)
   8576 				sv.NextRecordType = types.RRType(xtv)
   8577 			}
   8578 
   8579 		case strings.EqualFold("ResourceRecordSets", t.Name.Local):
   8580 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8581 			if err := awsRestxml_deserializeDocumentResourceRecordSets(&sv.ResourceRecordSets, nodeDecoder); err != nil {
   8582 				return err
   8583 			}
   8584 
   8585 		default:
   8586 			// Do nothing and ignore the unexpected tag element
   8587 			err = decoder.Decoder.Skip()
   8588 			if err != nil {
   8589 				return err
   8590 			}
   8591 
   8592 		}
   8593 		decoder = originalDecoder
   8594 	}
   8595 	*v = sv
   8596 	return nil
   8597 }
   8598 
   8599 type awsRestxml_deserializeOpListReusableDelegationSets struct {
   8600 }
   8601 
   8602 func (*awsRestxml_deserializeOpListReusableDelegationSets) ID() string {
   8603 	return "OperationDeserializer"
   8604 }
   8605 
   8606 func (m *awsRestxml_deserializeOpListReusableDelegationSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8607 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8608 ) {
   8609 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8610 	if err != nil {
   8611 		return out, metadata, err
   8612 	}
   8613 
   8614 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8615 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8616 	defer endTimer()
   8617 	defer span.End()
   8618 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8619 	if !ok {
   8620 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8621 	}
   8622 
   8623 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8624 		return out, metadata, awsRestxml_deserializeOpErrorListReusableDelegationSets(response, &metadata)
   8625 	}
   8626 	output := &ListReusableDelegationSetsOutput{}
   8627 	out.Result = output
   8628 
   8629 	var buff [1024]byte
   8630 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8631 	body := io.TeeReader(response.Body, ringBuffer)
   8632 	rootDecoder := xml.NewDecoder(body)
   8633 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8634 	if err == io.EOF {
   8635 		return out, metadata, nil
   8636 	}
   8637 	if err != nil {
   8638 		var snapshot bytes.Buffer
   8639 		io.Copy(&snapshot, ringBuffer)
   8640 		return out, metadata, &smithy.DeserializationError{
   8641 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8642 			Snapshot: snapshot.Bytes(),
   8643 		}
   8644 	}
   8645 
   8646 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8647 	err = awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(&output, decoder)
   8648 	if err != nil {
   8649 		var snapshot bytes.Buffer
   8650 		io.Copy(&snapshot, ringBuffer)
   8651 		return out, metadata, &smithy.DeserializationError{
   8652 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8653 			Snapshot: snapshot.Bytes(),
   8654 		}
   8655 	}
   8656 
   8657 	span.End()
   8658 	return out, metadata, err
   8659 }
   8660 
   8661 func awsRestxml_deserializeOpErrorListReusableDelegationSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8662 	var errorBuffer bytes.Buffer
   8663 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8664 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8665 	}
   8666 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8667 
   8668 	errorCode := "UnknownError"
   8669 	errorMessage := errorCode
   8670 
   8671 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8672 	if err != nil {
   8673 		return err
   8674 	}
   8675 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8676 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8677 	}
   8678 	if len(errorComponents.Code) != 0 {
   8679 		errorCode = errorComponents.Code
   8680 	}
   8681 	if len(errorComponents.Message) != 0 {
   8682 		errorMessage = errorComponents.Message
   8683 	}
   8684 	errorBody.Seek(0, io.SeekStart)
   8685 	switch {
   8686 	case strings.EqualFold("InvalidInput", errorCode):
   8687 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8688 
   8689 	default:
   8690 		genericError := &smithy.GenericAPIError{
   8691 			Code:    errorCode,
   8692 			Message: errorMessage,
   8693 		}
   8694 		return genericError
   8695 
   8696 	}
   8697 }
   8698 
   8699 func awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(v **ListReusableDelegationSetsOutput, decoder smithyxml.NodeDecoder) error {
   8700 	if v == nil {
   8701 		return fmt.Errorf("unexpected nil of type %T", v)
   8702 	}
   8703 	var sv *ListReusableDelegationSetsOutput
   8704 	if *v == nil {
   8705 		sv = &ListReusableDelegationSetsOutput{}
   8706 	} else {
   8707 		sv = *v
   8708 	}
   8709 
   8710 	for {
   8711 		t, done, err := decoder.Token()
   8712 		if err != nil {
   8713 			return err
   8714 		}
   8715 		if done {
   8716 			break
   8717 		}
   8718 		originalDecoder := decoder
   8719 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8720 		switch {
   8721 		case strings.EqualFold("DelegationSets", t.Name.Local):
   8722 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8723 			if err := awsRestxml_deserializeDocumentDelegationSets(&sv.DelegationSets, nodeDecoder); err != nil {
   8724 				return err
   8725 			}
   8726 
   8727 		case strings.EqualFold("IsTruncated", t.Name.Local):
   8728 			val, err := decoder.Value()
   8729 			if err != nil {
   8730 				return err
   8731 			}
   8732 			if val == nil {
   8733 				break
   8734 			}
   8735 			{
   8736 				xtv, err := strconv.ParseBool(string(val))
   8737 				if err != nil {
   8738 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   8739 				}
   8740 				sv.IsTruncated = xtv
   8741 			}
   8742 
   8743 		case strings.EqualFold("Marker", t.Name.Local):
   8744 			val, err := decoder.Value()
   8745 			if err != nil {
   8746 				return err
   8747 			}
   8748 			if val == nil {
   8749 				break
   8750 			}
   8751 			{
   8752 				xtv := string(val)
   8753 				sv.Marker = ptr.String(xtv)
   8754 			}
   8755 
   8756 		case strings.EqualFold("MaxItems", t.Name.Local):
   8757 			val, err := decoder.Value()
   8758 			if err != nil {
   8759 				return err
   8760 			}
   8761 			if val == nil {
   8762 				break
   8763 			}
   8764 			{
   8765 				xtv := string(val)
   8766 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8767 				if err != nil {
   8768 					return err
   8769 				}
   8770 				sv.MaxItems = ptr.Int32(int32(i64))
   8771 			}
   8772 
   8773 		case strings.EqualFold("NextMarker", t.Name.Local):
   8774 			val, err := decoder.Value()
   8775 			if err != nil {
   8776 				return err
   8777 			}
   8778 			if val == nil {
   8779 				break
   8780 			}
   8781 			{
   8782 				xtv := string(val)
   8783 				sv.NextMarker = ptr.String(xtv)
   8784 			}
   8785 
   8786 		default:
   8787 			// Do nothing and ignore the unexpected tag element
   8788 			err = decoder.Decoder.Skip()
   8789 			if err != nil {
   8790 				return err
   8791 			}
   8792 
   8793 		}
   8794 		decoder = originalDecoder
   8795 	}
   8796 	*v = sv
   8797 	return nil
   8798 }
   8799 
   8800 type awsRestxml_deserializeOpListTagsForResource struct {
   8801 }
   8802 
   8803 func (*awsRestxml_deserializeOpListTagsForResource) ID() string {
   8804 	return "OperationDeserializer"
   8805 }
   8806 
   8807 func (m *awsRestxml_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8808 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8809 ) {
   8810 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8811 	if err != nil {
   8812 		return out, metadata, err
   8813 	}
   8814 
   8815 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8816 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8817 	defer endTimer()
   8818 	defer span.End()
   8819 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8820 	if !ok {
   8821 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8822 	}
   8823 
   8824 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8825 		return out, metadata, awsRestxml_deserializeOpErrorListTagsForResource(response, &metadata)
   8826 	}
   8827 	output := &ListTagsForResourceOutput{}
   8828 	out.Result = output
   8829 
   8830 	var buff [1024]byte
   8831 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8832 	body := io.TeeReader(response.Body, ringBuffer)
   8833 	rootDecoder := xml.NewDecoder(body)
   8834 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8835 	if err == io.EOF {
   8836 		return out, metadata, nil
   8837 	}
   8838 	if err != nil {
   8839 		var snapshot bytes.Buffer
   8840 		io.Copy(&snapshot, ringBuffer)
   8841 		return out, metadata, &smithy.DeserializationError{
   8842 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8843 			Snapshot: snapshot.Bytes(),
   8844 		}
   8845 	}
   8846 
   8847 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8848 	err = awsRestxml_deserializeOpDocumentListTagsForResourceOutput(&output, decoder)
   8849 	if err != nil {
   8850 		var snapshot bytes.Buffer
   8851 		io.Copy(&snapshot, ringBuffer)
   8852 		return out, metadata, &smithy.DeserializationError{
   8853 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8854 			Snapshot: snapshot.Bytes(),
   8855 		}
   8856 	}
   8857 
   8858 	span.End()
   8859 	return out, metadata, err
   8860 }
   8861 
   8862 func awsRestxml_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8863 	var errorBuffer bytes.Buffer
   8864 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8865 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8866 	}
   8867 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8868 
   8869 	errorCode := "UnknownError"
   8870 	errorMessage := errorCode
   8871 
   8872 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8873 	if err != nil {
   8874 		return err
   8875 	}
   8876 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8877 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8878 	}
   8879 	if len(errorComponents.Code) != 0 {
   8880 		errorCode = errorComponents.Code
   8881 	}
   8882 	if len(errorComponents.Message) != 0 {
   8883 		errorMessage = errorComponents.Message
   8884 	}
   8885 	errorBody.Seek(0, io.SeekStart)
   8886 	switch {
   8887 	case strings.EqualFold("InvalidInput", errorCode):
   8888 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8889 
   8890 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   8891 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   8892 
   8893 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   8894 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   8895 
   8896 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   8897 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   8898 
   8899 	case strings.EqualFold("ThrottlingException", errorCode):
   8900 		return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
   8901 
   8902 	default:
   8903 		genericError := &smithy.GenericAPIError{
   8904 			Code:    errorCode,
   8905 			Message: errorMessage,
   8906 		}
   8907 		return genericError
   8908 
   8909 	}
   8910 }
   8911 
   8912 func awsRestxml_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, decoder smithyxml.NodeDecoder) error {
   8913 	if v == nil {
   8914 		return fmt.Errorf("unexpected nil of type %T", v)
   8915 	}
   8916 	var sv *ListTagsForResourceOutput
   8917 	if *v == nil {
   8918 		sv = &ListTagsForResourceOutput{}
   8919 	} else {
   8920 		sv = *v
   8921 	}
   8922 
   8923 	for {
   8924 		t, done, err := decoder.Token()
   8925 		if err != nil {
   8926 			return err
   8927 		}
   8928 		if done {
   8929 			break
   8930 		}
   8931 		originalDecoder := decoder
   8932 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8933 		switch {
   8934 		case strings.EqualFold("ResourceTagSet", t.Name.Local):
   8935 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8936 			if err := awsRestxml_deserializeDocumentResourceTagSet(&sv.ResourceTagSet, nodeDecoder); err != nil {
   8937 				return err
   8938 			}
   8939 
   8940 		default:
   8941 			// Do nothing and ignore the unexpected tag element
   8942 			err = decoder.Decoder.Skip()
   8943 			if err != nil {
   8944 				return err
   8945 			}
   8946 
   8947 		}
   8948 		decoder = originalDecoder
   8949 	}
   8950 	*v = sv
   8951 	return nil
   8952 }
   8953 
   8954 type awsRestxml_deserializeOpListTagsForResources struct {
   8955 }
   8956 
   8957 func (*awsRestxml_deserializeOpListTagsForResources) ID() string {
   8958 	return "OperationDeserializer"
   8959 }
   8960 
   8961 func (m *awsRestxml_deserializeOpListTagsForResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8962 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8963 ) {
   8964 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8965 	if err != nil {
   8966 		return out, metadata, err
   8967 	}
   8968 
   8969 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   8970 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   8971 	defer endTimer()
   8972 	defer span.End()
   8973 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8974 	if !ok {
   8975 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8976 	}
   8977 
   8978 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8979 		return out, metadata, awsRestxml_deserializeOpErrorListTagsForResources(response, &metadata)
   8980 	}
   8981 	output := &ListTagsForResourcesOutput{}
   8982 	out.Result = output
   8983 
   8984 	var buff [1024]byte
   8985 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8986 	body := io.TeeReader(response.Body, ringBuffer)
   8987 	rootDecoder := xml.NewDecoder(body)
   8988 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8989 	if err == io.EOF {
   8990 		return out, metadata, nil
   8991 	}
   8992 	if err != nil {
   8993 		var snapshot bytes.Buffer
   8994 		io.Copy(&snapshot, ringBuffer)
   8995 		return out, metadata, &smithy.DeserializationError{
   8996 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8997 			Snapshot: snapshot.Bytes(),
   8998 		}
   8999 	}
   9000 
   9001 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9002 	err = awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(&output, decoder)
   9003 	if err != nil {
   9004 		var snapshot bytes.Buffer
   9005 		io.Copy(&snapshot, ringBuffer)
   9006 		return out, metadata, &smithy.DeserializationError{
   9007 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9008 			Snapshot: snapshot.Bytes(),
   9009 		}
   9010 	}
   9011 
   9012 	span.End()
   9013 	return out, metadata, err
   9014 }
   9015 
   9016 func awsRestxml_deserializeOpErrorListTagsForResources(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9017 	var errorBuffer bytes.Buffer
   9018 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9019 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9020 	}
   9021 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9022 
   9023 	errorCode := "UnknownError"
   9024 	errorMessage := errorCode
   9025 
   9026 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9027 	if err != nil {
   9028 		return err
   9029 	}
   9030 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9031 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9032 	}
   9033 	if len(errorComponents.Code) != 0 {
   9034 		errorCode = errorComponents.Code
   9035 	}
   9036 	if len(errorComponents.Message) != 0 {
   9037 		errorMessage = errorComponents.Message
   9038 	}
   9039 	errorBody.Seek(0, io.SeekStart)
   9040 	switch {
   9041 	case strings.EqualFold("InvalidInput", errorCode):
   9042 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9043 
   9044 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   9045 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   9046 
   9047 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   9048 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   9049 
   9050 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   9051 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   9052 
   9053 	case strings.EqualFold("ThrottlingException", errorCode):
   9054 		return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
   9055 
   9056 	default:
   9057 		genericError := &smithy.GenericAPIError{
   9058 			Code:    errorCode,
   9059 			Message: errorMessage,
   9060 		}
   9061 		return genericError
   9062 
   9063 	}
   9064 }
   9065 
   9066 func awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(v **ListTagsForResourcesOutput, decoder smithyxml.NodeDecoder) error {
   9067 	if v == nil {
   9068 		return fmt.Errorf("unexpected nil of type %T", v)
   9069 	}
   9070 	var sv *ListTagsForResourcesOutput
   9071 	if *v == nil {
   9072 		sv = &ListTagsForResourcesOutput{}
   9073 	} else {
   9074 		sv = *v
   9075 	}
   9076 
   9077 	for {
   9078 		t, done, err := decoder.Token()
   9079 		if err != nil {
   9080 			return err
   9081 		}
   9082 		if done {
   9083 			break
   9084 		}
   9085 		originalDecoder := decoder
   9086 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9087 		switch {
   9088 		case strings.EqualFold("ResourceTagSets", t.Name.Local):
   9089 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9090 			if err := awsRestxml_deserializeDocumentResourceTagSetList(&sv.ResourceTagSets, nodeDecoder); err != nil {
   9091 				return err
   9092 			}
   9093 
   9094 		default:
   9095 			// Do nothing and ignore the unexpected tag element
   9096 			err = decoder.Decoder.Skip()
   9097 			if err != nil {
   9098 				return err
   9099 			}
   9100 
   9101 		}
   9102 		decoder = originalDecoder
   9103 	}
   9104 	*v = sv
   9105 	return nil
   9106 }
   9107 
   9108 type awsRestxml_deserializeOpListTrafficPolicies struct {
   9109 }
   9110 
   9111 func (*awsRestxml_deserializeOpListTrafficPolicies) ID() string {
   9112 	return "OperationDeserializer"
   9113 }
   9114 
   9115 func (m *awsRestxml_deserializeOpListTrafficPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9116 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9117 ) {
   9118 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9119 	if err != nil {
   9120 		return out, metadata, err
   9121 	}
   9122 
   9123 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   9124 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   9125 	defer endTimer()
   9126 	defer span.End()
   9127 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9128 	if !ok {
   9129 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9130 	}
   9131 
   9132 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9133 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicies(response, &metadata)
   9134 	}
   9135 	output := &ListTrafficPoliciesOutput{}
   9136 	out.Result = output
   9137 
   9138 	var buff [1024]byte
   9139 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9140 	body := io.TeeReader(response.Body, ringBuffer)
   9141 	rootDecoder := xml.NewDecoder(body)
   9142 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9143 	if err == io.EOF {
   9144 		return out, metadata, nil
   9145 	}
   9146 	if err != nil {
   9147 		var snapshot bytes.Buffer
   9148 		io.Copy(&snapshot, ringBuffer)
   9149 		return out, metadata, &smithy.DeserializationError{
   9150 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9151 			Snapshot: snapshot.Bytes(),
   9152 		}
   9153 	}
   9154 
   9155 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9156 	err = awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(&output, decoder)
   9157 	if err != nil {
   9158 		var snapshot bytes.Buffer
   9159 		io.Copy(&snapshot, ringBuffer)
   9160 		return out, metadata, &smithy.DeserializationError{
   9161 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9162 			Snapshot: snapshot.Bytes(),
   9163 		}
   9164 	}
   9165 
   9166 	span.End()
   9167 	return out, metadata, err
   9168 }
   9169 
   9170 func awsRestxml_deserializeOpErrorListTrafficPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9171 	var errorBuffer bytes.Buffer
   9172 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9173 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9174 	}
   9175 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9176 
   9177 	errorCode := "UnknownError"
   9178 	errorMessage := errorCode
   9179 
   9180 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9181 	if err != nil {
   9182 		return err
   9183 	}
   9184 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9185 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9186 	}
   9187 	if len(errorComponents.Code) != 0 {
   9188 		errorCode = errorComponents.Code
   9189 	}
   9190 	if len(errorComponents.Message) != 0 {
   9191 		errorMessage = errorComponents.Message
   9192 	}
   9193 	errorBody.Seek(0, io.SeekStart)
   9194 	switch {
   9195 	case strings.EqualFold("InvalidInput", errorCode):
   9196 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9197 
   9198 	default:
   9199 		genericError := &smithy.GenericAPIError{
   9200 			Code:    errorCode,
   9201 			Message: errorMessage,
   9202 		}
   9203 		return genericError
   9204 
   9205 	}
   9206 }
   9207 
   9208 func awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(v **ListTrafficPoliciesOutput, decoder smithyxml.NodeDecoder) error {
   9209 	if v == nil {
   9210 		return fmt.Errorf("unexpected nil of type %T", v)
   9211 	}
   9212 	var sv *ListTrafficPoliciesOutput
   9213 	if *v == nil {
   9214 		sv = &ListTrafficPoliciesOutput{}
   9215 	} else {
   9216 		sv = *v
   9217 	}
   9218 
   9219 	for {
   9220 		t, done, err := decoder.Token()
   9221 		if err != nil {
   9222 			return err
   9223 		}
   9224 		if done {
   9225 			break
   9226 		}
   9227 		originalDecoder := decoder
   9228 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9229 		switch {
   9230 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9231 			val, err := decoder.Value()
   9232 			if err != nil {
   9233 				return err
   9234 			}
   9235 			if val == nil {
   9236 				break
   9237 			}
   9238 			{
   9239 				xtv, err := strconv.ParseBool(string(val))
   9240 				if err != nil {
   9241 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9242 				}
   9243 				sv.IsTruncated = xtv
   9244 			}
   9245 
   9246 		case strings.EqualFold("MaxItems", t.Name.Local):
   9247 			val, err := decoder.Value()
   9248 			if err != nil {
   9249 				return err
   9250 			}
   9251 			if val == nil {
   9252 				break
   9253 			}
   9254 			{
   9255 				xtv := string(val)
   9256 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9257 				if err != nil {
   9258 					return err
   9259 				}
   9260 				sv.MaxItems = ptr.Int32(int32(i64))
   9261 			}
   9262 
   9263 		case strings.EqualFold("TrafficPolicyIdMarker", t.Name.Local):
   9264 			val, err := decoder.Value()
   9265 			if err != nil {
   9266 				return err
   9267 			}
   9268 			if val == nil {
   9269 				break
   9270 			}
   9271 			{
   9272 				xtv := string(val)
   9273 				sv.TrafficPolicyIdMarker = ptr.String(xtv)
   9274 			}
   9275 
   9276 		case strings.EqualFold("TrafficPolicySummaries", t.Name.Local):
   9277 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9278 			if err := awsRestxml_deserializeDocumentTrafficPolicySummaries(&sv.TrafficPolicySummaries, nodeDecoder); err != nil {
   9279 				return err
   9280 			}
   9281 
   9282 		default:
   9283 			// Do nothing and ignore the unexpected tag element
   9284 			err = decoder.Decoder.Skip()
   9285 			if err != nil {
   9286 				return err
   9287 			}
   9288 
   9289 		}
   9290 		decoder = originalDecoder
   9291 	}
   9292 	*v = sv
   9293 	return nil
   9294 }
   9295 
   9296 type awsRestxml_deserializeOpListTrafficPolicyInstances struct {
   9297 }
   9298 
   9299 func (*awsRestxml_deserializeOpListTrafficPolicyInstances) ID() string {
   9300 	return "OperationDeserializer"
   9301 }
   9302 
   9303 func (m *awsRestxml_deserializeOpListTrafficPolicyInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9304 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9305 ) {
   9306 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9307 	if err != nil {
   9308 		return out, metadata, err
   9309 	}
   9310 
   9311 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   9312 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   9313 	defer endTimer()
   9314 	defer span.End()
   9315 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9316 	if !ok {
   9317 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9318 	}
   9319 
   9320 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9321 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response, &metadata)
   9322 	}
   9323 	output := &ListTrafficPolicyInstancesOutput{}
   9324 	out.Result = output
   9325 
   9326 	var buff [1024]byte
   9327 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9328 	body := io.TeeReader(response.Body, ringBuffer)
   9329 	rootDecoder := xml.NewDecoder(body)
   9330 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9331 	if err == io.EOF {
   9332 		return out, metadata, nil
   9333 	}
   9334 	if err != nil {
   9335 		var snapshot bytes.Buffer
   9336 		io.Copy(&snapshot, ringBuffer)
   9337 		return out, metadata, &smithy.DeserializationError{
   9338 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9339 			Snapshot: snapshot.Bytes(),
   9340 		}
   9341 	}
   9342 
   9343 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9344 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(&output, decoder)
   9345 	if err != nil {
   9346 		var snapshot bytes.Buffer
   9347 		io.Copy(&snapshot, ringBuffer)
   9348 		return out, metadata, &smithy.DeserializationError{
   9349 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9350 			Snapshot: snapshot.Bytes(),
   9351 		}
   9352 	}
   9353 
   9354 	span.End()
   9355 	return out, metadata, err
   9356 }
   9357 
   9358 func awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9359 	var errorBuffer bytes.Buffer
   9360 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9361 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9362 	}
   9363 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9364 
   9365 	errorCode := "UnknownError"
   9366 	errorMessage := errorCode
   9367 
   9368 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9369 	if err != nil {
   9370 		return err
   9371 	}
   9372 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9373 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9374 	}
   9375 	if len(errorComponents.Code) != 0 {
   9376 		errorCode = errorComponents.Code
   9377 	}
   9378 	if len(errorComponents.Message) != 0 {
   9379 		errorMessage = errorComponents.Message
   9380 	}
   9381 	errorBody.Seek(0, io.SeekStart)
   9382 	switch {
   9383 	case strings.EqualFold("InvalidInput", errorCode):
   9384 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9385 
   9386 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   9387 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   9388 
   9389 	default:
   9390 		genericError := &smithy.GenericAPIError{
   9391 			Code:    errorCode,
   9392 			Message: errorMessage,
   9393 		}
   9394 		return genericError
   9395 
   9396 	}
   9397 }
   9398 
   9399 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(v **ListTrafficPolicyInstancesOutput, decoder smithyxml.NodeDecoder) error {
   9400 	if v == nil {
   9401 		return fmt.Errorf("unexpected nil of type %T", v)
   9402 	}
   9403 	var sv *ListTrafficPolicyInstancesOutput
   9404 	if *v == nil {
   9405 		sv = &ListTrafficPolicyInstancesOutput{}
   9406 	} else {
   9407 		sv = *v
   9408 	}
   9409 
   9410 	for {
   9411 		t, done, err := decoder.Token()
   9412 		if err != nil {
   9413 			return err
   9414 		}
   9415 		if done {
   9416 			break
   9417 		}
   9418 		originalDecoder := decoder
   9419 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9420 		switch {
   9421 		case strings.EqualFold("HostedZoneIdMarker", t.Name.Local):
   9422 			val, err := decoder.Value()
   9423 			if err != nil {
   9424 				return err
   9425 			}
   9426 			if val == nil {
   9427 				break
   9428 			}
   9429 			{
   9430 				xtv := string(val)
   9431 				sv.HostedZoneIdMarker = ptr.String(xtv)
   9432 			}
   9433 
   9434 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9435 			val, err := decoder.Value()
   9436 			if err != nil {
   9437 				return err
   9438 			}
   9439 			if val == nil {
   9440 				break
   9441 			}
   9442 			{
   9443 				xtv, err := strconv.ParseBool(string(val))
   9444 				if err != nil {
   9445 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9446 				}
   9447 				sv.IsTruncated = xtv
   9448 			}
   9449 
   9450 		case strings.EqualFold("MaxItems", t.Name.Local):
   9451 			val, err := decoder.Value()
   9452 			if err != nil {
   9453 				return err
   9454 			}
   9455 			if val == nil {
   9456 				break
   9457 			}
   9458 			{
   9459 				xtv := string(val)
   9460 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9461 				if err != nil {
   9462 					return err
   9463 				}
   9464 				sv.MaxItems = ptr.Int32(int32(i64))
   9465 			}
   9466 
   9467 		case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
   9468 			val, err := decoder.Value()
   9469 			if err != nil {
   9470 				return err
   9471 			}
   9472 			if val == nil {
   9473 				break
   9474 			}
   9475 			{
   9476 				xtv := string(val)
   9477 				sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
   9478 			}
   9479 
   9480 		case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
   9481 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9482 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
   9483 				return err
   9484 			}
   9485 
   9486 		case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
   9487 			val, err := decoder.Value()
   9488 			if err != nil {
   9489 				return err
   9490 			}
   9491 			if val == nil {
   9492 				break
   9493 			}
   9494 			{
   9495 				xtv := string(val)
   9496 				sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
   9497 			}
   9498 
   9499 		default:
   9500 			// Do nothing and ignore the unexpected tag element
   9501 			err = decoder.Decoder.Skip()
   9502 			if err != nil {
   9503 				return err
   9504 			}
   9505 
   9506 		}
   9507 		decoder = originalDecoder
   9508 	}
   9509 	*v = sv
   9510 	return nil
   9511 }
   9512 
   9513 type awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone struct {
   9514 }
   9515 
   9516 func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) ID() string {
   9517 	return "OperationDeserializer"
   9518 }
   9519 
   9520 func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9521 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9522 ) {
   9523 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9524 	if err != nil {
   9525 		return out, metadata, err
   9526 	}
   9527 
   9528 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   9529 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   9530 	defer endTimer()
   9531 	defer span.End()
   9532 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9533 	if !ok {
   9534 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9535 	}
   9536 
   9537 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9538 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response, &metadata)
   9539 	}
   9540 	output := &ListTrafficPolicyInstancesByHostedZoneOutput{}
   9541 	out.Result = output
   9542 
   9543 	var buff [1024]byte
   9544 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9545 	body := io.TeeReader(response.Body, ringBuffer)
   9546 	rootDecoder := xml.NewDecoder(body)
   9547 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9548 	if err == io.EOF {
   9549 		return out, metadata, nil
   9550 	}
   9551 	if err != nil {
   9552 		var snapshot bytes.Buffer
   9553 		io.Copy(&snapshot, ringBuffer)
   9554 		return out, metadata, &smithy.DeserializationError{
   9555 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9556 			Snapshot: snapshot.Bytes(),
   9557 		}
   9558 	}
   9559 
   9560 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9561 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(&output, decoder)
   9562 	if err != nil {
   9563 		var snapshot bytes.Buffer
   9564 		io.Copy(&snapshot, ringBuffer)
   9565 		return out, metadata, &smithy.DeserializationError{
   9566 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9567 			Snapshot: snapshot.Bytes(),
   9568 		}
   9569 	}
   9570 
   9571 	span.End()
   9572 	return out, metadata, err
   9573 }
   9574 
   9575 func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9576 	var errorBuffer bytes.Buffer
   9577 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9578 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9579 	}
   9580 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9581 
   9582 	errorCode := "UnknownError"
   9583 	errorMessage := errorCode
   9584 
   9585 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9586 	if err != nil {
   9587 		return err
   9588 	}
   9589 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9590 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9591 	}
   9592 	if len(errorComponents.Code) != 0 {
   9593 		errorCode = errorComponents.Code
   9594 	}
   9595 	if len(errorComponents.Message) != 0 {
   9596 		errorMessage = errorComponents.Message
   9597 	}
   9598 	errorBody.Seek(0, io.SeekStart)
   9599 	switch {
   9600 	case strings.EqualFold("InvalidInput", errorCode):
   9601 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9602 
   9603 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   9604 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   9605 
   9606 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   9607 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   9608 
   9609 	default:
   9610 		genericError := &smithy.GenericAPIError{
   9611 			Code:    errorCode,
   9612 			Message: errorMessage,
   9613 		}
   9614 		return genericError
   9615 
   9616 	}
   9617 }
   9618 
   9619 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(v **ListTrafficPolicyInstancesByHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   9620 	if v == nil {
   9621 		return fmt.Errorf("unexpected nil of type %T", v)
   9622 	}
   9623 	var sv *ListTrafficPolicyInstancesByHostedZoneOutput
   9624 	if *v == nil {
   9625 		sv = &ListTrafficPolicyInstancesByHostedZoneOutput{}
   9626 	} else {
   9627 		sv = *v
   9628 	}
   9629 
   9630 	for {
   9631 		t, done, err := decoder.Token()
   9632 		if err != nil {
   9633 			return err
   9634 		}
   9635 		if done {
   9636 			break
   9637 		}
   9638 		originalDecoder := decoder
   9639 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9640 		switch {
   9641 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9642 			val, err := decoder.Value()
   9643 			if err != nil {
   9644 				return err
   9645 			}
   9646 			if val == nil {
   9647 				break
   9648 			}
   9649 			{
   9650 				xtv, err := strconv.ParseBool(string(val))
   9651 				if err != nil {
   9652 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9653 				}
   9654 				sv.IsTruncated = xtv
   9655 			}
   9656 
   9657 		case strings.EqualFold("MaxItems", t.Name.Local):
   9658 			val, err := decoder.Value()
   9659 			if err != nil {
   9660 				return err
   9661 			}
   9662 			if val == nil {
   9663 				break
   9664 			}
   9665 			{
   9666 				xtv := string(val)
   9667 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9668 				if err != nil {
   9669 					return err
   9670 				}
   9671 				sv.MaxItems = ptr.Int32(int32(i64))
   9672 			}
   9673 
   9674 		case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
   9675 			val, err := decoder.Value()
   9676 			if err != nil {
   9677 				return err
   9678 			}
   9679 			if val == nil {
   9680 				break
   9681 			}
   9682 			{
   9683 				xtv := string(val)
   9684 				sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
   9685 			}
   9686 
   9687 		case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
   9688 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9689 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
   9690 				return err
   9691 			}
   9692 
   9693 		case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
   9694 			val, err := decoder.Value()
   9695 			if err != nil {
   9696 				return err
   9697 			}
   9698 			if val == nil {
   9699 				break
   9700 			}
   9701 			{
   9702 				xtv := string(val)
   9703 				sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
   9704 			}
   9705 
   9706 		default:
   9707 			// Do nothing and ignore the unexpected tag element
   9708 			err = decoder.Decoder.Skip()
   9709 			if err != nil {
   9710 				return err
   9711 			}
   9712 
   9713 		}
   9714 		decoder = originalDecoder
   9715 	}
   9716 	*v = sv
   9717 	return nil
   9718 }
   9719 
   9720 type awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy struct {
   9721 }
   9722 
   9723 func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) ID() string {
   9724 	return "OperationDeserializer"
   9725 }
   9726 
   9727 func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9728 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9729 ) {
   9730 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9731 	if err != nil {
   9732 		return out, metadata, err
   9733 	}
   9734 
   9735 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   9736 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   9737 	defer endTimer()
   9738 	defer span.End()
   9739 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9740 	if !ok {
   9741 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9742 	}
   9743 
   9744 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9745 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response, &metadata)
   9746 	}
   9747 	output := &ListTrafficPolicyInstancesByPolicyOutput{}
   9748 	out.Result = output
   9749 
   9750 	var buff [1024]byte
   9751 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9752 	body := io.TeeReader(response.Body, ringBuffer)
   9753 	rootDecoder := xml.NewDecoder(body)
   9754 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9755 	if err == io.EOF {
   9756 		return out, metadata, nil
   9757 	}
   9758 	if err != nil {
   9759 		var snapshot bytes.Buffer
   9760 		io.Copy(&snapshot, ringBuffer)
   9761 		return out, metadata, &smithy.DeserializationError{
   9762 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9763 			Snapshot: snapshot.Bytes(),
   9764 		}
   9765 	}
   9766 
   9767 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9768 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(&output, decoder)
   9769 	if err != nil {
   9770 		var snapshot bytes.Buffer
   9771 		io.Copy(&snapshot, ringBuffer)
   9772 		return out, metadata, &smithy.DeserializationError{
   9773 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9774 			Snapshot: snapshot.Bytes(),
   9775 		}
   9776 	}
   9777 
   9778 	span.End()
   9779 	return out, metadata, err
   9780 }
   9781 
   9782 func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9783 	var errorBuffer bytes.Buffer
   9784 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9785 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9786 	}
   9787 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9788 
   9789 	errorCode := "UnknownError"
   9790 	errorMessage := errorCode
   9791 
   9792 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9793 	if err != nil {
   9794 		return err
   9795 	}
   9796 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9797 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9798 	}
   9799 	if len(errorComponents.Code) != 0 {
   9800 		errorCode = errorComponents.Code
   9801 	}
   9802 	if len(errorComponents.Message) != 0 {
   9803 		errorMessage = errorComponents.Message
   9804 	}
   9805 	errorBody.Seek(0, io.SeekStart)
   9806 	switch {
   9807 	case strings.EqualFold("InvalidInput", errorCode):
   9808 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9809 
   9810 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   9811 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   9812 
   9813 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   9814 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   9815 
   9816 	default:
   9817 		genericError := &smithy.GenericAPIError{
   9818 			Code:    errorCode,
   9819 			Message: errorMessage,
   9820 		}
   9821 		return genericError
   9822 
   9823 	}
   9824 }
   9825 
   9826 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(v **ListTrafficPolicyInstancesByPolicyOutput, decoder smithyxml.NodeDecoder) error {
   9827 	if v == nil {
   9828 		return fmt.Errorf("unexpected nil of type %T", v)
   9829 	}
   9830 	var sv *ListTrafficPolicyInstancesByPolicyOutput
   9831 	if *v == nil {
   9832 		sv = &ListTrafficPolicyInstancesByPolicyOutput{}
   9833 	} else {
   9834 		sv = *v
   9835 	}
   9836 
   9837 	for {
   9838 		t, done, err := decoder.Token()
   9839 		if err != nil {
   9840 			return err
   9841 		}
   9842 		if done {
   9843 			break
   9844 		}
   9845 		originalDecoder := decoder
   9846 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9847 		switch {
   9848 		case strings.EqualFold("HostedZoneIdMarker", t.Name.Local):
   9849 			val, err := decoder.Value()
   9850 			if err != nil {
   9851 				return err
   9852 			}
   9853 			if val == nil {
   9854 				break
   9855 			}
   9856 			{
   9857 				xtv := string(val)
   9858 				sv.HostedZoneIdMarker = ptr.String(xtv)
   9859 			}
   9860 
   9861 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9862 			val, err := decoder.Value()
   9863 			if err != nil {
   9864 				return err
   9865 			}
   9866 			if val == nil {
   9867 				break
   9868 			}
   9869 			{
   9870 				xtv, err := strconv.ParseBool(string(val))
   9871 				if err != nil {
   9872 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9873 				}
   9874 				sv.IsTruncated = xtv
   9875 			}
   9876 
   9877 		case strings.EqualFold("MaxItems", t.Name.Local):
   9878 			val, err := decoder.Value()
   9879 			if err != nil {
   9880 				return err
   9881 			}
   9882 			if val == nil {
   9883 				break
   9884 			}
   9885 			{
   9886 				xtv := string(val)
   9887 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9888 				if err != nil {
   9889 					return err
   9890 				}
   9891 				sv.MaxItems = ptr.Int32(int32(i64))
   9892 			}
   9893 
   9894 		case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
   9895 			val, err := decoder.Value()
   9896 			if err != nil {
   9897 				return err
   9898 			}
   9899 			if val == nil {
   9900 				break
   9901 			}
   9902 			{
   9903 				xtv := string(val)
   9904 				sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
   9905 			}
   9906 
   9907 		case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
   9908 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9909 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
   9910 				return err
   9911 			}
   9912 
   9913 		case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
   9914 			val, err := decoder.Value()
   9915 			if err != nil {
   9916 				return err
   9917 			}
   9918 			if val == nil {
   9919 				break
   9920 			}
   9921 			{
   9922 				xtv := string(val)
   9923 				sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
   9924 			}
   9925 
   9926 		default:
   9927 			// Do nothing and ignore the unexpected tag element
   9928 			err = decoder.Decoder.Skip()
   9929 			if err != nil {
   9930 				return err
   9931 			}
   9932 
   9933 		}
   9934 		decoder = originalDecoder
   9935 	}
   9936 	*v = sv
   9937 	return nil
   9938 }
   9939 
   9940 type awsRestxml_deserializeOpListTrafficPolicyVersions struct {
   9941 }
   9942 
   9943 func (*awsRestxml_deserializeOpListTrafficPolicyVersions) ID() string {
   9944 	return "OperationDeserializer"
   9945 }
   9946 
   9947 func (m *awsRestxml_deserializeOpListTrafficPolicyVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9948 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9949 ) {
   9950 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9951 	if err != nil {
   9952 		return out, metadata, err
   9953 	}
   9954 
   9955 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   9956 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   9957 	defer endTimer()
   9958 	defer span.End()
   9959 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9960 	if !ok {
   9961 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9962 	}
   9963 
   9964 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9965 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response, &metadata)
   9966 	}
   9967 	output := &ListTrafficPolicyVersionsOutput{}
   9968 	out.Result = output
   9969 
   9970 	var buff [1024]byte
   9971 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9972 	body := io.TeeReader(response.Body, ringBuffer)
   9973 	rootDecoder := xml.NewDecoder(body)
   9974 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9975 	if err == io.EOF {
   9976 		return out, metadata, nil
   9977 	}
   9978 	if err != nil {
   9979 		var snapshot bytes.Buffer
   9980 		io.Copy(&snapshot, ringBuffer)
   9981 		return out, metadata, &smithy.DeserializationError{
   9982 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9983 			Snapshot: snapshot.Bytes(),
   9984 		}
   9985 	}
   9986 
   9987 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9988 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(&output, decoder)
   9989 	if err != nil {
   9990 		var snapshot bytes.Buffer
   9991 		io.Copy(&snapshot, ringBuffer)
   9992 		return out, metadata, &smithy.DeserializationError{
   9993 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9994 			Snapshot: snapshot.Bytes(),
   9995 		}
   9996 	}
   9997 
   9998 	span.End()
   9999 	return out, metadata, err
  10000 }
  10001 
  10002 func awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10003 	var errorBuffer bytes.Buffer
  10004 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10005 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10006 	}
  10007 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10008 
  10009 	errorCode := "UnknownError"
  10010 	errorMessage := errorCode
  10011 
  10012 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10013 	if err != nil {
  10014 		return err
  10015 	}
  10016 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10017 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10018 	}
  10019 	if len(errorComponents.Code) != 0 {
  10020 		errorCode = errorComponents.Code
  10021 	}
  10022 	if len(errorComponents.Message) != 0 {
  10023 		errorMessage = errorComponents.Message
  10024 	}
  10025 	errorBody.Seek(0, io.SeekStart)
  10026 	switch {
  10027 	case strings.EqualFold("InvalidInput", errorCode):
  10028 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10029 
  10030 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
  10031 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
  10032 
  10033 	default:
  10034 		genericError := &smithy.GenericAPIError{
  10035 			Code:    errorCode,
  10036 			Message: errorMessage,
  10037 		}
  10038 		return genericError
  10039 
  10040 	}
  10041 }
  10042 
  10043 func awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(v **ListTrafficPolicyVersionsOutput, decoder smithyxml.NodeDecoder) error {
  10044 	if v == nil {
  10045 		return fmt.Errorf("unexpected nil of type %T", v)
  10046 	}
  10047 	var sv *ListTrafficPolicyVersionsOutput
  10048 	if *v == nil {
  10049 		sv = &ListTrafficPolicyVersionsOutput{}
  10050 	} else {
  10051 		sv = *v
  10052 	}
  10053 
  10054 	for {
  10055 		t, done, err := decoder.Token()
  10056 		if err != nil {
  10057 			return err
  10058 		}
  10059 		if done {
  10060 			break
  10061 		}
  10062 		originalDecoder := decoder
  10063 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10064 		switch {
  10065 		case strings.EqualFold("IsTruncated", t.Name.Local):
  10066 			val, err := decoder.Value()
  10067 			if err != nil {
  10068 				return err
  10069 			}
  10070 			if val == nil {
  10071 				break
  10072 			}
  10073 			{
  10074 				xtv, err := strconv.ParseBool(string(val))
  10075 				if err != nil {
  10076 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
  10077 				}
  10078 				sv.IsTruncated = xtv
  10079 			}
  10080 
  10081 		case strings.EqualFold("MaxItems", t.Name.Local):
  10082 			val, err := decoder.Value()
  10083 			if err != nil {
  10084 				return err
  10085 			}
  10086 			if val == nil {
  10087 				break
  10088 			}
  10089 			{
  10090 				xtv := string(val)
  10091 				i64, err := strconv.ParseInt(xtv, 10, 64)
  10092 				if err != nil {
  10093 					return err
  10094 				}
  10095 				sv.MaxItems = ptr.Int32(int32(i64))
  10096 			}
  10097 
  10098 		case strings.EqualFold("TrafficPolicies", t.Name.Local):
  10099 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10100 			if err := awsRestxml_deserializeDocumentTrafficPolicies(&sv.TrafficPolicies, nodeDecoder); err != nil {
  10101 				return err
  10102 			}
  10103 
  10104 		case strings.EqualFold("TrafficPolicyVersionMarker", t.Name.Local):
  10105 			val, err := decoder.Value()
  10106 			if err != nil {
  10107 				return err
  10108 			}
  10109 			if val == nil {
  10110 				break
  10111 			}
  10112 			{
  10113 				xtv := string(val)
  10114 				sv.TrafficPolicyVersionMarker = ptr.String(xtv)
  10115 			}
  10116 
  10117 		default:
  10118 			// Do nothing and ignore the unexpected tag element
  10119 			err = decoder.Decoder.Skip()
  10120 			if err != nil {
  10121 				return err
  10122 			}
  10123 
  10124 		}
  10125 		decoder = originalDecoder
  10126 	}
  10127 	*v = sv
  10128 	return nil
  10129 }
  10130 
  10131 type awsRestxml_deserializeOpListVPCAssociationAuthorizations struct {
  10132 }
  10133 
  10134 func (*awsRestxml_deserializeOpListVPCAssociationAuthorizations) ID() string {
  10135 	return "OperationDeserializer"
  10136 }
  10137 
  10138 func (m *awsRestxml_deserializeOpListVPCAssociationAuthorizations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10139 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10140 ) {
  10141 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10142 	if err != nil {
  10143 		return out, metadata, err
  10144 	}
  10145 
  10146 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10147 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10148 	defer endTimer()
  10149 	defer span.End()
  10150 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10151 	if !ok {
  10152 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10153 	}
  10154 
  10155 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10156 		return out, metadata, awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response, &metadata)
  10157 	}
  10158 	output := &ListVPCAssociationAuthorizationsOutput{}
  10159 	out.Result = output
  10160 
  10161 	var buff [1024]byte
  10162 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10163 	body := io.TeeReader(response.Body, ringBuffer)
  10164 	rootDecoder := xml.NewDecoder(body)
  10165 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10166 	if err == io.EOF {
  10167 		return out, metadata, nil
  10168 	}
  10169 	if err != nil {
  10170 		var snapshot bytes.Buffer
  10171 		io.Copy(&snapshot, ringBuffer)
  10172 		return out, metadata, &smithy.DeserializationError{
  10173 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10174 			Snapshot: snapshot.Bytes(),
  10175 		}
  10176 	}
  10177 
  10178 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10179 	err = awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(&output, decoder)
  10180 	if err != nil {
  10181 		var snapshot bytes.Buffer
  10182 		io.Copy(&snapshot, ringBuffer)
  10183 		return out, metadata, &smithy.DeserializationError{
  10184 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10185 			Snapshot: snapshot.Bytes(),
  10186 		}
  10187 	}
  10188 
  10189 	span.End()
  10190 	return out, metadata, err
  10191 }
  10192 
  10193 func awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10194 	var errorBuffer bytes.Buffer
  10195 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10196 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10197 	}
  10198 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10199 
  10200 	errorCode := "UnknownError"
  10201 	errorMessage := errorCode
  10202 
  10203 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10204 	if err != nil {
  10205 		return err
  10206 	}
  10207 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10208 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10209 	}
  10210 	if len(errorComponents.Code) != 0 {
  10211 		errorCode = errorComponents.Code
  10212 	}
  10213 	if len(errorComponents.Message) != 0 {
  10214 		errorMessage = errorComponents.Message
  10215 	}
  10216 	errorBody.Seek(0, io.SeekStart)
  10217 	switch {
  10218 	case strings.EqualFold("InvalidInput", errorCode):
  10219 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10220 
  10221 	case strings.EqualFold("InvalidPaginationToken", errorCode):
  10222 		return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
  10223 
  10224 	case strings.EqualFold("NoSuchHostedZone", errorCode):
  10225 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
  10226 
  10227 	default:
  10228 		genericError := &smithy.GenericAPIError{
  10229 			Code:    errorCode,
  10230 			Message: errorMessage,
  10231 		}
  10232 		return genericError
  10233 
  10234 	}
  10235 }
  10236 
  10237 func awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(v **ListVPCAssociationAuthorizationsOutput, decoder smithyxml.NodeDecoder) error {
  10238 	if v == nil {
  10239 		return fmt.Errorf("unexpected nil of type %T", v)
  10240 	}
  10241 	var sv *ListVPCAssociationAuthorizationsOutput
  10242 	if *v == nil {
  10243 		sv = &ListVPCAssociationAuthorizationsOutput{}
  10244 	} else {
  10245 		sv = *v
  10246 	}
  10247 
  10248 	for {
  10249 		t, done, err := decoder.Token()
  10250 		if err != nil {
  10251 			return err
  10252 		}
  10253 		if done {
  10254 			break
  10255 		}
  10256 		originalDecoder := decoder
  10257 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10258 		switch {
  10259 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  10260 			val, err := decoder.Value()
  10261 			if err != nil {
  10262 				return err
  10263 			}
  10264 			if val == nil {
  10265 				break
  10266 			}
  10267 			{
  10268 				xtv := string(val)
  10269 				sv.HostedZoneId = ptr.String(xtv)
  10270 			}
  10271 
  10272 		case strings.EqualFold("NextToken", t.Name.Local):
  10273 			val, err := decoder.Value()
  10274 			if err != nil {
  10275 				return err
  10276 			}
  10277 			if val == nil {
  10278 				break
  10279 			}
  10280 			{
  10281 				xtv := string(val)
  10282 				sv.NextToken = ptr.String(xtv)
  10283 			}
  10284 
  10285 		case strings.EqualFold("VPCs", t.Name.Local):
  10286 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10287 			if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil {
  10288 				return err
  10289 			}
  10290 
  10291 		default:
  10292 			// Do nothing and ignore the unexpected tag element
  10293 			err = decoder.Decoder.Skip()
  10294 			if err != nil {
  10295 				return err
  10296 			}
  10297 
  10298 		}
  10299 		decoder = originalDecoder
  10300 	}
  10301 	*v = sv
  10302 	return nil
  10303 }
  10304 
  10305 type awsRestxml_deserializeOpTestDNSAnswer struct {
  10306 }
  10307 
  10308 func (*awsRestxml_deserializeOpTestDNSAnswer) ID() string {
  10309 	return "OperationDeserializer"
  10310 }
  10311 
  10312 func (m *awsRestxml_deserializeOpTestDNSAnswer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10313 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10314 ) {
  10315 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10316 	if err != nil {
  10317 		return out, metadata, err
  10318 	}
  10319 
  10320 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10321 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10322 	defer endTimer()
  10323 	defer span.End()
  10324 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10325 	if !ok {
  10326 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10327 	}
  10328 
  10329 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10330 		return out, metadata, awsRestxml_deserializeOpErrorTestDNSAnswer(response, &metadata)
  10331 	}
  10332 	output := &TestDNSAnswerOutput{}
  10333 	out.Result = output
  10334 
  10335 	var buff [1024]byte
  10336 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10337 	body := io.TeeReader(response.Body, ringBuffer)
  10338 	rootDecoder := xml.NewDecoder(body)
  10339 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10340 	if err == io.EOF {
  10341 		return out, metadata, nil
  10342 	}
  10343 	if err != nil {
  10344 		var snapshot bytes.Buffer
  10345 		io.Copy(&snapshot, ringBuffer)
  10346 		return out, metadata, &smithy.DeserializationError{
  10347 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10348 			Snapshot: snapshot.Bytes(),
  10349 		}
  10350 	}
  10351 
  10352 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10353 	err = awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(&output, decoder)
  10354 	if err != nil {
  10355 		var snapshot bytes.Buffer
  10356 		io.Copy(&snapshot, ringBuffer)
  10357 		return out, metadata, &smithy.DeserializationError{
  10358 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10359 			Snapshot: snapshot.Bytes(),
  10360 		}
  10361 	}
  10362 
  10363 	span.End()
  10364 	return out, metadata, err
  10365 }
  10366 
  10367 func awsRestxml_deserializeOpErrorTestDNSAnswer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10368 	var errorBuffer bytes.Buffer
  10369 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10370 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10371 	}
  10372 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10373 
  10374 	errorCode := "UnknownError"
  10375 	errorMessage := errorCode
  10376 
  10377 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10378 	if err != nil {
  10379 		return err
  10380 	}
  10381 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10382 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10383 	}
  10384 	if len(errorComponents.Code) != 0 {
  10385 		errorCode = errorComponents.Code
  10386 	}
  10387 	if len(errorComponents.Message) != 0 {
  10388 		errorMessage = errorComponents.Message
  10389 	}
  10390 	errorBody.Seek(0, io.SeekStart)
  10391 	switch {
  10392 	case strings.EqualFold("InvalidInput", errorCode):
  10393 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10394 
  10395 	case strings.EqualFold("NoSuchHostedZone", errorCode):
  10396 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
  10397 
  10398 	default:
  10399 		genericError := &smithy.GenericAPIError{
  10400 			Code:    errorCode,
  10401 			Message: errorMessage,
  10402 		}
  10403 		return genericError
  10404 
  10405 	}
  10406 }
  10407 
  10408 func awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(v **TestDNSAnswerOutput, decoder smithyxml.NodeDecoder) error {
  10409 	if v == nil {
  10410 		return fmt.Errorf("unexpected nil of type %T", v)
  10411 	}
  10412 	var sv *TestDNSAnswerOutput
  10413 	if *v == nil {
  10414 		sv = &TestDNSAnswerOutput{}
  10415 	} else {
  10416 		sv = *v
  10417 	}
  10418 
  10419 	for {
  10420 		t, done, err := decoder.Token()
  10421 		if err != nil {
  10422 			return err
  10423 		}
  10424 		if done {
  10425 			break
  10426 		}
  10427 		originalDecoder := decoder
  10428 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10429 		switch {
  10430 		case strings.EqualFold("Nameserver", t.Name.Local):
  10431 			val, err := decoder.Value()
  10432 			if err != nil {
  10433 				return err
  10434 			}
  10435 			if val == nil {
  10436 				break
  10437 			}
  10438 			{
  10439 				xtv := string(val)
  10440 				sv.Nameserver = ptr.String(xtv)
  10441 			}
  10442 
  10443 		case strings.EqualFold("Protocol", t.Name.Local):
  10444 			val, err := decoder.Value()
  10445 			if err != nil {
  10446 				return err
  10447 			}
  10448 			if val == nil {
  10449 				break
  10450 			}
  10451 			{
  10452 				xtv := string(val)
  10453 				sv.Protocol = ptr.String(xtv)
  10454 			}
  10455 
  10456 		case strings.EqualFold("RecordData", t.Name.Local):
  10457 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10458 			if err := awsRestxml_deserializeDocumentRecordData(&sv.RecordData, nodeDecoder); err != nil {
  10459 				return err
  10460 			}
  10461 
  10462 		case strings.EqualFold("RecordName", t.Name.Local):
  10463 			val, err := decoder.Value()
  10464 			if err != nil {
  10465 				return err
  10466 			}
  10467 			if val == nil {
  10468 				break
  10469 			}
  10470 			{
  10471 				xtv := string(val)
  10472 				sv.RecordName = ptr.String(xtv)
  10473 			}
  10474 
  10475 		case strings.EqualFold("RecordType", t.Name.Local):
  10476 			val, err := decoder.Value()
  10477 			if err != nil {
  10478 				return err
  10479 			}
  10480 			if val == nil {
  10481 				break
  10482 			}
  10483 			{
  10484 				xtv := string(val)
  10485 				sv.RecordType = types.RRType(xtv)
  10486 			}
  10487 
  10488 		case strings.EqualFold("ResponseCode", t.Name.Local):
  10489 			val, err := decoder.Value()
  10490 			if err != nil {
  10491 				return err
  10492 			}
  10493 			if val == nil {
  10494 				break
  10495 			}
  10496 			{
  10497 				xtv := string(val)
  10498 				sv.ResponseCode = ptr.String(xtv)
  10499 			}
  10500 
  10501 		default:
  10502 			// Do nothing and ignore the unexpected tag element
  10503 			err = decoder.Decoder.Skip()
  10504 			if err != nil {
  10505 				return err
  10506 			}
  10507 
  10508 		}
  10509 		decoder = originalDecoder
  10510 	}
  10511 	*v = sv
  10512 	return nil
  10513 }
  10514 
  10515 type awsRestxml_deserializeOpUpdateHealthCheck struct {
  10516 }
  10517 
  10518 func (*awsRestxml_deserializeOpUpdateHealthCheck) ID() string {
  10519 	return "OperationDeserializer"
  10520 }
  10521 
  10522 func (m *awsRestxml_deserializeOpUpdateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10523 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10524 ) {
  10525 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10526 	if err != nil {
  10527 		return out, metadata, err
  10528 	}
  10529 
  10530 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10531 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10532 	defer endTimer()
  10533 	defer span.End()
  10534 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10535 	if !ok {
  10536 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10537 	}
  10538 
  10539 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10540 		return out, metadata, awsRestxml_deserializeOpErrorUpdateHealthCheck(response, &metadata)
  10541 	}
  10542 	output := &UpdateHealthCheckOutput{}
  10543 	out.Result = output
  10544 
  10545 	var buff [1024]byte
  10546 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10547 	body := io.TeeReader(response.Body, ringBuffer)
  10548 	rootDecoder := xml.NewDecoder(body)
  10549 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10550 	if err == io.EOF {
  10551 		return out, metadata, nil
  10552 	}
  10553 	if err != nil {
  10554 		var snapshot bytes.Buffer
  10555 		io.Copy(&snapshot, ringBuffer)
  10556 		return out, metadata, &smithy.DeserializationError{
  10557 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10558 			Snapshot: snapshot.Bytes(),
  10559 		}
  10560 	}
  10561 
  10562 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10563 	err = awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(&output, decoder)
  10564 	if err != nil {
  10565 		var snapshot bytes.Buffer
  10566 		io.Copy(&snapshot, ringBuffer)
  10567 		return out, metadata, &smithy.DeserializationError{
  10568 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10569 			Snapshot: snapshot.Bytes(),
  10570 		}
  10571 	}
  10572 
  10573 	span.End()
  10574 	return out, metadata, err
  10575 }
  10576 
  10577 func awsRestxml_deserializeOpErrorUpdateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10578 	var errorBuffer bytes.Buffer
  10579 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10580 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10581 	}
  10582 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10583 
  10584 	errorCode := "UnknownError"
  10585 	errorMessage := errorCode
  10586 
  10587 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10588 	if err != nil {
  10589 		return err
  10590 	}
  10591 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10592 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10593 	}
  10594 	if len(errorComponents.Code) != 0 {
  10595 		errorCode = errorComponents.Code
  10596 	}
  10597 	if len(errorComponents.Message) != 0 {
  10598 		errorMessage = errorComponents.Message
  10599 	}
  10600 	errorBody.Seek(0, io.SeekStart)
  10601 	switch {
  10602 	case strings.EqualFold("HealthCheckVersionMismatch", errorCode):
  10603 		return awsRestxml_deserializeErrorHealthCheckVersionMismatch(response, errorBody)
  10604 
  10605 	case strings.EqualFold("InvalidInput", errorCode):
  10606 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10607 
  10608 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
  10609 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
  10610 
  10611 	default:
  10612 		genericError := &smithy.GenericAPIError{
  10613 			Code:    errorCode,
  10614 			Message: errorMessage,
  10615 		}
  10616 		return genericError
  10617 
  10618 	}
  10619 }
  10620 
  10621 func awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(v **UpdateHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
  10622 	if v == nil {
  10623 		return fmt.Errorf("unexpected nil of type %T", v)
  10624 	}
  10625 	var sv *UpdateHealthCheckOutput
  10626 	if *v == nil {
  10627 		sv = &UpdateHealthCheckOutput{}
  10628 	} else {
  10629 		sv = *v
  10630 	}
  10631 
  10632 	for {
  10633 		t, done, err := decoder.Token()
  10634 		if err != nil {
  10635 			return err
  10636 		}
  10637 		if done {
  10638 			break
  10639 		}
  10640 		originalDecoder := decoder
  10641 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10642 		switch {
  10643 		case strings.EqualFold("HealthCheck", t.Name.Local):
  10644 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10645 			if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
  10646 				return err
  10647 			}
  10648 
  10649 		default:
  10650 			// Do nothing and ignore the unexpected tag element
  10651 			err = decoder.Decoder.Skip()
  10652 			if err != nil {
  10653 				return err
  10654 			}
  10655 
  10656 		}
  10657 		decoder = originalDecoder
  10658 	}
  10659 	*v = sv
  10660 	return nil
  10661 }
  10662 
  10663 type awsRestxml_deserializeOpUpdateHostedZoneComment struct {
  10664 }
  10665 
  10666 func (*awsRestxml_deserializeOpUpdateHostedZoneComment) ID() string {
  10667 	return "OperationDeserializer"
  10668 }
  10669 
  10670 func (m *awsRestxml_deserializeOpUpdateHostedZoneComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10671 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10672 ) {
  10673 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10674 	if err != nil {
  10675 		return out, metadata, err
  10676 	}
  10677 
  10678 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10679 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10680 	defer endTimer()
  10681 	defer span.End()
  10682 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10683 	if !ok {
  10684 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10685 	}
  10686 
  10687 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10688 		return out, metadata, awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response, &metadata)
  10689 	}
  10690 	output := &UpdateHostedZoneCommentOutput{}
  10691 	out.Result = output
  10692 
  10693 	var buff [1024]byte
  10694 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10695 	body := io.TeeReader(response.Body, ringBuffer)
  10696 	rootDecoder := xml.NewDecoder(body)
  10697 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10698 	if err == io.EOF {
  10699 		return out, metadata, nil
  10700 	}
  10701 	if err != nil {
  10702 		var snapshot bytes.Buffer
  10703 		io.Copy(&snapshot, ringBuffer)
  10704 		return out, metadata, &smithy.DeserializationError{
  10705 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10706 			Snapshot: snapshot.Bytes(),
  10707 		}
  10708 	}
  10709 
  10710 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10711 	err = awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(&output, decoder)
  10712 	if err != nil {
  10713 		var snapshot bytes.Buffer
  10714 		io.Copy(&snapshot, ringBuffer)
  10715 		return out, metadata, &smithy.DeserializationError{
  10716 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10717 			Snapshot: snapshot.Bytes(),
  10718 		}
  10719 	}
  10720 
  10721 	span.End()
  10722 	return out, metadata, err
  10723 }
  10724 
  10725 func awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10726 	var errorBuffer bytes.Buffer
  10727 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10728 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10729 	}
  10730 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10731 
  10732 	errorCode := "UnknownError"
  10733 	errorMessage := errorCode
  10734 
  10735 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10736 	if err != nil {
  10737 		return err
  10738 	}
  10739 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10740 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10741 	}
  10742 	if len(errorComponents.Code) != 0 {
  10743 		errorCode = errorComponents.Code
  10744 	}
  10745 	if len(errorComponents.Message) != 0 {
  10746 		errorMessage = errorComponents.Message
  10747 	}
  10748 	errorBody.Seek(0, io.SeekStart)
  10749 	switch {
  10750 	case strings.EqualFold("InvalidInput", errorCode):
  10751 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10752 
  10753 	case strings.EqualFold("NoSuchHostedZone", errorCode):
  10754 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
  10755 
  10756 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
  10757 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
  10758 
  10759 	default:
  10760 		genericError := &smithy.GenericAPIError{
  10761 			Code:    errorCode,
  10762 			Message: errorMessage,
  10763 		}
  10764 		return genericError
  10765 
  10766 	}
  10767 }
  10768 
  10769 func awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(v **UpdateHostedZoneCommentOutput, decoder smithyxml.NodeDecoder) error {
  10770 	if v == nil {
  10771 		return fmt.Errorf("unexpected nil of type %T", v)
  10772 	}
  10773 	var sv *UpdateHostedZoneCommentOutput
  10774 	if *v == nil {
  10775 		sv = &UpdateHostedZoneCommentOutput{}
  10776 	} else {
  10777 		sv = *v
  10778 	}
  10779 
  10780 	for {
  10781 		t, done, err := decoder.Token()
  10782 		if err != nil {
  10783 			return err
  10784 		}
  10785 		if done {
  10786 			break
  10787 		}
  10788 		originalDecoder := decoder
  10789 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10790 		switch {
  10791 		case strings.EqualFold("HostedZone", t.Name.Local):
  10792 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10793 			if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
  10794 				return err
  10795 			}
  10796 
  10797 		default:
  10798 			// Do nothing and ignore the unexpected tag element
  10799 			err = decoder.Decoder.Skip()
  10800 			if err != nil {
  10801 				return err
  10802 			}
  10803 
  10804 		}
  10805 		decoder = originalDecoder
  10806 	}
  10807 	*v = sv
  10808 	return nil
  10809 }
  10810 
  10811 type awsRestxml_deserializeOpUpdateTrafficPolicyComment struct {
  10812 }
  10813 
  10814 func (*awsRestxml_deserializeOpUpdateTrafficPolicyComment) ID() string {
  10815 	return "OperationDeserializer"
  10816 }
  10817 
  10818 func (m *awsRestxml_deserializeOpUpdateTrafficPolicyComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10819 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10820 ) {
  10821 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10822 	if err != nil {
  10823 		return out, metadata, err
  10824 	}
  10825 
  10826 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10827 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10828 	defer endTimer()
  10829 	defer span.End()
  10830 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10831 	if !ok {
  10832 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10833 	}
  10834 
  10835 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10836 		return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response, &metadata)
  10837 	}
  10838 	output := &UpdateTrafficPolicyCommentOutput{}
  10839 	out.Result = output
  10840 
  10841 	var buff [1024]byte
  10842 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10843 	body := io.TeeReader(response.Body, ringBuffer)
  10844 	rootDecoder := xml.NewDecoder(body)
  10845 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10846 	if err == io.EOF {
  10847 		return out, metadata, nil
  10848 	}
  10849 	if err != nil {
  10850 		var snapshot bytes.Buffer
  10851 		io.Copy(&snapshot, ringBuffer)
  10852 		return out, metadata, &smithy.DeserializationError{
  10853 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10854 			Snapshot: snapshot.Bytes(),
  10855 		}
  10856 	}
  10857 
  10858 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10859 	err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(&output, decoder)
  10860 	if err != nil {
  10861 		var snapshot bytes.Buffer
  10862 		io.Copy(&snapshot, ringBuffer)
  10863 		return out, metadata, &smithy.DeserializationError{
  10864 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10865 			Snapshot: snapshot.Bytes(),
  10866 		}
  10867 	}
  10868 
  10869 	span.End()
  10870 	return out, metadata, err
  10871 }
  10872 
  10873 func awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10874 	var errorBuffer bytes.Buffer
  10875 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10876 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10877 	}
  10878 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10879 
  10880 	errorCode := "UnknownError"
  10881 	errorMessage := errorCode
  10882 
  10883 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10884 	if err != nil {
  10885 		return err
  10886 	}
  10887 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10888 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10889 	}
  10890 	if len(errorComponents.Code) != 0 {
  10891 		errorCode = errorComponents.Code
  10892 	}
  10893 	if len(errorComponents.Message) != 0 {
  10894 		errorMessage = errorComponents.Message
  10895 	}
  10896 	errorBody.Seek(0, io.SeekStart)
  10897 	switch {
  10898 	case strings.EqualFold("ConcurrentModification", errorCode):
  10899 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
  10900 
  10901 	case strings.EqualFold("InvalidInput", errorCode):
  10902 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10903 
  10904 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
  10905 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
  10906 
  10907 	default:
  10908 		genericError := &smithy.GenericAPIError{
  10909 			Code:    errorCode,
  10910 			Message: errorMessage,
  10911 		}
  10912 		return genericError
  10913 
  10914 	}
  10915 }
  10916 
  10917 func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(v **UpdateTrafficPolicyCommentOutput, decoder smithyxml.NodeDecoder) error {
  10918 	if v == nil {
  10919 		return fmt.Errorf("unexpected nil of type %T", v)
  10920 	}
  10921 	var sv *UpdateTrafficPolicyCommentOutput
  10922 	if *v == nil {
  10923 		sv = &UpdateTrafficPolicyCommentOutput{}
  10924 	} else {
  10925 		sv = *v
  10926 	}
  10927 
  10928 	for {
  10929 		t, done, err := decoder.Token()
  10930 		if err != nil {
  10931 			return err
  10932 		}
  10933 		if done {
  10934 			break
  10935 		}
  10936 		originalDecoder := decoder
  10937 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10938 		switch {
  10939 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
  10940 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10941 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
  10942 				return err
  10943 			}
  10944 
  10945 		default:
  10946 			// Do nothing and ignore the unexpected tag element
  10947 			err = decoder.Decoder.Skip()
  10948 			if err != nil {
  10949 				return err
  10950 			}
  10951 
  10952 		}
  10953 		decoder = originalDecoder
  10954 	}
  10955 	*v = sv
  10956 	return nil
  10957 }
  10958 
  10959 type awsRestxml_deserializeOpUpdateTrafficPolicyInstance struct {
  10960 }
  10961 
  10962 func (*awsRestxml_deserializeOpUpdateTrafficPolicyInstance) ID() string {
  10963 	return "OperationDeserializer"
  10964 }
  10965 
  10966 func (m *awsRestxml_deserializeOpUpdateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10967 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10968 ) {
  10969 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10970 	if err != nil {
  10971 		return out, metadata, err
  10972 	}
  10973 
  10974 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
  10975 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
  10976 	defer endTimer()
  10977 	defer span.End()
  10978 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10979 	if !ok {
  10980 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10981 	}
  10982 
  10983 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10984 		return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response, &metadata)
  10985 	}
  10986 	output := &UpdateTrafficPolicyInstanceOutput{}
  10987 	out.Result = output
  10988 
  10989 	var buff [1024]byte
  10990 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10991 	body := io.TeeReader(response.Body, ringBuffer)
  10992 	rootDecoder := xml.NewDecoder(body)
  10993 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10994 	if err == io.EOF {
  10995 		return out, metadata, nil
  10996 	}
  10997 	if err != nil {
  10998 		var snapshot bytes.Buffer
  10999 		io.Copy(&snapshot, ringBuffer)
  11000 		return out, metadata, &smithy.DeserializationError{
  11001 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11002 			Snapshot: snapshot.Bytes(),
  11003 		}
  11004 	}
  11005 
  11006 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11007 	err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(&output, decoder)
  11008 	if err != nil {
  11009 		var snapshot bytes.Buffer
  11010 		io.Copy(&snapshot, ringBuffer)
  11011 		return out, metadata, &smithy.DeserializationError{
  11012 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11013 			Snapshot: snapshot.Bytes(),
  11014 		}
  11015 	}
  11016 
  11017 	span.End()
  11018 	return out, metadata, err
  11019 }
  11020 
  11021 func awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  11022 	var errorBuffer bytes.Buffer
  11023 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  11024 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  11025 	}
  11026 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  11027 
  11028 	errorCode := "UnknownError"
  11029 	errorMessage := errorCode
  11030 
  11031 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  11032 	if err != nil {
  11033 		return err
  11034 	}
  11035 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  11036 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  11037 	}
  11038 	if len(errorComponents.Code) != 0 {
  11039 		errorCode = errorComponents.Code
  11040 	}
  11041 	if len(errorComponents.Message) != 0 {
  11042 		errorMessage = errorComponents.Message
  11043 	}
  11044 	errorBody.Seek(0, io.SeekStart)
  11045 	switch {
  11046 	case strings.EqualFold("ConflictingTypes", errorCode):
  11047 		return awsRestxml_deserializeErrorConflictingTypes(response, errorBody)
  11048 
  11049 	case strings.EqualFold("InvalidInput", errorCode):
  11050 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  11051 
  11052 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
  11053 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
  11054 
  11055 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
  11056 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
  11057 
  11058 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
  11059 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
  11060 
  11061 	default:
  11062 		genericError := &smithy.GenericAPIError{
  11063 			Code:    errorCode,
  11064 			Message: errorMessage,
  11065 		}
  11066 		return genericError
  11067 
  11068 	}
  11069 }
  11070 
  11071 func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(v **UpdateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
  11072 	if v == nil {
  11073 		return fmt.Errorf("unexpected nil of type %T", v)
  11074 	}
  11075 	var sv *UpdateTrafficPolicyInstanceOutput
  11076 	if *v == nil {
  11077 		sv = &UpdateTrafficPolicyInstanceOutput{}
  11078 	} else {
  11079 		sv = *v
  11080 	}
  11081 
  11082 	for {
  11083 		t, done, err := decoder.Token()
  11084 		if err != nil {
  11085 			return err
  11086 		}
  11087 		if done {
  11088 			break
  11089 		}
  11090 		originalDecoder := decoder
  11091 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  11092 		switch {
  11093 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
  11094 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11095 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
  11096 				return err
  11097 			}
  11098 
  11099 		default:
  11100 			// Do nothing and ignore the unexpected tag element
  11101 			err = decoder.Decoder.Skip()
  11102 			if err != nil {
  11103 				return err
  11104 			}
  11105 
  11106 		}
  11107 		decoder = originalDecoder
  11108 	}
  11109 	*v = sv
  11110 	return nil
  11111 }
  11112 
  11113 func awsRestxml_deserializeErrorCidrBlockInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11114 	output := &types.CidrBlockInUseException{}
  11115 	var buff [1024]byte
  11116 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11117 	body := io.TeeReader(errorBody, ringBuffer)
  11118 	rootDecoder := xml.NewDecoder(body)
  11119 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11120 	if err == io.EOF {
  11121 		return output
  11122 	}
  11123 	if err != nil {
  11124 		var snapshot bytes.Buffer
  11125 		io.Copy(&snapshot, ringBuffer)
  11126 		return &smithy.DeserializationError{
  11127 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11128 			Snapshot: snapshot.Bytes(),
  11129 		}
  11130 	}
  11131 
  11132 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11133 	t, err = decoder.GetElement("Error")
  11134 	if err != nil {
  11135 		var snapshot bytes.Buffer
  11136 		io.Copy(&snapshot, ringBuffer)
  11137 		return &smithy.DeserializationError{
  11138 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11139 			Snapshot: snapshot.Bytes(),
  11140 		}
  11141 	}
  11142 
  11143 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11144 	err = awsRestxml_deserializeDocumentCidrBlockInUseException(&output, decoder)
  11145 	if err != nil {
  11146 		var snapshot bytes.Buffer
  11147 		io.Copy(&snapshot, ringBuffer)
  11148 		return &smithy.DeserializationError{
  11149 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11150 			Snapshot: snapshot.Bytes(),
  11151 		}
  11152 	}
  11153 
  11154 	return output
  11155 }
  11156 
  11157 func awsRestxml_deserializeErrorCidrCollectionAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11158 	output := &types.CidrCollectionAlreadyExistsException{}
  11159 	var buff [1024]byte
  11160 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11161 	body := io.TeeReader(errorBody, ringBuffer)
  11162 	rootDecoder := xml.NewDecoder(body)
  11163 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11164 	if err == io.EOF {
  11165 		return output
  11166 	}
  11167 	if err != nil {
  11168 		var snapshot bytes.Buffer
  11169 		io.Copy(&snapshot, ringBuffer)
  11170 		return &smithy.DeserializationError{
  11171 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11172 			Snapshot: snapshot.Bytes(),
  11173 		}
  11174 	}
  11175 
  11176 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11177 	t, err = decoder.GetElement("Error")
  11178 	if err != nil {
  11179 		var snapshot bytes.Buffer
  11180 		io.Copy(&snapshot, ringBuffer)
  11181 		return &smithy.DeserializationError{
  11182 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11183 			Snapshot: snapshot.Bytes(),
  11184 		}
  11185 	}
  11186 
  11187 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11188 	err = awsRestxml_deserializeDocumentCidrCollectionAlreadyExistsException(&output, decoder)
  11189 	if err != nil {
  11190 		var snapshot bytes.Buffer
  11191 		io.Copy(&snapshot, ringBuffer)
  11192 		return &smithy.DeserializationError{
  11193 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11194 			Snapshot: snapshot.Bytes(),
  11195 		}
  11196 	}
  11197 
  11198 	return output
  11199 }
  11200 
  11201 func awsRestxml_deserializeErrorCidrCollectionInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11202 	output := &types.CidrCollectionInUseException{}
  11203 	var buff [1024]byte
  11204 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11205 	body := io.TeeReader(errorBody, ringBuffer)
  11206 	rootDecoder := xml.NewDecoder(body)
  11207 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11208 	if err == io.EOF {
  11209 		return output
  11210 	}
  11211 	if err != nil {
  11212 		var snapshot bytes.Buffer
  11213 		io.Copy(&snapshot, ringBuffer)
  11214 		return &smithy.DeserializationError{
  11215 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11216 			Snapshot: snapshot.Bytes(),
  11217 		}
  11218 	}
  11219 
  11220 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11221 	t, err = decoder.GetElement("Error")
  11222 	if err != nil {
  11223 		var snapshot bytes.Buffer
  11224 		io.Copy(&snapshot, ringBuffer)
  11225 		return &smithy.DeserializationError{
  11226 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11227 			Snapshot: snapshot.Bytes(),
  11228 		}
  11229 	}
  11230 
  11231 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11232 	err = awsRestxml_deserializeDocumentCidrCollectionInUseException(&output, decoder)
  11233 	if err != nil {
  11234 		var snapshot bytes.Buffer
  11235 		io.Copy(&snapshot, ringBuffer)
  11236 		return &smithy.DeserializationError{
  11237 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11238 			Snapshot: snapshot.Bytes(),
  11239 		}
  11240 	}
  11241 
  11242 	return output
  11243 }
  11244 
  11245 func awsRestxml_deserializeErrorCidrCollectionVersionMismatchException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11246 	output := &types.CidrCollectionVersionMismatchException{}
  11247 	var buff [1024]byte
  11248 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11249 	body := io.TeeReader(errorBody, ringBuffer)
  11250 	rootDecoder := xml.NewDecoder(body)
  11251 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11252 	if err == io.EOF {
  11253 		return output
  11254 	}
  11255 	if err != nil {
  11256 		var snapshot bytes.Buffer
  11257 		io.Copy(&snapshot, ringBuffer)
  11258 		return &smithy.DeserializationError{
  11259 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11260 			Snapshot: snapshot.Bytes(),
  11261 		}
  11262 	}
  11263 
  11264 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11265 	t, err = decoder.GetElement("Error")
  11266 	if err != nil {
  11267 		var snapshot bytes.Buffer
  11268 		io.Copy(&snapshot, ringBuffer)
  11269 		return &smithy.DeserializationError{
  11270 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11271 			Snapshot: snapshot.Bytes(),
  11272 		}
  11273 	}
  11274 
  11275 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11276 	err = awsRestxml_deserializeDocumentCidrCollectionVersionMismatchException(&output, decoder)
  11277 	if err != nil {
  11278 		var snapshot bytes.Buffer
  11279 		io.Copy(&snapshot, ringBuffer)
  11280 		return &smithy.DeserializationError{
  11281 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11282 			Snapshot: snapshot.Bytes(),
  11283 		}
  11284 	}
  11285 
  11286 	return output
  11287 }
  11288 
  11289 func awsRestxml_deserializeErrorConcurrentModification(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11290 	output := &types.ConcurrentModification{}
  11291 	var buff [1024]byte
  11292 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11293 	body := io.TeeReader(errorBody, ringBuffer)
  11294 	rootDecoder := xml.NewDecoder(body)
  11295 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11296 	if err == io.EOF {
  11297 		return output
  11298 	}
  11299 	if err != nil {
  11300 		var snapshot bytes.Buffer
  11301 		io.Copy(&snapshot, ringBuffer)
  11302 		return &smithy.DeserializationError{
  11303 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11304 			Snapshot: snapshot.Bytes(),
  11305 		}
  11306 	}
  11307 
  11308 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11309 	t, err = decoder.GetElement("Error")
  11310 	if err != nil {
  11311 		var snapshot bytes.Buffer
  11312 		io.Copy(&snapshot, ringBuffer)
  11313 		return &smithy.DeserializationError{
  11314 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11315 			Snapshot: snapshot.Bytes(),
  11316 		}
  11317 	}
  11318 
  11319 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11320 	err = awsRestxml_deserializeDocumentConcurrentModification(&output, decoder)
  11321 	if err != nil {
  11322 		var snapshot bytes.Buffer
  11323 		io.Copy(&snapshot, ringBuffer)
  11324 		return &smithy.DeserializationError{
  11325 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11326 			Snapshot: snapshot.Bytes(),
  11327 		}
  11328 	}
  11329 
  11330 	return output
  11331 }
  11332 
  11333 func awsRestxml_deserializeErrorConflictingDomainExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11334 	output := &types.ConflictingDomainExists{}
  11335 	var buff [1024]byte
  11336 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11337 	body := io.TeeReader(errorBody, ringBuffer)
  11338 	rootDecoder := xml.NewDecoder(body)
  11339 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11340 	if err == io.EOF {
  11341 		return output
  11342 	}
  11343 	if err != nil {
  11344 		var snapshot bytes.Buffer
  11345 		io.Copy(&snapshot, ringBuffer)
  11346 		return &smithy.DeserializationError{
  11347 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11348 			Snapshot: snapshot.Bytes(),
  11349 		}
  11350 	}
  11351 
  11352 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11353 	t, err = decoder.GetElement("Error")
  11354 	if err != nil {
  11355 		var snapshot bytes.Buffer
  11356 		io.Copy(&snapshot, ringBuffer)
  11357 		return &smithy.DeserializationError{
  11358 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11359 			Snapshot: snapshot.Bytes(),
  11360 		}
  11361 	}
  11362 
  11363 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11364 	err = awsRestxml_deserializeDocumentConflictingDomainExists(&output, decoder)
  11365 	if err != nil {
  11366 		var snapshot bytes.Buffer
  11367 		io.Copy(&snapshot, ringBuffer)
  11368 		return &smithy.DeserializationError{
  11369 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11370 			Snapshot: snapshot.Bytes(),
  11371 		}
  11372 	}
  11373 
  11374 	return output
  11375 }
  11376 
  11377 func awsRestxml_deserializeErrorConflictingTypes(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11378 	output := &types.ConflictingTypes{}
  11379 	var buff [1024]byte
  11380 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11381 	body := io.TeeReader(errorBody, ringBuffer)
  11382 	rootDecoder := xml.NewDecoder(body)
  11383 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11384 	if err == io.EOF {
  11385 		return output
  11386 	}
  11387 	if err != nil {
  11388 		var snapshot bytes.Buffer
  11389 		io.Copy(&snapshot, ringBuffer)
  11390 		return &smithy.DeserializationError{
  11391 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11392 			Snapshot: snapshot.Bytes(),
  11393 		}
  11394 	}
  11395 
  11396 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11397 	t, err = decoder.GetElement("Error")
  11398 	if err != nil {
  11399 		var snapshot bytes.Buffer
  11400 		io.Copy(&snapshot, ringBuffer)
  11401 		return &smithy.DeserializationError{
  11402 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11403 			Snapshot: snapshot.Bytes(),
  11404 		}
  11405 	}
  11406 
  11407 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11408 	err = awsRestxml_deserializeDocumentConflictingTypes(&output, decoder)
  11409 	if err != nil {
  11410 		var snapshot bytes.Buffer
  11411 		io.Copy(&snapshot, ringBuffer)
  11412 		return &smithy.DeserializationError{
  11413 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11414 			Snapshot: snapshot.Bytes(),
  11415 		}
  11416 	}
  11417 
  11418 	return output
  11419 }
  11420 
  11421 func awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11422 	output := &types.DelegationSetAlreadyCreated{}
  11423 	var buff [1024]byte
  11424 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11425 	body := io.TeeReader(errorBody, ringBuffer)
  11426 	rootDecoder := xml.NewDecoder(body)
  11427 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11428 	if err == io.EOF {
  11429 		return output
  11430 	}
  11431 	if err != nil {
  11432 		var snapshot bytes.Buffer
  11433 		io.Copy(&snapshot, ringBuffer)
  11434 		return &smithy.DeserializationError{
  11435 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11436 			Snapshot: snapshot.Bytes(),
  11437 		}
  11438 	}
  11439 
  11440 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11441 	t, err = decoder.GetElement("Error")
  11442 	if err != nil {
  11443 		var snapshot bytes.Buffer
  11444 		io.Copy(&snapshot, ringBuffer)
  11445 		return &smithy.DeserializationError{
  11446 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11447 			Snapshot: snapshot.Bytes(),
  11448 		}
  11449 	}
  11450 
  11451 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11452 	err = awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(&output, decoder)
  11453 	if err != nil {
  11454 		var snapshot bytes.Buffer
  11455 		io.Copy(&snapshot, ringBuffer)
  11456 		return &smithy.DeserializationError{
  11457 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11458 			Snapshot: snapshot.Bytes(),
  11459 		}
  11460 	}
  11461 
  11462 	return output
  11463 }
  11464 
  11465 func awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11466 	output := &types.DelegationSetAlreadyReusable{}
  11467 	var buff [1024]byte
  11468 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11469 	body := io.TeeReader(errorBody, ringBuffer)
  11470 	rootDecoder := xml.NewDecoder(body)
  11471 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11472 	if err == io.EOF {
  11473 		return output
  11474 	}
  11475 	if err != nil {
  11476 		var snapshot bytes.Buffer
  11477 		io.Copy(&snapshot, ringBuffer)
  11478 		return &smithy.DeserializationError{
  11479 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11480 			Snapshot: snapshot.Bytes(),
  11481 		}
  11482 	}
  11483 
  11484 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11485 	t, err = decoder.GetElement("Error")
  11486 	if err != nil {
  11487 		var snapshot bytes.Buffer
  11488 		io.Copy(&snapshot, ringBuffer)
  11489 		return &smithy.DeserializationError{
  11490 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11491 			Snapshot: snapshot.Bytes(),
  11492 		}
  11493 	}
  11494 
  11495 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11496 	err = awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(&output, decoder)
  11497 	if err != nil {
  11498 		var snapshot bytes.Buffer
  11499 		io.Copy(&snapshot, ringBuffer)
  11500 		return &smithy.DeserializationError{
  11501 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11502 			Snapshot: snapshot.Bytes(),
  11503 		}
  11504 	}
  11505 
  11506 	return output
  11507 }
  11508 
  11509 func awsRestxml_deserializeErrorDelegationSetInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11510 	output := &types.DelegationSetInUse{}
  11511 	var buff [1024]byte
  11512 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11513 	body := io.TeeReader(errorBody, ringBuffer)
  11514 	rootDecoder := xml.NewDecoder(body)
  11515 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11516 	if err == io.EOF {
  11517 		return output
  11518 	}
  11519 	if err != nil {
  11520 		var snapshot bytes.Buffer
  11521 		io.Copy(&snapshot, ringBuffer)
  11522 		return &smithy.DeserializationError{
  11523 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11524 			Snapshot: snapshot.Bytes(),
  11525 		}
  11526 	}
  11527 
  11528 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11529 	t, err = decoder.GetElement("Error")
  11530 	if err != nil {
  11531 		var snapshot bytes.Buffer
  11532 		io.Copy(&snapshot, ringBuffer)
  11533 		return &smithy.DeserializationError{
  11534 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11535 			Snapshot: snapshot.Bytes(),
  11536 		}
  11537 	}
  11538 
  11539 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11540 	err = awsRestxml_deserializeDocumentDelegationSetInUse(&output, decoder)
  11541 	if err != nil {
  11542 		var snapshot bytes.Buffer
  11543 		io.Copy(&snapshot, ringBuffer)
  11544 		return &smithy.DeserializationError{
  11545 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11546 			Snapshot: snapshot.Bytes(),
  11547 		}
  11548 	}
  11549 
  11550 	return output
  11551 }
  11552 
  11553 func awsRestxml_deserializeErrorDelegationSetNotAvailable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11554 	output := &types.DelegationSetNotAvailable{}
  11555 	var buff [1024]byte
  11556 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11557 	body := io.TeeReader(errorBody, ringBuffer)
  11558 	rootDecoder := xml.NewDecoder(body)
  11559 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11560 	if err == io.EOF {
  11561 		return output
  11562 	}
  11563 	if err != nil {
  11564 		var snapshot bytes.Buffer
  11565 		io.Copy(&snapshot, ringBuffer)
  11566 		return &smithy.DeserializationError{
  11567 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11568 			Snapshot: snapshot.Bytes(),
  11569 		}
  11570 	}
  11571 
  11572 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11573 	t, err = decoder.GetElement("Error")
  11574 	if err != nil {
  11575 		var snapshot bytes.Buffer
  11576 		io.Copy(&snapshot, ringBuffer)
  11577 		return &smithy.DeserializationError{
  11578 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11579 			Snapshot: snapshot.Bytes(),
  11580 		}
  11581 	}
  11582 
  11583 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11584 	err = awsRestxml_deserializeDocumentDelegationSetNotAvailable(&output, decoder)
  11585 	if err != nil {
  11586 		var snapshot bytes.Buffer
  11587 		io.Copy(&snapshot, ringBuffer)
  11588 		return &smithy.DeserializationError{
  11589 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11590 			Snapshot: snapshot.Bytes(),
  11591 		}
  11592 	}
  11593 
  11594 	return output
  11595 }
  11596 
  11597 func awsRestxml_deserializeErrorDelegationSetNotReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11598 	output := &types.DelegationSetNotReusable{}
  11599 	var buff [1024]byte
  11600 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11601 	body := io.TeeReader(errorBody, ringBuffer)
  11602 	rootDecoder := xml.NewDecoder(body)
  11603 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11604 	if err == io.EOF {
  11605 		return output
  11606 	}
  11607 	if err != nil {
  11608 		var snapshot bytes.Buffer
  11609 		io.Copy(&snapshot, ringBuffer)
  11610 		return &smithy.DeserializationError{
  11611 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11612 			Snapshot: snapshot.Bytes(),
  11613 		}
  11614 	}
  11615 
  11616 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11617 	t, err = decoder.GetElement("Error")
  11618 	if err != nil {
  11619 		var snapshot bytes.Buffer
  11620 		io.Copy(&snapshot, ringBuffer)
  11621 		return &smithy.DeserializationError{
  11622 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11623 			Snapshot: snapshot.Bytes(),
  11624 		}
  11625 	}
  11626 
  11627 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11628 	err = awsRestxml_deserializeDocumentDelegationSetNotReusable(&output, decoder)
  11629 	if err != nil {
  11630 		var snapshot bytes.Buffer
  11631 		io.Copy(&snapshot, ringBuffer)
  11632 		return &smithy.DeserializationError{
  11633 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11634 			Snapshot: snapshot.Bytes(),
  11635 		}
  11636 	}
  11637 
  11638 	return output
  11639 }
  11640 
  11641 func awsRestxml_deserializeErrorDNSSECNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11642 	output := &types.DNSSECNotFound{}
  11643 	var buff [1024]byte
  11644 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11645 	body := io.TeeReader(errorBody, ringBuffer)
  11646 	rootDecoder := xml.NewDecoder(body)
  11647 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11648 	if err == io.EOF {
  11649 		return output
  11650 	}
  11651 	if err != nil {
  11652 		var snapshot bytes.Buffer
  11653 		io.Copy(&snapshot, ringBuffer)
  11654 		return &smithy.DeserializationError{
  11655 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11656 			Snapshot: snapshot.Bytes(),
  11657 		}
  11658 	}
  11659 
  11660 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11661 	t, err = decoder.GetElement("Error")
  11662 	if err != nil {
  11663 		var snapshot bytes.Buffer
  11664 		io.Copy(&snapshot, ringBuffer)
  11665 		return &smithy.DeserializationError{
  11666 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11667 			Snapshot: snapshot.Bytes(),
  11668 		}
  11669 	}
  11670 
  11671 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11672 	err = awsRestxml_deserializeDocumentDNSSECNotFound(&output, decoder)
  11673 	if err != nil {
  11674 		var snapshot bytes.Buffer
  11675 		io.Copy(&snapshot, ringBuffer)
  11676 		return &smithy.DeserializationError{
  11677 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11678 			Snapshot: snapshot.Bytes(),
  11679 		}
  11680 	}
  11681 
  11682 	return output
  11683 }
  11684 
  11685 func awsRestxml_deserializeErrorHealthCheckAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11686 	output := &types.HealthCheckAlreadyExists{}
  11687 	var buff [1024]byte
  11688 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11689 	body := io.TeeReader(errorBody, ringBuffer)
  11690 	rootDecoder := xml.NewDecoder(body)
  11691 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11692 	if err == io.EOF {
  11693 		return output
  11694 	}
  11695 	if err != nil {
  11696 		var snapshot bytes.Buffer
  11697 		io.Copy(&snapshot, ringBuffer)
  11698 		return &smithy.DeserializationError{
  11699 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11700 			Snapshot: snapshot.Bytes(),
  11701 		}
  11702 	}
  11703 
  11704 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11705 	t, err = decoder.GetElement("Error")
  11706 	if err != nil {
  11707 		var snapshot bytes.Buffer
  11708 		io.Copy(&snapshot, ringBuffer)
  11709 		return &smithy.DeserializationError{
  11710 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11711 			Snapshot: snapshot.Bytes(),
  11712 		}
  11713 	}
  11714 
  11715 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11716 	err = awsRestxml_deserializeDocumentHealthCheckAlreadyExists(&output, decoder)
  11717 	if err != nil {
  11718 		var snapshot bytes.Buffer
  11719 		io.Copy(&snapshot, ringBuffer)
  11720 		return &smithy.DeserializationError{
  11721 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11722 			Snapshot: snapshot.Bytes(),
  11723 		}
  11724 	}
  11725 
  11726 	return output
  11727 }
  11728 
  11729 func awsRestxml_deserializeErrorHealthCheckInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11730 	output := &types.HealthCheckInUse{}
  11731 	var buff [1024]byte
  11732 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11733 	body := io.TeeReader(errorBody, ringBuffer)
  11734 	rootDecoder := xml.NewDecoder(body)
  11735 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11736 	if err == io.EOF {
  11737 		return output
  11738 	}
  11739 	if err != nil {
  11740 		var snapshot bytes.Buffer
  11741 		io.Copy(&snapshot, ringBuffer)
  11742 		return &smithy.DeserializationError{
  11743 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11744 			Snapshot: snapshot.Bytes(),
  11745 		}
  11746 	}
  11747 
  11748 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11749 	t, err = decoder.GetElement("Error")
  11750 	if err != nil {
  11751 		var snapshot bytes.Buffer
  11752 		io.Copy(&snapshot, ringBuffer)
  11753 		return &smithy.DeserializationError{
  11754 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11755 			Snapshot: snapshot.Bytes(),
  11756 		}
  11757 	}
  11758 
  11759 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11760 	err = awsRestxml_deserializeDocumentHealthCheckInUse(&output, decoder)
  11761 	if err != nil {
  11762 		var snapshot bytes.Buffer
  11763 		io.Copy(&snapshot, ringBuffer)
  11764 		return &smithy.DeserializationError{
  11765 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11766 			Snapshot: snapshot.Bytes(),
  11767 		}
  11768 	}
  11769 
  11770 	return output
  11771 }
  11772 
  11773 func awsRestxml_deserializeErrorHealthCheckVersionMismatch(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11774 	output := &types.HealthCheckVersionMismatch{}
  11775 	var buff [1024]byte
  11776 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11777 	body := io.TeeReader(errorBody, ringBuffer)
  11778 	rootDecoder := xml.NewDecoder(body)
  11779 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11780 	if err == io.EOF {
  11781 		return output
  11782 	}
  11783 	if err != nil {
  11784 		var snapshot bytes.Buffer
  11785 		io.Copy(&snapshot, ringBuffer)
  11786 		return &smithy.DeserializationError{
  11787 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11788 			Snapshot: snapshot.Bytes(),
  11789 		}
  11790 	}
  11791 
  11792 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11793 	t, err = decoder.GetElement("Error")
  11794 	if err != nil {
  11795 		var snapshot bytes.Buffer
  11796 		io.Copy(&snapshot, ringBuffer)
  11797 		return &smithy.DeserializationError{
  11798 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11799 			Snapshot: snapshot.Bytes(),
  11800 		}
  11801 	}
  11802 
  11803 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11804 	err = awsRestxml_deserializeDocumentHealthCheckVersionMismatch(&output, decoder)
  11805 	if err != nil {
  11806 		var snapshot bytes.Buffer
  11807 		io.Copy(&snapshot, ringBuffer)
  11808 		return &smithy.DeserializationError{
  11809 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11810 			Snapshot: snapshot.Bytes(),
  11811 		}
  11812 	}
  11813 
  11814 	return output
  11815 }
  11816 
  11817 func awsRestxml_deserializeErrorHostedZoneAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11818 	output := &types.HostedZoneAlreadyExists{}
  11819 	var buff [1024]byte
  11820 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11821 	body := io.TeeReader(errorBody, ringBuffer)
  11822 	rootDecoder := xml.NewDecoder(body)
  11823 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11824 	if err == io.EOF {
  11825 		return output
  11826 	}
  11827 	if err != nil {
  11828 		var snapshot bytes.Buffer
  11829 		io.Copy(&snapshot, ringBuffer)
  11830 		return &smithy.DeserializationError{
  11831 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11832 			Snapshot: snapshot.Bytes(),
  11833 		}
  11834 	}
  11835 
  11836 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11837 	t, err = decoder.GetElement("Error")
  11838 	if err != nil {
  11839 		var snapshot bytes.Buffer
  11840 		io.Copy(&snapshot, ringBuffer)
  11841 		return &smithy.DeserializationError{
  11842 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11843 			Snapshot: snapshot.Bytes(),
  11844 		}
  11845 	}
  11846 
  11847 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11848 	err = awsRestxml_deserializeDocumentHostedZoneAlreadyExists(&output, decoder)
  11849 	if err != nil {
  11850 		var snapshot bytes.Buffer
  11851 		io.Copy(&snapshot, ringBuffer)
  11852 		return &smithy.DeserializationError{
  11853 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11854 			Snapshot: snapshot.Bytes(),
  11855 		}
  11856 	}
  11857 
  11858 	return output
  11859 }
  11860 
  11861 func awsRestxml_deserializeErrorHostedZoneNotEmpty(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11862 	output := &types.HostedZoneNotEmpty{}
  11863 	var buff [1024]byte
  11864 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11865 	body := io.TeeReader(errorBody, ringBuffer)
  11866 	rootDecoder := xml.NewDecoder(body)
  11867 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11868 	if err == io.EOF {
  11869 		return output
  11870 	}
  11871 	if err != nil {
  11872 		var snapshot bytes.Buffer
  11873 		io.Copy(&snapshot, ringBuffer)
  11874 		return &smithy.DeserializationError{
  11875 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11876 			Snapshot: snapshot.Bytes(),
  11877 		}
  11878 	}
  11879 
  11880 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11881 	t, err = decoder.GetElement("Error")
  11882 	if err != nil {
  11883 		var snapshot bytes.Buffer
  11884 		io.Copy(&snapshot, ringBuffer)
  11885 		return &smithy.DeserializationError{
  11886 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11887 			Snapshot: snapshot.Bytes(),
  11888 		}
  11889 	}
  11890 
  11891 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11892 	err = awsRestxml_deserializeDocumentHostedZoneNotEmpty(&output, decoder)
  11893 	if err != nil {
  11894 		var snapshot bytes.Buffer
  11895 		io.Copy(&snapshot, ringBuffer)
  11896 		return &smithy.DeserializationError{
  11897 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11898 			Snapshot: snapshot.Bytes(),
  11899 		}
  11900 	}
  11901 
  11902 	return output
  11903 }
  11904 
  11905 func awsRestxml_deserializeErrorHostedZoneNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11906 	output := &types.HostedZoneNotFound{}
  11907 	var buff [1024]byte
  11908 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11909 	body := io.TeeReader(errorBody, ringBuffer)
  11910 	rootDecoder := xml.NewDecoder(body)
  11911 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11912 	if err == io.EOF {
  11913 		return output
  11914 	}
  11915 	if err != nil {
  11916 		var snapshot bytes.Buffer
  11917 		io.Copy(&snapshot, ringBuffer)
  11918 		return &smithy.DeserializationError{
  11919 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11920 			Snapshot: snapshot.Bytes(),
  11921 		}
  11922 	}
  11923 
  11924 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11925 	t, err = decoder.GetElement("Error")
  11926 	if err != nil {
  11927 		var snapshot bytes.Buffer
  11928 		io.Copy(&snapshot, ringBuffer)
  11929 		return &smithy.DeserializationError{
  11930 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11931 			Snapshot: snapshot.Bytes(),
  11932 		}
  11933 	}
  11934 
  11935 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11936 	err = awsRestxml_deserializeDocumentHostedZoneNotFound(&output, decoder)
  11937 	if err != nil {
  11938 		var snapshot bytes.Buffer
  11939 		io.Copy(&snapshot, ringBuffer)
  11940 		return &smithy.DeserializationError{
  11941 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11942 			Snapshot: snapshot.Bytes(),
  11943 		}
  11944 	}
  11945 
  11946 	return output
  11947 }
  11948 
  11949 func awsRestxml_deserializeErrorHostedZoneNotPrivate(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11950 	output := &types.HostedZoneNotPrivate{}
  11951 	var buff [1024]byte
  11952 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11953 	body := io.TeeReader(errorBody, ringBuffer)
  11954 	rootDecoder := xml.NewDecoder(body)
  11955 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11956 	if err == io.EOF {
  11957 		return output
  11958 	}
  11959 	if err != nil {
  11960 		var snapshot bytes.Buffer
  11961 		io.Copy(&snapshot, ringBuffer)
  11962 		return &smithy.DeserializationError{
  11963 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11964 			Snapshot: snapshot.Bytes(),
  11965 		}
  11966 	}
  11967 
  11968 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11969 	t, err = decoder.GetElement("Error")
  11970 	if err != nil {
  11971 		var snapshot bytes.Buffer
  11972 		io.Copy(&snapshot, ringBuffer)
  11973 		return &smithy.DeserializationError{
  11974 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11975 			Snapshot: snapshot.Bytes(),
  11976 		}
  11977 	}
  11978 
  11979 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11980 	err = awsRestxml_deserializeDocumentHostedZoneNotPrivate(&output, decoder)
  11981 	if err != nil {
  11982 		var snapshot bytes.Buffer
  11983 		io.Copy(&snapshot, ringBuffer)
  11984 		return &smithy.DeserializationError{
  11985 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11986 			Snapshot: snapshot.Bytes(),
  11987 		}
  11988 	}
  11989 
  11990 	return output
  11991 }
  11992 
  11993 func awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11994 	output := &types.HostedZonePartiallyDelegated{}
  11995 	var buff [1024]byte
  11996 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11997 	body := io.TeeReader(errorBody, ringBuffer)
  11998 	rootDecoder := xml.NewDecoder(body)
  11999 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12000 	if err == io.EOF {
  12001 		return output
  12002 	}
  12003 	if err != nil {
  12004 		var snapshot bytes.Buffer
  12005 		io.Copy(&snapshot, ringBuffer)
  12006 		return &smithy.DeserializationError{
  12007 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12008 			Snapshot: snapshot.Bytes(),
  12009 		}
  12010 	}
  12011 
  12012 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12013 	t, err = decoder.GetElement("Error")
  12014 	if err != nil {
  12015 		var snapshot bytes.Buffer
  12016 		io.Copy(&snapshot, ringBuffer)
  12017 		return &smithy.DeserializationError{
  12018 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12019 			Snapshot: snapshot.Bytes(),
  12020 		}
  12021 	}
  12022 
  12023 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12024 	err = awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(&output, decoder)
  12025 	if err != nil {
  12026 		var snapshot bytes.Buffer
  12027 		io.Copy(&snapshot, ringBuffer)
  12028 		return &smithy.DeserializationError{
  12029 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12030 			Snapshot: snapshot.Bytes(),
  12031 		}
  12032 	}
  12033 
  12034 	return output
  12035 }
  12036 
  12037 func awsRestxml_deserializeErrorIncompatibleVersion(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12038 	output := &types.IncompatibleVersion{}
  12039 	var buff [1024]byte
  12040 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12041 	body := io.TeeReader(errorBody, ringBuffer)
  12042 	rootDecoder := xml.NewDecoder(body)
  12043 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12044 	if err == io.EOF {
  12045 		return output
  12046 	}
  12047 	if err != nil {
  12048 		var snapshot bytes.Buffer
  12049 		io.Copy(&snapshot, ringBuffer)
  12050 		return &smithy.DeserializationError{
  12051 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12052 			Snapshot: snapshot.Bytes(),
  12053 		}
  12054 	}
  12055 
  12056 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12057 	t, err = decoder.GetElement("Error")
  12058 	if err != nil {
  12059 		var snapshot bytes.Buffer
  12060 		io.Copy(&snapshot, ringBuffer)
  12061 		return &smithy.DeserializationError{
  12062 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12063 			Snapshot: snapshot.Bytes(),
  12064 		}
  12065 	}
  12066 
  12067 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12068 	err = awsRestxml_deserializeDocumentIncompatibleVersion(&output, decoder)
  12069 	if err != nil {
  12070 		var snapshot bytes.Buffer
  12071 		io.Copy(&snapshot, ringBuffer)
  12072 		return &smithy.DeserializationError{
  12073 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12074 			Snapshot: snapshot.Bytes(),
  12075 		}
  12076 	}
  12077 
  12078 	return output
  12079 }
  12080 
  12081 func awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12082 	output := &types.InsufficientCloudWatchLogsResourcePolicy{}
  12083 	var buff [1024]byte
  12084 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12085 	body := io.TeeReader(errorBody, ringBuffer)
  12086 	rootDecoder := xml.NewDecoder(body)
  12087 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12088 	if err == io.EOF {
  12089 		return output
  12090 	}
  12091 	if err != nil {
  12092 		var snapshot bytes.Buffer
  12093 		io.Copy(&snapshot, ringBuffer)
  12094 		return &smithy.DeserializationError{
  12095 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12096 			Snapshot: snapshot.Bytes(),
  12097 		}
  12098 	}
  12099 
  12100 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12101 	t, err = decoder.GetElement("Error")
  12102 	if err != nil {
  12103 		var snapshot bytes.Buffer
  12104 		io.Copy(&snapshot, ringBuffer)
  12105 		return &smithy.DeserializationError{
  12106 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12107 			Snapshot: snapshot.Bytes(),
  12108 		}
  12109 	}
  12110 
  12111 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12112 	err = awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(&output, decoder)
  12113 	if err != nil {
  12114 		var snapshot bytes.Buffer
  12115 		io.Copy(&snapshot, ringBuffer)
  12116 		return &smithy.DeserializationError{
  12117 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12118 			Snapshot: snapshot.Bytes(),
  12119 		}
  12120 	}
  12121 
  12122 	return output
  12123 }
  12124 
  12125 func awsRestxml_deserializeErrorInvalidArgument(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12126 	output := &types.InvalidArgument{}
  12127 	var buff [1024]byte
  12128 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12129 	body := io.TeeReader(errorBody, ringBuffer)
  12130 	rootDecoder := xml.NewDecoder(body)
  12131 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12132 	if err == io.EOF {
  12133 		return output
  12134 	}
  12135 	if err != nil {
  12136 		var snapshot bytes.Buffer
  12137 		io.Copy(&snapshot, ringBuffer)
  12138 		return &smithy.DeserializationError{
  12139 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12140 			Snapshot: snapshot.Bytes(),
  12141 		}
  12142 	}
  12143 
  12144 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12145 	t, err = decoder.GetElement("Error")
  12146 	if err != nil {
  12147 		var snapshot bytes.Buffer
  12148 		io.Copy(&snapshot, ringBuffer)
  12149 		return &smithy.DeserializationError{
  12150 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12151 			Snapshot: snapshot.Bytes(),
  12152 		}
  12153 	}
  12154 
  12155 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12156 	err = awsRestxml_deserializeDocumentInvalidArgument(&output, decoder)
  12157 	if err != nil {
  12158 		var snapshot bytes.Buffer
  12159 		io.Copy(&snapshot, ringBuffer)
  12160 		return &smithy.DeserializationError{
  12161 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12162 			Snapshot: snapshot.Bytes(),
  12163 		}
  12164 	}
  12165 
  12166 	return output
  12167 }
  12168 
  12169 func awsRestxml_deserializeErrorInvalidChangeBatch(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12170 	output := &types.InvalidChangeBatch{}
  12171 	var buff [1024]byte
  12172 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12173 	body := io.TeeReader(errorBody, ringBuffer)
  12174 	rootDecoder := xml.NewDecoder(body)
  12175 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12176 	if err == io.EOF {
  12177 		return output
  12178 	}
  12179 	if err != nil {
  12180 		var snapshot bytes.Buffer
  12181 		io.Copy(&snapshot, ringBuffer)
  12182 		return &smithy.DeserializationError{
  12183 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12184 			Snapshot: snapshot.Bytes(),
  12185 		}
  12186 	}
  12187 
  12188 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12189 	t, err = decoder.GetElement("Error")
  12190 	if err != nil {
  12191 		var snapshot bytes.Buffer
  12192 		io.Copy(&snapshot, ringBuffer)
  12193 		return &smithy.DeserializationError{
  12194 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12195 			Snapshot: snapshot.Bytes(),
  12196 		}
  12197 	}
  12198 
  12199 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12200 	err = awsRestxml_deserializeDocumentInvalidChangeBatch(&output, decoder)
  12201 	if err != nil {
  12202 		var snapshot bytes.Buffer
  12203 		io.Copy(&snapshot, ringBuffer)
  12204 		return &smithy.DeserializationError{
  12205 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12206 			Snapshot: snapshot.Bytes(),
  12207 		}
  12208 	}
  12209 
  12210 	return output
  12211 }
  12212 
  12213 func awsRestxml_deserializeErrorInvalidDomainName(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12214 	output := &types.InvalidDomainName{}
  12215 	var buff [1024]byte
  12216 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12217 	body := io.TeeReader(errorBody, ringBuffer)
  12218 	rootDecoder := xml.NewDecoder(body)
  12219 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12220 	if err == io.EOF {
  12221 		return output
  12222 	}
  12223 	if err != nil {
  12224 		var snapshot bytes.Buffer
  12225 		io.Copy(&snapshot, ringBuffer)
  12226 		return &smithy.DeserializationError{
  12227 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12228 			Snapshot: snapshot.Bytes(),
  12229 		}
  12230 	}
  12231 
  12232 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12233 	t, err = decoder.GetElement("Error")
  12234 	if err != nil {
  12235 		var snapshot bytes.Buffer
  12236 		io.Copy(&snapshot, ringBuffer)
  12237 		return &smithy.DeserializationError{
  12238 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12239 			Snapshot: snapshot.Bytes(),
  12240 		}
  12241 	}
  12242 
  12243 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12244 	err = awsRestxml_deserializeDocumentInvalidDomainName(&output, decoder)
  12245 	if err != nil {
  12246 		var snapshot bytes.Buffer
  12247 		io.Copy(&snapshot, ringBuffer)
  12248 		return &smithy.DeserializationError{
  12249 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12250 			Snapshot: snapshot.Bytes(),
  12251 		}
  12252 	}
  12253 
  12254 	return output
  12255 }
  12256 
  12257 func awsRestxml_deserializeErrorInvalidInput(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12258 	output := &types.InvalidInput{}
  12259 	var buff [1024]byte
  12260 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12261 	body := io.TeeReader(errorBody, ringBuffer)
  12262 	rootDecoder := xml.NewDecoder(body)
  12263 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12264 	if err == io.EOF {
  12265 		return output
  12266 	}
  12267 	if err != nil {
  12268 		var snapshot bytes.Buffer
  12269 		io.Copy(&snapshot, ringBuffer)
  12270 		return &smithy.DeserializationError{
  12271 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12272 			Snapshot: snapshot.Bytes(),
  12273 		}
  12274 	}
  12275 
  12276 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12277 	t, err = decoder.GetElement("Error")
  12278 	if err != nil {
  12279 		var snapshot bytes.Buffer
  12280 		io.Copy(&snapshot, ringBuffer)
  12281 		return &smithy.DeserializationError{
  12282 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12283 			Snapshot: snapshot.Bytes(),
  12284 		}
  12285 	}
  12286 
  12287 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12288 	err = awsRestxml_deserializeDocumentInvalidInput(&output, decoder)
  12289 	if err != nil {
  12290 		var snapshot bytes.Buffer
  12291 		io.Copy(&snapshot, ringBuffer)
  12292 		return &smithy.DeserializationError{
  12293 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12294 			Snapshot: snapshot.Bytes(),
  12295 		}
  12296 	}
  12297 
  12298 	return output
  12299 }
  12300 
  12301 func awsRestxml_deserializeErrorInvalidKeySigningKeyName(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12302 	output := &types.InvalidKeySigningKeyName{}
  12303 	var buff [1024]byte
  12304 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12305 	body := io.TeeReader(errorBody, ringBuffer)
  12306 	rootDecoder := xml.NewDecoder(body)
  12307 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12308 	if err == io.EOF {
  12309 		return output
  12310 	}
  12311 	if err != nil {
  12312 		var snapshot bytes.Buffer
  12313 		io.Copy(&snapshot, ringBuffer)
  12314 		return &smithy.DeserializationError{
  12315 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12316 			Snapshot: snapshot.Bytes(),
  12317 		}
  12318 	}
  12319 
  12320 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12321 	t, err = decoder.GetElement("Error")
  12322 	if err != nil {
  12323 		var snapshot bytes.Buffer
  12324 		io.Copy(&snapshot, ringBuffer)
  12325 		return &smithy.DeserializationError{
  12326 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12327 			Snapshot: snapshot.Bytes(),
  12328 		}
  12329 	}
  12330 
  12331 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12332 	err = awsRestxml_deserializeDocumentInvalidKeySigningKeyName(&output, decoder)
  12333 	if err != nil {
  12334 		var snapshot bytes.Buffer
  12335 		io.Copy(&snapshot, ringBuffer)
  12336 		return &smithy.DeserializationError{
  12337 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12338 			Snapshot: snapshot.Bytes(),
  12339 		}
  12340 	}
  12341 
  12342 	return output
  12343 }
  12344 
  12345 func awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12346 	output := &types.InvalidKeySigningKeyStatus{}
  12347 	var buff [1024]byte
  12348 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12349 	body := io.TeeReader(errorBody, ringBuffer)
  12350 	rootDecoder := xml.NewDecoder(body)
  12351 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12352 	if err == io.EOF {
  12353 		return output
  12354 	}
  12355 	if err != nil {
  12356 		var snapshot bytes.Buffer
  12357 		io.Copy(&snapshot, ringBuffer)
  12358 		return &smithy.DeserializationError{
  12359 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12360 			Snapshot: snapshot.Bytes(),
  12361 		}
  12362 	}
  12363 
  12364 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12365 	t, err = decoder.GetElement("Error")
  12366 	if err != nil {
  12367 		var snapshot bytes.Buffer
  12368 		io.Copy(&snapshot, ringBuffer)
  12369 		return &smithy.DeserializationError{
  12370 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12371 			Snapshot: snapshot.Bytes(),
  12372 		}
  12373 	}
  12374 
  12375 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12376 	err = awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(&output, decoder)
  12377 	if err != nil {
  12378 		var snapshot bytes.Buffer
  12379 		io.Copy(&snapshot, ringBuffer)
  12380 		return &smithy.DeserializationError{
  12381 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12382 			Snapshot: snapshot.Bytes(),
  12383 		}
  12384 	}
  12385 
  12386 	return output
  12387 }
  12388 
  12389 func awsRestxml_deserializeErrorInvalidKMSArn(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12390 	output := &types.InvalidKMSArn{}
  12391 	var buff [1024]byte
  12392 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12393 	body := io.TeeReader(errorBody, ringBuffer)
  12394 	rootDecoder := xml.NewDecoder(body)
  12395 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12396 	if err == io.EOF {
  12397 		return output
  12398 	}
  12399 	if err != nil {
  12400 		var snapshot bytes.Buffer
  12401 		io.Copy(&snapshot, ringBuffer)
  12402 		return &smithy.DeserializationError{
  12403 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12404 			Snapshot: snapshot.Bytes(),
  12405 		}
  12406 	}
  12407 
  12408 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12409 	t, err = decoder.GetElement("Error")
  12410 	if err != nil {
  12411 		var snapshot bytes.Buffer
  12412 		io.Copy(&snapshot, ringBuffer)
  12413 		return &smithy.DeserializationError{
  12414 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12415 			Snapshot: snapshot.Bytes(),
  12416 		}
  12417 	}
  12418 
  12419 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12420 	err = awsRestxml_deserializeDocumentInvalidKMSArn(&output, decoder)
  12421 	if err != nil {
  12422 		var snapshot bytes.Buffer
  12423 		io.Copy(&snapshot, ringBuffer)
  12424 		return &smithy.DeserializationError{
  12425 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12426 			Snapshot: snapshot.Bytes(),
  12427 		}
  12428 	}
  12429 
  12430 	return output
  12431 }
  12432 
  12433 func awsRestxml_deserializeErrorInvalidPaginationToken(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12434 	output := &types.InvalidPaginationToken{}
  12435 	var buff [1024]byte
  12436 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12437 	body := io.TeeReader(errorBody, ringBuffer)
  12438 	rootDecoder := xml.NewDecoder(body)
  12439 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12440 	if err == io.EOF {
  12441 		return output
  12442 	}
  12443 	if err != nil {
  12444 		var snapshot bytes.Buffer
  12445 		io.Copy(&snapshot, ringBuffer)
  12446 		return &smithy.DeserializationError{
  12447 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12448 			Snapshot: snapshot.Bytes(),
  12449 		}
  12450 	}
  12451 
  12452 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12453 	t, err = decoder.GetElement("Error")
  12454 	if err != nil {
  12455 		var snapshot bytes.Buffer
  12456 		io.Copy(&snapshot, ringBuffer)
  12457 		return &smithy.DeserializationError{
  12458 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12459 			Snapshot: snapshot.Bytes(),
  12460 		}
  12461 	}
  12462 
  12463 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12464 	err = awsRestxml_deserializeDocumentInvalidPaginationToken(&output, decoder)
  12465 	if err != nil {
  12466 		var snapshot bytes.Buffer
  12467 		io.Copy(&snapshot, ringBuffer)
  12468 		return &smithy.DeserializationError{
  12469 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12470 			Snapshot: snapshot.Bytes(),
  12471 		}
  12472 	}
  12473 
  12474 	return output
  12475 }
  12476 
  12477 func awsRestxml_deserializeErrorInvalidSigningStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12478 	output := &types.InvalidSigningStatus{}
  12479 	var buff [1024]byte
  12480 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12481 	body := io.TeeReader(errorBody, ringBuffer)
  12482 	rootDecoder := xml.NewDecoder(body)
  12483 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12484 	if err == io.EOF {
  12485 		return output
  12486 	}
  12487 	if err != nil {
  12488 		var snapshot bytes.Buffer
  12489 		io.Copy(&snapshot, ringBuffer)
  12490 		return &smithy.DeserializationError{
  12491 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12492 			Snapshot: snapshot.Bytes(),
  12493 		}
  12494 	}
  12495 
  12496 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12497 	t, err = decoder.GetElement("Error")
  12498 	if err != nil {
  12499 		var snapshot bytes.Buffer
  12500 		io.Copy(&snapshot, ringBuffer)
  12501 		return &smithy.DeserializationError{
  12502 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12503 			Snapshot: snapshot.Bytes(),
  12504 		}
  12505 	}
  12506 
  12507 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12508 	err = awsRestxml_deserializeDocumentInvalidSigningStatus(&output, decoder)
  12509 	if err != nil {
  12510 		var snapshot bytes.Buffer
  12511 		io.Copy(&snapshot, ringBuffer)
  12512 		return &smithy.DeserializationError{
  12513 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12514 			Snapshot: snapshot.Bytes(),
  12515 		}
  12516 	}
  12517 
  12518 	return output
  12519 }
  12520 
  12521 func awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12522 	output := &types.InvalidTrafficPolicyDocument{}
  12523 	var buff [1024]byte
  12524 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12525 	body := io.TeeReader(errorBody, ringBuffer)
  12526 	rootDecoder := xml.NewDecoder(body)
  12527 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12528 	if err == io.EOF {
  12529 		return output
  12530 	}
  12531 	if err != nil {
  12532 		var snapshot bytes.Buffer
  12533 		io.Copy(&snapshot, ringBuffer)
  12534 		return &smithy.DeserializationError{
  12535 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12536 			Snapshot: snapshot.Bytes(),
  12537 		}
  12538 	}
  12539 
  12540 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12541 	t, err = decoder.GetElement("Error")
  12542 	if err != nil {
  12543 		var snapshot bytes.Buffer
  12544 		io.Copy(&snapshot, ringBuffer)
  12545 		return &smithy.DeserializationError{
  12546 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12547 			Snapshot: snapshot.Bytes(),
  12548 		}
  12549 	}
  12550 
  12551 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12552 	err = awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(&output, decoder)
  12553 	if err != nil {
  12554 		var snapshot bytes.Buffer
  12555 		io.Copy(&snapshot, ringBuffer)
  12556 		return &smithy.DeserializationError{
  12557 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12558 			Snapshot: snapshot.Bytes(),
  12559 		}
  12560 	}
  12561 
  12562 	return output
  12563 }
  12564 
  12565 func awsRestxml_deserializeErrorInvalidVPCId(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12566 	output := &types.InvalidVPCId{}
  12567 	var buff [1024]byte
  12568 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12569 	body := io.TeeReader(errorBody, ringBuffer)
  12570 	rootDecoder := xml.NewDecoder(body)
  12571 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12572 	if err == io.EOF {
  12573 		return output
  12574 	}
  12575 	if err != nil {
  12576 		var snapshot bytes.Buffer
  12577 		io.Copy(&snapshot, ringBuffer)
  12578 		return &smithy.DeserializationError{
  12579 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12580 			Snapshot: snapshot.Bytes(),
  12581 		}
  12582 	}
  12583 
  12584 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12585 	t, err = decoder.GetElement("Error")
  12586 	if err != nil {
  12587 		var snapshot bytes.Buffer
  12588 		io.Copy(&snapshot, ringBuffer)
  12589 		return &smithy.DeserializationError{
  12590 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12591 			Snapshot: snapshot.Bytes(),
  12592 		}
  12593 	}
  12594 
  12595 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12596 	err = awsRestxml_deserializeDocumentInvalidVPCId(&output, decoder)
  12597 	if err != nil {
  12598 		var snapshot bytes.Buffer
  12599 		io.Copy(&snapshot, ringBuffer)
  12600 		return &smithy.DeserializationError{
  12601 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12602 			Snapshot: snapshot.Bytes(),
  12603 		}
  12604 	}
  12605 
  12606 	return output
  12607 }
  12608 
  12609 func awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12610 	output := &types.KeySigningKeyAlreadyExists{}
  12611 	var buff [1024]byte
  12612 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12613 	body := io.TeeReader(errorBody, ringBuffer)
  12614 	rootDecoder := xml.NewDecoder(body)
  12615 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12616 	if err == io.EOF {
  12617 		return output
  12618 	}
  12619 	if err != nil {
  12620 		var snapshot bytes.Buffer
  12621 		io.Copy(&snapshot, ringBuffer)
  12622 		return &smithy.DeserializationError{
  12623 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12624 			Snapshot: snapshot.Bytes(),
  12625 		}
  12626 	}
  12627 
  12628 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12629 	t, err = decoder.GetElement("Error")
  12630 	if err != nil {
  12631 		var snapshot bytes.Buffer
  12632 		io.Copy(&snapshot, ringBuffer)
  12633 		return &smithy.DeserializationError{
  12634 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12635 			Snapshot: snapshot.Bytes(),
  12636 		}
  12637 	}
  12638 
  12639 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12640 	err = awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(&output, decoder)
  12641 	if err != nil {
  12642 		var snapshot bytes.Buffer
  12643 		io.Copy(&snapshot, ringBuffer)
  12644 		return &smithy.DeserializationError{
  12645 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12646 			Snapshot: snapshot.Bytes(),
  12647 		}
  12648 	}
  12649 
  12650 	return output
  12651 }
  12652 
  12653 func awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12654 	output := &types.KeySigningKeyInParentDSRecord{}
  12655 	var buff [1024]byte
  12656 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12657 	body := io.TeeReader(errorBody, ringBuffer)
  12658 	rootDecoder := xml.NewDecoder(body)
  12659 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12660 	if err == io.EOF {
  12661 		return output
  12662 	}
  12663 	if err != nil {
  12664 		var snapshot bytes.Buffer
  12665 		io.Copy(&snapshot, ringBuffer)
  12666 		return &smithy.DeserializationError{
  12667 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12668 			Snapshot: snapshot.Bytes(),
  12669 		}
  12670 	}
  12671 
  12672 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12673 	t, err = decoder.GetElement("Error")
  12674 	if err != nil {
  12675 		var snapshot bytes.Buffer
  12676 		io.Copy(&snapshot, ringBuffer)
  12677 		return &smithy.DeserializationError{
  12678 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12679 			Snapshot: snapshot.Bytes(),
  12680 		}
  12681 	}
  12682 
  12683 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12684 	err = awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(&output, decoder)
  12685 	if err != nil {
  12686 		var snapshot bytes.Buffer
  12687 		io.Copy(&snapshot, ringBuffer)
  12688 		return &smithy.DeserializationError{
  12689 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12690 			Snapshot: snapshot.Bytes(),
  12691 		}
  12692 	}
  12693 
  12694 	return output
  12695 }
  12696 
  12697 func awsRestxml_deserializeErrorKeySigningKeyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12698 	output := &types.KeySigningKeyInUse{}
  12699 	var buff [1024]byte
  12700 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12701 	body := io.TeeReader(errorBody, ringBuffer)
  12702 	rootDecoder := xml.NewDecoder(body)
  12703 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12704 	if err == io.EOF {
  12705 		return output
  12706 	}
  12707 	if err != nil {
  12708 		var snapshot bytes.Buffer
  12709 		io.Copy(&snapshot, ringBuffer)
  12710 		return &smithy.DeserializationError{
  12711 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12712 			Snapshot: snapshot.Bytes(),
  12713 		}
  12714 	}
  12715 
  12716 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12717 	t, err = decoder.GetElement("Error")
  12718 	if err != nil {
  12719 		var snapshot bytes.Buffer
  12720 		io.Copy(&snapshot, ringBuffer)
  12721 		return &smithy.DeserializationError{
  12722 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12723 			Snapshot: snapshot.Bytes(),
  12724 		}
  12725 	}
  12726 
  12727 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12728 	err = awsRestxml_deserializeDocumentKeySigningKeyInUse(&output, decoder)
  12729 	if err != nil {
  12730 		var snapshot bytes.Buffer
  12731 		io.Copy(&snapshot, ringBuffer)
  12732 		return &smithy.DeserializationError{
  12733 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12734 			Snapshot: snapshot.Bytes(),
  12735 		}
  12736 	}
  12737 
  12738 	return output
  12739 }
  12740 
  12741 func awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12742 	output := &types.KeySigningKeyWithActiveStatusNotFound{}
  12743 	var buff [1024]byte
  12744 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12745 	body := io.TeeReader(errorBody, ringBuffer)
  12746 	rootDecoder := xml.NewDecoder(body)
  12747 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12748 	if err == io.EOF {
  12749 		return output
  12750 	}
  12751 	if err != nil {
  12752 		var snapshot bytes.Buffer
  12753 		io.Copy(&snapshot, ringBuffer)
  12754 		return &smithy.DeserializationError{
  12755 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12756 			Snapshot: snapshot.Bytes(),
  12757 		}
  12758 	}
  12759 
  12760 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12761 	t, err = decoder.GetElement("Error")
  12762 	if err != nil {
  12763 		var snapshot bytes.Buffer
  12764 		io.Copy(&snapshot, ringBuffer)
  12765 		return &smithy.DeserializationError{
  12766 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12767 			Snapshot: snapshot.Bytes(),
  12768 		}
  12769 	}
  12770 
  12771 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12772 	err = awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(&output, decoder)
  12773 	if err != nil {
  12774 		var snapshot bytes.Buffer
  12775 		io.Copy(&snapshot, ringBuffer)
  12776 		return &smithy.DeserializationError{
  12777 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12778 			Snapshot: snapshot.Bytes(),
  12779 		}
  12780 	}
  12781 
  12782 	return output
  12783 }
  12784 
  12785 func awsRestxml_deserializeErrorLastVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12786 	output := &types.LastVPCAssociation{}
  12787 	var buff [1024]byte
  12788 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12789 	body := io.TeeReader(errorBody, ringBuffer)
  12790 	rootDecoder := xml.NewDecoder(body)
  12791 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12792 	if err == io.EOF {
  12793 		return output
  12794 	}
  12795 	if err != nil {
  12796 		var snapshot bytes.Buffer
  12797 		io.Copy(&snapshot, ringBuffer)
  12798 		return &smithy.DeserializationError{
  12799 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12800 			Snapshot: snapshot.Bytes(),
  12801 		}
  12802 	}
  12803 
  12804 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12805 	t, err = decoder.GetElement("Error")
  12806 	if err != nil {
  12807 		var snapshot bytes.Buffer
  12808 		io.Copy(&snapshot, ringBuffer)
  12809 		return &smithy.DeserializationError{
  12810 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12811 			Snapshot: snapshot.Bytes(),
  12812 		}
  12813 	}
  12814 
  12815 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12816 	err = awsRestxml_deserializeDocumentLastVPCAssociation(&output, decoder)
  12817 	if err != nil {
  12818 		var snapshot bytes.Buffer
  12819 		io.Copy(&snapshot, ringBuffer)
  12820 		return &smithy.DeserializationError{
  12821 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12822 			Snapshot: snapshot.Bytes(),
  12823 		}
  12824 	}
  12825 
  12826 	return output
  12827 }
  12828 
  12829 func awsRestxml_deserializeErrorLimitsExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12830 	output := &types.LimitsExceeded{}
  12831 	var buff [1024]byte
  12832 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12833 	body := io.TeeReader(errorBody, ringBuffer)
  12834 	rootDecoder := xml.NewDecoder(body)
  12835 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12836 	if err == io.EOF {
  12837 		return output
  12838 	}
  12839 	if err != nil {
  12840 		var snapshot bytes.Buffer
  12841 		io.Copy(&snapshot, ringBuffer)
  12842 		return &smithy.DeserializationError{
  12843 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12844 			Snapshot: snapshot.Bytes(),
  12845 		}
  12846 	}
  12847 
  12848 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12849 	t, err = decoder.GetElement("Error")
  12850 	if err != nil {
  12851 		var snapshot bytes.Buffer
  12852 		io.Copy(&snapshot, ringBuffer)
  12853 		return &smithy.DeserializationError{
  12854 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12855 			Snapshot: snapshot.Bytes(),
  12856 		}
  12857 	}
  12858 
  12859 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12860 	err = awsRestxml_deserializeDocumentLimitsExceeded(&output, decoder)
  12861 	if err != nil {
  12862 		var snapshot bytes.Buffer
  12863 		io.Copy(&snapshot, ringBuffer)
  12864 		return &smithy.DeserializationError{
  12865 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12866 			Snapshot: snapshot.Bytes(),
  12867 		}
  12868 	}
  12869 
  12870 	return output
  12871 }
  12872 
  12873 func awsRestxml_deserializeErrorNoSuchChange(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12874 	output := &types.NoSuchChange{}
  12875 	var buff [1024]byte
  12876 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12877 	body := io.TeeReader(errorBody, ringBuffer)
  12878 	rootDecoder := xml.NewDecoder(body)
  12879 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12880 	if err == io.EOF {
  12881 		return output
  12882 	}
  12883 	if err != nil {
  12884 		var snapshot bytes.Buffer
  12885 		io.Copy(&snapshot, ringBuffer)
  12886 		return &smithy.DeserializationError{
  12887 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12888 			Snapshot: snapshot.Bytes(),
  12889 		}
  12890 	}
  12891 
  12892 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12893 	t, err = decoder.GetElement("Error")
  12894 	if err != nil {
  12895 		var snapshot bytes.Buffer
  12896 		io.Copy(&snapshot, ringBuffer)
  12897 		return &smithy.DeserializationError{
  12898 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12899 			Snapshot: snapshot.Bytes(),
  12900 		}
  12901 	}
  12902 
  12903 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12904 	err = awsRestxml_deserializeDocumentNoSuchChange(&output, decoder)
  12905 	if err != nil {
  12906 		var snapshot bytes.Buffer
  12907 		io.Copy(&snapshot, ringBuffer)
  12908 		return &smithy.DeserializationError{
  12909 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12910 			Snapshot: snapshot.Bytes(),
  12911 		}
  12912 	}
  12913 
  12914 	return output
  12915 }
  12916 
  12917 func awsRestxml_deserializeErrorNoSuchCidrCollectionException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12918 	output := &types.NoSuchCidrCollectionException{}
  12919 	var buff [1024]byte
  12920 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12921 	body := io.TeeReader(errorBody, ringBuffer)
  12922 	rootDecoder := xml.NewDecoder(body)
  12923 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12924 	if err == io.EOF {
  12925 		return output
  12926 	}
  12927 	if err != nil {
  12928 		var snapshot bytes.Buffer
  12929 		io.Copy(&snapshot, ringBuffer)
  12930 		return &smithy.DeserializationError{
  12931 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12932 			Snapshot: snapshot.Bytes(),
  12933 		}
  12934 	}
  12935 
  12936 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12937 	t, err = decoder.GetElement("Error")
  12938 	if err != nil {
  12939 		var snapshot bytes.Buffer
  12940 		io.Copy(&snapshot, ringBuffer)
  12941 		return &smithy.DeserializationError{
  12942 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12943 			Snapshot: snapshot.Bytes(),
  12944 		}
  12945 	}
  12946 
  12947 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12948 	err = awsRestxml_deserializeDocumentNoSuchCidrCollectionException(&output, decoder)
  12949 	if err != nil {
  12950 		var snapshot bytes.Buffer
  12951 		io.Copy(&snapshot, ringBuffer)
  12952 		return &smithy.DeserializationError{
  12953 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12954 			Snapshot: snapshot.Bytes(),
  12955 		}
  12956 	}
  12957 
  12958 	return output
  12959 }
  12960 
  12961 func awsRestxml_deserializeErrorNoSuchCidrLocationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12962 	output := &types.NoSuchCidrLocationException{}
  12963 	var buff [1024]byte
  12964 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12965 	body := io.TeeReader(errorBody, ringBuffer)
  12966 	rootDecoder := xml.NewDecoder(body)
  12967 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12968 	if err == io.EOF {
  12969 		return output
  12970 	}
  12971 	if err != nil {
  12972 		var snapshot bytes.Buffer
  12973 		io.Copy(&snapshot, ringBuffer)
  12974 		return &smithy.DeserializationError{
  12975 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12976 			Snapshot: snapshot.Bytes(),
  12977 		}
  12978 	}
  12979 
  12980 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12981 	t, err = decoder.GetElement("Error")
  12982 	if err != nil {
  12983 		var snapshot bytes.Buffer
  12984 		io.Copy(&snapshot, ringBuffer)
  12985 		return &smithy.DeserializationError{
  12986 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12987 			Snapshot: snapshot.Bytes(),
  12988 		}
  12989 	}
  12990 
  12991 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12992 	err = awsRestxml_deserializeDocumentNoSuchCidrLocationException(&output, decoder)
  12993 	if err != nil {
  12994 		var snapshot bytes.Buffer
  12995 		io.Copy(&snapshot, ringBuffer)
  12996 		return &smithy.DeserializationError{
  12997 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12998 			Snapshot: snapshot.Bytes(),
  12999 		}
  13000 	}
  13001 
  13002 	return output
  13003 }
  13004 
  13005 func awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13006 	output := &types.NoSuchCloudWatchLogsLogGroup{}
  13007 	var buff [1024]byte
  13008 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13009 	body := io.TeeReader(errorBody, ringBuffer)
  13010 	rootDecoder := xml.NewDecoder(body)
  13011 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13012 	if err == io.EOF {
  13013 		return output
  13014 	}
  13015 	if err != nil {
  13016 		var snapshot bytes.Buffer
  13017 		io.Copy(&snapshot, ringBuffer)
  13018 		return &smithy.DeserializationError{
  13019 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13020 			Snapshot: snapshot.Bytes(),
  13021 		}
  13022 	}
  13023 
  13024 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13025 	t, err = decoder.GetElement("Error")
  13026 	if err != nil {
  13027 		var snapshot bytes.Buffer
  13028 		io.Copy(&snapshot, ringBuffer)
  13029 		return &smithy.DeserializationError{
  13030 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13031 			Snapshot: snapshot.Bytes(),
  13032 		}
  13033 	}
  13034 
  13035 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13036 	err = awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(&output, decoder)
  13037 	if err != nil {
  13038 		var snapshot bytes.Buffer
  13039 		io.Copy(&snapshot, ringBuffer)
  13040 		return &smithy.DeserializationError{
  13041 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13042 			Snapshot: snapshot.Bytes(),
  13043 		}
  13044 	}
  13045 
  13046 	return output
  13047 }
  13048 
  13049 func awsRestxml_deserializeErrorNoSuchDelegationSet(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13050 	output := &types.NoSuchDelegationSet{}
  13051 	var buff [1024]byte
  13052 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13053 	body := io.TeeReader(errorBody, ringBuffer)
  13054 	rootDecoder := xml.NewDecoder(body)
  13055 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13056 	if err == io.EOF {
  13057 		return output
  13058 	}
  13059 	if err != nil {
  13060 		var snapshot bytes.Buffer
  13061 		io.Copy(&snapshot, ringBuffer)
  13062 		return &smithy.DeserializationError{
  13063 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13064 			Snapshot: snapshot.Bytes(),
  13065 		}
  13066 	}
  13067 
  13068 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13069 	t, err = decoder.GetElement("Error")
  13070 	if err != nil {
  13071 		var snapshot bytes.Buffer
  13072 		io.Copy(&snapshot, ringBuffer)
  13073 		return &smithy.DeserializationError{
  13074 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13075 			Snapshot: snapshot.Bytes(),
  13076 		}
  13077 	}
  13078 
  13079 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13080 	err = awsRestxml_deserializeDocumentNoSuchDelegationSet(&output, decoder)
  13081 	if err != nil {
  13082 		var snapshot bytes.Buffer
  13083 		io.Copy(&snapshot, ringBuffer)
  13084 		return &smithy.DeserializationError{
  13085 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13086 			Snapshot: snapshot.Bytes(),
  13087 		}
  13088 	}
  13089 
  13090 	return output
  13091 }
  13092 
  13093 func awsRestxml_deserializeErrorNoSuchGeoLocation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13094 	output := &types.NoSuchGeoLocation{}
  13095 	var buff [1024]byte
  13096 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13097 	body := io.TeeReader(errorBody, ringBuffer)
  13098 	rootDecoder := xml.NewDecoder(body)
  13099 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13100 	if err == io.EOF {
  13101 		return output
  13102 	}
  13103 	if err != nil {
  13104 		var snapshot bytes.Buffer
  13105 		io.Copy(&snapshot, ringBuffer)
  13106 		return &smithy.DeserializationError{
  13107 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13108 			Snapshot: snapshot.Bytes(),
  13109 		}
  13110 	}
  13111 
  13112 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13113 	t, err = decoder.GetElement("Error")
  13114 	if err != nil {
  13115 		var snapshot bytes.Buffer
  13116 		io.Copy(&snapshot, ringBuffer)
  13117 		return &smithy.DeserializationError{
  13118 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13119 			Snapshot: snapshot.Bytes(),
  13120 		}
  13121 	}
  13122 
  13123 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13124 	err = awsRestxml_deserializeDocumentNoSuchGeoLocation(&output, decoder)
  13125 	if err != nil {
  13126 		var snapshot bytes.Buffer
  13127 		io.Copy(&snapshot, ringBuffer)
  13128 		return &smithy.DeserializationError{
  13129 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13130 			Snapshot: snapshot.Bytes(),
  13131 		}
  13132 	}
  13133 
  13134 	return output
  13135 }
  13136 
  13137 func awsRestxml_deserializeErrorNoSuchHealthCheck(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13138 	output := &types.NoSuchHealthCheck{}
  13139 	var buff [1024]byte
  13140 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13141 	body := io.TeeReader(errorBody, ringBuffer)
  13142 	rootDecoder := xml.NewDecoder(body)
  13143 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13144 	if err == io.EOF {
  13145 		return output
  13146 	}
  13147 	if err != nil {
  13148 		var snapshot bytes.Buffer
  13149 		io.Copy(&snapshot, ringBuffer)
  13150 		return &smithy.DeserializationError{
  13151 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13152 			Snapshot: snapshot.Bytes(),
  13153 		}
  13154 	}
  13155 
  13156 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13157 	t, err = decoder.GetElement("Error")
  13158 	if err != nil {
  13159 		var snapshot bytes.Buffer
  13160 		io.Copy(&snapshot, ringBuffer)
  13161 		return &smithy.DeserializationError{
  13162 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13163 			Snapshot: snapshot.Bytes(),
  13164 		}
  13165 	}
  13166 
  13167 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13168 	err = awsRestxml_deserializeDocumentNoSuchHealthCheck(&output, decoder)
  13169 	if err != nil {
  13170 		var snapshot bytes.Buffer
  13171 		io.Copy(&snapshot, ringBuffer)
  13172 		return &smithy.DeserializationError{
  13173 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13174 			Snapshot: snapshot.Bytes(),
  13175 		}
  13176 	}
  13177 
  13178 	return output
  13179 }
  13180 
  13181 func awsRestxml_deserializeErrorNoSuchHostedZone(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13182 	output := &types.NoSuchHostedZone{}
  13183 	var buff [1024]byte
  13184 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13185 	body := io.TeeReader(errorBody, ringBuffer)
  13186 	rootDecoder := xml.NewDecoder(body)
  13187 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13188 	if err == io.EOF {
  13189 		return output
  13190 	}
  13191 	if err != nil {
  13192 		var snapshot bytes.Buffer
  13193 		io.Copy(&snapshot, ringBuffer)
  13194 		return &smithy.DeserializationError{
  13195 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13196 			Snapshot: snapshot.Bytes(),
  13197 		}
  13198 	}
  13199 
  13200 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13201 	t, err = decoder.GetElement("Error")
  13202 	if err != nil {
  13203 		var snapshot bytes.Buffer
  13204 		io.Copy(&snapshot, ringBuffer)
  13205 		return &smithy.DeserializationError{
  13206 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13207 			Snapshot: snapshot.Bytes(),
  13208 		}
  13209 	}
  13210 
  13211 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13212 	err = awsRestxml_deserializeDocumentNoSuchHostedZone(&output, decoder)
  13213 	if err != nil {
  13214 		var snapshot bytes.Buffer
  13215 		io.Copy(&snapshot, ringBuffer)
  13216 		return &smithy.DeserializationError{
  13217 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13218 			Snapshot: snapshot.Bytes(),
  13219 		}
  13220 	}
  13221 
  13222 	return output
  13223 }
  13224 
  13225 func awsRestxml_deserializeErrorNoSuchKeySigningKey(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13226 	output := &types.NoSuchKeySigningKey{}
  13227 	var buff [1024]byte
  13228 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13229 	body := io.TeeReader(errorBody, ringBuffer)
  13230 	rootDecoder := xml.NewDecoder(body)
  13231 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13232 	if err == io.EOF {
  13233 		return output
  13234 	}
  13235 	if err != nil {
  13236 		var snapshot bytes.Buffer
  13237 		io.Copy(&snapshot, ringBuffer)
  13238 		return &smithy.DeserializationError{
  13239 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13240 			Snapshot: snapshot.Bytes(),
  13241 		}
  13242 	}
  13243 
  13244 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13245 	t, err = decoder.GetElement("Error")
  13246 	if err != nil {
  13247 		var snapshot bytes.Buffer
  13248 		io.Copy(&snapshot, ringBuffer)
  13249 		return &smithy.DeserializationError{
  13250 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13251 			Snapshot: snapshot.Bytes(),
  13252 		}
  13253 	}
  13254 
  13255 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13256 	err = awsRestxml_deserializeDocumentNoSuchKeySigningKey(&output, decoder)
  13257 	if err != nil {
  13258 		var snapshot bytes.Buffer
  13259 		io.Copy(&snapshot, ringBuffer)
  13260 		return &smithy.DeserializationError{
  13261 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13262 			Snapshot: snapshot.Bytes(),
  13263 		}
  13264 	}
  13265 
  13266 	return output
  13267 }
  13268 
  13269 func awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13270 	output := &types.NoSuchQueryLoggingConfig{}
  13271 	var buff [1024]byte
  13272 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13273 	body := io.TeeReader(errorBody, ringBuffer)
  13274 	rootDecoder := xml.NewDecoder(body)
  13275 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13276 	if err == io.EOF {
  13277 		return output
  13278 	}
  13279 	if err != nil {
  13280 		var snapshot bytes.Buffer
  13281 		io.Copy(&snapshot, ringBuffer)
  13282 		return &smithy.DeserializationError{
  13283 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13284 			Snapshot: snapshot.Bytes(),
  13285 		}
  13286 	}
  13287 
  13288 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13289 	t, err = decoder.GetElement("Error")
  13290 	if err != nil {
  13291 		var snapshot bytes.Buffer
  13292 		io.Copy(&snapshot, ringBuffer)
  13293 		return &smithy.DeserializationError{
  13294 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13295 			Snapshot: snapshot.Bytes(),
  13296 		}
  13297 	}
  13298 
  13299 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13300 	err = awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(&output, decoder)
  13301 	if err != nil {
  13302 		var snapshot bytes.Buffer
  13303 		io.Copy(&snapshot, ringBuffer)
  13304 		return &smithy.DeserializationError{
  13305 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13306 			Snapshot: snapshot.Bytes(),
  13307 		}
  13308 	}
  13309 
  13310 	return output
  13311 }
  13312 
  13313 func awsRestxml_deserializeErrorNoSuchTrafficPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13314 	output := &types.NoSuchTrafficPolicy{}
  13315 	var buff [1024]byte
  13316 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13317 	body := io.TeeReader(errorBody, ringBuffer)
  13318 	rootDecoder := xml.NewDecoder(body)
  13319 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13320 	if err == io.EOF {
  13321 		return output
  13322 	}
  13323 	if err != nil {
  13324 		var snapshot bytes.Buffer
  13325 		io.Copy(&snapshot, ringBuffer)
  13326 		return &smithy.DeserializationError{
  13327 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13328 			Snapshot: snapshot.Bytes(),
  13329 		}
  13330 	}
  13331 
  13332 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13333 	t, err = decoder.GetElement("Error")
  13334 	if err != nil {
  13335 		var snapshot bytes.Buffer
  13336 		io.Copy(&snapshot, ringBuffer)
  13337 		return &smithy.DeserializationError{
  13338 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13339 			Snapshot: snapshot.Bytes(),
  13340 		}
  13341 	}
  13342 
  13343 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13344 	err = awsRestxml_deserializeDocumentNoSuchTrafficPolicy(&output, decoder)
  13345 	if err != nil {
  13346 		var snapshot bytes.Buffer
  13347 		io.Copy(&snapshot, ringBuffer)
  13348 		return &smithy.DeserializationError{
  13349 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13350 			Snapshot: snapshot.Bytes(),
  13351 		}
  13352 	}
  13353 
  13354 	return output
  13355 }
  13356 
  13357 func awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13358 	output := &types.NoSuchTrafficPolicyInstance{}
  13359 	var buff [1024]byte
  13360 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13361 	body := io.TeeReader(errorBody, ringBuffer)
  13362 	rootDecoder := xml.NewDecoder(body)
  13363 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13364 	if err == io.EOF {
  13365 		return output
  13366 	}
  13367 	if err != nil {
  13368 		var snapshot bytes.Buffer
  13369 		io.Copy(&snapshot, ringBuffer)
  13370 		return &smithy.DeserializationError{
  13371 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13372 			Snapshot: snapshot.Bytes(),
  13373 		}
  13374 	}
  13375 
  13376 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13377 	t, err = decoder.GetElement("Error")
  13378 	if err != nil {
  13379 		var snapshot bytes.Buffer
  13380 		io.Copy(&snapshot, ringBuffer)
  13381 		return &smithy.DeserializationError{
  13382 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13383 			Snapshot: snapshot.Bytes(),
  13384 		}
  13385 	}
  13386 
  13387 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13388 	err = awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(&output, decoder)
  13389 	if err != nil {
  13390 		var snapshot bytes.Buffer
  13391 		io.Copy(&snapshot, ringBuffer)
  13392 		return &smithy.DeserializationError{
  13393 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13394 			Snapshot: snapshot.Bytes(),
  13395 		}
  13396 	}
  13397 
  13398 	return output
  13399 }
  13400 
  13401 func awsRestxml_deserializeErrorNotAuthorizedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13402 	output := &types.NotAuthorizedException{}
  13403 	var buff [1024]byte
  13404 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13405 	body := io.TeeReader(errorBody, ringBuffer)
  13406 	rootDecoder := xml.NewDecoder(body)
  13407 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13408 	if err == io.EOF {
  13409 		return output
  13410 	}
  13411 	if err != nil {
  13412 		var snapshot bytes.Buffer
  13413 		io.Copy(&snapshot, ringBuffer)
  13414 		return &smithy.DeserializationError{
  13415 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13416 			Snapshot: snapshot.Bytes(),
  13417 		}
  13418 	}
  13419 
  13420 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13421 	t, err = decoder.GetElement("Error")
  13422 	if err != nil {
  13423 		var snapshot bytes.Buffer
  13424 		io.Copy(&snapshot, ringBuffer)
  13425 		return &smithy.DeserializationError{
  13426 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13427 			Snapshot: snapshot.Bytes(),
  13428 		}
  13429 	}
  13430 
  13431 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13432 	err = awsRestxml_deserializeDocumentNotAuthorizedException(&output, decoder)
  13433 	if err != nil {
  13434 		var snapshot bytes.Buffer
  13435 		io.Copy(&snapshot, ringBuffer)
  13436 		return &smithy.DeserializationError{
  13437 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13438 			Snapshot: snapshot.Bytes(),
  13439 		}
  13440 	}
  13441 
  13442 	return output
  13443 }
  13444 
  13445 func awsRestxml_deserializeErrorPriorRequestNotComplete(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13446 	output := &types.PriorRequestNotComplete{}
  13447 	var buff [1024]byte
  13448 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13449 	body := io.TeeReader(errorBody, ringBuffer)
  13450 	rootDecoder := xml.NewDecoder(body)
  13451 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13452 	if err == io.EOF {
  13453 		return output
  13454 	}
  13455 	if err != nil {
  13456 		var snapshot bytes.Buffer
  13457 		io.Copy(&snapshot, ringBuffer)
  13458 		return &smithy.DeserializationError{
  13459 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13460 			Snapshot: snapshot.Bytes(),
  13461 		}
  13462 	}
  13463 
  13464 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13465 	t, err = decoder.GetElement("Error")
  13466 	if err != nil {
  13467 		var snapshot bytes.Buffer
  13468 		io.Copy(&snapshot, ringBuffer)
  13469 		return &smithy.DeserializationError{
  13470 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13471 			Snapshot: snapshot.Bytes(),
  13472 		}
  13473 	}
  13474 
  13475 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13476 	err = awsRestxml_deserializeDocumentPriorRequestNotComplete(&output, decoder)
  13477 	if err != nil {
  13478 		var snapshot bytes.Buffer
  13479 		io.Copy(&snapshot, ringBuffer)
  13480 		return &smithy.DeserializationError{
  13481 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13482 			Snapshot: snapshot.Bytes(),
  13483 		}
  13484 	}
  13485 
  13486 	return output
  13487 }
  13488 
  13489 func awsRestxml_deserializeErrorPublicZoneVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13490 	output := &types.PublicZoneVPCAssociation{}
  13491 	var buff [1024]byte
  13492 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13493 	body := io.TeeReader(errorBody, ringBuffer)
  13494 	rootDecoder := xml.NewDecoder(body)
  13495 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13496 	if err == io.EOF {
  13497 		return output
  13498 	}
  13499 	if err != nil {
  13500 		var snapshot bytes.Buffer
  13501 		io.Copy(&snapshot, ringBuffer)
  13502 		return &smithy.DeserializationError{
  13503 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13504 			Snapshot: snapshot.Bytes(),
  13505 		}
  13506 	}
  13507 
  13508 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13509 	t, err = decoder.GetElement("Error")
  13510 	if err != nil {
  13511 		var snapshot bytes.Buffer
  13512 		io.Copy(&snapshot, ringBuffer)
  13513 		return &smithy.DeserializationError{
  13514 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13515 			Snapshot: snapshot.Bytes(),
  13516 		}
  13517 	}
  13518 
  13519 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13520 	err = awsRestxml_deserializeDocumentPublicZoneVPCAssociation(&output, decoder)
  13521 	if err != nil {
  13522 		var snapshot bytes.Buffer
  13523 		io.Copy(&snapshot, ringBuffer)
  13524 		return &smithy.DeserializationError{
  13525 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13526 			Snapshot: snapshot.Bytes(),
  13527 		}
  13528 	}
  13529 
  13530 	return output
  13531 }
  13532 
  13533 func awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13534 	output := &types.QueryLoggingConfigAlreadyExists{}
  13535 	var buff [1024]byte
  13536 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13537 	body := io.TeeReader(errorBody, ringBuffer)
  13538 	rootDecoder := xml.NewDecoder(body)
  13539 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13540 	if err == io.EOF {
  13541 		return output
  13542 	}
  13543 	if err != nil {
  13544 		var snapshot bytes.Buffer
  13545 		io.Copy(&snapshot, ringBuffer)
  13546 		return &smithy.DeserializationError{
  13547 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13548 			Snapshot: snapshot.Bytes(),
  13549 		}
  13550 	}
  13551 
  13552 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13553 	t, err = decoder.GetElement("Error")
  13554 	if err != nil {
  13555 		var snapshot bytes.Buffer
  13556 		io.Copy(&snapshot, ringBuffer)
  13557 		return &smithy.DeserializationError{
  13558 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13559 			Snapshot: snapshot.Bytes(),
  13560 		}
  13561 	}
  13562 
  13563 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13564 	err = awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(&output, decoder)
  13565 	if err != nil {
  13566 		var snapshot bytes.Buffer
  13567 		io.Copy(&snapshot, ringBuffer)
  13568 		return &smithy.DeserializationError{
  13569 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13570 			Snapshot: snapshot.Bytes(),
  13571 		}
  13572 	}
  13573 
  13574 	return output
  13575 }
  13576 
  13577 func awsRestxml_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13578 	output := &types.ThrottlingException{}
  13579 	var buff [1024]byte
  13580 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13581 	body := io.TeeReader(errorBody, ringBuffer)
  13582 	rootDecoder := xml.NewDecoder(body)
  13583 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13584 	if err == io.EOF {
  13585 		return output
  13586 	}
  13587 	if err != nil {
  13588 		var snapshot bytes.Buffer
  13589 		io.Copy(&snapshot, ringBuffer)
  13590 		return &smithy.DeserializationError{
  13591 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13592 			Snapshot: snapshot.Bytes(),
  13593 		}
  13594 	}
  13595 
  13596 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13597 	t, err = decoder.GetElement("Error")
  13598 	if err != nil {
  13599 		var snapshot bytes.Buffer
  13600 		io.Copy(&snapshot, ringBuffer)
  13601 		return &smithy.DeserializationError{
  13602 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13603 			Snapshot: snapshot.Bytes(),
  13604 		}
  13605 	}
  13606 
  13607 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13608 	err = awsRestxml_deserializeDocumentThrottlingException(&output, decoder)
  13609 	if err != nil {
  13610 		var snapshot bytes.Buffer
  13611 		io.Copy(&snapshot, ringBuffer)
  13612 		return &smithy.DeserializationError{
  13613 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13614 			Snapshot: snapshot.Bytes(),
  13615 		}
  13616 	}
  13617 
  13618 	return output
  13619 }
  13620 
  13621 func awsRestxml_deserializeErrorTooManyHealthChecks(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13622 	output := &types.TooManyHealthChecks{}
  13623 	var buff [1024]byte
  13624 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13625 	body := io.TeeReader(errorBody, ringBuffer)
  13626 	rootDecoder := xml.NewDecoder(body)
  13627 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13628 	if err == io.EOF {
  13629 		return output
  13630 	}
  13631 	if err != nil {
  13632 		var snapshot bytes.Buffer
  13633 		io.Copy(&snapshot, ringBuffer)
  13634 		return &smithy.DeserializationError{
  13635 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13636 			Snapshot: snapshot.Bytes(),
  13637 		}
  13638 	}
  13639 
  13640 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13641 	t, err = decoder.GetElement("Error")
  13642 	if err != nil {
  13643 		var snapshot bytes.Buffer
  13644 		io.Copy(&snapshot, ringBuffer)
  13645 		return &smithy.DeserializationError{
  13646 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13647 			Snapshot: snapshot.Bytes(),
  13648 		}
  13649 	}
  13650 
  13651 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13652 	err = awsRestxml_deserializeDocumentTooManyHealthChecks(&output, decoder)
  13653 	if err != nil {
  13654 		var snapshot bytes.Buffer
  13655 		io.Copy(&snapshot, ringBuffer)
  13656 		return &smithy.DeserializationError{
  13657 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13658 			Snapshot: snapshot.Bytes(),
  13659 		}
  13660 	}
  13661 
  13662 	return output
  13663 }
  13664 
  13665 func awsRestxml_deserializeErrorTooManyHostedZones(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13666 	output := &types.TooManyHostedZones{}
  13667 	var buff [1024]byte
  13668 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13669 	body := io.TeeReader(errorBody, ringBuffer)
  13670 	rootDecoder := xml.NewDecoder(body)
  13671 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13672 	if err == io.EOF {
  13673 		return output
  13674 	}
  13675 	if err != nil {
  13676 		var snapshot bytes.Buffer
  13677 		io.Copy(&snapshot, ringBuffer)
  13678 		return &smithy.DeserializationError{
  13679 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13680 			Snapshot: snapshot.Bytes(),
  13681 		}
  13682 	}
  13683 
  13684 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13685 	t, err = decoder.GetElement("Error")
  13686 	if err != nil {
  13687 		var snapshot bytes.Buffer
  13688 		io.Copy(&snapshot, ringBuffer)
  13689 		return &smithy.DeserializationError{
  13690 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13691 			Snapshot: snapshot.Bytes(),
  13692 		}
  13693 	}
  13694 
  13695 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13696 	err = awsRestxml_deserializeDocumentTooManyHostedZones(&output, decoder)
  13697 	if err != nil {
  13698 		var snapshot bytes.Buffer
  13699 		io.Copy(&snapshot, ringBuffer)
  13700 		return &smithy.DeserializationError{
  13701 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13702 			Snapshot: snapshot.Bytes(),
  13703 		}
  13704 	}
  13705 
  13706 	return output
  13707 }
  13708 
  13709 func awsRestxml_deserializeErrorTooManyKeySigningKeys(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13710 	output := &types.TooManyKeySigningKeys{}
  13711 	var buff [1024]byte
  13712 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13713 	body := io.TeeReader(errorBody, ringBuffer)
  13714 	rootDecoder := xml.NewDecoder(body)
  13715 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13716 	if err == io.EOF {
  13717 		return output
  13718 	}
  13719 	if err != nil {
  13720 		var snapshot bytes.Buffer
  13721 		io.Copy(&snapshot, ringBuffer)
  13722 		return &smithy.DeserializationError{
  13723 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13724 			Snapshot: snapshot.Bytes(),
  13725 		}
  13726 	}
  13727 
  13728 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13729 	t, err = decoder.GetElement("Error")
  13730 	if err != nil {
  13731 		var snapshot bytes.Buffer
  13732 		io.Copy(&snapshot, ringBuffer)
  13733 		return &smithy.DeserializationError{
  13734 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13735 			Snapshot: snapshot.Bytes(),
  13736 		}
  13737 	}
  13738 
  13739 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13740 	err = awsRestxml_deserializeDocumentTooManyKeySigningKeys(&output, decoder)
  13741 	if err != nil {
  13742 		var snapshot bytes.Buffer
  13743 		io.Copy(&snapshot, ringBuffer)
  13744 		return &smithy.DeserializationError{
  13745 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13746 			Snapshot: snapshot.Bytes(),
  13747 		}
  13748 	}
  13749 
  13750 	return output
  13751 }
  13752 
  13753 func awsRestxml_deserializeErrorTooManyTrafficPolicies(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13754 	output := &types.TooManyTrafficPolicies{}
  13755 	var buff [1024]byte
  13756 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13757 	body := io.TeeReader(errorBody, ringBuffer)
  13758 	rootDecoder := xml.NewDecoder(body)
  13759 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13760 	if err == io.EOF {
  13761 		return output
  13762 	}
  13763 	if err != nil {
  13764 		var snapshot bytes.Buffer
  13765 		io.Copy(&snapshot, ringBuffer)
  13766 		return &smithy.DeserializationError{
  13767 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13768 			Snapshot: snapshot.Bytes(),
  13769 		}
  13770 	}
  13771 
  13772 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13773 	t, err = decoder.GetElement("Error")
  13774 	if err != nil {
  13775 		var snapshot bytes.Buffer
  13776 		io.Copy(&snapshot, ringBuffer)
  13777 		return &smithy.DeserializationError{
  13778 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13779 			Snapshot: snapshot.Bytes(),
  13780 		}
  13781 	}
  13782 
  13783 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13784 	err = awsRestxml_deserializeDocumentTooManyTrafficPolicies(&output, decoder)
  13785 	if err != nil {
  13786 		var snapshot bytes.Buffer
  13787 		io.Copy(&snapshot, ringBuffer)
  13788 		return &smithy.DeserializationError{
  13789 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13790 			Snapshot: snapshot.Bytes(),
  13791 		}
  13792 	}
  13793 
  13794 	return output
  13795 }
  13796 
  13797 func awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13798 	output := &types.TooManyTrafficPolicyInstances{}
  13799 	var buff [1024]byte
  13800 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13801 	body := io.TeeReader(errorBody, ringBuffer)
  13802 	rootDecoder := xml.NewDecoder(body)
  13803 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13804 	if err == io.EOF {
  13805 		return output
  13806 	}
  13807 	if err != nil {
  13808 		var snapshot bytes.Buffer
  13809 		io.Copy(&snapshot, ringBuffer)
  13810 		return &smithy.DeserializationError{
  13811 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13812 			Snapshot: snapshot.Bytes(),
  13813 		}
  13814 	}
  13815 
  13816 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13817 	t, err = decoder.GetElement("Error")
  13818 	if err != nil {
  13819 		var snapshot bytes.Buffer
  13820 		io.Copy(&snapshot, ringBuffer)
  13821 		return &smithy.DeserializationError{
  13822 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13823 			Snapshot: snapshot.Bytes(),
  13824 		}
  13825 	}
  13826 
  13827 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13828 	err = awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(&output, decoder)
  13829 	if err != nil {
  13830 		var snapshot bytes.Buffer
  13831 		io.Copy(&snapshot, ringBuffer)
  13832 		return &smithy.DeserializationError{
  13833 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13834 			Snapshot: snapshot.Bytes(),
  13835 		}
  13836 	}
  13837 
  13838 	return output
  13839 }
  13840 
  13841 func awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13842 	output := &types.TooManyTrafficPolicyVersionsForCurrentPolicy{}
  13843 	var buff [1024]byte
  13844 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13845 	body := io.TeeReader(errorBody, ringBuffer)
  13846 	rootDecoder := xml.NewDecoder(body)
  13847 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13848 	if err == io.EOF {
  13849 		return output
  13850 	}
  13851 	if err != nil {
  13852 		var snapshot bytes.Buffer
  13853 		io.Copy(&snapshot, ringBuffer)
  13854 		return &smithy.DeserializationError{
  13855 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13856 			Snapshot: snapshot.Bytes(),
  13857 		}
  13858 	}
  13859 
  13860 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13861 	t, err = decoder.GetElement("Error")
  13862 	if err != nil {
  13863 		var snapshot bytes.Buffer
  13864 		io.Copy(&snapshot, ringBuffer)
  13865 		return &smithy.DeserializationError{
  13866 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13867 			Snapshot: snapshot.Bytes(),
  13868 		}
  13869 	}
  13870 
  13871 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13872 	err = awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(&output, decoder)
  13873 	if err != nil {
  13874 		var snapshot bytes.Buffer
  13875 		io.Copy(&snapshot, ringBuffer)
  13876 		return &smithy.DeserializationError{
  13877 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13878 			Snapshot: snapshot.Bytes(),
  13879 		}
  13880 	}
  13881 
  13882 	return output
  13883 }
  13884 
  13885 func awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13886 	output := &types.TooManyVPCAssociationAuthorizations{}
  13887 	var buff [1024]byte
  13888 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13889 	body := io.TeeReader(errorBody, ringBuffer)
  13890 	rootDecoder := xml.NewDecoder(body)
  13891 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13892 	if err == io.EOF {
  13893 		return output
  13894 	}
  13895 	if err != nil {
  13896 		var snapshot bytes.Buffer
  13897 		io.Copy(&snapshot, ringBuffer)
  13898 		return &smithy.DeserializationError{
  13899 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13900 			Snapshot: snapshot.Bytes(),
  13901 		}
  13902 	}
  13903 
  13904 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13905 	t, err = decoder.GetElement("Error")
  13906 	if err != nil {
  13907 		var snapshot bytes.Buffer
  13908 		io.Copy(&snapshot, ringBuffer)
  13909 		return &smithy.DeserializationError{
  13910 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13911 			Snapshot: snapshot.Bytes(),
  13912 		}
  13913 	}
  13914 
  13915 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13916 	err = awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(&output, decoder)
  13917 	if err != nil {
  13918 		var snapshot bytes.Buffer
  13919 		io.Copy(&snapshot, ringBuffer)
  13920 		return &smithy.DeserializationError{
  13921 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13922 			Snapshot: snapshot.Bytes(),
  13923 		}
  13924 	}
  13925 
  13926 	return output
  13927 }
  13928 
  13929 func awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13930 	output := &types.TrafficPolicyAlreadyExists{}
  13931 	var buff [1024]byte
  13932 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13933 	body := io.TeeReader(errorBody, ringBuffer)
  13934 	rootDecoder := xml.NewDecoder(body)
  13935 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13936 	if err == io.EOF {
  13937 		return output
  13938 	}
  13939 	if err != nil {
  13940 		var snapshot bytes.Buffer
  13941 		io.Copy(&snapshot, ringBuffer)
  13942 		return &smithy.DeserializationError{
  13943 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13944 			Snapshot: snapshot.Bytes(),
  13945 		}
  13946 	}
  13947 
  13948 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13949 	t, err = decoder.GetElement("Error")
  13950 	if err != nil {
  13951 		var snapshot bytes.Buffer
  13952 		io.Copy(&snapshot, ringBuffer)
  13953 		return &smithy.DeserializationError{
  13954 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13955 			Snapshot: snapshot.Bytes(),
  13956 		}
  13957 	}
  13958 
  13959 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13960 	err = awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(&output, decoder)
  13961 	if err != nil {
  13962 		var snapshot bytes.Buffer
  13963 		io.Copy(&snapshot, ringBuffer)
  13964 		return &smithy.DeserializationError{
  13965 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13966 			Snapshot: snapshot.Bytes(),
  13967 		}
  13968 	}
  13969 
  13970 	return output
  13971 }
  13972 
  13973 func awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13974 	output := &types.TrafficPolicyInstanceAlreadyExists{}
  13975 	var buff [1024]byte
  13976 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13977 	body := io.TeeReader(errorBody, ringBuffer)
  13978 	rootDecoder := xml.NewDecoder(body)
  13979 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13980 	if err == io.EOF {
  13981 		return output
  13982 	}
  13983 	if err != nil {
  13984 		var snapshot bytes.Buffer
  13985 		io.Copy(&snapshot, ringBuffer)
  13986 		return &smithy.DeserializationError{
  13987 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13988 			Snapshot: snapshot.Bytes(),
  13989 		}
  13990 	}
  13991 
  13992 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13993 	t, err = decoder.GetElement("Error")
  13994 	if err != nil {
  13995 		var snapshot bytes.Buffer
  13996 		io.Copy(&snapshot, ringBuffer)
  13997 		return &smithy.DeserializationError{
  13998 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13999 			Snapshot: snapshot.Bytes(),
  14000 		}
  14001 	}
  14002 
  14003 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14004 	err = awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(&output, decoder)
  14005 	if err != nil {
  14006 		var snapshot bytes.Buffer
  14007 		io.Copy(&snapshot, ringBuffer)
  14008 		return &smithy.DeserializationError{
  14009 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14010 			Snapshot: snapshot.Bytes(),
  14011 		}
  14012 	}
  14013 
  14014 	return output
  14015 }
  14016 
  14017 func awsRestxml_deserializeErrorTrafficPolicyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14018 	output := &types.TrafficPolicyInUse{}
  14019 	var buff [1024]byte
  14020 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14021 	body := io.TeeReader(errorBody, ringBuffer)
  14022 	rootDecoder := xml.NewDecoder(body)
  14023 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14024 	if err == io.EOF {
  14025 		return output
  14026 	}
  14027 	if err != nil {
  14028 		var snapshot bytes.Buffer
  14029 		io.Copy(&snapshot, ringBuffer)
  14030 		return &smithy.DeserializationError{
  14031 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14032 			Snapshot: snapshot.Bytes(),
  14033 		}
  14034 	}
  14035 
  14036 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14037 	t, err = decoder.GetElement("Error")
  14038 	if err != nil {
  14039 		var snapshot bytes.Buffer
  14040 		io.Copy(&snapshot, ringBuffer)
  14041 		return &smithy.DeserializationError{
  14042 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14043 			Snapshot: snapshot.Bytes(),
  14044 		}
  14045 	}
  14046 
  14047 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14048 	err = awsRestxml_deserializeDocumentTrafficPolicyInUse(&output, decoder)
  14049 	if err != nil {
  14050 		var snapshot bytes.Buffer
  14051 		io.Copy(&snapshot, ringBuffer)
  14052 		return &smithy.DeserializationError{
  14053 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14054 			Snapshot: snapshot.Bytes(),
  14055 		}
  14056 	}
  14057 
  14058 	return output
  14059 }
  14060 
  14061 func awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14062 	output := &types.VPCAssociationAuthorizationNotFound{}
  14063 	var buff [1024]byte
  14064 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14065 	body := io.TeeReader(errorBody, ringBuffer)
  14066 	rootDecoder := xml.NewDecoder(body)
  14067 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14068 	if err == io.EOF {
  14069 		return output
  14070 	}
  14071 	if err != nil {
  14072 		var snapshot bytes.Buffer
  14073 		io.Copy(&snapshot, ringBuffer)
  14074 		return &smithy.DeserializationError{
  14075 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14076 			Snapshot: snapshot.Bytes(),
  14077 		}
  14078 	}
  14079 
  14080 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14081 	t, err = decoder.GetElement("Error")
  14082 	if err != nil {
  14083 		var snapshot bytes.Buffer
  14084 		io.Copy(&snapshot, ringBuffer)
  14085 		return &smithy.DeserializationError{
  14086 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14087 			Snapshot: snapshot.Bytes(),
  14088 		}
  14089 	}
  14090 
  14091 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14092 	err = awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(&output, decoder)
  14093 	if err != nil {
  14094 		var snapshot bytes.Buffer
  14095 		io.Copy(&snapshot, ringBuffer)
  14096 		return &smithy.DeserializationError{
  14097 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14098 			Snapshot: snapshot.Bytes(),
  14099 		}
  14100 	}
  14101 
  14102 	return output
  14103 }
  14104 
  14105 func awsRestxml_deserializeErrorVPCAssociationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  14106 	output := &types.VPCAssociationNotFound{}
  14107 	var buff [1024]byte
  14108 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  14109 	body := io.TeeReader(errorBody, ringBuffer)
  14110 	rootDecoder := xml.NewDecoder(body)
  14111 	t, err := smithyxml.FetchRootElement(rootDecoder)
  14112 	if err == io.EOF {
  14113 		return output
  14114 	}
  14115 	if err != nil {
  14116 		var snapshot bytes.Buffer
  14117 		io.Copy(&snapshot, ringBuffer)
  14118 		return &smithy.DeserializationError{
  14119 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14120 			Snapshot: snapshot.Bytes(),
  14121 		}
  14122 	}
  14123 
  14124 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  14125 	t, err = decoder.GetElement("Error")
  14126 	if err != nil {
  14127 		var snapshot bytes.Buffer
  14128 		io.Copy(&snapshot, ringBuffer)
  14129 		return &smithy.DeserializationError{
  14130 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14131 			Snapshot: snapshot.Bytes(),
  14132 		}
  14133 	}
  14134 
  14135 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14136 	err = awsRestxml_deserializeDocumentVPCAssociationNotFound(&output, decoder)
  14137 	if err != nil {
  14138 		var snapshot bytes.Buffer
  14139 		io.Copy(&snapshot, ringBuffer)
  14140 		return &smithy.DeserializationError{
  14141 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  14142 			Snapshot: snapshot.Bytes(),
  14143 		}
  14144 	}
  14145 
  14146 	return output
  14147 }
  14148 
  14149 func awsRestxml_deserializeDocumentAccountLimit(v **types.AccountLimit, decoder smithyxml.NodeDecoder) error {
  14150 	if v == nil {
  14151 		return fmt.Errorf("unexpected nil of type %T", v)
  14152 	}
  14153 	var sv *types.AccountLimit
  14154 	if *v == nil {
  14155 		sv = &types.AccountLimit{}
  14156 	} else {
  14157 		sv = *v
  14158 	}
  14159 
  14160 	for {
  14161 		t, done, err := decoder.Token()
  14162 		if err != nil {
  14163 			return err
  14164 		}
  14165 		if done {
  14166 			break
  14167 		}
  14168 		originalDecoder := decoder
  14169 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14170 		switch {
  14171 		case strings.EqualFold("Type", t.Name.Local):
  14172 			val, err := decoder.Value()
  14173 			if err != nil {
  14174 				return err
  14175 			}
  14176 			if val == nil {
  14177 				break
  14178 			}
  14179 			{
  14180 				xtv := string(val)
  14181 				sv.Type = types.AccountLimitType(xtv)
  14182 			}
  14183 
  14184 		case strings.EqualFold("Value", t.Name.Local):
  14185 			val, err := decoder.Value()
  14186 			if err != nil {
  14187 				return err
  14188 			}
  14189 			if val == nil {
  14190 				break
  14191 			}
  14192 			{
  14193 				xtv := string(val)
  14194 				i64, err := strconv.ParseInt(xtv, 10, 64)
  14195 				if err != nil {
  14196 					return err
  14197 				}
  14198 				sv.Value = ptr.Int64(i64)
  14199 			}
  14200 
  14201 		default:
  14202 			// Do nothing and ignore the unexpected tag element
  14203 			err = decoder.Decoder.Skip()
  14204 			if err != nil {
  14205 				return err
  14206 			}
  14207 
  14208 		}
  14209 		decoder = originalDecoder
  14210 	}
  14211 	*v = sv
  14212 	return nil
  14213 }
  14214 
  14215 func awsRestxml_deserializeDocumentAlarmIdentifier(v **types.AlarmIdentifier, decoder smithyxml.NodeDecoder) error {
  14216 	if v == nil {
  14217 		return fmt.Errorf("unexpected nil of type %T", v)
  14218 	}
  14219 	var sv *types.AlarmIdentifier
  14220 	if *v == nil {
  14221 		sv = &types.AlarmIdentifier{}
  14222 	} else {
  14223 		sv = *v
  14224 	}
  14225 
  14226 	for {
  14227 		t, done, err := decoder.Token()
  14228 		if err != nil {
  14229 			return err
  14230 		}
  14231 		if done {
  14232 			break
  14233 		}
  14234 		originalDecoder := decoder
  14235 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14236 		switch {
  14237 		case strings.EqualFold("Name", t.Name.Local):
  14238 			val, err := decoder.Value()
  14239 			if err != nil {
  14240 				return err
  14241 			}
  14242 			if val == nil {
  14243 				break
  14244 			}
  14245 			{
  14246 				xtv := string(val)
  14247 				sv.Name = ptr.String(xtv)
  14248 			}
  14249 
  14250 		case strings.EqualFold("Region", t.Name.Local):
  14251 			val, err := decoder.Value()
  14252 			if err != nil {
  14253 				return err
  14254 			}
  14255 			if val == nil {
  14256 				break
  14257 			}
  14258 			{
  14259 				xtv := string(val)
  14260 				sv.Region = types.CloudWatchRegion(xtv)
  14261 			}
  14262 
  14263 		default:
  14264 			// Do nothing and ignore the unexpected tag element
  14265 			err = decoder.Decoder.Skip()
  14266 			if err != nil {
  14267 				return err
  14268 			}
  14269 
  14270 		}
  14271 		decoder = originalDecoder
  14272 	}
  14273 	*v = sv
  14274 	return nil
  14275 }
  14276 
  14277 func awsRestxml_deserializeDocumentAliasTarget(v **types.AliasTarget, decoder smithyxml.NodeDecoder) error {
  14278 	if v == nil {
  14279 		return fmt.Errorf("unexpected nil of type %T", v)
  14280 	}
  14281 	var sv *types.AliasTarget
  14282 	if *v == nil {
  14283 		sv = &types.AliasTarget{}
  14284 	} else {
  14285 		sv = *v
  14286 	}
  14287 
  14288 	for {
  14289 		t, done, err := decoder.Token()
  14290 		if err != nil {
  14291 			return err
  14292 		}
  14293 		if done {
  14294 			break
  14295 		}
  14296 		originalDecoder := decoder
  14297 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14298 		switch {
  14299 		case strings.EqualFold("DNSName", t.Name.Local):
  14300 			val, err := decoder.Value()
  14301 			if err != nil {
  14302 				return err
  14303 			}
  14304 			if val == nil {
  14305 				break
  14306 			}
  14307 			{
  14308 				xtv := string(val)
  14309 				sv.DNSName = ptr.String(xtv)
  14310 			}
  14311 
  14312 		case strings.EqualFold("EvaluateTargetHealth", t.Name.Local):
  14313 			val, err := decoder.Value()
  14314 			if err != nil {
  14315 				return err
  14316 			}
  14317 			if val == nil {
  14318 				break
  14319 			}
  14320 			{
  14321 				xtv, err := strconv.ParseBool(string(val))
  14322 				if err != nil {
  14323 					return fmt.Errorf("expected AliasHealthEnabled to be of type *bool, got %T instead", val)
  14324 				}
  14325 				sv.EvaluateTargetHealth = xtv
  14326 			}
  14327 
  14328 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  14329 			val, err := decoder.Value()
  14330 			if err != nil {
  14331 				return err
  14332 			}
  14333 			if val == nil {
  14334 				break
  14335 			}
  14336 			{
  14337 				xtv := string(val)
  14338 				sv.HostedZoneId = ptr.String(xtv)
  14339 			}
  14340 
  14341 		default:
  14342 			// Do nothing and ignore the unexpected tag element
  14343 			err = decoder.Decoder.Skip()
  14344 			if err != nil {
  14345 				return err
  14346 			}
  14347 
  14348 		}
  14349 		decoder = originalDecoder
  14350 	}
  14351 	*v = sv
  14352 	return nil
  14353 }
  14354 
  14355 func awsRestxml_deserializeDocumentChangeInfo(v **types.ChangeInfo, decoder smithyxml.NodeDecoder) error {
  14356 	if v == nil {
  14357 		return fmt.Errorf("unexpected nil of type %T", v)
  14358 	}
  14359 	var sv *types.ChangeInfo
  14360 	if *v == nil {
  14361 		sv = &types.ChangeInfo{}
  14362 	} else {
  14363 		sv = *v
  14364 	}
  14365 
  14366 	for {
  14367 		t, done, err := decoder.Token()
  14368 		if err != nil {
  14369 			return err
  14370 		}
  14371 		if done {
  14372 			break
  14373 		}
  14374 		originalDecoder := decoder
  14375 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14376 		switch {
  14377 		case strings.EqualFold("Comment", t.Name.Local):
  14378 			val, err := decoder.Value()
  14379 			if err != nil {
  14380 				return err
  14381 			}
  14382 			if val == nil {
  14383 				break
  14384 			}
  14385 			{
  14386 				xtv := string(val)
  14387 				sv.Comment = ptr.String(xtv)
  14388 			}
  14389 
  14390 		case strings.EqualFold("Id", t.Name.Local):
  14391 			val, err := decoder.Value()
  14392 			if err != nil {
  14393 				return err
  14394 			}
  14395 			if val == nil {
  14396 				break
  14397 			}
  14398 			{
  14399 				xtv := string(val)
  14400 				sv.Id = ptr.String(xtv)
  14401 			}
  14402 
  14403 		case strings.EqualFold("Status", t.Name.Local):
  14404 			val, err := decoder.Value()
  14405 			if err != nil {
  14406 				return err
  14407 			}
  14408 			if val == nil {
  14409 				break
  14410 			}
  14411 			{
  14412 				xtv := string(val)
  14413 				sv.Status = types.ChangeStatus(xtv)
  14414 			}
  14415 
  14416 		case strings.EqualFold("SubmittedAt", t.Name.Local):
  14417 			val, err := decoder.Value()
  14418 			if err != nil {
  14419 				return err
  14420 			}
  14421 			if val == nil {
  14422 				break
  14423 			}
  14424 			{
  14425 				xtv := string(val)
  14426 				t, err := smithytime.ParseDateTime(xtv)
  14427 				if err != nil {
  14428 					return err
  14429 				}
  14430 				sv.SubmittedAt = ptr.Time(t)
  14431 			}
  14432 
  14433 		default:
  14434 			// Do nothing and ignore the unexpected tag element
  14435 			err = decoder.Decoder.Skip()
  14436 			if err != nil {
  14437 				return err
  14438 			}
  14439 
  14440 		}
  14441 		decoder = originalDecoder
  14442 	}
  14443 	*v = sv
  14444 	return nil
  14445 }
  14446 
  14447 func awsRestxml_deserializeDocumentCheckerIpRanges(v *[]string, decoder smithyxml.NodeDecoder) error {
  14448 	if v == nil {
  14449 		return fmt.Errorf("unexpected nil of type %T", v)
  14450 	}
  14451 	var sv []string
  14452 	if *v == nil {
  14453 		sv = make([]string, 0)
  14454 	} else {
  14455 		sv = *v
  14456 	}
  14457 
  14458 	originalDecoder := decoder
  14459 	for {
  14460 		t, done, err := decoder.Token()
  14461 		if err != nil {
  14462 			return err
  14463 		}
  14464 		if done {
  14465 			break
  14466 		}
  14467 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14468 		decoder = memberDecoder
  14469 		switch {
  14470 		case strings.EqualFold("member", t.Name.Local):
  14471 			var col string
  14472 			val, err := decoder.Value()
  14473 			if err != nil {
  14474 				return err
  14475 			}
  14476 			if val == nil {
  14477 				break
  14478 			}
  14479 			{
  14480 				xtv := string(val)
  14481 				col = xtv
  14482 			}
  14483 			sv = append(sv, col)
  14484 
  14485 		default:
  14486 			err = decoder.Decoder.Skip()
  14487 			if err != nil {
  14488 				return err
  14489 			}
  14490 
  14491 		}
  14492 		decoder = originalDecoder
  14493 	}
  14494 	*v = sv
  14495 	return nil
  14496 }
  14497 
  14498 func awsRestxml_deserializeDocumentCheckerIpRangesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  14499 	var sv []string
  14500 	if *v == nil {
  14501 		sv = make([]string, 0)
  14502 	} else {
  14503 		sv = *v
  14504 	}
  14505 
  14506 	switch {
  14507 	default:
  14508 		var mv string
  14509 		t := decoder.StartEl
  14510 		_ = t
  14511 		val, err := decoder.Value()
  14512 		if err != nil {
  14513 			return err
  14514 		}
  14515 		if val == nil {
  14516 			break
  14517 		}
  14518 		{
  14519 			xtv := string(val)
  14520 			mv = xtv
  14521 		}
  14522 		sv = append(sv, mv)
  14523 	}
  14524 	*v = sv
  14525 	return nil
  14526 }
  14527 func awsRestxml_deserializeDocumentChildHealthCheckList(v *[]string, decoder smithyxml.NodeDecoder) error {
  14528 	if v == nil {
  14529 		return fmt.Errorf("unexpected nil of type %T", v)
  14530 	}
  14531 	var sv []string
  14532 	if *v == nil {
  14533 		sv = make([]string, 0)
  14534 	} else {
  14535 		sv = *v
  14536 	}
  14537 
  14538 	originalDecoder := decoder
  14539 	for {
  14540 		t, done, err := decoder.Token()
  14541 		if err != nil {
  14542 			return err
  14543 		}
  14544 		if done {
  14545 			break
  14546 		}
  14547 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14548 		decoder = memberDecoder
  14549 		switch {
  14550 		case strings.EqualFold("ChildHealthCheck", t.Name.Local):
  14551 			var col string
  14552 			val, err := decoder.Value()
  14553 			if err != nil {
  14554 				return err
  14555 			}
  14556 			if val == nil {
  14557 				break
  14558 			}
  14559 			{
  14560 				xtv := string(val)
  14561 				col = xtv
  14562 			}
  14563 			sv = append(sv, col)
  14564 
  14565 		default:
  14566 			err = decoder.Decoder.Skip()
  14567 			if err != nil {
  14568 				return err
  14569 			}
  14570 
  14571 		}
  14572 		decoder = originalDecoder
  14573 	}
  14574 	*v = sv
  14575 	return nil
  14576 }
  14577 
  14578 func awsRestxml_deserializeDocumentChildHealthCheckListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  14579 	var sv []string
  14580 	if *v == nil {
  14581 		sv = make([]string, 0)
  14582 	} else {
  14583 		sv = *v
  14584 	}
  14585 
  14586 	switch {
  14587 	default:
  14588 		var mv string
  14589 		t := decoder.StartEl
  14590 		_ = t
  14591 		val, err := decoder.Value()
  14592 		if err != nil {
  14593 			return err
  14594 		}
  14595 		if val == nil {
  14596 			break
  14597 		}
  14598 		{
  14599 			xtv := string(val)
  14600 			mv = xtv
  14601 		}
  14602 		sv = append(sv, mv)
  14603 	}
  14604 	*v = sv
  14605 	return nil
  14606 }
  14607 func awsRestxml_deserializeDocumentCidrBlockInUseException(v **types.CidrBlockInUseException, decoder smithyxml.NodeDecoder) error {
  14608 	if v == nil {
  14609 		return fmt.Errorf("unexpected nil of type %T", v)
  14610 	}
  14611 	var sv *types.CidrBlockInUseException
  14612 	if *v == nil {
  14613 		sv = &types.CidrBlockInUseException{}
  14614 	} else {
  14615 		sv = *v
  14616 	}
  14617 
  14618 	for {
  14619 		t, done, err := decoder.Token()
  14620 		if err != nil {
  14621 			return err
  14622 		}
  14623 		if done {
  14624 			break
  14625 		}
  14626 		originalDecoder := decoder
  14627 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14628 		switch {
  14629 		case strings.EqualFold("Message", t.Name.Local):
  14630 			val, err := decoder.Value()
  14631 			if err != nil {
  14632 				return err
  14633 			}
  14634 			if val == nil {
  14635 				break
  14636 			}
  14637 			{
  14638 				xtv := string(val)
  14639 				sv.Message = ptr.String(xtv)
  14640 			}
  14641 
  14642 		default:
  14643 			// Do nothing and ignore the unexpected tag element
  14644 			err = decoder.Decoder.Skip()
  14645 			if err != nil {
  14646 				return err
  14647 			}
  14648 
  14649 		}
  14650 		decoder = originalDecoder
  14651 	}
  14652 	*v = sv
  14653 	return nil
  14654 }
  14655 
  14656 func awsRestxml_deserializeDocumentCidrBlockSummaries(v *[]types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
  14657 	if v == nil {
  14658 		return fmt.Errorf("unexpected nil of type %T", v)
  14659 	}
  14660 	var sv []types.CidrBlockSummary
  14661 	if *v == nil {
  14662 		sv = make([]types.CidrBlockSummary, 0)
  14663 	} else {
  14664 		sv = *v
  14665 	}
  14666 
  14667 	originalDecoder := decoder
  14668 	for {
  14669 		t, done, err := decoder.Token()
  14670 		if err != nil {
  14671 			return err
  14672 		}
  14673 		if done {
  14674 			break
  14675 		}
  14676 		switch {
  14677 		case strings.EqualFold("member", t.Name.Local):
  14678 			var col types.CidrBlockSummary
  14679 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14680 			destAddr := &col
  14681 			if err := awsRestxml_deserializeDocumentCidrBlockSummary(&destAddr, nodeDecoder); err != nil {
  14682 				return err
  14683 			}
  14684 			col = *destAddr
  14685 			sv = append(sv, col)
  14686 
  14687 		default:
  14688 			err = decoder.Decoder.Skip()
  14689 			if err != nil {
  14690 				return err
  14691 			}
  14692 
  14693 		}
  14694 		decoder = originalDecoder
  14695 	}
  14696 	*v = sv
  14697 	return nil
  14698 }
  14699 
  14700 func awsRestxml_deserializeDocumentCidrBlockSummariesUnwrapped(v *[]types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
  14701 	var sv []types.CidrBlockSummary
  14702 	if *v == nil {
  14703 		sv = make([]types.CidrBlockSummary, 0)
  14704 	} else {
  14705 		sv = *v
  14706 	}
  14707 
  14708 	switch {
  14709 	default:
  14710 		var mv types.CidrBlockSummary
  14711 		t := decoder.StartEl
  14712 		_ = t
  14713 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14714 		destAddr := &mv
  14715 		if err := awsRestxml_deserializeDocumentCidrBlockSummary(&destAddr, nodeDecoder); err != nil {
  14716 			return err
  14717 		}
  14718 		mv = *destAddr
  14719 		sv = append(sv, mv)
  14720 	}
  14721 	*v = sv
  14722 	return nil
  14723 }
  14724 func awsRestxml_deserializeDocumentCidrBlockSummary(v **types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
  14725 	if v == nil {
  14726 		return fmt.Errorf("unexpected nil of type %T", v)
  14727 	}
  14728 	var sv *types.CidrBlockSummary
  14729 	if *v == nil {
  14730 		sv = &types.CidrBlockSummary{}
  14731 	} else {
  14732 		sv = *v
  14733 	}
  14734 
  14735 	for {
  14736 		t, done, err := decoder.Token()
  14737 		if err != nil {
  14738 			return err
  14739 		}
  14740 		if done {
  14741 			break
  14742 		}
  14743 		originalDecoder := decoder
  14744 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14745 		switch {
  14746 		case strings.EqualFold("CidrBlock", t.Name.Local):
  14747 			val, err := decoder.Value()
  14748 			if err != nil {
  14749 				return err
  14750 			}
  14751 			if val == nil {
  14752 				break
  14753 			}
  14754 			{
  14755 				xtv := string(val)
  14756 				sv.CidrBlock = ptr.String(xtv)
  14757 			}
  14758 
  14759 		case strings.EqualFold("LocationName", t.Name.Local):
  14760 			val, err := decoder.Value()
  14761 			if err != nil {
  14762 				return err
  14763 			}
  14764 			if val == nil {
  14765 				break
  14766 			}
  14767 			{
  14768 				xtv := string(val)
  14769 				sv.LocationName = ptr.String(xtv)
  14770 			}
  14771 
  14772 		default:
  14773 			// Do nothing and ignore the unexpected tag element
  14774 			err = decoder.Decoder.Skip()
  14775 			if err != nil {
  14776 				return err
  14777 			}
  14778 
  14779 		}
  14780 		decoder = originalDecoder
  14781 	}
  14782 	*v = sv
  14783 	return nil
  14784 }
  14785 
  14786 func awsRestxml_deserializeDocumentCidrCollection(v **types.CidrCollection, decoder smithyxml.NodeDecoder) error {
  14787 	if v == nil {
  14788 		return fmt.Errorf("unexpected nil of type %T", v)
  14789 	}
  14790 	var sv *types.CidrCollection
  14791 	if *v == nil {
  14792 		sv = &types.CidrCollection{}
  14793 	} else {
  14794 		sv = *v
  14795 	}
  14796 
  14797 	for {
  14798 		t, done, err := decoder.Token()
  14799 		if err != nil {
  14800 			return err
  14801 		}
  14802 		if done {
  14803 			break
  14804 		}
  14805 		originalDecoder := decoder
  14806 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14807 		switch {
  14808 		case strings.EqualFold("Arn", t.Name.Local):
  14809 			val, err := decoder.Value()
  14810 			if err != nil {
  14811 				return err
  14812 			}
  14813 			if val == nil {
  14814 				break
  14815 			}
  14816 			{
  14817 				xtv := string(val)
  14818 				sv.Arn = ptr.String(xtv)
  14819 			}
  14820 
  14821 		case strings.EqualFold("Id", t.Name.Local):
  14822 			val, err := decoder.Value()
  14823 			if err != nil {
  14824 				return err
  14825 			}
  14826 			if val == nil {
  14827 				break
  14828 			}
  14829 			{
  14830 				xtv := string(val)
  14831 				sv.Id = ptr.String(xtv)
  14832 			}
  14833 
  14834 		case strings.EqualFold("Name", t.Name.Local):
  14835 			val, err := decoder.Value()
  14836 			if err != nil {
  14837 				return err
  14838 			}
  14839 			if val == nil {
  14840 				break
  14841 			}
  14842 			{
  14843 				xtv := string(val)
  14844 				sv.Name = ptr.String(xtv)
  14845 			}
  14846 
  14847 		case strings.EqualFold("Version", t.Name.Local):
  14848 			val, err := decoder.Value()
  14849 			if err != nil {
  14850 				return err
  14851 			}
  14852 			if val == nil {
  14853 				break
  14854 			}
  14855 			{
  14856 				xtv := string(val)
  14857 				i64, err := strconv.ParseInt(xtv, 10, 64)
  14858 				if err != nil {
  14859 					return err
  14860 				}
  14861 				sv.Version = ptr.Int64(i64)
  14862 			}
  14863 
  14864 		default:
  14865 			// Do nothing and ignore the unexpected tag element
  14866 			err = decoder.Decoder.Skip()
  14867 			if err != nil {
  14868 				return err
  14869 			}
  14870 
  14871 		}
  14872 		decoder = originalDecoder
  14873 	}
  14874 	*v = sv
  14875 	return nil
  14876 }
  14877 
  14878 func awsRestxml_deserializeDocumentCidrCollectionAlreadyExistsException(v **types.CidrCollectionAlreadyExistsException, decoder smithyxml.NodeDecoder) error {
  14879 	if v == nil {
  14880 		return fmt.Errorf("unexpected nil of type %T", v)
  14881 	}
  14882 	var sv *types.CidrCollectionAlreadyExistsException
  14883 	if *v == nil {
  14884 		sv = &types.CidrCollectionAlreadyExistsException{}
  14885 	} else {
  14886 		sv = *v
  14887 	}
  14888 
  14889 	for {
  14890 		t, done, err := decoder.Token()
  14891 		if err != nil {
  14892 			return err
  14893 		}
  14894 		if done {
  14895 			break
  14896 		}
  14897 		originalDecoder := decoder
  14898 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14899 		switch {
  14900 		case strings.EqualFold("Message", t.Name.Local):
  14901 			val, err := decoder.Value()
  14902 			if err != nil {
  14903 				return err
  14904 			}
  14905 			if val == nil {
  14906 				break
  14907 			}
  14908 			{
  14909 				xtv := string(val)
  14910 				sv.Message = ptr.String(xtv)
  14911 			}
  14912 
  14913 		default:
  14914 			// Do nothing and ignore the unexpected tag element
  14915 			err = decoder.Decoder.Skip()
  14916 			if err != nil {
  14917 				return err
  14918 			}
  14919 
  14920 		}
  14921 		decoder = originalDecoder
  14922 	}
  14923 	*v = sv
  14924 	return nil
  14925 }
  14926 
  14927 func awsRestxml_deserializeDocumentCidrCollectionInUseException(v **types.CidrCollectionInUseException, decoder smithyxml.NodeDecoder) error {
  14928 	if v == nil {
  14929 		return fmt.Errorf("unexpected nil of type %T", v)
  14930 	}
  14931 	var sv *types.CidrCollectionInUseException
  14932 	if *v == nil {
  14933 		sv = &types.CidrCollectionInUseException{}
  14934 	} else {
  14935 		sv = *v
  14936 	}
  14937 
  14938 	for {
  14939 		t, done, err := decoder.Token()
  14940 		if err != nil {
  14941 			return err
  14942 		}
  14943 		if done {
  14944 			break
  14945 		}
  14946 		originalDecoder := decoder
  14947 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14948 		switch {
  14949 		case strings.EqualFold("Message", t.Name.Local):
  14950 			val, err := decoder.Value()
  14951 			if err != nil {
  14952 				return err
  14953 			}
  14954 			if val == nil {
  14955 				break
  14956 			}
  14957 			{
  14958 				xtv := string(val)
  14959 				sv.Message = ptr.String(xtv)
  14960 			}
  14961 
  14962 		default:
  14963 			// Do nothing and ignore the unexpected tag element
  14964 			err = decoder.Decoder.Skip()
  14965 			if err != nil {
  14966 				return err
  14967 			}
  14968 
  14969 		}
  14970 		decoder = originalDecoder
  14971 	}
  14972 	*v = sv
  14973 	return nil
  14974 }
  14975 
  14976 func awsRestxml_deserializeDocumentCidrCollectionVersionMismatchException(v **types.CidrCollectionVersionMismatchException, decoder smithyxml.NodeDecoder) error {
  14977 	if v == nil {
  14978 		return fmt.Errorf("unexpected nil of type %T", v)
  14979 	}
  14980 	var sv *types.CidrCollectionVersionMismatchException
  14981 	if *v == nil {
  14982 		sv = &types.CidrCollectionVersionMismatchException{}
  14983 	} else {
  14984 		sv = *v
  14985 	}
  14986 
  14987 	for {
  14988 		t, done, err := decoder.Token()
  14989 		if err != nil {
  14990 			return err
  14991 		}
  14992 		if done {
  14993 			break
  14994 		}
  14995 		originalDecoder := decoder
  14996 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14997 		switch {
  14998 		case strings.EqualFold("Message", t.Name.Local):
  14999 			val, err := decoder.Value()
  15000 			if err != nil {
  15001 				return err
  15002 			}
  15003 			if val == nil {
  15004 				break
  15005 			}
  15006 			{
  15007 				xtv := string(val)
  15008 				sv.Message = ptr.String(xtv)
  15009 			}
  15010 
  15011 		default:
  15012 			// Do nothing and ignore the unexpected tag element
  15013 			err = decoder.Decoder.Skip()
  15014 			if err != nil {
  15015 				return err
  15016 			}
  15017 
  15018 		}
  15019 		decoder = originalDecoder
  15020 	}
  15021 	*v = sv
  15022 	return nil
  15023 }
  15024 
  15025 func awsRestxml_deserializeDocumentCidrRoutingConfig(v **types.CidrRoutingConfig, decoder smithyxml.NodeDecoder) error {
  15026 	if v == nil {
  15027 		return fmt.Errorf("unexpected nil of type %T", v)
  15028 	}
  15029 	var sv *types.CidrRoutingConfig
  15030 	if *v == nil {
  15031 		sv = &types.CidrRoutingConfig{}
  15032 	} else {
  15033 		sv = *v
  15034 	}
  15035 
  15036 	for {
  15037 		t, done, err := decoder.Token()
  15038 		if err != nil {
  15039 			return err
  15040 		}
  15041 		if done {
  15042 			break
  15043 		}
  15044 		originalDecoder := decoder
  15045 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15046 		switch {
  15047 		case strings.EqualFold("CollectionId", t.Name.Local):
  15048 			val, err := decoder.Value()
  15049 			if err != nil {
  15050 				return err
  15051 			}
  15052 			if val == nil {
  15053 				break
  15054 			}
  15055 			{
  15056 				xtv := string(val)
  15057 				sv.CollectionId = ptr.String(xtv)
  15058 			}
  15059 
  15060 		case strings.EqualFold("LocationName", t.Name.Local):
  15061 			val, err := decoder.Value()
  15062 			if err != nil {
  15063 				return err
  15064 			}
  15065 			if val == nil {
  15066 				break
  15067 			}
  15068 			{
  15069 				xtv := string(val)
  15070 				sv.LocationName = ptr.String(xtv)
  15071 			}
  15072 
  15073 		default:
  15074 			// Do nothing and ignore the unexpected tag element
  15075 			err = decoder.Decoder.Skip()
  15076 			if err != nil {
  15077 				return err
  15078 			}
  15079 
  15080 		}
  15081 		decoder = originalDecoder
  15082 	}
  15083 	*v = sv
  15084 	return nil
  15085 }
  15086 
  15087 func awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(v **types.CloudWatchAlarmConfiguration, decoder smithyxml.NodeDecoder) error {
  15088 	if v == nil {
  15089 		return fmt.Errorf("unexpected nil of type %T", v)
  15090 	}
  15091 	var sv *types.CloudWatchAlarmConfiguration
  15092 	if *v == nil {
  15093 		sv = &types.CloudWatchAlarmConfiguration{}
  15094 	} else {
  15095 		sv = *v
  15096 	}
  15097 
  15098 	for {
  15099 		t, done, err := decoder.Token()
  15100 		if err != nil {
  15101 			return err
  15102 		}
  15103 		if done {
  15104 			break
  15105 		}
  15106 		originalDecoder := decoder
  15107 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15108 		switch {
  15109 		case strings.EqualFold("ComparisonOperator", t.Name.Local):
  15110 			val, err := decoder.Value()
  15111 			if err != nil {
  15112 				return err
  15113 			}
  15114 			if val == nil {
  15115 				break
  15116 			}
  15117 			{
  15118 				xtv := string(val)
  15119 				sv.ComparisonOperator = types.ComparisonOperator(xtv)
  15120 			}
  15121 
  15122 		case strings.EqualFold("Dimensions", t.Name.Local):
  15123 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15124 			if err := awsRestxml_deserializeDocumentDimensionList(&sv.Dimensions, nodeDecoder); err != nil {
  15125 				return err
  15126 			}
  15127 
  15128 		case strings.EqualFold("EvaluationPeriods", t.Name.Local):
  15129 			val, err := decoder.Value()
  15130 			if err != nil {
  15131 				return err
  15132 			}
  15133 			if val == nil {
  15134 				break
  15135 			}
  15136 			{
  15137 				xtv := string(val)
  15138 				i64, err := strconv.ParseInt(xtv, 10, 64)
  15139 				if err != nil {
  15140 					return err
  15141 				}
  15142 				sv.EvaluationPeriods = ptr.Int32(int32(i64))
  15143 			}
  15144 
  15145 		case strings.EqualFold("MetricName", t.Name.Local):
  15146 			val, err := decoder.Value()
  15147 			if err != nil {
  15148 				return err
  15149 			}
  15150 			if val == nil {
  15151 				break
  15152 			}
  15153 			{
  15154 				xtv := string(val)
  15155 				sv.MetricName = ptr.String(xtv)
  15156 			}
  15157 
  15158 		case strings.EqualFold("Namespace", t.Name.Local):
  15159 			val, err := decoder.Value()
  15160 			if err != nil {
  15161 				return err
  15162 			}
  15163 			if val == nil {
  15164 				break
  15165 			}
  15166 			{
  15167 				xtv := string(val)
  15168 				sv.Namespace = ptr.String(xtv)
  15169 			}
  15170 
  15171 		case strings.EqualFold("Period", t.Name.Local):
  15172 			val, err := decoder.Value()
  15173 			if err != nil {
  15174 				return err
  15175 			}
  15176 			if val == nil {
  15177 				break
  15178 			}
  15179 			{
  15180 				xtv := string(val)
  15181 				i64, err := strconv.ParseInt(xtv, 10, 64)
  15182 				if err != nil {
  15183 					return err
  15184 				}
  15185 				sv.Period = ptr.Int32(int32(i64))
  15186 			}
  15187 
  15188 		case strings.EqualFold("Statistic", t.Name.Local):
  15189 			val, err := decoder.Value()
  15190 			if err != nil {
  15191 				return err
  15192 			}
  15193 			if val == nil {
  15194 				break
  15195 			}
  15196 			{
  15197 				xtv := string(val)
  15198 				sv.Statistic = types.Statistic(xtv)
  15199 			}
  15200 
  15201 		case strings.EqualFold("Threshold", t.Name.Local):
  15202 			val, err := decoder.Value()
  15203 			if err != nil {
  15204 				return err
  15205 			}
  15206 			if val == nil {
  15207 				break
  15208 			}
  15209 			{
  15210 				xtv := string(val)
  15211 				f64, err := strconv.ParseFloat(xtv, 64)
  15212 				if err != nil {
  15213 					return err
  15214 				}
  15215 				sv.Threshold = ptr.Float64(f64)
  15216 			}
  15217 
  15218 		default:
  15219 			// Do nothing and ignore the unexpected tag element
  15220 			err = decoder.Decoder.Skip()
  15221 			if err != nil {
  15222 				return err
  15223 			}
  15224 
  15225 		}
  15226 		decoder = originalDecoder
  15227 	}
  15228 	*v = sv
  15229 	return nil
  15230 }
  15231 
  15232 func awsRestxml_deserializeDocumentCollectionSummaries(v *[]types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
  15233 	if v == nil {
  15234 		return fmt.Errorf("unexpected nil of type %T", v)
  15235 	}
  15236 	var sv []types.CollectionSummary
  15237 	if *v == nil {
  15238 		sv = make([]types.CollectionSummary, 0)
  15239 	} else {
  15240 		sv = *v
  15241 	}
  15242 
  15243 	originalDecoder := decoder
  15244 	for {
  15245 		t, done, err := decoder.Token()
  15246 		if err != nil {
  15247 			return err
  15248 		}
  15249 		if done {
  15250 			break
  15251 		}
  15252 		switch {
  15253 		case strings.EqualFold("member", t.Name.Local):
  15254 			var col types.CollectionSummary
  15255 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15256 			destAddr := &col
  15257 			if err := awsRestxml_deserializeDocumentCollectionSummary(&destAddr, nodeDecoder); err != nil {
  15258 				return err
  15259 			}
  15260 			col = *destAddr
  15261 			sv = append(sv, col)
  15262 
  15263 		default:
  15264 			err = decoder.Decoder.Skip()
  15265 			if err != nil {
  15266 				return err
  15267 			}
  15268 
  15269 		}
  15270 		decoder = originalDecoder
  15271 	}
  15272 	*v = sv
  15273 	return nil
  15274 }
  15275 
  15276 func awsRestxml_deserializeDocumentCollectionSummariesUnwrapped(v *[]types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
  15277 	var sv []types.CollectionSummary
  15278 	if *v == nil {
  15279 		sv = make([]types.CollectionSummary, 0)
  15280 	} else {
  15281 		sv = *v
  15282 	}
  15283 
  15284 	switch {
  15285 	default:
  15286 		var mv types.CollectionSummary
  15287 		t := decoder.StartEl
  15288 		_ = t
  15289 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15290 		destAddr := &mv
  15291 		if err := awsRestxml_deserializeDocumentCollectionSummary(&destAddr, nodeDecoder); err != nil {
  15292 			return err
  15293 		}
  15294 		mv = *destAddr
  15295 		sv = append(sv, mv)
  15296 	}
  15297 	*v = sv
  15298 	return nil
  15299 }
  15300 func awsRestxml_deserializeDocumentCollectionSummary(v **types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
  15301 	if v == nil {
  15302 		return fmt.Errorf("unexpected nil of type %T", v)
  15303 	}
  15304 	var sv *types.CollectionSummary
  15305 	if *v == nil {
  15306 		sv = &types.CollectionSummary{}
  15307 	} else {
  15308 		sv = *v
  15309 	}
  15310 
  15311 	for {
  15312 		t, done, err := decoder.Token()
  15313 		if err != nil {
  15314 			return err
  15315 		}
  15316 		if done {
  15317 			break
  15318 		}
  15319 		originalDecoder := decoder
  15320 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15321 		switch {
  15322 		case strings.EqualFold("Arn", t.Name.Local):
  15323 			val, err := decoder.Value()
  15324 			if err != nil {
  15325 				return err
  15326 			}
  15327 			if val == nil {
  15328 				break
  15329 			}
  15330 			{
  15331 				xtv := string(val)
  15332 				sv.Arn = ptr.String(xtv)
  15333 			}
  15334 
  15335 		case strings.EqualFold("Id", t.Name.Local):
  15336 			val, err := decoder.Value()
  15337 			if err != nil {
  15338 				return err
  15339 			}
  15340 			if val == nil {
  15341 				break
  15342 			}
  15343 			{
  15344 				xtv := string(val)
  15345 				sv.Id = ptr.String(xtv)
  15346 			}
  15347 
  15348 		case strings.EqualFold("Name", t.Name.Local):
  15349 			val, err := decoder.Value()
  15350 			if err != nil {
  15351 				return err
  15352 			}
  15353 			if val == nil {
  15354 				break
  15355 			}
  15356 			{
  15357 				xtv := string(val)
  15358 				sv.Name = ptr.String(xtv)
  15359 			}
  15360 
  15361 		case strings.EqualFold("Version", t.Name.Local):
  15362 			val, err := decoder.Value()
  15363 			if err != nil {
  15364 				return err
  15365 			}
  15366 			if val == nil {
  15367 				break
  15368 			}
  15369 			{
  15370 				xtv := string(val)
  15371 				i64, err := strconv.ParseInt(xtv, 10, 64)
  15372 				if err != nil {
  15373 					return err
  15374 				}
  15375 				sv.Version = ptr.Int64(i64)
  15376 			}
  15377 
  15378 		default:
  15379 			// Do nothing and ignore the unexpected tag element
  15380 			err = decoder.Decoder.Skip()
  15381 			if err != nil {
  15382 				return err
  15383 			}
  15384 
  15385 		}
  15386 		decoder = originalDecoder
  15387 	}
  15388 	*v = sv
  15389 	return nil
  15390 }
  15391 
  15392 func awsRestxml_deserializeDocumentConcurrentModification(v **types.ConcurrentModification, decoder smithyxml.NodeDecoder) error {
  15393 	if v == nil {
  15394 		return fmt.Errorf("unexpected nil of type %T", v)
  15395 	}
  15396 	var sv *types.ConcurrentModification
  15397 	if *v == nil {
  15398 		sv = &types.ConcurrentModification{}
  15399 	} else {
  15400 		sv = *v
  15401 	}
  15402 
  15403 	for {
  15404 		t, done, err := decoder.Token()
  15405 		if err != nil {
  15406 			return err
  15407 		}
  15408 		if done {
  15409 			break
  15410 		}
  15411 		originalDecoder := decoder
  15412 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15413 		switch {
  15414 		case strings.EqualFold("message", t.Name.Local):
  15415 			val, err := decoder.Value()
  15416 			if err != nil {
  15417 				return err
  15418 			}
  15419 			if val == nil {
  15420 				break
  15421 			}
  15422 			{
  15423 				xtv := string(val)
  15424 				sv.Message = ptr.String(xtv)
  15425 			}
  15426 
  15427 		default:
  15428 			// Do nothing and ignore the unexpected tag element
  15429 			err = decoder.Decoder.Skip()
  15430 			if err != nil {
  15431 				return err
  15432 			}
  15433 
  15434 		}
  15435 		decoder = originalDecoder
  15436 	}
  15437 	*v = sv
  15438 	return nil
  15439 }
  15440 
  15441 func awsRestxml_deserializeDocumentConflictingDomainExists(v **types.ConflictingDomainExists, decoder smithyxml.NodeDecoder) error {
  15442 	if v == nil {
  15443 		return fmt.Errorf("unexpected nil of type %T", v)
  15444 	}
  15445 	var sv *types.ConflictingDomainExists
  15446 	if *v == nil {
  15447 		sv = &types.ConflictingDomainExists{}
  15448 	} else {
  15449 		sv = *v
  15450 	}
  15451 
  15452 	for {
  15453 		t, done, err := decoder.Token()
  15454 		if err != nil {
  15455 			return err
  15456 		}
  15457 		if done {
  15458 			break
  15459 		}
  15460 		originalDecoder := decoder
  15461 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15462 		switch {
  15463 		case strings.EqualFold("message", t.Name.Local):
  15464 			val, err := decoder.Value()
  15465 			if err != nil {
  15466 				return err
  15467 			}
  15468 			if val == nil {
  15469 				break
  15470 			}
  15471 			{
  15472 				xtv := string(val)
  15473 				sv.Message = ptr.String(xtv)
  15474 			}
  15475 
  15476 		default:
  15477 			// Do nothing and ignore the unexpected tag element
  15478 			err = decoder.Decoder.Skip()
  15479 			if err != nil {
  15480 				return err
  15481 			}
  15482 
  15483 		}
  15484 		decoder = originalDecoder
  15485 	}
  15486 	*v = sv
  15487 	return nil
  15488 }
  15489 
  15490 func awsRestxml_deserializeDocumentConflictingTypes(v **types.ConflictingTypes, decoder smithyxml.NodeDecoder) error {
  15491 	if v == nil {
  15492 		return fmt.Errorf("unexpected nil of type %T", v)
  15493 	}
  15494 	var sv *types.ConflictingTypes
  15495 	if *v == nil {
  15496 		sv = &types.ConflictingTypes{}
  15497 	} else {
  15498 		sv = *v
  15499 	}
  15500 
  15501 	for {
  15502 		t, done, err := decoder.Token()
  15503 		if err != nil {
  15504 			return err
  15505 		}
  15506 		if done {
  15507 			break
  15508 		}
  15509 		originalDecoder := decoder
  15510 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15511 		switch {
  15512 		case strings.EqualFold("message", t.Name.Local):
  15513 			val, err := decoder.Value()
  15514 			if err != nil {
  15515 				return err
  15516 			}
  15517 			if val == nil {
  15518 				break
  15519 			}
  15520 			{
  15521 				xtv := string(val)
  15522 				sv.Message = ptr.String(xtv)
  15523 			}
  15524 
  15525 		default:
  15526 			// Do nothing and ignore the unexpected tag element
  15527 			err = decoder.Decoder.Skip()
  15528 			if err != nil {
  15529 				return err
  15530 			}
  15531 
  15532 		}
  15533 		decoder = originalDecoder
  15534 	}
  15535 	*v = sv
  15536 	return nil
  15537 }
  15538 
  15539 func awsRestxml_deserializeDocumentCoordinates(v **types.Coordinates, decoder smithyxml.NodeDecoder) error {
  15540 	if v == nil {
  15541 		return fmt.Errorf("unexpected nil of type %T", v)
  15542 	}
  15543 	var sv *types.Coordinates
  15544 	if *v == nil {
  15545 		sv = &types.Coordinates{}
  15546 	} else {
  15547 		sv = *v
  15548 	}
  15549 
  15550 	for {
  15551 		t, done, err := decoder.Token()
  15552 		if err != nil {
  15553 			return err
  15554 		}
  15555 		if done {
  15556 			break
  15557 		}
  15558 		originalDecoder := decoder
  15559 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15560 		switch {
  15561 		case strings.EqualFold("Latitude", t.Name.Local):
  15562 			val, err := decoder.Value()
  15563 			if err != nil {
  15564 				return err
  15565 			}
  15566 			if val == nil {
  15567 				break
  15568 			}
  15569 			{
  15570 				xtv := string(val)
  15571 				sv.Latitude = ptr.String(xtv)
  15572 			}
  15573 
  15574 		case strings.EqualFold("Longitude", t.Name.Local):
  15575 			val, err := decoder.Value()
  15576 			if err != nil {
  15577 				return err
  15578 			}
  15579 			if val == nil {
  15580 				break
  15581 			}
  15582 			{
  15583 				xtv := string(val)
  15584 				sv.Longitude = ptr.String(xtv)
  15585 			}
  15586 
  15587 		default:
  15588 			// Do nothing and ignore the unexpected tag element
  15589 			err = decoder.Decoder.Skip()
  15590 			if err != nil {
  15591 				return err
  15592 			}
  15593 
  15594 		}
  15595 		decoder = originalDecoder
  15596 	}
  15597 	*v = sv
  15598 	return nil
  15599 }
  15600 
  15601 func awsRestxml_deserializeDocumentDelegationSet(v **types.DelegationSet, decoder smithyxml.NodeDecoder) error {
  15602 	if v == nil {
  15603 		return fmt.Errorf("unexpected nil of type %T", v)
  15604 	}
  15605 	var sv *types.DelegationSet
  15606 	if *v == nil {
  15607 		sv = &types.DelegationSet{}
  15608 	} else {
  15609 		sv = *v
  15610 	}
  15611 
  15612 	for {
  15613 		t, done, err := decoder.Token()
  15614 		if err != nil {
  15615 			return err
  15616 		}
  15617 		if done {
  15618 			break
  15619 		}
  15620 		originalDecoder := decoder
  15621 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15622 		switch {
  15623 		case strings.EqualFold("CallerReference", t.Name.Local):
  15624 			val, err := decoder.Value()
  15625 			if err != nil {
  15626 				return err
  15627 			}
  15628 			if val == nil {
  15629 				break
  15630 			}
  15631 			{
  15632 				xtv := string(val)
  15633 				sv.CallerReference = ptr.String(xtv)
  15634 			}
  15635 
  15636 		case strings.EqualFold("Id", t.Name.Local):
  15637 			val, err := decoder.Value()
  15638 			if err != nil {
  15639 				return err
  15640 			}
  15641 			if val == nil {
  15642 				break
  15643 			}
  15644 			{
  15645 				xtv := string(val)
  15646 				sv.Id = ptr.String(xtv)
  15647 			}
  15648 
  15649 		case strings.EqualFold("NameServers", t.Name.Local):
  15650 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15651 			if err := awsRestxml_deserializeDocumentDelegationSetNameServers(&sv.NameServers, nodeDecoder); err != nil {
  15652 				return err
  15653 			}
  15654 
  15655 		default:
  15656 			// Do nothing and ignore the unexpected tag element
  15657 			err = decoder.Decoder.Skip()
  15658 			if err != nil {
  15659 				return err
  15660 			}
  15661 
  15662 		}
  15663 		decoder = originalDecoder
  15664 	}
  15665 	*v = sv
  15666 	return nil
  15667 }
  15668 
  15669 func awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(v **types.DelegationSetAlreadyCreated, decoder smithyxml.NodeDecoder) error {
  15670 	if v == nil {
  15671 		return fmt.Errorf("unexpected nil of type %T", v)
  15672 	}
  15673 	var sv *types.DelegationSetAlreadyCreated
  15674 	if *v == nil {
  15675 		sv = &types.DelegationSetAlreadyCreated{}
  15676 	} else {
  15677 		sv = *v
  15678 	}
  15679 
  15680 	for {
  15681 		t, done, err := decoder.Token()
  15682 		if err != nil {
  15683 			return err
  15684 		}
  15685 		if done {
  15686 			break
  15687 		}
  15688 		originalDecoder := decoder
  15689 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15690 		switch {
  15691 		case strings.EqualFold("message", t.Name.Local):
  15692 			val, err := decoder.Value()
  15693 			if err != nil {
  15694 				return err
  15695 			}
  15696 			if val == nil {
  15697 				break
  15698 			}
  15699 			{
  15700 				xtv := string(val)
  15701 				sv.Message = ptr.String(xtv)
  15702 			}
  15703 
  15704 		default:
  15705 			// Do nothing and ignore the unexpected tag element
  15706 			err = decoder.Decoder.Skip()
  15707 			if err != nil {
  15708 				return err
  15709 			}
  15710 
  15711 		}
  15712 		decoder = originalDecoder
  15713 	}
  15714 	*v = sv
  15715 	return nil
  15716 }
  15717 
  15718 func awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(v **types.DelegationSetAlreadyReusable, decoder smithyxml.NodeDecoder) error {
  15719 	if v == nil {
  15720 		return fmt.Errorf("unexpected nil of type %T", v)
  15721 	}
  15722 	var sv *types.DelegationSetAlreadyReusable
  15723 	if *v == nil {
  15724 		sv = &types.DelegationSetAlreadyReusable{}
  15725 	} else {
  15726 		sv = *v
  15727 	}
  15728 
  15729 	for {
  15730 		t, done, err := decoder.Token()
  15731 		if err != nil {
  15732 			return err
  15733 		}
  15734 		if done {
  15735 			break
  15736 		}
  15737 		originalDecoder := decoder
  15738 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15739 		switch {
  15740 		case strings.EqualFold("message", t.Name.Local):
  15741 			val, err := decoder.Value()
  15742 			if err != nil {
  15743 				return err
  15744 			}
  15745 			if val == nil {
  15746 				break
  15747 			}
  15748 			{
  15749 				xtv := string(val)
  15750 				sv.Message = ptr.String(xtv)
  15751 			}
  15752 
  15753 		default:
  15754 			// Do nothing and ignore the unexpected tag element
  15755 			err = decoder.Decoder.Skip()
  15756 			if err != nil {
  15757 				return err
  15758 			}
  15759 
  15760 		}
  15761 		decoder = originalDecoder
  15762 	}
  15763 	*v = sv
  15764 	return nil
  15765 }
  15766 
  15767 func awsRestxml_deserializeDocumentDelegationSetInUse(v **types.DelegationSetInUse, decoder smithyxml.NodeDecoder) error {
  15768 	if v == nil {
  15769 		return fmt.Errorf("unexpected nil of type %T", v)
  15770 	}
  15771 	var sv *types.DelegationSetInUse
  15772 	if *v == nil {
  15773 		sv = &types.DelegationSetInUse{}
  15774 	} else {
  15775 		sv = *v
  15776 	}
  15777 
  15778 	for {
  15779 		t, done, err := decoder.Token()
  15780 		if err != nil {
  15781 			return err
  15782 		}
  15783 		if done {
  15784 			break
  15785 		}
  15786 		originalDecoder := decoder
  15787 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15788 		switch {
  15789 		case strings.EqualFold("message", t.Name.Local):
  15790 			val, err := decoder.Value()
  15791 			if err != nil {
  15792 				return err
  15793 			}
  15794 			if val == nil {
  15795 				break
  15796 			}
  15797 			{
  15798 				xtv := string(val)
  15799 				sv.Message = ptr.String(xtv)
  15800 			}
  15801 
  15802 		default:
  15803 			// Do nothing and ignore the unexpected tag element
  15804 			err = decoder.Decoder.Skip()
  15805 			if err != nil {
  15806 				return err
  15807 			}
  15808 
  15809 		}
  15810 		decoder = originalDecoder
  15811 	}
  15812 	*v = sv
  15813 	return nil
  15814 }
  15815 
  15816 func awsRestxml_deserializeDocumentDelegationSetNameServers(v *[]string, decoder smithyxml.NodeDecoder) error {
  15817 	if v == nil {
  15818 		return fmt.Errorf("unexpected nil of type %T", v)
  15819 	}
  15820 	var sv []string
  15821 	if *v == nil {
  15822 		sv = make([]string, 0)
  15823 	} else {
  15824 		sv = *v
  15825 	}
  15826 
  15827 	originalDecoder := decoder
  15828 	for {
  15829 		t, done, err := decoder.Token()
  15830 		if err != nil {
  15831 			return err
  15832 		}
  15833 		if done {
  15834 			break
  15835 		}
  15836 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15837 		decoder = memberDecoder
  15838 		switch {
  15839 		case strings.EqualFold("NameServer", t.Name.Local):
  15840 			var col string
  15841 			val, err := decoder.Value()
  15842 			if err != nil {
  15843 				return err
  15844 			}
  15845 			if val == nil {
  15846 				break
  15847 			}
  15848 			{
  15849 				xtv := string(val)
  15850 				col = xtv
  15851 			}
  15852 			sv = append(sv, col)
  15853 
  15854 		default:
  15855 			err = decoder.Decoder.Skip()
  15856 			if err != nil {
  15857 				return err
  15858 			}
  15859 
  15860 		}
  15861 		decoder = originalDecoder
  15862 	}
  15863 	*v = sv
  15864 	return nil
  15865 }
  15866 
  15867 func awsRestxml_deserializeDocumentDelegationSetNameServersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  15868 	var sv []string
  15869 	if *v == nil {
  15870 		sv = make([]string, 0)
  15871 	} else {
  15872 		sv = *v
  15873 	}
  15874 
  15875 	switch {
  15876 	default:
  15877 		var mv string
  15878 		t := decoder.StartEl
  15879 		_ = t
  15880 		val, err := decoder.Value()
  15881 		if err != nil {
  15882 			return err
  15883 		}
  15884 		if val == nil {
  15885 			break
  15886 		}
  15887 		{
  15888 			xtv := string(val)
  15889 			mv = xtv
  15890 		}
  15891 		sv = append(sv, mv)
  15892 	}
  15893 	*v = sv
  15894 	return nil
  15895 }
  15896 func awsRestxml_deserializeDocumentDelegationSetNotAvailable(v **types.DelegationSetNotAvailable, decoder smithyxml.NodeDecoder) error {
  15897 	if v == nil {
  15898 		return fmt.Errorf("unexpected nil of type %T", v)
  15899 	}
  15900 	var sv *types.DelegationSetNotAvailable
  15901 	if *v == nil {
  15902 		sv = &types.DelegationSetNotAvailable{}
  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("message", 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.Message = ptr.String(xtv)
  15929 			}
  15930 
  15931 		default:
  15932 			// Do nothing and ignore the unexpected tag element
  15933 			err = decoder.Decoder.Skip()
  15934 			if err != nil {
  15935 				return err
  15936 			}
  15937 
  15938 		}
  15939 		decoder = originalDecoder
  15940 	}
  15941 	*v = sv
  15942 	return nil
  15943 }
  15944 
  15945 func awsRestxml_deserializeDocumentDelegationSetNotReusable(v **types.DelegationSetNotReusable, decoder smithyxml.NodeDecoder) error {
  15946 	if v == nil {
  15947 		return fmt.Errorf("unexpected nil of type %T", v)
  15948 	}
  15949 	var sv *types.DelegationSetNotReusable
  15950 	if *v == nil {
  15951 		sv = &types.DelegationSetNotReusable{}
  15952 	} else {
  15953 		sv = *v
  15954 	}
  15955 
  15956 	for {
  15957 		t, done, err := decoder.Token()
  15958 		if err != nil {
  15959 			return err
  15960 		}
  15961 		if done {
  15962 			break
  15963 		}
  15964 		originalDecoder := decoder
  15965 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15966 		switch {
  15967 		case strings.EqualFold("message", t.Name.Local):
  15968 			val, err := decoder.Value()
  15969 			if err != nil {
  15970 				return err
  15971 			}
  15972 			if val == nil {
  15973 				break
  15974 			}
  15975 			{
  15976 				xtv := string(val)
  15977 				sv.Message = ptr.String(xtv)
  15978 			}
  15979 
  15980 		default:
  15981 			// Do nothing and ignore the unexpected tag element
  15982 			err = decoder.Decoder.Skip()
  15983 			if err != nil {
  15984 				return err
  15985 			}
  15986 
  15987 		}
  15988 		decoder = originalDecoder
  15989 	}
  15990 	*v = sv
  15991 	return nil
  15992 }
  15993 
  15994 func awsRestxml_deserializeDocumentDelegationSets(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error {
  15995 	if v == nil {
  15996 		return fmt.Errorf("unexpected nil of type %T", v)
  15997 	}
  15998 	var sv []types.DelegationSet
  15999 	if *v == nil {
  16000 		sv = make([]types.DelegationSet, 0)
  16001 	} else {
  16002 		sv = *v
  16003 	}
  16004 
  16005 	originalDecoder := decoder
  16006 	for {
  16007 		t, done, err := decoder.Token()
  16008 		if err != nil {
  16009 			return err
  16010 		}
  16011 		if done {
  16012 			break
  16013 		}
  16014 		switch {
  16015 		case strings.EqualFold("DelegationSet", t.Name.Local):
  16016 			var col types.DelegationSet
  16017 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16018 			destAddr := &col
  16019 			if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil {
  16020 				return err
  16021 			}
  16022 			col = *destAddr
  16023 			sv = append(sv, col)
  16024 
  16025 		default:
  16026 			err = decoder.Decoder.Skip()
  16027 			if err != nil {
  16028 				return err
  16029 			}
  16030 
  16031 		}
  16032 		decoder = originalDecoder
  16033 	}
  16034 	*v = sv
  16035 	return nil
  16036 }
  16037 
  16038 func awsRestxml_deserializeDocumentDelegationSetsUnwrapped(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error {
  16039 	var sv []types.DelegationSet
  16040 	if *v == nil {
  16041 		sv = make([]types.DelegationSet, 0)
  16042 	} else {
  16043 		sv = *v
  16044 	}
  16045 
  16046 	switch {
  16047 	default:
  16048 		var mv types.DelegationSet
  16049 		t := decoder.StartEl
  16050 		_ = t
  16051 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16052 		destAddr := &mv
  16053 		if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil {
  16054 			return err
  16055 		}
  16056 		mv = *destAddr
  16057 		sv = append(sv, mv)
  16058 	}
  16059 	*v = sv
  16060 	return nil
  16061 }
  16062 func awsRestxml_deserializeDocumentDimension(v **types.Dimension, decoder smithyxml.NodeDecoder) error {
  16063 	if v == nil {
  16064 		return fmt.Errorf("unexpected nil of type %T", v)
  16065 	}
  16066 	var sv *types.Dimension
  16067 	if *v == nil {
  16068 		sv = &types.Dimension{}
  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("Name", 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.Name = ptr.String(xtv)
  16095 			}
  16096 
  16097 		case strings.EqualFold("Value", t.Name.Local):
  16098 			val, err := decoder.Value()
  16099 			if err != nil {
  16100 				return err
  16101 			}
  16102 			if val == nil {
  16103 				break
  16104 			}
  16105 			{
  16106 				xtv := string(val)
  16107 				sv.Value = ptr.String(xtv)
  16108 			}
  16109 
  16110 		default:
  16111 			// Do nothing and ignore the unexpected tag element
  16112 			err = decoder.Decoder.Skip()
  16113 			if err != nil {
  16114 				return err
  16115 			}
  16116 
  16117 		}
  16118 		decoder = originalDecoder
  16119 	}
  16120 	*v = sv
  16121 	return nil
  16122 }
  16123 
  16124 func awsRestxml_deserializeDocumentDimensionList(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error {
  16125 	if v == nil {
  16126 		return fmt.Errorf("unexpected nil of type %T", v)
  16127 	}
  16128 	var sv []types.Dimension
  16129 	if *v == nil {
  16130 		sv = make([]types.Dimension, 0)
  16131 	} else {
  16132 		sv = *v
  16133 	}
  16134 
  16135 	originalDecoder := decoder
  16136 	for {
  16137 		t, done, err := decoder.Token()
  16138 		if err != nil {
  16139 			return err
  16140 		}
  16141 		if done {
  16142 			break
  16143 		}
  16144 		switch {
  16145 		case strings.EqualFold("Dimension", t.Name.Local):
  16146 			var col types.Dimension
  16147 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16148 			destAddr := &col
  16149 			if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil {
  16150 				return err
  16151 			}
  16152 			col = *destAddr
  16153 			sv = append(sv, col)
  16154 
  16155 		default:
  16156 			err = decoder.Decoder.Skip()
  16157 			if err != nil {
  16158 				return err
  16159 			}
  16160 
  16161 		}
  16162 		decoder = originalDecoder
  16163 	}
  16164 	*v = sv
  16165 	return nil
  16166 }
  16167 
  16168 func awsRestxml_deserializeDocumentDimensionListUnwrapped(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error {
  16169 	var sv []types.Dimension
  16170 	if *v == nil {
  16171 		sv = make([]types.Dimension, 0)
  16172 	} else {
  16173 		sv = *v
  16174 	}
  16175 
  16176 	switch {
  16177 	default:
  16178 		var mv types.Dimension
  16179 		t := decoder.StartEl
  16180 		_ = t
  16181 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16182 		destAddr := &mv
  16183 		if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil {
  16184 			return err
  16185 		}
  16186 		mv = *destAddr
  16187 		sv = append(sv, mv)
  16188 	}
  16189 	*v = sv
  16190 	return nil
  16191 }
  16192 func awsRestxml_deserializeDocumentDNSSECNotFound(v **types.DNSSECNotFound, decoder smithyxml.NodeDecoder) error {
  16193 	if v == nil {
  16194 		return fmt.Errorf("unexpected nil of type %T", v)
  16195 	}
  16196 	var sv *types.DNSSECNotFound
  16197 	if *v == nil {
  16198 		sv = &types.DNSSECNotFound{}
  16199 	} else {
  16200 		sv = *v
  16201 	}
  16202 
  16203 	for {
  16204 		t, done, err := decoder.Token()
  16205 		if err != nil {
  16206 			return err
  16207 		}
  16208 		if done {
  16209 			break
  16210 		}
  16211 		originalDecoder := decoder
  16212 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16213 		switch {
  16214 		case strings.EqualFold("message", t.Name.Local):
  16215 			val, err := decoder.Value()
  16216 			if err != nil {
  16217 				return err
  16218 			}
  16219 			if val == nil {
  16220 				break
  16221 			}
  16222 			{
  16223 				xtv := string(val)
  16224 				sv.Message = ptr.String(xtv)
  16225 			}
  16226 
  16227 		default:
  16228 			// Do nothing and ignore the unexpected tag element
  16229 			err = decoder.Decoder.Skip()
  16230 			if err != nil {
  16231 				return err
  16232 			}
  16233 
  16234 		}
  16235 		decoder = originalDecoder
  16236 	}
  16237 	*v = sv
  16238 	return nil
  16239 }
  16240 
  16241 func awsRestxml_deserializeDocumentDNSSECStatus(v **types.DNSSECStatus, decoder smithyxml.NodeDecoder) error {
  16242 	if v == nil {
  16243 		return fmt.Errorf("unexpected nil of type %T", v)
  16244 	}
  16245 	var sv *types.DNSSECStatus
  16246 	if *v == nil {
  16247 		sv = &types.DNSSECStatus{}
  16248 	} else {
  16249 		sv = *v
  16250 	}
  16251 
  16252 	for {
  16253 		t, done, err := decoder.Token()
  16254 		if err != nil {
  16255 			return err
  16256 		}
  16257 		if done {
  16258 			break
  16259 		}
  16260 		originalDecoder := decoder
  16261 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16262 		switch {
  16263 		case strings.EqualFold("ServeSignature", t.Name.Local):
  16264 			val, err := decoder.Value()
  16265 			if err != nil {
  16266 				return err
  16267 			}
  16268 			if val == nil {
  16269 				break
  16270 			}
  16271 			{
  16272 				xtv := string(val)
  16273 				sv.ServeSignature = ptr.String(xtv)
  16274 			}
  16275 
  16276 		case strings.EqualFold("StatusMessage", t.Name.Local):
  16277 			val, err := decoder.Value()
  16278 			if err != nil {
  16279 				return err
  16280 			}
  16281 			if val == nil {
  16282 				break
  16283 			}
  16284 			{
  16285 				xtv := string(val)
  16286 				sv.StatusMessage = ptr.String(xtv)
  16287 			}
  16288 
  16289 		default:
  16290 			// Do nothing and ignore the unexpected tag element
  16291 			err = decoder.Decoder.Skip()
  16292 			if err != nil {
  16293 				return err
  16294 			}
  16295 
  16296 		}
  16297 		decoder = originalDecoder
  16298 	}
  16299 	*v = sv
  16300 	return nil
  16301 }
  16302 
  16303 func awsRestxml_deserializeDocumentErrorMessages(v *[]string, decoder smithyxml.NodeDecoder) error {
  16304 	if v == nil {
  16305 		return fmt.Errorf("unexpected nil of type %T", v)
  16306 	}
  16307 	var sv []string
  16308 	if *v == nil {
  16309 		sv = make([]string, 0)
  16310 	} else {
  16311 		sv = *v
  16312 	}
  16313 
  16314 	originalDecoder := decoder
  16315 	for {
  16316 		t, done, err := decoder.Token()
  16317 		if err != nil {
  16318 			return err
  16319 		}
  16320 		if done {
  16321 			break
  16322 		}
  16323 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16324 		decoder = memberDecoder
  16325 		switch {
  16326 		case strings.EqualFold("Message", t.Name.Local):
  16327 			var col string
  16328 			val, err := decoder.Value()
  16329 			if err != nil {
  16330 				return err
  16331 			}
  16332 			if val == nil {
  16333 				break
  16334 			}
  16335 			{
  16336 				xtv := string(val)
  16337 				col = xtv
  16338 			}
  16339 			sv = append(sv, col)
  16340 
  16341 		default:
  16342 			err = decoder.Decoder.Skip()
  16343 			if err != nil {
  16344 				return err
  16345 			}
  16346 
  16347 		}
  16348 		decoder = originalDecoder
  16349 	}
  16350 	*v = sv
  16351 	return nil
  16352 }
  16353 
  16354 func awsRestxml_deserializeDocumentErrorMessagesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  16355 	var sv []string
  16356 	if *v == nil {
  16357 		sv = make([]string, 0)
  16358 	} else {
  16359 		sv = *v
  16360 	}
  16361 
  16362 	switch {
  16363 	default:
  16364 		var mv string
  16365 		t := decoder.StartEl
  16366 		_ = t
  16367 		val, err := decoder.Value()
  16368 		if err != nil {
  16369 			return err
  16370 		}
  16371 		if val == nil {
  16372 			break
  16373 		}
  16374 		{
  16375 			xtv := string(val)
  16376 			mv = xtv
  16377 		}
  16378 		sv = append(sv, mv)
  16379 	}
  16380 	*v = sv
  16381 	return nil
  16382 }
  16383 func awsRestxml_deserializeDocumentGeoLocation(v **types.GeoLocation, decoder smithyxml.NodeDecoder) error {
  16384 	if v == nil {
  16385 		return fmt.Errorf("unexpected nil of type %T", v)
  16386 	}
  16387 	var sv *types.GeoLocation
  16388 	if *v == nil {
  16389 		sv = &types.GeoLocation{}
  16390 	} else {
  16391 		sv = *v
  16392 	}
  16393 
  16394 	for {
  16395 		t, done, err := decoder.Token()
  16396 		if err != nil {
  16397 			return err
  16398 		}
  16399 		if done {
  16400 			break
  16401 		}
  16402 		originalDecoder := decoder
  16403 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16404 		switch {
  16405 		case strings.EqualFold("ContinentCode", t.Name.Local):
  16406 			val, err := decoder.Value()
  16407 			if err != nil {
  16408 				return err
  16409 			}
  16410 			if val == nil {
  16411 				break
  16412 			}
  16413 			{
  16414 				xtv := string(val)
  16415 				sv.ContinentCode = ptr.String(xtv)
  16416 			}
  16417 
  16418 		case strings.EqualFold("CountryCode", t.Name.Local):
  16419 			val, err := decoder.Value()
  16420 			if err != nil {
  16421 				return err
  16422 			}
  16423 			if val == nil {
  16424 				break
  16425 			}
  16426 			{
  16427 				xtv := string(val)
  16428 				sv.CountryCode = ptr.String(xtv)
  16429 			}
  16430 
  16431 		case strings.EqualFold("SubdivisionCode", t.Name.Local):
  16432 			val, err := decoder.Value()
  16433 			if err != nil {
  16434 				return err
  16435 			}
  16436 			if val == nil {
  16437 				break
  16438 			}
  16439 			{
  16440 				xtv := string(val)
  16441 				sv.SubdivisionCode = ptr.String(xtv)
  16442 			}
  16443 
  16444 		default:
  16445 			// Do nothing and ignore the unexpected tag element
  16446 			err = decoder.Decoder.Skip()
  16447 			if err != nil {
  16448 				return err
  16449 			}
  16450 
  16451 		}
  16452 		decoder = originalDecoder
  16453 	}
  16454 	*v = sv
  16455 	return nil
  16456 }
  16457 
  16458 func awsRestxml_deserializeDocumentGeoLocationDetails(v **types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
  16459 	if v == nil {
  16460 		return fmt.Errorf("unexpected nil of type %T", v)
  16461 	}
  16462 	var sv *types.GeoLocationDetails
  16463 	if *v == nil {
  16464 		sv = &types.GeoLocationDetails{}
  16465 	} else {
  16466 		sv = *v
  16467 	}
  16468 
  16469 	for {
  16470 		t, done, err := decoder.Token()
  16471 		if err != nil {
  16472 			return err
  16473 		}
  16474 		if done {
  16475 			break
  16476 		}
  16477 		originalDecoder := decoder
  16478 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16479 		switch {
  16480 		case strings.EqualFold("ContinentCode", t.Name.Local):
  16481 			val, err := decoder.Value()
  16482 			if err != nil {
  16483 				return err
  16484 			}
  16485 			if val == nil {
  16486 				break
  16487 			}
  16488 			{
  16489 				xtv := string(val)
  16490 				sv.ContinentCode = ptr.String(xtv)
  16491 			}
  16492 
  16493 		case strings.EqualFold("ContinentName", t.Name.Local):
  16494 			val, err := decoder.Value()
  16495 			if err != nil {
  16496 				return err
  16497 			}
  16498 			if val == nil {
  16499 				break
  16500 			}
  16501 			{
  16502 				xtv := string(val)
  16503 				sv.ContinentName = ptr.String(xtv)
  16504 			}
  16505 
  16506 		case strings.EqualFold("CountryCode", t.Name.Local):
  16507 			val, err := decoder.Value()
  16508 			if err != nil {
  16509 				return err
  16510 			}
  16511 			if val == nil {
  16512 				break
  16513 			}
  16514 			{
  16515 				xtv := string(val)
  16516 				sv.CountryCode = ptr.String(xtv)
  16517 			}
  16518 
  16519 		case strings.EqualFold("CountryName", t.Name.Local):
  16520 			val, err := decoder.Value()
  16521 			if err != nil {
  16522 				return err
  16523 			}
  16524 			if val == nil {
  16525 				break
  16526 			}
  16527 			{
  16528 				xtv := string(val)
  16529 				sv.CountryName = ptr.String(xtv)
  16530 			}
  16531 
  16532 		case strings.EqualFold("SubdivisionCode", t.Name.Local):
  16533 			val, err := decoder.Value()
  16534 			if err != nil {
  16535 				return err
  16536 			}
  16537 			if val == nil {
  16538 				break
  16539 			}
  16540 			{
  16541 				xtv := string(val)
  16542 				sv.SubdivisionCode = ptr.String(xtv)
  16543 			}
  16544 
  16545 		case strings.EqualFold("SubdivisionName", t.Name.Local):
  16546 			val, err := decoder.Value()
  16547 			if err != nil {
  16548 				return err
  16549 			}
  16550 			if val == nil {
  16551 				break
  16552 			}
  16553 			{
  16554 				xtv := string(val)
  16555 				sv.SubdivisionName = ptr.String(xtv)
  16556 			}
  16557 
  16558 		default:
  16559 			// Do nothing and ignore the unexpected tag element
  16560 			err = decoder.Decoder.Skip()
  16561 			if err != nil {
  16562 				return err
  16563 			}
  16564 
  16565 		}
  16566 		decoder = originalDecoder
  16567 	}
  16568 	*v = sv
  16569 	return nil
  16570 }
  16571 
  16572 func awsRestxml_deserializeDocumentGeoLocationDetailsList(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
  16573 	if v == nil {
  16574 		return fmt.Errorf("unexpected nil of type %T", v)
  16575 	}
  16576 	var sv []types.GeoLocationDetails
  16577 	if *v == nil {
  16578 		sv = make([]types.GeoLocationDetails, 0)
  16579 	} else {
  16580 		sv = *v
  16581 	}
  16582 
  16583 	originalDecoder := decoder
  16584 	for {
  16585 		t, done, err := decoder.Token()
  16586 		if err != nil {
  16587 			return err
  16588 		}
  16589 		if done {
  16590 			break
  16591 		}
  16592 		switch {
  16593 		case strings.EqualFold("GeoLocationDetails", t.Name.Local):
  16594 			var col types.GeoLocationDetails
  16595 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16596 			destAddr := &col
  16597 			if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil {
  16598 				return err
  16599 			}
  16600 			col = *destAddr
  16601 			sv = append(sv, col)
  16602 
  16603 		default:
  16604 			err = decoder.Decoder.Skip()
  16605 			if err != nil {
  16606 				return err
  16607 			}
  16608 
  16609 		}
  16610 		decoder = originalDecoder
  16611 	}
  16612 	*v = sv
  16613 	return nil
  16614 }
  16615 
  16616 func awsRestxml_deserializeDocumentGeoLocationDetailsListUnwrapped(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
  16617 	var sv []types.GeoLocationDetails
  16618 	if *v == nil {
  16619 		sv = make([]types.GeoLocationDetails, 0)
  16620 	} else {
  16621 		sv = *v
  16622 	}
  16623 
  16624 	switch {
  16625 	default:
  16626 		var mv types.GeoLocationDetails
  16627 		t := decoder.StartEl
  16628 		_ = t
  16629 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16630 		destAddr := &mv
  16631 		if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil {
  16632 			return err
  16633 		}
  16634 		mv = *destAddr
  16635 		sv = append(sv, mv)
  16636 	}
  16637 	*v = sv
  16638 	return nil
  16639 }
  16640 func awsRestxml_deserializeDocumentGeoProximityLocation(v **types.GeoProximityLocation, decoder smithyxml.NodeDecoder) error {
  16641 	if v == nil {
  16642 		return fmt.Errorf("unexpected nil of type %T", v)
  16643 	}
  16644 	var sv *types.GeoProximityLocation
  16645 	if *v == nil {
  16646 		sv = &types.GeoProximityLocation{}
  16647 	} else {
  16648 		sv = *v
  16649 	}
  16650 
  16651 	for {
  16652 		t, done, err := decoder.Token()
  16653 		if err != nil {
  16654 			return err
  16655 		}
  16656 		if done {
  16657 			break
  16658 		}
  16659 		originalDecoder := decoder
  16660 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16661 		switch {
  16662 		case strings.EqualFold("AWSRegion", t.Name.Local):
  16663 			val, err := decoder.Value()
  16664 			if err != nil {
  16665 				return err
  16666 			}
  16667 			if val == nil {
  16668 				break
  16669 			}
  16670 			{
  16671 				xtv := string(val)
  16672 				sv.AWSRegion = ptr.String(xtv)
  16673 			}
  16674 
  16675 		case strings.EqualFold("Bias", t.Name.Local):
  16676 			val, err := decoder.Value()
  16677 			if err != nil {
  16678 				return err
  16679 			}
  16680 			if val == nil {
  16681 				break
  16682 			}
  16683 			{
  16684 				xtv := string(val)
  16685 				i64, err := strconv.ParseInt(xtv, 10, 64)
  16686 				if err != nil {
  16687 					return err
  16688 				}
  16689 				sv.Bias = ptr.Int32(int32(i64))
  16690 			}
  16691 
  16692 		case strings.EqualFold("Coordinates", t.Name.Local):
  16693 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16694 			if err := awsRestxml_deserializeDocumentCoordinates(&sv.Coordinates, nodeDecoder); err != nil {
  16695 				return err
  16696 			}
  16697 
  16698 		case strings.EqualFold("LocalZoneGroup", t.Name.Local):
  16699 			val, err := decoder.Value()
  16700 			if err != nil {
  16701 				return err
  16702 			}
  16703 			if val == nil {
  16704 				break
  16705 			}
  16706 			{
  16707 				xtv := string(val)
  16708 				sv.LocalZoneGroup = ptr.String(xtv)
  16709 			}
  16710 
  16711 		default:
  16712 			// Do nothing and ignore the unexpected tag element
  16713 			err = decoder.Decoder.Skip()
  16714 			if err != nil {
  16715 				return err
  16716 			}
  16717 
  16718 		}
  16719 		decoder = originalDecoder
  16720 	}
  16721 	*v = sv
  16722 	return nil
  16723 }
  16724 
  16725 func awsRestxml_deserializeDocumentHealthCheck(v **types.HealthCheck, decoder smithyxml.NodeDecoder) error {
  16726 	if v == nil {
  16727 		return fmt.Errorf("unexpected nil of type %T", v)
  16728 	}
  16729 	var sv *types.HealthCheck
  16730 	if *v == nil {
  16731 		sv = &types.HealthCheck{}
  16732 	} else {
  16733 		sv = *v
  16734 	}
  16735 
  16736 	for {
  16737 		t, done, err := decoder.Token()
  16738 		if err != nil {
  16739 			return err
  16740 		}
  16741 		if done {
  16742 			break
  16743 		}
  16744 		originalDecoder := decoder
  16745 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16746 		switch {
  16747 		case strings.EqualFold("CallerReference", t.Name.Local):
  16748 			val, err := decoder.Value()
  16749 			if err != nil {
  16750 				return err
  16751 			}
  16752 			if val == nil {
  16753 				break
  16754 			}
  16755 			{
  16756 				xtv := string(val)
  16757 				sv.CallerReference = ptr.String(xtv)
  16758 			}
  16759 
  16760 		case strings.EqualFold("CloudWatchAlarmConfiguration", t.Name.Local):
  16761 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16762 			if err := awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(&sv.CloudWatchAlarmConfiguration, nodeDecoder); err != nil {
  16763 				return err
  16764 			}
  16765 
  16766 		case strings.EqualFold("HealthCheckConfig", t.Name.Local):
  16767 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16768 			if err := awsRestxml_deserializeDocumentHealthCheckConfig(&sv.HealthCheckConfig, nodeDecoder); err != nil {
  16769 				return err
  16770 			}
  16771 
  16772 		case strings.EqualFold("HealthCheckVersion", t.Name.Local):
  16773 			val, err := decoder.Value()
  16774 			if err != nil {
  16775 				return err
  16776 			}
  16777 			if val == nil {
  16778 				break
  16779 			}
  16780 			{
  16781 				xtv := string(val)
  16782 				i64, err := strconv.ParseInt(xtv, 10, 64)
  16783 				if err != nil {
  16784 					return err
  16785 				}
  16786 				sv.HealthCheckVersion = ptr.Int64(i64)
  16787 			}
  16788 
  16789 		case strings.EqualFold("Id", t.Name.Local):
  16790 			val, err := decoder.Value()
  16791 			if err != nil {
  16792 				return err
  16793 			}
  16794 			if val == nil {
  16795 				break
  16796 			}
  16797 			{
  16798 				xtv := string(val)
  16799 				sv.Id = ptr.String(xtv)
  16800 			}
  16801 
  16802 		case strings.EqualFold("LinkedService", t.Name.Local):
  16803 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16804 			if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil {
  16805 				return err
  16806 			}
  16807 
  16808 		default:
  16809 			// Do nothing and ignore the unexpected tag element
  16810 			err = decoder.Decoder.Skip()
  16811 			if err != nil {
  16812 				return err
  16813 			}
  16814 
  16815 		}
  16816 		decoder = originalDecoder
  16817 	}
  16818 	*v = sv
  16819 	return nil
  16820 }
  16821 
  16822 func awsRestxml_deserializeDocumentHealthCheckAlreadyExists(v **types.HealthCheckAlreadyExists, decoder smithyxml.NodeDecoder) error {
  16823 	if v == nil {
  16824 		return fmt.Errorf("unexpected nil of type %T", v)
  16825 	}
  16826 	var sv *types.HealthCheckAlreadyExists
  16827 	if *v == nil {
  16828 		sv = &types.HealthCheckAlreadyExists{}
  16829 	} else {
  16830 		sv = *v
  16831 	}
  16832 
  16833 	for {
  16834 		t, done, err := decoder.Token()
  16835 		if err != nil {
  16836 			return err
  16837 		}
  16838 		if done {
  16839 			break
  16840 		}
  16841 		originalDecoder := decoder
  16842 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16843 		switch {
  16844 		case strings.EqualFold("message", t.Name.Local):
  16845 			val, err := decoder.Value()
  16846 			if err != nil {
  16847 				return err
  16848 			}
  16849 			if val == nil {
  16850 				break
  16851 			}
  16852 			{
  16853 				xtv := string(val)
  16854 				sv.Message = ptr.String(xtv)
  16855 			}
  16856 
  16857 		default:
  16858 			// Do nothing and ignore the unexpected tag element
  16859 			err = decoder.Decoder.Skip()
  16860 			if err != nil {
  16861 				return err
  16862 			}
  16863 
  16864 		}
  16865 		decoder = originalDecoder
  16866 	}
  16867 	*v = sv
  16868 	return nil
  16869 }
  16870 
  16871 func awsRestxml_deserializeDocumentHealthCheckConfig(v **types.HealthCheckConfig, decoder smithyxml.NodeDecoder) error {
  16872 	if v == nil {
  16873 		return fmt.Errorf("unexpected nil of type %T", v)
  16874 	}
  16875 	var sv *types.HealthCheckConfig
  16876 	if *v == nil {
  16877 		sv = &types.HealthCheckConfig{}
  16878 	} else {
  16879 		sv = *v
  16880 	}
  16881 
  16882 	for {
  16883 		t, done, err := decoder.Token()
  16884 		if err != nil {
  16885 			return err
  16886 		}
  16887 		if done {
  16888 			break
  16889 		}
  16890 		originalDecoder := decoder
  16891 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16892 		switch {
  16893 		case strings.EqualFold("AlarmIdentifier", t.Name.Local):
  16894 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16895 			if err := awsRestxml_deserializeDocumentAlarmIdentifier(&sv.AlarmIdentifier, nodeDecoder); err != nil {
  16896 				return err
  16897 			}
  16898 
  16899 		case strings.EqualFold("ChildHealthChecks", t.Name.Local):
  16900 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16901 			if err := awsRestxml_deserializeDocumentChildHealthCheckList(&sv.ChildHealthChecks, nodeDecoder); err != nil {
  16902 				return err
  16903 			}
  16904 
  16905 		case strings.EqualFold("Disabled", t.Name.Local):
  16906 			val, err := decoder.Value()
  16907 			if err != nil {
  16908 				return err
  16909 			}
  16910 			if val == nil {
  16911 				break
  16912 			}
  16913 			{
  16914 				xtv, err := strconv.ParseBool(string(val))
  16915 				if err != nil {
  16916 					return fmt.Errorf("expected Disabled to be of type *bool, got %T instead", val)
  16917 				}
  16918 				sv.Disabled = ptr.Bool(xtv)
  16919 			}
  16920 
  16921 		case strings.EqualFold("EnableSNI", t.Name.Local):
  16922 			val, err := decoder.Value()
  16923 			if err != nil {
  16924 				return err
  16925 			}
  16926 			if val == nil {
  16927 				break
  16928 			}
  16929 			{
  16930 				xtv, err := strconv.ParseBool(string(val))
  16931 				if err != nil {
  16932 					return fmt.Errorf("expected EnableSNI to be of type *bool, got %T instead", val)
  16933 				}
  16934 				sv.EnableSNI = ptr.Bool(xtv)
  16935 			}
  16936 
  16937 		case strings.EqualFold("FailureThreshold", t.Name.Local):
  16938 			val, err := decoder.Value()
  16939 			if err != nil {
  16940 				return err
  16941 			}
  16942 			if val == nil {
  16943 				break
  16944 			}
  16945 			{
  16946 				xtv := string(val)
  16947 				i64, err := strconv.ParseInt(xtv, 10, 64)
  16948 				if err != nil {
  16949 					return err
  16950 				}
  16951 				sv.FailureThreshold = ptr.Int32(int32(i64))
  16952 			}
  16953 
  16954 		case strings.EqualFold("FullyQualifiedDomainName", t.Name.Local):
  16955 			val, err := decoder.Value()
  16956 			if err != nil {
  16957 				return err
  16958 			}
  16959 			if val == nil {
  16960 				break
  16961 			}
  16962 			{
  16963 				xtv := string(val)
  16964 				sv.FullyQualifiedDomainName = ptr.String(xtv)
  16965 			}
  16966 
  16967 		case strings.EqualFold("HealthThreshold", t.Name.Local):
  16968 			val, err := decoder.Value()
  16969 			if err != nil {
  16970 				return err
  16971 			}
  16972 			if val == nil {
  16973 				break
  16974 			}
  16975 			{
  16976 				xtv := string(val)
  16977 				i64, err := strconv.ParseInt(xtv, 10, 64)
  16978 				if err != nil {
  16979 					return err
  16980 				}
  16981 				sv.HealthThreshold = ptr.Int32(int32(i64))
  16982 			}
  16983 
  16984 		case strings.EqualFold("InsufficientDataHealthStatus", t.Name.Local):
  16985 			val, err := decoder.Value()
  16986 			if err != nil {
  16987 				return err
  16988 			}
  16989 			if val == nil {
  16990 				break
  16991 			}
  16992 			{
  16993 				xtv := string(val)
  16994 				sv.InsufficientDataHealthStatus = types.InsufficientDataHealthStatus(xtv)
  16995 			}
  16996 
  16997 		case strings.EqualFold("Inverted", t.Name.Local):
  16998 			val, err := decoder.Value()
  16999 			if err != nil {
  17000 				return err
  17001 			}
  17002 			if val == nil {
  17003 				break
  17004 			}
  17005 			{
  17006 				xtv, err := strconv.ParseBool(string(val))
  17007 				if err != nil {
  17008 					return fmt.Errorf("expected Inverted to be of type *bool, got %T instead", val)
  17009 				}
  17010 				sv.Inverted = ptr.Bool(xtv)
  17011 			}
  17012 
  17013 		case strings.EqualFold("IPAddress", t.Name.Local):
  17014 			val, err := decoder.Value()
  17015 			if err != nil {
  17016 				return err
  17017 			}
  17018 			if val == nil {
  17019 				break
  17020 			}
  17021 			{
  17022 				xtv := string(val)
  17023 				sv.IPAddress = ptr.String(xtv)
  17024 			}
  17025 
  17026 		case strings.EqualFold("MeasureLatency", t.Name.Local):
  17027 			val, err := decoder.Value()
  17028 			if err != nil {
  17029 				return err
  17030 			}
  17031 			if val == nil {
  17032 				break
  17033 			}
  17034 			{
  17035 				xtv, err := strconv.ParseBool(string(val))
  17036 				if err != nil {
  17037 					return fmt.Errorf("expected MeasureLatency to be of type *bool, got %T instead", val)
  17038 				}
  17039 				sv.MeasureLatency = ptr.Bool(xtv)
  17040 			}
  17041 
  17042 		case strings.EqualFold("Port", 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 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17053 				if err != nil {
  17054 					return err
  17055 				}
  17056 				sv.Port = ptr.Int32(int32(i64))
  17057 			}
  17058 
  17059 		case strings.EqualFold("Regions", t.Name.Local):
  17060 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17061 			if err := awsRestxml_deserializeDocumentHealthCheckRegionList(&sv.Regions, nodeDecoder); err != nil {
  17062 				return err
  17063 			}
  17064 
  17065 		case strings.EqualFold("RequestInterval", t.Name.Local):
  17066 			val, err := decoder.Value()
  17067 			if err != nil {
  17068 				return err
  17069 			}
  17070 			if val == nil {
  17071 				break
  17072 			}
  17073 			{
  17074 				xtv := string(val)
  17075 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17076 				if err != nil {
  17077 					return err
  17078 				}
  17079 				sv.RequestInterval = ptr.Int32(int32(i64))
  17080 			}
  17081 
  17082 		case strings.EqualFold("ResourcePath", t.Name.Local):
  17083 			val, err := decoder.Value()
  17084 			if err != nil {
  17085 				return err
  17086 			}
  17087 			if val == nil {
  17088 				break
  17089 			}
  17090 			{
  17091 				xtv := string(val)
  17092 				sv.ResourcePath = ptr.String(xtv)
  17093 			}
  17094 
  17095 		case strings.EqualFold("RoutingControlArn", t.Name.Local):
  17096 			val, err := decoder.Value()
  17097 			if err != nil {
  17098 				return err
  17099 			}
  17100 			if val == nil {
  17101 				break
  17102 			}
  17103 			{
  17104 				xtv := string(val)
  17105 				sv.RoutingControlArn = ptr.String(xtv)
  17106 			}
  17107 
  17108 		case strings.EqualFold("SearchString", t.Name.Local):
  17109 			val, err := decoder.Value()
  17110 			if err != nil {
  17111 				return err
  17112 			}
  17113 			if val == nil {
  17114 				break
  17115 			}
  17116 			{
  17117 				xtv := string(val)
  17118 				sv.SearchString = ptr.String(xtv)
  17119 			}
  17120 
  17121 		case strings.EqualFold("Type", t.Name.Local):
  17122 			val, err := decoder.Value()
  17123 			if err != nil {
  17124 				return err
  17125 			}
  17126 			if val == nil {
  17127 				break
  17128 			}
  17129 			{
  17130 				xtv := string(val)
  17131 				sv.Type = types.HealthCheckType(xtv)
  17132 			}
  17133 
  17134 		default:
  17135 			// Do nothing and ignore the unexpected tag element
  17136 			err = decoder.Decoder.Skip()
  17137 			if err != nil {
  17138 				return err
  17139 			}
  17140 
  17141 		}
  17142 		decoder = originalDecoder
  17143 	}
  17144 	*v = sv
  17145 	return nil
  17146 }
  17147 
  17148 func awsRestxml_deserializeDocumentHealthCheckInUse(v **types.HealthCheckInUse, decoder smithyxml.NodeDecoder) error {
  17149 	if v == nil {
  17150 		return fmt.Errorf("unexpected nil of type %T", v)
  17151 	}
  17152 	var sv *types.HealthCheckInUse
  17153 	if *v == nil {
  17154 		sv = &types.HealthCheckInUse{}
  17155 	} else {
  17156 		sv = *v
  17157 	}
  17158 
  17159 	for {
  17160 		t, done, err := decoder.Token()
  17161 		if err != nil {
  17162 			return err
  17163 		}
  17164 		if done {
  17165 			break
  17166 		}
  17167 		originalDecoder := decoder
  17168 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17169 		switch {
  17170 		case strings.EqualFold("message", t.Name.Local):
  17171 			val, err := decoder.Value()
  17172 			if err != nil {
  17173 				return err
  17174 			}
  17175 			if val == nil {
  17176 				break
  17177 			}
  17178 			{
  17179 				xtv := string(val)
  17180 				sv.Message = ptr.String(xtv)
  17181 			}
  17182 
  17183 		default:
  17184 			// Do nothing and ignore the unexpected tag element
  17185 			err = decoder.Decoder.Skip()
  17186 			if err != nil {
  17187 				return err
  17188 			}
  17189 
  17190 		}
  17191 		decoder = originalDecoder
  17192 	}
  17193 	*v = sv
  17194 	return nil
  17195 }
  17196 
  17197 func awsRestxml_deserializeDocumentHealthCheckObservation(v **types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
  17198 	if v == nil {
  17199 		return fmt.Errorf("unexpected nil of type %T", v)
  17200 	}
  17201 	var sv *types.HealthCheckObservation
  17202 	if *v == nil {
  17203 		sv = &types.HealthCheckObservation{}
  17204 	} else {
  17205 		sv = *v
  17206 	}
  17207 
  17208 	for {
  17209 		t, done, err := decoder.Token()
  17210 		if err != nil {
  17211 			return err
  17212 		}
  17213 		if done {
  17214 			break
  17215 		}
  17216 		originalDecoder := decoder
  17217 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17218 		switch {
  17219 		case strings.EqualFold("IPAddress", t.Name.Local):
  17220 			val, err := decoder.Value()
  17221 			if err != nil {
  17222 				return err
  17223 			}
  17224 			if val == nil {
  17225 				break
  17226 			}
  17227 			{
  17228 				xtv := string(val)
  17229 				sv.IPAddress = ptr.String(xtv)
  17230 			}
  17231 
  17232 		case strings.EqualFold("Region", 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 				sv.Region = types.HealthCheckRegion(xtv)
  17243 			}
  17244 
  17245 		case strings.EqualFold("StatusReport", t.Name.Local):
  17246 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17247 			if err := awsRestxml_deserializeDocumentStatusReport(&sv.StatusReport, nodeDecoder); err != nil {
  17248 				return err
  17249 			}
  17250 
  17251 		default:
  17252 			// Do nothing and ignore the unexpected tag element
  17253 			err = decoder.Decoder.Skip()
  17254 			if err != nil {
  17255 				return err
  17256 			}
  17257 
  17258 		}
  17259 		decoder = originalDecoder
  17260 	}
  17261 	*v = sv
  17262 	return nil
  17263 }
  17264 
  17265 func awsRestxml_deserializeDocumentHealthCheckObservations(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
  17266 	if v == nil {
  17267 		return fmt.Errorf("unexpected nil of type %T", v)
  17268 	}
  17269 	var sv []types.HealthCheckObservation
  17270 	if *v == nil {
  17271 		sv = make([]types.HealthCheckObservation, 0)
  17272 	} else {
  17273 		sv = *v
  17274 	}
  17275 
  17276 	originalDecoder := decoder
  17277 	for {
  17278 		t, done, err := decoder.Token()
  17279 		if err != nil {
  17280 			return err
  17281 		}
  17282 		if done {
  17283 			break
  17284 		}
  17285 		switch {
  17286 		case strings.EqualFold("HealthCheckObservation", t.Name.Local):
  17287 			var col types.HealthCheckObservation
  17288 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17289 			destAddr := &col
  17290 			if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil {
  17291 				return err
  17292 			}
  17293 			col = *destAddr
  17294 			sv = append(sv, col)
  17295 
  17296 		default:
  17297 			err = decoder.Decoder.Skip()
  17298 			if err != nil {
  17299 				return err
  17300 			}
  17301 
  17302 		}
  17303 		decoder = originalDecoder
  17304 	}
  17305 	*v = sv
  17306 	return nil
  17307 }
  17308 
  17309 func awsRestxml_deserializeDocumentHealthCheckObservationsUnwrapped(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
  17310 	var sv []types.HealthCheckObservation
  17311 	if *v == nil {
  17312 		sv = make([]types.HealthCheckObservation, 0)
  17313 	} else {
  17314 		sv = *v
  17315 	}
  17316 
  17317 	switch {
  17318 	default:
  17319 		var mv types.HealthCheckObservation
  17320 		t := decoder.StartEl
  17321 		_ = t
  17322 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17323 		destAddr := &mv
  17324 		if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil {
  17325 			return err
  17326 		}
  17327 		mv = *destAddr
  17328 		sv = append(sv, mv)
  17329 	}
  17330 	*v = sv
  17331 	return nil
  17332 }
  17333 func awsRestxml_deserializeDocumentHealthCheckRegionList(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error {
  17334 	if v == nil {
  17335 		return fmt.Errorf("unexpected nil of type %T", v)
  17336 	}
  17337 	var sv []types.HealthCheckRegion
  17338 	if *v == nil {
  17339 		sv = make([]types.HealthCheckRegion, 0)
  17340 	} else {
  17341 		sv = *v
  17342 	}
  17343 
  17344 	originalDecoder := decoder
  17345 	for {
  17346 		t, done, err := decoder.Token()
  17347 		if err != nil {
  17348 			return err
  17349 		}
  17350 		if done {
  17351 			break
  17352 		}
  17353 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17354 		decoder = memberDecoder
  17355 		switch {
  17356 		case strings.EqualFold("Region", t.Name.Local):
  17357 			var col types.HealthCheckRegion
  17358 			val, err := decoder.Value()
  17359 			if err != nil {
  17360 				return err
  17361 			}
  17362 			if val == nil {
  17363 				break
  17364 			}
  17365 			{
  17366 				xtv := string(val)
  17367 				col = types.HealthCheckRegion(xtv)
  17368 			}
  17369 			sv = append(sv, col)
  17370 
  17371 		default:
  17372 			err = decoder.Decoder.Skip()
  17373 			if err != nil {
  17374 				return err
  17375 			}
  17376 
  17377 		}
  17378 		decoder = originalDecoder
  17379 	}
  17380 	*v = sv
  17381 	return nil
  17382 }
  17383 
  17384 func awsRestxml_deserializeDocumentHealthCheckRegionListUnwrapped(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error {
  17385 	var sv []types.HealthCheckRegion
  17386 	if *v == nil {
  17387 		sv = make([]types.HealthCheckRegion, 0)
  17388 	} else {
  17389 		sv = *v
  17390 	}
  17391 
  17392 	switch {
  17393 	default:
  17394 		var mv types.HealthCheckRegion
  17395 		t := decoder.StartEl
  17396 		_ = t
  17397 		val, err := decoder.Value()
  17398 		if err != nil {
  17399 			return err
  17400 		}
  17401 		if val == nil {
  17402 			break
  17403 		}
  17404 		{
  17405 			xtv := string(val)
  17406 			mv = types.HealthCheckRegion(xtv)
  17407 		}
  17408 		sv = append(sv, mv)
  17409 	}
  17410 	*v = sv
  17411 	return nil
  17412 }
  17413 func awsRestxml_deserializeDocumentHealthChecks(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error {
  17414 	if v == nil {
  17415 		return fmt.Errorf("unexpected nil of type %T", v)
  17416 	}
  17417 	var sv []types.HealthCheck
  17418 	if *v == nil {
  17419 		sv = make([]types.HealthCheck, 0)
  17420 	} else {
  17421 		sv = *v
  17422 	}
  17423 
  17424 	originalDecoder := decoder
  17425 	for {
  17426 		t, done, err := decoder.Token()
  17427 		if err != nil {
  17428 			return err
  17429 		}
  17430 		if done {
  17431 			break
  17432 		}
  17433 		switch {
  17434 		case strings.EqualFold("HealthCheck", t.Name.Local):
  17435 			var col types.HealthCheck
  17436 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17437 			destAddr := &col
  17438 			if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil {
  17439 				return err
  17440 			}
  17441 			col = *destAddr
  17442 			sv = append(sv, col)
  17443 
  17444 		default:
  17445 			err = decoder.Decoder.Skip()
  17446 			if err != nil {
  17447 				return err
  17448 			}
  17449 
  17450 		}
  17451 		decoder = originalDecoder
  17452 	}
  17453 	*v = sv
  17454 	return nil
  17455 }
  17456 
  17457 func awsRestxml_deserializeDocumentHealthChecksUnwrapped(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error {
  17458 	var sv []types.HealthCheck
  17459 	if *v == nil {
  17460 		sv = make([]types.HealthCheck, 0)
  17461 	} else {
  17462 		sv = *v
  17463 	}
  17464 
  17465 	switch {
  17466 	default:
  17467 		var mv types.HealthCheck
  17468 		t := decoder.StartEl
  17469 		_ = t
  17470 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17471 		destAddr := &mv
  17472 		if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil {
  17473 			return err
  17474 		}
  17475 		mv = *destAddr
  17476 		sv = append(sv, mv)
  17477 	}
  17478 	*v = sv
  17479 	return nil
  17480 }
  17481 func awsRestxml_deserializeDocumentHealthCheckVersionMismatch(v **types.HealthCheckVersionMismatch, decoder smithyxml.NodeDecoder) error {
  17482 	if v == nil {
  17483 		return fmt.Errorf("unexpected nil of type %T", v)
  17484 	}
  17485 	var sv *types.HealthCheckVersionMismatch
  17486 	if *v == nil {
  17487 		sv = &types.HealthCheckVersionMismatch{}
  17488 	} else {
  17489 		sv = *v
  17490 	}
  17491 
  17492 	for {
  17493 		t, done, err := decoder.Token()
  17494 		if err != nil {
  17495 			return err
  17496 		}
  17497 		if done {
  17498 			break
  17499 		}
  17500 		originalDecoder := decoder
  17501 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17502 		switch {
  17503 		case strings.EqualFold("message", t.Name.Local):
  17504 			val, err := decoder.Value()
  17505 			if err != nil {
  17506 				return err
  17507 			}
  17508 			if val == nil {
  17509 				break
  17510 			}
  17511 			{
  17512 				xtv := string(val)
  17513 				sv.Message = ptr.String(xtv)
  17514 			}
  17515 
  17516 		default:
  17517 			// Do nothing and ignore the unexpected tag element
  17518 			err = decoder.Decoder.Skip()
  17519 			if err != nil {
  17520 				return err
  17521 			}
  17522 
  17523 		}
  17524 		decoder = originalDecoder
  17525 	}
  17526 	*v = sv
  17527 	return nil
  17528 }
  17529 
  17530 func awsRestxml_deserializeDocumentHostedZone(v **types.HostedZone, decoder smithyxml.NodeDecoder) error {
  17531 	if v == nil {
  17532 		return fmt.Errorf("unexpected nil of type %T", v)
  17533 	}
  17534 	var sv *types.HostedZone
  17535 	if *v == nil {
  17536 		sv = &types.HostedZone{}
  17537 	} else {
  17538 		sv = *v
  17539 	}
  17540 
  17541 	for {
  17542 		t, done, err := decoder.Token()
  17543 		if err != nil {
  17544 			return err
  17545 		}
  17546 		if done {
  17547 			break
  17548 		}
  17549 		originalDecoder := decoder
  17550 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17551 		switch {
  17552 		case strings.EqualFold("CallerReference", t.Name.Local):
  17553 			val, err := decoder.Value()
  17554 			if err != nil {
  17555 				return err
  17556 			}
  17557 			if val == nil {
  17558 				break
  17559 			}
  17560 			{
  17561 				xtv := string(val)
  17562 				sv.CallerReference = ptr.String(xtv)
  17563 			}
  17564 
  17565 		case strings.EqualFold("Config", t.Name.Local):
  17566 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17567 			if err := awsRestxml_deserializeDocumentHostedZoneConfig(&sv.Config, nodeDecoder); err != nil {
  17568 				return err
  17569 			}
  17570 
  17571 		case strings.EqualFold("Id", t.Name.Local):
  17572 			val, err := decoder.Value()
  17573 			if err != nil {
  17574 				return err
  17575 			}
  17576 			if val == nil {
  17577 				break
  17578 			}
  17579 			{
  17580 				xtv := string(val)
  17581 				sv.Id = ptr.String(xtv)
  17582 			}
  17583 
  17584 		case strings.EqualFold("LinkedService", t.Name.Local):
  17585 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17586 			if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil {
  17587 				return err
  17588 			}
  17589 
  17590 		case strings.EqualFold("Name", t.Name.Local):
  17591 			val, err := decoder.Value()
  17592 			if err != nil {
  17593 				return err
  17594 			}
  17595 			if val == nil {
  17596 				break
  17597 			}
  17598 			{
  17599 				xtv := string(val)
  17600 				sv.Name = ptr.String(xtv)
  17601 			}
  17602 
  17603 		case strings.EqualFold("ResourceRecordSetCount", t.Name.Local):
  17604 			val, err := decoder.Value()
  17605 			if err != nil {
  17606 				return err
  17607 			}
  17608 			if val == nil {
  17609 				break
  17610 			}
  17611 			{
  17612 				xtv := string(val)
  17613 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17614 				if err != nil {
  17615 					return err
  17616 				}
  17617 				sv.ResourceRecordSetCount = ptr.Int64(i64)
  17618 			}
  17619 
  17620 		default:
  17621 			// Do nothing and ignore the unexpected tag element
  17622 			err = decoder.Decoder.Skip()
  17623 			if err != nil {
  17624 				return err
  17625 			}
  17626 
  17627 		}
  17628 		decoder = originalDecoder
  17629 	}
  17630 	*v = sv
  17631 	return nil
  17632 }
  17633 
  17634 func awsRestxml_deserializeDocumentHostedZoneAlreadyExists(v **types.HostedZoneAlreadyExists, decoder smithyxml.NodeDecoder) error {
  17635 	if v == nil {
  17636 		return fmt.Errorf("unexpected nil of type %T", v)
  17637 	}
  17638 	var sv *types.HostedZoneAlreadyExists
  17639 	if *v == nil {
  17640 		sv = &types.HostedZoneAlreadyExists{}
  17641 	} else {
  17642 		sv = *v
  17643 	}
  17644 
  17645 	for {
  17646 		t, done, err := decoder.Token()
  17647 		if err != nil {
  17648 			return err
  17649 		}
  17650 		if done {
  17651 			break
  17652 		}
  17653 		originalDecoder := decoder
  17654 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17655 		switch {
  17656 		case strings.EqualFold("message", t.Name.Local):
  17657 			val, err := decoder.Value()
  17658 			if err != nil {
  17659 				return err
  17660 			}
  17661 			if val == nil {
  17662 				break
  17663 			}
  17664 			{
  17665 				xtv := string(val)
  17666 				sv.Message = ptr.String(xtv)
  17667 			}
  17668 
  17669 		default:
  17670 			// Do nothing and ignore the unexpected tag element
  17671 			err = decoder.Decoder.Skip()
  17672 			if err != nil {
  17673 				return err
  17674 			}
  17675 
  17676 		}
  17677 		decoder = originalDecoder
  17678 	}
  17679 	*v = sv
  17680 	return nil
  17681 }
  17682 
  17683 func awsRestxml_deserializeDocumentHostedZoneConfig(v **types.HostedZoneConfig, decoder smithyxml.NodeDecoder) error {
  17684 	if v == nil {
  17685 		return fmt.Errorf("unexpected nil of type %T", v)
  17686 	}
  17687 	var sv *types.HostedZoneConfig
  17688 	if *v == nil {
  17689 		sv = &types.HostedZoneConfig{}
  17690 	} else {
  17691 		sv = *v
  17692 	}
  17693 
  17694 	for {
  17695 		t, done, err := decoder.Token()
  17696 		if err != nil {
  17697 			return err
  17698 		}
  17699 		if done {
  17700 			break
  17701 		}
  17702 		originalDecoder := decoder
  17703 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17704 		switch {
  17705 		case strings.EqualFold("Comment", t.Name.Local):
  17706 			val, err := decoder.Value()
  17707 			if err != nil {
  17708 				return err
  17709 			}
  17710 			if val == nil {
  17711 				break
  17712 			}
  17713 			{
  17714 				xtv := string(val)
  17715 				sv.Comment = ptr.String(xtv)
  17716 			}
  17717 
  17718 		case strings.EqualFold("PrivateZone", t.Name.Local):
  17719 			val, err := decoder.Value()
  17720 			if err != nil {
  17721 				return err
  17722 			}
  17723 			if val == nil {
  17724 				break
  17725 			}
  17726 			{
  17727 				xtv, err := strconv.ParseBool(string(val))
  17728 				if err != nil {
  17729 					return fmt.Errorf("expected IsPrivateZone to be of type *bool, got %T instead", val)
  17730 				}
  17731 				sv.PrivateZone = xtv
  17732 			}
  17733 
  17734 		default:
  17735 			// Do nothing and ignore the unexpected tag element
  17736 			err = decoder.Decoder.Skip()
  17737 			if err != nil {
  17738 				return err
  17739 			}
  17740 
  17741 		}
  17742 		decoder = originalDecoder
  17743 	}
  17744 	*v = sv
  17745 	return nil
  17746 }
  17747 
  17748 func awsRestxml_deserializeDocumentHostedZoneLimit(v **types.HostedZoneLimit, decoder smithyxml.NodeDecoder) error {
  17749 	if v == nil {
  17750 		return fmt.Errorf("unexpected nil of type %T", v)
  17751 	}
  17752 	var sv *types.HostedZoneLimit
  17753 	if *v == nil {
  17754 		sv = &types.HostedZoneLimit{}
  17755 	} else {
  17756 		sv = *v
  17757 	}
  17758 
  17759 	for {
  17760 		t, done, err := decoder.Token()
  17761 		if err != nil {
  17762 			return err
  17763 		}
  17764 		if done {
  17765 			break
  17766 		}
  17767 		originalDecoder := decoder
  17768 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17769 		switch {
  17770 		case strings.EqualFold("Type", t.Name.Local):
  17771 			val, err := decoder.Value()
  17772 			if err != nil {
  17773 				return err
  17774 			}
  17775 			if val == nil {
  17776 				break
  17777 			}
  17778 			{
  17779 				xtv := string(val)
  17780 				sv.Type = types.HostedZoneLimitType(xtv)
  17781 			}
  17782 
  17783 		case strings.EqualFold("Value", t.Name.Local):
  17784 			val, err := decoder.Value()
  17785 			if err != nil {
  17786 				return err
  17787 			}
  17788 			if val == nil {
  17789 				break
  17790 			}
  17791 			{
  17792 				xtv := string(val)
  17793 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17794 				if err != nil {
  17795 					return err
  17796 				}
  17797 				sv.Value = ptr.Int64(i64)
  17798 			}
  17799 
  17800 		default:
  17801 			// Do nothing and ignore the unexpected tag element
  17802 			err = decoder.Decoder.Skip()
  17803 			if err != nil {
  17804 				return err
  17805 			}
  17806 
  17807 		}
  17808 		decoder = originalDecoder
  17809 	}
  17810 	*v = sv
  17811 	return nil
  17812 }
  17813 
  17814 func awsRestxml_deserializeDocumentHostedZoneNotEmpty(v **types.HostedZoneNotEmpty, decoder smithyxml.NodeDecoder) error {
  17815 	if v == nil {
  17816 		return fmt.Errorf("unexpected nil of type %T", v)
  17817 	}
  17818 	var sv *types.HostedZoneNotEmpty
  17819 	if *v == nil {
  17820 		sv = &types.HostedZoneNotEmpty{}
  17821 	} else {
  17822 		sv = *v
  17823 	}
  17824 
  17825 	for {
  17826 		t, done, err := decoder.Token()
  17827 		if err != nil {
  17828 			return err
  17829 		}
  17830 		if done {
  17831 			break
  17832 		}
  17833 		originalDecoder := decoder
  17834 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17835 		switch {
  17836 		case strings.EqualFold("message", t.Name.Local):
  17837 			val, err := decoder.Value()
  17838 			if err != nil {
  17839 				return err
  17840 			}
  17841 			if val == nil {
  17842 				break
  17843 			}
  17844 			{
  17845 				xtv := string(val)
  17846 				sv.Message = ptr.String(xtv)
  17847 			}
  17848 
  17849 		default:
  17850 			// Do nothing and ignore the unexpected tag element
  17851 			err = decoder.Decoder.Skip()
  17852 			if err != nil {
  17853 				return err
  17854 			}
  17855 
  17856 		}
  17857 		decoder = originalDecoder
  17858 	}
  17859 	*v = sv
  17860 	return nil
  17861 }
  17862 
  17863 func awsRestxml_deserializeDocumentHostedZoneNotFound(v **types.HostedZoneNotFound, decoder smithyxml.NodeDecoder) error {
  17864 	if v == nil {
  17865 		return fmt.Errorf("unexpected nil of type %T", v)
  17866 	}
  17867 	var sv *types.HostedZoneNotFound
  17868 	if *v == nil {
  17869 		sv = &types.HostedZoneNotFound{}
  17870 	} else {
  17871 		sv = *v
  17872 	}
  17873 
  17874 	for {
  17875 		t, done, err := decoder.Token()
  17876 		if err != nil {
  17877 			return err
  17878 		}
  17879 		if done {
  17880 			break
  17881 		}
  17882 		originalDecoder := decoder
  17883 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17884 		switch {
  17885 		case strings.EqualFold("message", t.Name.Local):
  17886 			val, err := decoder.Value()
  17887 			if err != nil {
  17888 				return err
  17889 			}
  17890 			if val == nil {
  17891 				break
  17892 			}
  17893 			{
  17894 				xtv := string(val)
  17895 				sv.Message = ptr.String(xtv)
  17896 			}
  17897 
  17898 		default:
  17899 			// Do nothing and ignore the unexpected tag element
  17900 			err = decoder.Decoder.Skip()
  17901 			if err != nil {
  17902 				return err
  17903 			}
  17904 
  17905 		}
  17906 		decoder = originalDecoder
  17907 	}
  17908 	*v = sv
  17909 	return nil
  17910 }
  17911 
  17912 func awsRestxml_deserializeDocumentHostedZoneNotPrivate(v **types.HostedZoneNotPrivate, decoder smithyxml.NodeDecoder) error {
  17913 	if v == nil {
  17914 		return fmt.Errorf("unexpected nil of type %T", v)
  17915 	}
  17916 	var sv *types.HostedZoneNotPrivate
  17917 	if *v == nil {
  17918 		sv = &types.HostedZoneNotPrivate{}
  17919 	} else {
  17920 		sv = *v
  17921 	}
  17922 
  17923 	for {
  17924 		t, done, err := decoder.Token()
  17925 		if err != nil {
  17926 			return err
  17927 		}
  17928 		if done {
  17929 			break
  17930 		}
  17931 		originalDecoder := decoder
  17932 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17933 		switch {
  17934 		case strings.EqualFold("message", t.Name.Local):
  17935 			val, err := decoder.Value()
  17936 			if err != nil {
  17937 				return err
  17938 			}
  17939 			if val == nil {
  17940 				break
  17941 			}
  17942 			{
  17943 				xtv := string(val)
  17944 				sv.Message = ptr.String(xtv)
  17945 			}
  17946 
  17947 		default:
  17948 			// Do nothing and ignore the unexpected tag element
  17949 			err = decoder.Decoder.Skip()
  17950 			if err != nil {
  17951 				return err
  17952 			}
  17953 
  17954 		}
  17955 		decoder = originalDecoder
  17956 	}
  17957 	*v = sv
  17958 	return nil
  17959 }
  17960 
  17961 func awsRestxml_deserializeDocumentHostedZoneOwner(v **types.HostedZoneOwner, decoder smithyxml.NodeDecoder) error {
  17962 	if v == nil {
  17963 		return fmt.Errorf("unexpected nil of type %T", v)
  17964 	}
  17965 	var sv *types.HostedZoneOwner
  17966 	if *v == nil {
  17967 		sv = &types.HostedZoneOwner{}
  17968 	} else {
  17969 		sv = *v
  17970 	}
  17971 
  17972 	for {
  17973 		t, done, err := decoder.Token()
  17974 		if err != nil {
  17975 			return err
  17976 		}
  17977 		if done {
  17978 			break
  17979 		}
  17980 		originalDecoder := decoder
  17981 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17982 		switch {
  17983 		case strings.EqualFold("OwningAccount", t.Name.Local):
  17984 			val, err := decoder.Value()
  17985 			if err != nil {
  17986 				return err
  17987 			}
  17988 			if val == nil {
  17989 				break
  17990 			}
  17991 			{
  17992 				xtv := string(val)
  17993 				sv.OwningAccount = ptr.String(xtv)
  17994 			}
  17995 
  17996 		case strings.EqualFold("OwningService", t.Name.Local):
  17997 			val, err := decoder.Value()
  17998 			if err != nil {
  17999 				return err
  18000 			}
  18001 			if val == nil {
  18002 				break
  18003 			}
  18004 			{
  18005 				xtv := string(val)
  18006 				sv.OwningService = ptr.String(xtv)
  18007 			}
  18008 
  18009 		default:
  18010 			// Do nothing and ignore the unexpected tag element
  18011 			err = decoder.Decoder.Skip()
  18012 			if err != nil {
  18013 				return err
  18014 			}
  18015 
  18016 		}
  18017 		decoder = originalDecoder
  18018 	}
  18019 	*v = sv
  18020 	return nil
  18021 }
  18022 
  18023 func awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(v **types.HostedZonePartiallyDelegated, decoder smithyxml.NodeDecoder) error {
  18024 	if v == nil {
  18025 		return fmt.Errorf("unexpected nil of type %T", v)
  18026 	}
  18027 	var sv *types.HostedZonePartiallyDelegated
  18028 	if *v == nil {
  18029 		sv = &types.HostedZonePartiallyDelegated{}
  18030 	} else {
  18031 		sv = *v
  18032 	}
  18033 
  18034 	for {
  18035 		t, done, err := decoder.Token()
  18036 		if err != nil {
  18037 			return err
  18038 		}
  18039 		if done {
  18040 			break
  18041 		}
  18042 		originalDecoder := decoder
  18043 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18044 		switch {
  18045 		case strings.EqualFold("message", t.Name.Local):
  18046 			val, err := decoder.Value()
  18047 			if err != nil {
  18048 				return err
  18049 			}
  18050 			if val == nil {
  18051 				break
  18052 			}
  18053 			{
  18054 				xtv := string(val)
  18055 				sv.Message = ptr.String(xtv)
  18056 			}
  18057 
  18058 		default:
  18059 			// Do nothing and ignore the unexpected tag element
  18060 			err = decoder.Decoder.Skip()
  18061 			if err != nil {
  18062 				return err
  18063 			}
  18064 
  18065 		}
  18066 		decoder = originalDecoder
  18067 	}
  18068 	*v = sv
  18069 	return nil
  18070 }
  18071 
  18072 func awsRestxml_deserializeDocumentHostedZones(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error {
  18073 	if v == nil {
  18074 		return fmt.Errorf("unexpected nil of type %T", v)
  18075 	}
  18076 	var sv []types.HostedZone
  18077 	if *v == nil {
  18078 		sv = make([]types.HostedZone, 0)
  18079 	} else {
  18080 		sv = *v
  18081 	}
  18082 
  18083 	originalDecoder := decoder
  18084 	for {
  18085 		t, done, err := decoder.Token()
  18086 		if err != nil {
  18087 			return err
  18088 		}
  18089 		if done {
  18090 			break
  18091 		}
  18092 		switch {
  18093 		case strings.EqualFold("HostedZone", t.Name.Local):
  18094 			var col types.HostedZone
  18095 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18096 			destAddr := &col
  18097 			if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil {
  18098 				return err
  18099 			}
  18100 			col = *destAddr
  18101 			sv = append(sv, col)
  18102 
  18103 		default:
  18104 			err = decoder.Decoder.Skip()
  18105 			if err != nil {
  18106 				return err
  18107 			}
  18108 
  18109 		}
  18110 		decoder = originalDecoder
  18111 	}
  18112 	*v = sv
  18113 	return nil
  18114 }
  18115 
  18116 func awsRestxml_deserializeDocumentHostedZonesUnwrapped(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error {
  18117 	var sv []types.HostedZone
  18118 	if *v == nil {
  18119 		sv = make([]types.HostedZone, 0)
  18120 	} else {
  18121 		sv = *v
  18122 	}
  18123 
  18124 	switch {
  18125 	default:
  18126 		var mv types.HostedZone
  18127 		t := decoder.StartEl
  18128 		_ = t
  18129 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18130 		destAddr := &mv
  18131 		if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil {
  18132 			return err
  18133 		}
  18134 		mv = *destAddr
  18135 		sv = append(sv, mv)
  18136 	}
  18137 	*v = sv
  18138 	return nil
  18139 }
  18140 func awsRestxml_deserializeDocumentHostedZoneSummaries(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
  18141 	if v == nil {
  18142 		return fmt.Errorf("unexpected nil of type %T", v)
  18143 	}
  18144 	var sv []types.HostedZoneSummary
  18145 	if *v == nil {
  18146 		sv = make([]types.HostedZoneSummary, 0)
  18147 	} else {
  18148 		sv = *v
  18149 	}
  18150 
  18151 	originalDecoder := decoder
  18152 	for {
  18153 		t, done, err := decoder.Token()
  18154 		if err != nil {
  18155 			return err
  18156 		}
  18157 		if done {
  18158 			break
  18159 		}
  18160 		switch {
  18161 		case strings.EqualFold("HostedZoneSummary", t.Name.Local):
  18162 			var col types.HostedZoneSummary
  18163 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18164 			destAddr := &col
  18165 			if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil {
  18166 				return err
  18167 			}
  18168 			col = *destAddr
  18169 			sv = append(sv, col)
  18170 
  18171 		default:
  18172 			err = decoder.Decoder.Skip()
  18173 			if err != nil {
  18174 				return err
  18175 			}
  18176 
  18177 		}
  18178 		decoder = originalDecoder
  18179 	}
  18180 	*v = sv
  18181 	return nil
  18182 }
  18183 
  18184 func awsRestxml_deserializeDocumentHostedZoneSummariesUnwrapped(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
  18185 	var sv []types.HostedZoneSummary
  18186 	if *v == nil {
  18187 		sv = make([]types.HostedZoneSummary, 0)
  18188 	} else {
  18189 		sv = *v
  18190 	}
  18191 
  18192 	switch {
  18193 	default:
  18194 		var mv types.HostedZoneSummary
  18195 		t := decoder.StartEl
  18196 		_ = t
  18197 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18198 		destAddr := &mv
  18199 		if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil {
  18200 			return err
  18201 		}
  18202 		mv = *destAddr
  18203 		sv = append(sv, mv)
  18204 	}
  18205 	*v = sv
  18206 	return nil
  18207 }
  18208 func awsRestxml_deserializeDocumentHostedZoneSummary(v **types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
  18209 	if v == nil {
  18210 		return fmt.Errorf("unexpected nil of type %T", v)
  18211 	}
  18212 	var sv *types.HostedZoneSummary
  18213 	if *v == nil {
  18214 		sv = &types.HostedZoneSummary{}
  18215 	} else {
  18216 		sv = *v
  18217 	}
  18218 
  18219 	for {
  18220 		t, done, err := decoder.Token()
  18221 		if err != nil {
  18222 			return err
  18223 		}
  18224 		if done {
  18225 			break
  18226 		}
  18227 		originalDecoder := decoder
  18228 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18229 		switch {
  18230 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  18231 			val, err := decoder.Value()
  18232 			if err != nil {
  18233 				return err
  18234 			}
  18235 			if val == nil {
  18236 				break
  18237 			}
  18238 			{
  18239 				xtv := string(val)
  18240 				sv.HostedZoneId = ptr.String(xtv)
  18241 			}
  18242 
  18243 		case strings.EqualFold("Name", t.Name.Local):
  18244 			val, err := decoder.Value()
  18245 			if err != nil {
  18246 				return err
  18247 			}
  18248 			if val == nil {
  18249 				break
  18250 			}
  18251 			{
  18252 				xtv := string(val)
  18253 				sv.Name = ptr.String(xtv)
  18254 			}
  18255 
  18256 		case strings.EqualFold("Owner", t.Name.Local):
  18257 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18258 			if err := awsRestxml_deserializeDocumentHostedZoneOwner(&sv.Owner, nodeDecoder); err != nil {
  18259 				return err
  18260 			}
  18261 
  18262 		default:
  18263 			// Do nothing and ignore the unexpected tag element
  18264 			err = decoder.Decoder.Skip()
  18265 			if err != nil {
  18266 				return err
  18267 			}
  18268 
  18269 		}
  18270 		decoder = originalDecoder
  18271 	}
  18272 	*v = sv
  18273 	return nil
  18274 }
  18275 
  18276 func awsRestxml_deserializeDocumentIncompatibleVersion(v **types.IncompatibleVersion, decoder smithyxml.NodeDecoder) error {
  18277 	if v == nil {
  18278 		return fmt.Errorf("unexpected nil of type %T", v)
  18279 	}
  18280 	var sv *types.IncompatibleVersion
  18281 	if *v == nil {
  18282 		sv = &types.IncompatibleVersion{}
  18283 	} else {
  18284 		sv = *v
  18285 	}
  18286 
  18287 	for {
  18288 		t, done, err := decoder.Token()
  18289 		if err != nil {
  18290 			return err
  18291 		}
  18292 		if done {
  18293 			break
  18294 		}
  18295 		originalDecoder := decoder
  18296 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18297 		switch {
  18298 		case strings.EqualFold("message", t.Name.Local):
  18299 			val, err := decoder.Value()
  18300 			if err != nil {
  18301 				return err
  18302 			}
  18303 			if val == nil {
  18304 				break
  18305 			}
  18306 			{
  18307 				xtv := string(val)
  18308 				sv.Message = ptr.String(xtv)
  18309 			}
  18310 
  18311 		default:
  18312 			// Do nothing and ignore the unexpected tag element
  18313 			err = decoder.Decoder.Skip()
  18314 			if err != nil {
  18315 				return err
  18316 			}
  18317 
  18318 		}
  18319 		decoder = originalDecoder
  18320 	}
  18321 	*v = sv
  18322 	return nil
  18323 }
  18324 
  18325 func awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(v **types.InsufficientCloudWatchLogsResourcePolicy, decoder smithyxml.NodeDecoder) error {
  18326 	if v == nil {
  18327 		return fmt.Errorf("unexpected nil of type %T", v)
  18328 	}
  18329 	var sv *types.InsufficientCloudWatchLogsResourcePolicy
  18330 	if *v == nil {
  18331 		sv = &types.InsufficientCloudWatchLogsResourcePolicy{}
  18332 	} else {
  18333 		sv = *v
  18334 	}
  18335 
  18336 	for {
  18337 		t, done, err := decoder.Token()
  18338 		if err != nil {
  18339 			return err
  18340 		}
  18341 		if done {
  18342 			break
  18343 		}
  18344 		originalDecoder := decoder
  18345 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18346 		switch {
  18347 		case strings.EqualFold("message", t.Name.Local):
  18348 			val, err := decoder.Value()
  18349 			if err != nil {
  18350 				return err
  18351 			}
  18352 			if val == nil {
  18353 				break
  18354 			}
  18355 			{
  18356 				xtv := string(val)
  18357 				sv.Message = ptr.String(xtv)
  18358 			}
  18359 
  18360 		default:
  18361 			// Do nothing and ignore the unexpected tag element
  18362 			err = decoder.Decoder.Skip()
  18363 			if err != nil {
  18364 				return err
  18365 			}
  18366 
  18367 		}
  18368 		decoder = originalDecoder
  18369 	}
  18370 	*v = sv
  18371 	return nil
  18372 }
  18373 
  18374 func awsRestxml_deserializeDocumentInvalidArgument(v **types.InvalidArgument, decoder smithyxml.NodeDecoder) error {
  18375 	if v == nil {
  18376 		return fmt.Errorf("unexpected nil of type %T", v)
  18377 	}
  18378 	var sv *types.InvalidArgument
  18379 	if *v == nil {
  18380 		sv = &types.InvalidArgument{}
  18381 	} else {
  18382 		sv = *v
  18383 	}
  18384 
  18385 	for {
  18386 		t, done, err := decoder.Token()
  18387 		if err != nil {
  18388 			return err
  18389 		}
  18390 		if done {
  18391 			break
  18392 		}
  18393 		originalDecoder := decoder
  18394 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18395 		switch {
  18396 		case strings.EqualFold("message", t.Name.Local):
  18397 			val, err := decoder.Value()
  18398 			if err != nil {
  18399 				return err
  18400 			}
  18401 			if val == nil {
  18402 				break
  18403 			}
  18404 			{
  18405 				xtv := string(val)
  18406 				sv.Message = ptr.String(xtv)
  18407 			}
  18408 
  18409 		default:
  18410 			// Do nothing and ignore the unexpected tag element
  18411 			err = decoder.Decoder.Skip()
  18412 			if err != nil {
  18413 				return err
  18414 			}
  18415 
  18416 		}
  18417 		decoder = originalDecoder
  18418 	}
  18419 	*v = sv
  18420 	return nil
  18421 }
  18422 
  18423 func awsRestxml_deserializeDocumentInvalidChangeBatch(v **types.InvalidChangeBatch, decoder smithyxml.NodeDecoder) error {
  18424 	if v == nil {
  18425 		return fmt.Errorf("unexpected nil of type %T", v)
  18426 	}
  18427 	var sv *types.InvalidChangeBatch
  18428 	if *v == nil {
  18429 		sv = &types.InvalidChangeBatch{}
  18430 	} else {
  18431 		sv = *v
  18432 	}
  18433 
  18434 	for {
  18435 		t, done, err := decoder.Token()
  18436 		if err != nil {
  18437 			return err
  18438 		}
  18439 		if done {
  18440 			break
  18441 		}
  18442 		originalDecoder := decoder
  18443 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18444 		switch {
  18445 		case strings.EqualFold("message", t.Name.Local):
  18446 			val, err := decoder.Value()
  18447 			if err != nil {
  18448 				return err
  18449 			}
  18450 			if val == nil {
  18451 				break
  18452 			}
  18453 			{
  18454 				xtv := string(val)
  18455 				sv.Message = ptr.String(xtv)
  18456 			}
  18457 
  18458 		case strings.EqualFold("messages", t.Name.Local):
  18459 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18460 			if err := awsRestxml_deserializeDocumentErrorMessages(&sv.Messages, nodeDecoder); err != nil {
  18461 				return err
  18462 			}
  18463 
  18464 		default:
  18465 			// Do nothing and ignore the unexpected tag element
  18466 			err = decoder.Decoder.Skip()
  18467 			if err != nil {
  18468 				return err
  18469 			}
  18470 
  18471 		}
  18472 		decoder = originalDecoder
  18473 	}
  18474 	*v = sv
  18475 	return nil
  18476 }
  18477 
  18478 func awsRestxml_deserializeDocumentInvalidDomainName(v **types.InvalidDomainName, decoder smithyxml.NodeDecoder) error {
  18479 	if v == nil {
  18480 		return fmt.Errorf("unexpected nil of type %T", v)
  18481 	}
  18482 	var sv *types.InvalidDomainName
  18483 	if *v == nil {
  18484 		sv = &types.InvalidDomainName{}
  18485 	} else {
  18486 		sv = *v
  18487 	}
  18488 
  18489 	for {
  18490 		t, done, err := decoder.Token()
  18491 		if err != nil {
  18492 			return err
  18493 		}
  18494 		if done {
  18495 			break
  18496 		}
  18497 		originalDecoder := decoder
  18498 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18499 		switch {
  18500 		case strings.EqualFold("message", t.Name.Local):
  18501 			val, err := decoder.Value()
  18502 			if err != nil {
  18503 				return err
  18504 			}
  18505 			if val == nil {
  18506 				break
  18507 			}
  18508 			{
  18509 				xtv := string(val)
  18510 				sv.Message = ptr.String(xtv)
  18511 			}
  18512 
  18513 		default:
  18514 			// Do nothing and ignore the unexpected tag element
  18515 			err = decoder.Decoder.Skip()
  18516 			if err != nil {
  18517 				return err
  18518 			}
  18519 
  18520 		}
  18521 		decoder = originalDecoder
  18522 	}
  18523 	*v = sv
  18524 	return nil
  18525 }
  18526 
  18527 func awsRestxml_deserializeDocumentInvalidInput(v **types.InvalidInput, decoder smithyxml.NodeDecoder) error {
  18528 	if v == nil {
  18529 		return fmt.Errorf("unexpected nil of type %T", v)
  18530 	}
  18531 	var sv *types.InvalidInput
  18532 	if *v == nil {
  18533 		sv = &types.InvalidInput{}
  18534 	} else {
  18535 		sv = *v
  18536 	}
  18537 
  18538 	for {
  18539 		t, done, err := decoder.Token()
  18540 		if err != nil {
  18541 			return err
  18542 		}
  18543 		if done {
  18544 			break
  18545 		}
  18546 		originalDecoder := decoder
  18547 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18548 		switch {
  18549 		case strings.EqualFold("message", t.Name.Local):
  18550 			val, err := decoder.Value()
  18551 			if err != nil {
  18552 				return err
  18553 			}
  18554 			if val == nil {
  18555 				break
  18556 			}
  18557 			{
  18558 				xtv := string(val)
  18559 				sv.Message = ptr.String(xtv)
  18560 			}
  18561 
  18562 		default:
  18563 			// Do nothing and ignore the unexpected tag element
  18564 			err = decoder.Decoder.Skip()
  18565 			if err != nil {
  18566 				return err
  18567 			}
  18568 
  18569 		}
  18570 		decoder = originalDecoder
  18571 	}
  18572 	*v = sv
  18573 	return nil
  18574 }
  18575 
  18576 func awsRestxml_deserializeDocumentInvalidKeySigningKeyName(v **types.InvalidKeySigningKeyName, decoder smithyxml.NodeDecoder) error {
  18577 	if v == nil {
  18578 		return fmt.Errorf("unexpected nil of type %T", v)
  18579 	}
  18580 	var sv *types.InvalidKeySigningKeyName
  18581 	if *v == nil {
  18582 		sv = &types.InvalidKeySigningKeyName{}
  18583 	} else {
  18584 		sv = *v
  18585 	}
  18586 
  18587 	for {
  18588 		t, done, err := decoder.Token()
  18589 		if err != nil {
  18590 			return err
  18591 		}
  18592 		if done {
  18593 			break
  18594 		}
  18595 		originalDecoder := decoder
  18596 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18597 		switch {
  18598 		case strings.EqualFold("message", t.Name.Local):
  18599 			val, err := decoder.Value()
  18600 			if err != nil {
  18601 				return err
  18602 			}
  18603 			if val == nil {
  18604 				break
  18605 			}
  18606 			{
  18607 				xtv := string(val)
  18608 				sv.Message = ptr.String(xtv)
  18609 			}
  18610 
  18611 		default:
  18612 			// Do nothing and ignore the unexpected tag element
  18613 			err = decoder.Decoder.Skip()
  18614 			if err != nil {
  18615 				return err
  18616 			}
  18617 
  18618 		}
  18619 		decoder = originalDecoder
  18620 	}
  18621 	*v = sv
  18622 	return nil
  18623 }
  18624 
  18625 func awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(v **types.InvalidKeySigningKeyStatus, decoder smithyxml.NodeDecoder) error {
  18626 	if v == nil {
  18627 		return fmt.Errorf("unexpected nil of type %T", v)
  18628 	}
  18629 	var sv *types.InvalidKeySigningKeyStatus
  18630 	if *v == nil {
  18631 		sv = &types.InvalidKeySigningKeyStatus{}
  18632 	} else {
  18633 		sv = *v
  18634 	}
  18635 
  18636 	for {
  18637 		t, done, err := decoder.Token()
  18638 		if err != nil {
  18639 			return err
  18640 		}
  18641 		if done {
  18642 			break
  18643 		}
  18644 		originalDecoder := decoder
  18645 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18646 		switch {
  18647 		case strings.EqualFold("message", t.Name.Local):
  18648 			val, err := decoder.Value()
  18649 			if err != nil {
  18650 				return err
  18651 			}
  18652 			if val == nil {
  18653 				break
  18654 			}
  18655 			{
  18656 				xtv := string(val)
  18657 				sv.Message = ptr.String(xtv)
  18658 			}
  18659 
  18660 		default:
  18661 			// Do nothing and ignore the unexpected tag element
  18662 			err = decoder.Decoder.Skip()
  18663 			if err != nil {
  18664 				return err
  18665 			}
  18666 
  18667 		}
  18668 		decoder = originalDecoder
  18669 	}
  18670 	*v = sv
  18671 	return nil
  18672 }
  18673 
  18674 func awsRestxml_deserializeDocumentInvalidKMSArn(v **types.InvalidKMSArn, decoder smithyxml.NodeDecoder) error {
  18675 	if v == nil {
  18676 		return fmt.Errorf("unexpected nil of type %T", v)
  18677 	}
  18678 	var sv *types.InvalidKMSArn
  18679 	if *v == nil {
  18680 		sv = &types.InvalidKMSArn{}
  18681 	} else {
  18682 		sv = *v
  18683 	}
  18684 
  18685 	for {
  18686 		t, done, err := decoder.Token()
  18687 		if err != nil {
  18688 			return err
  18689 		}
  18690 		if done {
  18691 			break
  18692 		}
  18693 		originalDecoder := decoder
  18694 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18695 		switch {
  18696 		case strings.EqualFold("message", t.Name.Local):
  18697 			val, err := decoder.Value()
  18698 			if err != nil {
  18699 				return err
  18700 			}
  18701 			if val == nil {
  18702 				break
  18703 			}
  18704 			{
  18705 				xtv := string(val)
  18706 				sv.Message = ptr.String(xtv)
  18707 			}
  18708 
  18709 		default:
  18710 			// Do nothing and ignore the unexpected tag element
  18711 			err = decoder.Decoder.Skip()
  18712 			if err != nil {
  18713 				return err
  18714 			}
  18715 
  18716 		}
  18717 		decoder = originalDecoder
  18718 	}
  18719 	*v = sv
  18720 	return nil
  18721 }
  18722 
  18723 func awsRestxml_deserializeDocumentInvalidPaginationToken(v **types.InvalidPaginationToken, decoder smithyxml.NodeDecoder) error {
  18724 	if v == nil {
  18725 		return fmt.Errorf("unexpected nil of type %T", v)
  18726 	}
  18727 	var sv *types.InvalidPaginationToken
  18728 	if *v == nil {
  18729 		sv = &types.InvalidPaginationToken{}
  18730 	} else {
  18731 		sv = *v
  18732 	}
  18733 
  18734 	for {
  18735 		t, done, err := decoder.Token()
  18736 		if err != nil {
  18737 			return err
  18738 		}
  18739 		if done {
  18740 			break
  18741 		}
  18742 		originalDecoder := decoder
  18743 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18744 		switch {
  18745 		case strings.EqualFold("message", t.Name.Local):
  18746 			val, err := decoder.Value()
  18747 			if err != nil {
  18748 				return err
  18749 			}
  18750 			if val == nil {
  18751 				break
  18752 			}
  18753 			{
  18754 				xtv := string(val)
  18755 				sv.Message = ptr.String(xtv)
  18756 			}
  18757 
  18758 		default:
  18759 			// Do nothing and ignore the unexpected tag element
  18760 			err = decoder.Decoder.Skip()
  18761 			if err != nil {
  18762 				return err
  18763 			}
  18764 
  18765 		}
  18766 		decoder = originalDecoder
  18767 	}
  18768 	*v = sv
  18769 	return nil
  18770 }
  18771 
  18772 func awsRestxml_deserializeDocumentInvalidSigningStatus(v **types.InvalidSigningStatus, decoder smithyxml.NodeDecoder) error {
  18773 	if v == nil {
  18774 		return fmt.Errorf("unexpected nil of type %T", v)
  18775 	}
  18776 	var sv *types.InvalidSigningStatus
  18777 	if *v == nil {
  18778 		sv = &types.InvalidSigningStatus{}
  18779 	} else {
  18780 		sv = *v
  18781 	}
  18782 
  18783 	for {
  18784 		t, done, err := decoder.Token()
  18785 		if err != nil {
  18786 			return err
  18787 		}
  18788 		if done {
  18789 			break
  18790 		}
  18791 		originalDecoder := decoder
  18792 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18793 		switch {
  18794 		case strings.EqualFold("message", t.Name.Local):
  18795 			val, err := decoder.Value()
  18796 			if err != nil {
  18797 				return err
  18798 			}
  18799 			if val == nil {
  18800 				break
  18801 			}
  18802 			{
  18803 				xtv := string(val)
  18804 				sv.Message = ptr.String(xtv)
  18805 			}
  18806 
  18807 		default:
  18808 			// Do nothing and ignore the unexpected tag element
  18809 			err = decoder.Decoder.Skip()
  18810 			if err != nil {
  18811 				return err
  18812 			}
  18813 
  18814 		}
  18815 		decoder = originalDecoder
  18816 	}
  18817 	*v = sv
  18818 	return nil
  18819 }
  18820 
  18821 func awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(v **types.InvalidTrafficPolicyDocument, decoder smithyxml.NodeDecoder) error {
  18822 	if v == nil {
  18823 		return fmt.Errorf("unexpected nil of type %T", v)
  18824 	}
  18825 	var sv *types.InvalidTrafficPolicyDocument
  18826 	if *v == nil {
  18827 		sv = &types.InvalidTrafficPolicyDocument{}
  18828 	} else {
  18829 		sv = *v
  18830 	}
  18831 
  18832 	for {
  18833 		t, done, err := decoder.Token()
  18834 		if err != nil {
  18835 			return err
  18836 		}
  18837 		if done {
  18838 			break
  18839 		}
  18840 		originalDecoder := decoder
  18841 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18842 		switch {
  18843 		case strings.EqualFold("message", t.Name.Local):
  18844 			val, err := decoder.Value()
  18845 			if err != nil {
  18846 				return err
  18847 			}
  18848 			if val == nil {
  18849 				break
  18850 			}
  18851 			{
  18852 				xtv := string(val)
  18853 				sv.Message = ptr.String(xtv)
  18854 			}
  18855 
  18856 		default:
  18857 			// Do nothing and ignore the unexpected tag element
  18858 			err = decoder.Decoder.Skip()
  18859 			if err != nil {
  18860 				return err
  18861 			}
  18862 
  18863 		}
  18864 		decoder = originalDecoder
  18865 	}
  18866 	*v = sv
  18867 	return nil
  18868 }
  18869 
  18870 func awsRestxml_deserializeDocumentInvalidVPCId(v **types.InvalidVPCId, decoder smithyxml.NodeDecoder) error {
  18871 	if v == nil {
  18872 		return fmt.Errorf("unexpected nil of type %T", v)
  18873 	}
  18874 	var sv *types.InvalidVPCId
  18875 	if *v == nil {
  18876 		sv = &types.InvalidVPCId{}
  18877 	} else {
  18878 		sv = *v
  18879 	}
  18880 
  18881 	for {
  18882 		t, done, err := decoder.Token()
  18883 		if err != nil {
  18884 			return err
  18885 		}
  18886 		if done {
  18887 			break
  18888 		}
  18889 		originalDecoder := decoder
  18890 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18891 		switch {
  18892 		case strings.EqualFold("message", t.Name.Local):
  18893 			val, err := decoder.Value()
  18894 			if err != nil {
  18895 				return err
  18896 			}
  18897 			if val == nil {
  18898 				break
  18899 			}
  18900 			{
  18901 				xtv := string(val)
  18902 				sv.Message = ptr.String(xtv)
  18903 			}
  18904 
  18905 		default:
  18906 			// Do nothing and ignore the unexpected tag element
  18907 			err = decoder.Decoder.Skip()
  18908 			if err != nil {
  18909 				return err
  18910 			}
  18911 
  18912 		}
  18913 		decoder = originalDecoder
  18914 	}
  18915 	*v = sv
  18916 	return nil
  18917 }
  18918 
  18919 func awsRestxml_deserializeDocumentKeySigningKey(v **types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
  18920 	if v == nil {
  18921 		return fmt.Errorf("unexpected nil of type %T", v)
  18922 	}
  18923 	var sv *types.KeySigningKey
  18924 	if *v == nil {
  18925 		sv = &types.KeySigningKey{}
  18926 	} else {
  18927 		sv = *v
  18928 	}
  18929 
  18930 	for {
  18931 		t, done, err := decoder.Token()
  18932 		if err != nil {
  18933 			return err
  18934 		}
  18935 		if done {
  18936 			break
  18937 		}
  18938 		originalDecoder := decoder
  18939 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18940 		switch {
  18941 		case strings.EqualFold("CreatedDate", t.Name.Local):
  18942 			val, err := decoder.Value()
  18943 			if err != nil {
  18944 				return err
  18945 			}
  18946 			if val == nil {
  18947 				break
  18948 			}
  18949 			{
  18950 				xtv := string(val)
  18951 				t, err := smithytime.ParseDateTime(xtv)
  18952 				if err != nil {
  18953 					return err
  18954 				}
  18955 				sv.CreatedDate = ptr.Time(t)
  18956 			}
  18957 
  18958 		case strings.EqualFold("DigestAlgorithmMnemonic", t.Name.Local):
  18959 			val, err := decoder.Value()
  18960 			if err != nil {
  18961 				return err
  18962 			}
  18963 			if val == nil {
  18964 				break
  18965 			}
  18966 			{
  18967 				xtv := string(val)
  18968 				sv.DigestAlgorithmMnemonic = ptr.String(xtv)
  18969 			}
  18970 
  18971 		case strings.EqualFold("DigestAlgorithmType", t.Name.Local):
  18972 			val, err := decoder.Value()
  18973 			if err != nil {
  18974 				return err
  18975 			}
  18976 			if val == nil {
  18977 				break
  18978 			}
  18979 			{
  18980 				xtv := string(val)
  18981 				i64, err := strconv.ParseInt(xtv, 10, 64)
  18982 				if err != nil {
  18983 					return err
  18984 				}
  18985 				sv.DigestAlgorithmType = int32(i64)
  18986 			}
  18987 
  18988 		case strings.EqualFold("DigestValue", t.Name.Local):
  18989 			val, err := decoder.Value()
  18990 			if err != nil {
  18991 				return err
  18992 			}
  18993 			if val == nil {
  18994 				break
  18995 			}
  18996 			{
  18997 				xtv := string(val)
  18998 				sv.DigestValue = ptr.String(xtv)
  18999 			}
  19000 
  19001 		case strings.EqualFold("DNSKEYRecord", t.Name.Local):
  19002 			val, err := decoder.Value()
  19003 			if err != nil {
  19004 				return err
  19005 			}
  19006 			if val == nil {
  19007 				break
  19008 			}
  19009 			{
  19010 				xtv := string(val)
  19011 				sv.DNSKEYRecord = ptr.String(xtv)
  19012 			}
  19013 
  19014 		case strings.EqualFold("DSRecord", t.Name.Local):
  19015 			val, err := decoder.Value()
  19016 			if err != nil {
  19017 				return err
  19018 			}
  19019 			if val == nil {
  19020 				break
  19021 			}
  19022 			{
  19023 				xtv := string(val)
  19024 				sv.DSRecord = ptr.String(xtv)
  19025 			}
  19026 
  19027 		case strings.EqualFold("Flag", t.Name.Local):
  19028 			val, err := decoder.Value()
  19029 			if err != nil {
  19030 				return err
  19031 			}
  19032 			if val == nil {
  19033 				break
  19034 			}
  19035 			{
  19036 				xtv := string(val)
  19037 				i64, err := strconv.ParseInt(xtv, 10, 64)
  19038 				if err != nil {
  19039 					return err
  19040 				}
  19041 				sv.Flag = int32(i64)
  19042 			}
  19043 
  19044 		case strings.EqualFold("KeyTag", t.Name.Local):
  19045 			val, err := decoder.Value()
  19046 			if err != nil {
  19047 				return err
  19048 			}
  19049 			if val == nil {
  19050 				break
  19051 			}
  19052 			{
  19053 				xtv := string(val)
  19054 				i64, err := strconv.ParseInt(xtv, 10, 64)
  19055 				if err != nil {
  19056 					return err
  19057 				}
  19058 				sv.KeyTag = int32(i64)
  19059 			}
  19060 
  19061 		case strings.EqualFold("KmsArn", t.Name.Local):
  19062 			val, err := decoder.Value()
  19063 			if err != nil {
  19064 				return err
  19065 			}
  19066 			if val == nil {
  19067 				break
  19068 			}
  19069 			{
  19070 				xtv := string(val)
  19071 				sv.KmsArn = ptr.String(xtv)
  19072 			}
  19073 
  19074 		case strings.EqualFold("LastModifiedDate", t.Name.Local):
  19075 			val, err := decoder.Value()
  19076 			if err != nil {
  19077 				return err
  19078 			}
  19079 			if val == nil {
  19080 				break
  19081 			}
  19082 			{
  19083 				xtv := string(val)
  19084 				t, err := smithytime.ParseDateTime(xtv)
  19085 				if err != nil {
  19086 					return err
  19087 				}
  19088 				sv.LastModifiedDate = ptr.Time(t)
  19089 			}
  19090 
  19091 		case strings.EqualFold("Name", t.Name.Local):
  19092 			val, err := decoder.Value()
  19093 			if err != nil {
  19094 				return err
  19095 			}
  19096 			if val == nil {
  19097 				break
  19098 			}
  19099 			{
  19100 				xtv := string(val)
  19101 				sv.Name = ptr.String(xtv)
  19102 			}
  19103 
  19104 		case strings.EqualFold("PublicKey", t.Name.Local):
  19105 			val, err := decoder.Value()
  19106 			if err != nil {
  19107 				return err
  19108 			}
  19109 			if val == nil {
  19110 				break
  19111 			}
  19112 			{
  19113 				xtv := string(val)
  19114 				sv.PublicKey = ptr.String(xtv)
  19115 			}
  19116 
  19117 		case strings.EqualFold("SigningAlgorithmMnemonic", t.Name.Local):
  19118 			val, err := decoder.Value()
  19119 			if err != nil {
  19120 				return err
  19121 			}
  19122 			if val == nil {
  19123 				break
  19124 			}
  19125 			{
  19126 				xtv := string(val)
  19127 				sv.SigningAlgorithmMnemonic = ptr.String(xtv)
  19128 			}
  19129 
  19130 		case strings.EqualFold("SigningAlgorithmType", t.Name.Local):
  19131 			val, err := decoder.Value()
  19132 			if err != nil {
  19133 				return err
  19134 			}
  19135 			if val == nil {
  19136 				break
  19137 			}
  19138 			{
  19139 				xtv := string(val)
  19140 				i64, err := strconv.ParseInt(xtv, 10, 64)
  19141 				if err != nil {
  19142 					return err
  19143 				}
  19144 				sv.SigningAlgorithmType = int32(i64)
  19145 			}
  19146 
  19147 		case strings.EqualFold("Status", t.Name.Local):
  19148 			val, err := decoder.Value()
  19149 			if err != nil {
  19150 				return err
  19151 			}
  19152 			if val == nil {
  19153 				break
  19154 			}
  19155 			{
  19156 				xtv := string(val)
  19157 				sv.Status = ptr.String(xtv)
  19158 			}
  19159 
  19160 		case strings.EqualFold("StatusMessage", t.Name.Local):
  19161 			val, err := decoder.Value()
  19162 			if err != nil {
  19163 				return err
  19164 			}
  19165 			if val == nil {
  19166 				break
  19167 			}
  19168 			{
  19169 				xtv := string(val)
  19170 				sv.StatusMessage = ptr.String(xtv)
  19171 			}
  19172 
  19173 		default:
  19174 			// Do nothing and ignore the unexpected tag element
  19175 			err = decoder.Decoder.Skip()
  19176 			if err != nil {
  19177 				return err
  19178 			}
  19179 
  19180 		}
  19181 		decoder = originalDecoder
  19182 	}
  19183 	*v = sv
  19184 	return nil
  19185 }
  19186 
  19187 func awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(v **types.KeySigningKeyAlreadyExists, decoder smithyxml.NodeDecoder) error {
  19188 	if v == nil {
  19189 		return fmt.Errorf("unexpected nil of type %T", v)
  19190 	}
  19191 	var sv *types.KeySigningKeyAlreadyExists
  19192 	if *v == nil {
  19193 		sv = &types.KeySigningKeyAlreadyExists{}
  19194 	} else {
  19195 		sv = *v
  19196 	}
  19197 
  19198 	for {
  19199 		t, done, err := decoder.Token()
  19200 		if err != nil {
  19201 			return err
  19202 		}
  19203 		if done {
  19204 			break
  19205 		}
  19206 		originalDecoder := decoder
  19207 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19208 		switch {
  19209 		case strings.EqualFold("message", t.Name.Local):
  19210 			val, err := decoder.Value()
  19211 			if err != nil {
  19212 				return err
  19213 			}
  19214 			if val == nil {
  19215 				break
  19216 			}
  19217 			{
  19218 				xtv := string(val)
  19219 				sv.Message = ptr.String(xtv)
  19220 			}
  19221 
  19222 		default:
  19223 			// Do nothing and ignore the unexpected tag element
  19224 			err = decoder.Decoder.Skip()
  19225 			if err != nil {
  19226 				return err
  19227 			}
  19228 
  19229 		}
  19230 		decoder = originalDecoder
  19231 	}
  19232 	*v = sv
  19233 	return nil
  19234 }
  19235 
  19236 func awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(v **types.KeySigningKeyInParentDSRecord, decoder smithyxml.NodeDecoder) error {
  19237 	if v == nil {
  19238 		return fmt.Errorf("unexpected nil of type %T", v)
  19239 	}
  19240 	var sv *types.KeySigningKeyInParentDSRecord
  19241 	if *v == nil {
  19242 		sv = &types.KeySigningKeyInParentDSRecord{}
  19243 	} else {
  19244 		sv = *v
  19245 	}
  19246 
  19247 	for {
  19248 		t, done, err := decoder.Token()
  19249 		if err != nil {
  19250 			return err
  19251 		}
  19252 		if done {
  19253 			break
  19254 		}
  19255 		originalDecoder := decoder
  19256 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19257 		switch {
  19258 		case strings.EqualFold("message", t.Name.Local):
  19259 			val, err := decoder.Value()
  19260 			if err != nil {
  19261 				return err
  19262 			}
  19263 			if val == nil {
  19264 				break
  19265 			}
  19266 			{
  19267 				xtv := string(val)
  19268 				sv.Message = ptr.String(xtv)
  19269 			}
  19270 
  19271 		default:
  19272 			// Do nothing and ignore the unexpected tag element
  19273 			err = decoder.Decoder.Skip()
  19274 			if err != nil {
  19275 				return err
  19276 			}
  19277 
  19278 		}
  19279 		decoder = originalDecoder
  19280 	}
  19281 	*v = sv
  19282 	return nil
  19283 }
  19284 
  19285 func awsRestxml_deserializeDocumentKeySigningKeyInUse(v **types.KeySigningKeyInUse, decoder smithyxml.NodeDecoder) error {
  19286 	if v == nil {
  19287 		return fmt.Errorf("unexpected nil of type %T", v)
  19288 	}
  19289 	var sv *types.KeySigningKeyInUse
  19290 	if *v == nil {
  19291 		sv = &types.KeySigningKeyInUse{}
  19292 	} else {
  19293 		sv = *v
  19294 	}
  19295 
  19296 	for {
  19297 		t, done, err := decoder.Token()
  19298 		if err != nil {
  19299 			return err
  19300 		}
  19301 		if done {
  19302 			break
  19303 		}
  19304 		originalDecoder := decoder
  19305 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19306 		switch {
  19307 		case strings.EqualFold("message", t.Name.Local):
  19308 			val, err := decoder.Value()
  19309 			if err != nil {
  19310 				return err
  19311 			}
  19312 			if val == nil {
  19313 				break
  19314 			}
  19315 			{
  19316 				xtv := string(val)
  19317 				sv.Message = ptr.String(xtv)
  19318 			}
  19319 
  19320 		default:
  19321 			// Do nothing and ignore the unexpected tag element
  19322 			err = decoder.Decoder.Skip()
  19323 			if err != nil {
  19324 				return err
  19325 			}
  19326 
  19327 		}
  19328 		decoder = originalDecoder
  19329 	}
  19330 	*v = sv
  19331 	return nil
  19332 }
  19333 
  19334 func awsRestxml_deserializeDocumentKeySigningKeys(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
  19335 	if v == nil {
  19336 		return fmt.Errorf("unexpected nil of type %T", v)
  19337 	}
  19338 	var sv []types.KeySigningKey
  19339 	if *v == nil {
  19340 		sv = make([]types.KeySigningKey, 0)
  19341 	} else {
  19342 		sv = *v
  19343 	}
  19344 
  19345 	originalDecoder := decoder
  19346 	for {
  19347 		t, done, err := decoder.Token()
  19348 		if err != nil {
  19349 			return err
  19350 		}
  19351 		if done {
  19352 			break
  19353 		}
  19354 		switch {
  19355 		case strings.EqualFold("member", t.Name.Local):
  19356 			var col types.KeySigningKey
  19357 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  19358 			destAddr := &col
  19359 			if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil {
  19360 				return err
  19361 			}
  19362 			col = *destAddr
  19363 			sv = append(sv, col)
  19364 
  19365 		default:
  19366 			err = decoder.Decoder.Skip()
  19367 			if err != nil {
  19368 				return err
  19369 			}
  19370 
  19371 		}
  19372 		decoder = originalDecoder
  19373 	}
  19374 	*v = sv
  19375 	return nil
  19376 }
  19377 
  19378 func awsRestxml_deserializeDocumentKeySigningKeysUnwrapped(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
  19379 	var sv []types.KeySigningKey
  19380 	if *v == nil {
  19381 		sv = make([]types.KeySigningKey, 0)
  19382 	} else {
  19383 		sv = *v
  19384 	}
  19385 
  19386 	switch {
  19387 	default:
  19388 		var mv types.KeySigningKey
  19389 		t := decoder.StartEl
  19390 		_ = t
  19391 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  19392 		destAddr := &mv
  19393 		if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil {
  19394 			return err
  19395 		}
  19396 		mv = *destAddr
  19397 		sv = append(sv, mv)
  19398 	}
  19399 	*v = sv
  19400 	return nil
  19401 }
  19402 func awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(v **types.KeySigningKeyWithActiveStatusNotFound, decoder smithyxml.NodeDecoder) error {
  19403 	if v == nil {
  19404 		return fmt.Errorf("unexpected nil of type %T", v)
  19405 	}
  19406 	var sv *types.KeySigningKeyWithActiveStatusNotFound
  19407 	if *v == nil {
  19408 		sv = &types.KeySigningKeyWithActiveStatusNotFound{}
  19409 	} else {
  19410 		sv = *v
  19411 	}
  19412 
  19413 	for {
  19414 		t, done, err := decoder.Token()
  19415 		if err != nil {
  19416 			return err
  19417 		}
  19418 		if done {
  19419 			break
  19420 		}
  19421 		originalDecoder := decoder
  19422 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19423 		switch {
  19424 		case strings.EqualFold("message", t.Name.Local):
  19425 			val, err := decoder.Value()
  19426 			if err != nil {
  19427 				return err
  19428 			}
  19429 			if val == nil {
  19430 				break
  19431 			}
  19432 			{
  19433 				xtv := string(val)
  19434 				sv.Message = ptr.String(xtv)
  19435 			}
  19436 
  19437 		default:
  19438 			// Do nothing and ignore the unexpected tag element
  19439 			err = decoder.Decoder.Skip()
  19440 			if err != nil {
  19441 				return err
  19442 			}
  19443 
  19444 		}
  19445 		decoder = originalDecoder
  19446 	}
  19447 	*v = sv
  19448 	return nil
  19449 }
  19450 
  19451 func awsRestxml_deserializeDocumentLastVPCAssociation(v **types.LastVPCAssociation, decoder smithyxml.NodeDecoder) error {
  19452 	if v == nil {
  19453 		return fmt.Errorf("unexpected nil of type %T", v)
  19454 	}
  19455 	var sv *types.LastVPCAssociation
  19456 	if *v == nil {
  19457 		sv = &types.LastVPCAssociation{}
  19458 	} else {
  19459 		sv = *v
  19460 	}
  19461 
  19462 	for {
  19463 		t, done, err := decoder.Token()
  19464 		if err != nil {
  19465 			return err
  19466 		}
  19467 		if done {
  19468 			break
  19469 		}
  19470 		originalDecoder := decoder
  19471 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19472 		switch {
  19473 		case strings.EqualFold("message", t.Name.Local):
  19474 			val, err := decoder.Value()
  19475 			if err != nil {
  19476 				return err
  19477 			}
  19478 			if val == nil {
  19479 				break
  19480 			}
  19481 			{
  19482 				xtv := string(val)
  19483 				sv.Message = ptr.String(xtv)
  19484 			}
  19485 
  19486 		default:
  19487 			// Do nothing and ignore the unexpected tag element
  19488 			err = decoder.Decoder.Skip()
  19489 			if err != nil {
  19490 				return err
  19491 			}
  19492 
  19493 		}
  19494 		decoder = originalDecoder
  19495 	}
  19496 	*v = sv
  19497 	return nil
  19498 }
  19499 
  19500 func awsRestxml_deserializeDocumentLimitsExceeded(v **types.LimitsExceeded, decoder smithyxml.NodeDecoder) error {
  19501 	if v == nil {
  19502 		return fmt.Errorf("unexpected nil of type %T", v)
  19503 	}
  19504 	var sv *types.LimitsExceeded
  19505 	if *v == nil {
  19506 		sv = &types.LimitsExceeded{}
  19507 	} else {
  19508 		sv = *v
  19509 	}
  19510 
  19511 	for {
  19512 		t, done, err := decoder.Token()
  19513 		if err != nil {
  19514 			return err
  19515 		}
  19516 		if done {
  19517 			break
  19518 		}
  19519 		originalDecoder := decoder
  19520 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19521 		switch {
  19522 		case strings.EqualFold("message", 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.Message = ptr.String(xtv)
  19533 			}
  19534 
  19535 		default:
  19536 			// Do nothing and ignore the unexpected tag element
  19537 			err = decoder.Decoder.Skip()
  19538 			if err != nil {
  19539 				return err
  19540 			}
  19541 
  19542 		}
  19543 		decoder = originalDecoder
  19544 	}
  19545 	*v = sv
  19546 	return nil
  19547 }
  19548 
  19549 func awsRestxml_deserializeDocumentLinkedService(v **types.LinkedService, decoder smithyxml.NodeDecoder) error {
  19550 	if v == nil {
  19551 		return fmt.Errorf("unexpected nil of type %T", v)
  19552 	}
  19553 	var sv *types.LinkedService
  19554 	if *v == nil {
  19555 		sv = &types.LinkedService{}
  19556 	} else {
  19557 		sv = *v
  19558 	}
  19559 
  19560 	for {
  19561 		t, done, err := decoder.Token()
  19562 		if err != nil {
  19563 			return err
  19564 		}
  19565 		if done {
  19566 			break
  19567 		}
  19568 		originalDecoder := decoder
  19569 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19570 		switch {
  19571 		case strings.EqualFold("Description", t.Name.Local):
  19572 			val, err := decoder.Value()
  19573 			if err != nil {
  19574 				return err
  19575 			}
  19576 			if val == nil {
  19577 				break
  19578 			}
  19579 			{
  19580 				xtv := string(val)
  19581 				sv.Description = ptr.String(xtv)
  19582 			}
  19583 
  19584 		case strings.EqualFold("ServicePrincipal", t.Name.Local):
  19585 			val, err := decoder.Value()
  19586 			if err != nil {
  19587 				return err
  19588 			}
  19589 			if val == nil {
  19590 				break
  19591 			}
  19592 			{
  19593 				xtv := string(val)
  19594 				sv.ServicePrincipal = ptr.String(xtv)
  19595 			}
  19596 
  19597 		default:
  19598 			// Do nothing and ignore the unexpected tag element
  19599 			err = decoder.Decoder.Skip()
  19600 			if err != nil {
  19601 				return err
  19602 			}
  19603 
  19604 		}
  19605 		decoder = originalDecoder
  19606 	}
  19607 	*v = sv
  19608 	return nil
  19609 }
  19610 
  19611 func awsRestxml_deserializeDocumentLocationSummaries(v *[]types.LocationSummary, decoder smithyxml.NodeDecoder) error {
  19612 	if v == nil {
  19613 		return fmt.Errorf("unexpected nil of type %T", v)
  19614 	}
  19615 	var sv []types.LocationSummary
  19616 	if *v == nil {
  19617 		sv = make([]types.LocationSummary, 0)
  19618 	} else {
  19619 		sv = *v
  19620 	}
  19621 
  19622 	originalDecoder := decoder
  19623 	for {
  19624 		t, done, err := decoder.Token()
  19625 		if err != nil {
  19626 			return err
  19627 		}
  19628 		if done {
  19629 			break
  19630 		}
  19631 		switch {
  19632 		case strings.EqualFold("member", t.Name.Local):
  19633 			var col types.LocationSummary
  19634 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  19635 			destAddr := &col
  19636 			if err := awsRestxml_deserializeDocumentLocationSummary(&destAddr, nodeDecoder); err != nil {
  19637 				return err
  19638 			}
  19639 			col = *destAddr
  19640 			sv = append(sv, col)
  19641 
  19642 		default:
  19643 			err = decoder.Decoder.Skip()
  19644 			if err != nil {
  19645 				return err
  19646 			}
  19647 
  19648 		}
  19649 		decoder = originalDecoder
  19650 	}
  19651 	*v = sv
  19652 	return nil
  19653 }
  19654 
  19655 func awsRestxml_deserializeDocumentLocationSummariesUnwrapped(v *[]types.LocationSummary, decoder smithyxml.NodeDecoder) error {
  19656 	var sv []types.LocationSummary
  19657 	if *v == nil {
  19658 		sv = make([]types.LocationSummary, 0)
  19659 	} else {
  19660 		sv = *v
  19661 	}
  19662 
  19663 	switch {
  19664 	default:
  19665 		var mv types.LocationSummary
  19666 		t := decoder.StartEl
  19667 		_ = t
  19668 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  19669 		destAddr := &mv
  19670 		if err := awsRestxml_deserializeDocumentLocationSummary(&destAddr, nodeDecoder); err != nil {
  19671 			return err
  19672 		}
  19673 		mv = *destAddr
  19674 		sv = append(sv, mv)
  19675 	}
  19676 	*v = sv
  19677 	return nil
  19678 }
  19679 func awsRestxml_deserializeDocumentLocationSummary(v **types.LocationSummary, decoder smithyxml.NodeDecoder) error {
  19680 	if v == nil {
  19681 		return fmt.Errorf("unexpected nil of type %T", v)
  19682 	}
  19683 	var sv *types.LocationSummary
  19684 	if *v == nil {
  19685 		sv = &types.LocationSummary{}
  19686 	} else {
  19687 		sv = *v
  19688 	}
  19689 
  19690 	for {
  19691 		t, done, err := decoder.Token()
  19692 		if err != nil {
  19693 			return err
  19694 		}
  19695 		if done {
  19696 			break
  19697 		}
  19698 		originalDecoder := decoder
  19699 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19700 		switch {
  19701 		case strings.EqualFold("LocationName", t.Name.Local):
  19702 			val, err := decoder.Value()
  19703 			if err != nil {
  19704 				return err
  19705 			}
  19706 			if val == nil {
  19707 				break
  19708 			}
  19709 			{
  19710 				xtv := string(val)
  19711 				sv.LocationName = ptr.String(xtv)
  19712 			}
  19713 
  19714 		default:
  19715 			// Do nothing and ignore the unexpected tag element
  19716 			err = decoder.Decoder.Skip()
  19717 			if err != nil {
  19718 				return err
  19719 			}
  19720 
  19721 		}
  19722 		decoder = originalDecoder
  19723 	}
  19724 	*v = sv
  19725 	return nil
  19726 }
  19727 
  19728 func awsRestxml_deserializeDocumentNoSuchChange(v **types.NoSuchChange, decoder smithyxml.NodeDecoder) error {
  19729 	if v == nil {
  19730 		return fmt.Errorf("unexpected nil of type %T", v)
  19731 	}
  19732 	var sv *types.NoSuchChange
  19733 	if *v == nil {
  19734 		sv = &types.NoSuchChange{}
  19735 	} else {
  19736 		sv = *v
  19737 	}
  19738 
  19739 	for {
  19740 		t, done, err := decoder.Token()
  19741 		if err != nil {
  19742 			return err
  19743 		}
  19744 		if done {
  19745 			break
  19746 		}
  19747 		originalDecoder := decoder
  19748 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19749 		switch {
  19750 		case strings.EqualFold("message", t.Name.Local):
  19751 			val, err := decoder.Value()
  19752 			if err != nil {
  19753 				return err
  19754 			}
  19755 			if val == nil {
  19756 				break
  19757 			}
  19758 			{
  19759 				xtv := string(val)
  19760 				sv.Message = ptr.String(xtv)
  19761 			}
  19762 
  19763 		default:
  19764 			// Do nothing and ignore the unexpected tag element
  19765 			err = decoder.Decoder.Skip()
  19766 			if err != nil {
  19767 				return err
  19768 			}
  19769 
  19770 		}
  19771 		decoder = originalDecoder
  19772 	}
  19773 	*v = sv
  19774 	return nil
  19775 }
  19776 
  19777 func awsRestxml_deserializeDocumentNoSuchCidrCollectionException(v **types.NoSuchCidrCollectionException, decoder smithyxml.NodeDecoder) error {
  19778 	if v == nil {
  19779 		return fmt.Errorf("unexpected nil of type %T", v)
  19780 	}
  19781 	var sv *types.NoSuchCidrCollectionException
  19782 	if *v == nil {
  19783 		sv = &types.NoSuchCidrCollectionException{}
  19784 	} else {
  19785 		sv = *v
  19786 	}
  19787 
  19788 	for {
  19789 		t, done, err := decoder.Token()
  19790 		if err != nil {
  19791 			return err
  19792 		}
  19793 		if done {
  19794 			break
  19795 		}
  19796 		originalDecoder := decoder
  19797 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19798 		switch {
  19799 		case strings.EqualFold("Message", t.Name.Local):
  19800 			val, err := decoder.Value()
  19801 			if err != nil {
  19802 				return err
  19803 			}
  19804 			if val == nil {
  19805 				break
  19806 			}
  19807 			{
  19808 				xtv := string(val)
  19809 				sv.Message = ptr.String(xtv)
  19810 			}
  19811 
  19812 		default:
  19813 			// Do nothing and ignore the unexpected tag element
  19814 			err = decoder.Decoder.Skip()
  19815 			if err != nil {
  19816 				return err
  19817 			}
  19818 
  19819 		}
  19820 		decoder = originalDecoder
  19821 	}
  19822 	*v = sv
  19823 	return nil
  19824 }
  19825 
  19826 func awsRestxml_deserializeDocumentNoSuchCidrLocationException(v **types.NoSuchCidrLocationException, decoder smithyxml.NodeDecoder) error {
  19827 	if v == nil {
  19828 		return fmt.Errorf("unexpected nil of type %T", v)
  19829 	}
  19830 	var sv *types.NoSuchCidrLocationException
  19831 	if *v == nil {
  19832 		sv = &types.NoSuchCidrLocationException{}
  19833 	} else {
  19834 		sv = *v
  19835 	}
  19836 
  19837 	for {
  19838 		t, done, err := decoder.Token()
  19839 		if err != nil {
  19840 			return err
  19841 		}
  19842 		if done {
  19843 			break
  19844 		}
  19845 		originalDecoder := decoder
  19846 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19847 		switch {
  19848 		case strings.EqualFold("Message", t.Name.Local):
  19849 			val, err := decoder.Value()
  19850 			if err != nil {
  19851 				return err
  19852 			}
  19853 			if val == nil {
  19854 				break
  19855 			}
  19856 			{
  19857 				xtv := string(val)
  19858 				sv.Message = ptr.String(xtv)
  19859 			}
  19860 
  19861 		default:
  19862 			// Do nothing and ignore the unexpected tag element
  19863 			err = decoder.Decoder.Skip()
  19864 			if err != nil {
  19865 				return err
  19866 			}
  19867 
  19868 		}
  19869 		decoder = originalDecoder
  19870 	}
  19871 	*v = sv
  19872 	return nil
  19873 }
  19874 
  19875 func awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(v **types.NoSuchCloudWatchLogsLogGroup, decoder smithyxml.NodeDecoder) error {
  19876 	if v == nil {
  19877 		return fmt.Errorf("unexpected nil of type %T", v)
  19878 	}
  19879 	var sv *types.NoSuchCloudWatchLogsLogGroup
  19880 	if *v == nil {
  19881 		sv = &types.NoSuchCloudWatchLogsLogGroup{}
  19882 	} else {
  19883 		sv = *v
  19884 	}
  19885 
  19886 	for {
  19887 		t, done, err := decoder.Token()
  19888 		if err != nil {
  19889 			return err
  19890 		}
  19891 		if done {
  19892 			break
  19893 		}
  19894 		originalDecoder := decoder
  19895 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19896 		switch {
  19897 		case strings.EqualFold("message", t.Name.Local):
  19898 			val, err := decoder.Value()
  19899 			if err != nil {
  19900 				return err
  19901 			}
  19902 			if val == nil {
  19903 				break
  19904 			}
  19905 			{
  19906 				xtv := string(val)
  19907 				sv.Message = ptr.String(xtv)
  19908 			}
  19909 
  19910 		default:
  19911 			// Do nothing and ignore the unexpected tag element
  19912 			err = decoder.Decoder.Skip()
  19913 			if err != nil {
  19914 				return err
  19915 			}
  19916 
  19917 		}
  19918 		decoder = originalDecoder
  19919 	}
  19920 	*v = sv
  19921 	return nil
  19922 }
  19923 
  19924 func awsRestxml_deserializeDocumentNoSuchDelegationSet(v **types.NoSuchDelegationSet, decoder smithyxml.NodeDecoder) error {
  19925 	if v == nil {
  19926 		return fmt.Errorf("unexpected nil of type %T", v)
  19927 	}
  19928 	var sv *types.NoSuchDelegationSet
  19929 	if *v == nil {
  19930 		sv = &types.NoSuchDelegationSet{}
  19931 	} else {
  19932 		sv = *v
  19933 	}
  19934 
  19935 	for {
  19936 		t, done, err := decoder.Token()
  19937 		if err != nil {
  19938 			return err
  19939 		}
  19940 		if done {
  19941 			break
  19942 		}
  19943 		originalDecoder := decoder
  19944 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19945 		switch {
  19946 		case strings.EqualFold("message", t.Name.Local):
  19947 			val, err := decoder.Value()
  19948 			if err != nil {
  19949 				return err
  19950 			}
  19951 			if val == nil {
  19952 				break
  19953 			}
  19954 			{
  19955 				xtv := string(val)
  19956 				sv.Message = ptr.String(xtv)
  19957 			}
  19958 
  19959 		default:
  19960 			// Do nothing and ignore the unexpected tag element
  19961 			err = decoder.Decoder.Skip()
  19962 			if err != nil {
  19963 				return err
  19964 			}
  19965 
  19966 		}
  19967 		decoder = originalDecoder
  19968 	}
  19969 	*v = sv
  19970 	return nil
  19971 }
  19972 
  19973 func awsRestxml_deserializeDocumentNoSuchGeoLocation(v **types.NoSuchGeoLocation, decoder smithyxml.NodeDecoder) error {
  19974 	if v == nil {
  19975 		return fmt.Errorf("unexpected nil of type %T", v)
  19976 	}
  19977 	var sv *types.NoSuchGeoLocation
  19978 	if *v == nil {
  19979 		sv = &types.NoSuchGeoLocation{}
  19980 	} else {
  19981 		sv = *v
  19982 	}
  19983 
  19984 	for {
  19985 		t, done, err := decoder.Token()
  19986 		if err != nil {
  19987 			return err
  19988 		}
  19989 		if done {
  19990 			break
  19991 		}
  19992 		originalDecoder := decoder
  19993 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19994 		switch {
  19995 		case strings.EqualFold("message", t.Name.Local):
  19996 			val, err := decoder.Value()
  19997 			if err != nil {
  19998 				return err
  19999 			}
  20000 			if val == nil {
  20001 				break
  20002 			}
  20003 			{
  20004 				xtv := string(val)
  20005 				sv.Message = ptr.String(xtv)
  20006 			}
  20007 
  20008 		default:
  20009 			// Do nothing and ignore the unexpected tag element
  20010 			err = decoder.Decoder.Skip()
  20011 			if err != nil {
  20012 				return err
  20013 			}
  20014 
  20015 		}
  20016 		decoder = originalDecoder
  20017 	}
  20018 	*v = sv
  20019 	return nil
  20020 }
  20021 
  20022 func awsRestxml_deserializeDocumentNoSuchHealthCheck(v **types.NoSuchHealthCheck, decoder smithyxml.NodeDecoder) error {
  20023 	if v == nil {
  20024 		return fmt.Errorf("unexpected nil of type %T", v)
  20025 	}
  20026 	var sv *types.NoSuchHealthCheck
  20027 	if *v == nil {
  20028 		sv = &types.NoSuchHealthCheck{}
  20029 	} else {
  20030 		sv = *v
  20031 	}
  20032 
  20033 	for {
  20034 		t, done, err := decoder.Token()
  20035 		if err != nil {
  20036 			return err
  20037 		}
  20038 		if done {
  20039 			break
  20040 		}
  20041 		originalDecoder := decoder
  20042 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20043 		switch {
  20044 		case strings.EqualFold("message", t.Name.Local):
  20045 			val, err := decoder.Value()
  20046 			if err != nil {
  20047 				return err
  20048 			}
  20049 			if val == nil {
  20050 				break
  20051 			}
  20052 			{
  20053 				xtv := string(val)
  20054 				sv.Message = ptr.String(xtv)
  20055 			}
  20056 
  20057 		default:
  20058 			// Do nothing and ignore the unexpected tag element
  20059 			err = decoder.Decoder.Skip()
  20060 			if err != nil {
  20061 				return err
  20062 			}
  20063 
  20064 		}
  20065 		decoder = originalDecoder
  20066 	}
  20067 	*v = sv
  20068 	return nil
  20069 }
  20070 
  20071 func awsRestxml_deserializeDocumentNoSuchHostedZone(v **types.NoSuchHostedZone, decoder smithyxml.NodeDecoder) error {
  20072 	if v == nil {
  20073 		return fmt.Errorf("unexpected nil of type %T", v)
  20074 	}
  20075 	var sv *types.NoSuchHostedZone
  20076 	if *v == nil {
  20077 		sv = &types.NoSuchHostedZone{}
  20078 	} else {
  20079 		sv = *v
  20080 	}
  20081 
  20082 	for {
  20083 		t, done, err := decoder.Token()
  20084 		if err != nil {
  20085 			return err
  20086 		}
  20087 		if done {
  20088 			break
  20089 		}
  20090 		originalDecoder := decoder
  20091 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20092 		switch {
  20093 		case strings.EqualFold("message", t.Name.Local):
  20094 			val, err := decoder.Value()
  20095 			if err != nil {
  20096 				return err
  20097 			}
  20098 			if val == nil {
  20099 				break
  20100 			}
  20101 			{
  20102 				xtv := string(val)
  20103 				sv.Message = ptr.String(xtv)
  20104 			}
  20105 
  20106 		default:
  20107 			// Do nothing and ignore the unexpected tag element
  20108 			err = decoder.Decoder.Skip()
  20109 			if err != nil {
  20110 				return err
  20111 			}
  20112 
  20113 		}
  20114 		decoder = originalDecoder
  20115 	}
  20116 	*v = sv
  20117 	return nil
  20118 }
  20119 
  20120 func awsRestxml_deserializeDocumentNoSuchKeySigningKey(v **types.NoSuchKeySigningKey, decoder smithyxml.NodeDecoder) error {
  20121 	if v == nil {
  20122 		return fmt.Errorf("unexpected nil of type %T", v)
  20123 	}
  20124 	var sv *types.NoSuchKeySigningKey
  20125 	if *v == nil {
  20126 		sv = &types.NoSuchKeySigningKey{}
  20127 	} else {
  20128 		sv = *v
  20129 	}
  20130 
  20131 	for {
  20132 		t, done, err := decoder.Token()
  20133 		if err != nil {
  20134 			return err
  20135 		}
  20136 		if done {
  20137 			break
  20138 		}
  20139 		originalDecoder := decoder
  20140 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20141 		switch {
  20142 		case strings.EqualFold("message", t.Name.Local):
  20143 			val, err := decoder.Value()
  20144 			if err != nil {
  20145 				return err
  20146 			}
  20147 			if val == nil {
  20148 				break
  20149 			}
  20150 			{
  20151 				xtv := string(val)
  20152 				sv.Message = ptr.String(xtv)
  20153 			}
  20154 
  20155 		default:
  20156 			// Do nothing and ignore the unexpected tag element
  20157 			err = decoder.Decoder.Skip()
  20158 			if err != nil {
  20159 				return err
  20160 			}
  20161 
  20162 		}
  20163 		decoder = originalDecoder
  20164 	}
  20165 	*v = sv
  20166 	return nil
  20167 }
  20168 
  20169 func awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(v **types.NoSuchQueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  20170 	if v == nil {
  20171 		return fmt.Errorf("unexpected nil of type %T", v)
  20172 	}
  20173 	var sv *types.NoSuchQueryLoggingConfig
  20174 	if *v == nil {
  20175 		sv = &types.NoSuchQueryLoggingConfig{}
  20176 	} else {
  20177 		sv = *v
  20178 	}
  20179 
  20180 	for {
  20181 		t, done, err := decoder.Token()
  20182 		if err != nil {
  20183 			return err
  20184 		}
  20185 		if done {
  20186 			break
  20187 		}
  20188 		originalDecoder := decoder
  20189 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20190 		switch {
  20191 		case strings.EqualFold("message", t.Name.Local):
  20192 			val, err := decoder.Value()
  20193 			if err != nil {
  20194 				return err
  20195 			}
  20196 			if val == nil {
  20197 				break
  20198 			}
  20199 			{
  20200 				xtv := string(val)
  20201 				sv.Message = ptr.String(xtv)
  20202 			}
  20203 
  20204 		default:
  20205 			// Do nothing and ignore the unexpected tag element
  20206 			err = decoder.Decoder.Skip()
  20207 			if err != nil {
  20208 				return err
  20209 			}
  20210 
  20211 		}
  20212 		decoder = originalDecoder
  20213 	}
  20214 	*v = sv
  20215 	return nil
  20216 }
  20217 
  20218 func awsRestxml_deserializeDocumentNoSuchTrafficPolicy(v **types.NoSuchTrafficPolicy, decoder smithyxml.NodeDecoder) error {
  20219 	if v == nil {
  20220 		return fmt.Errorf("unexpected nil of type %T", v)
  20221 	}
  20222 	var sv *types.NoSuchTrafficPolicy
  20223 	if *v == nil {
  20224 		sv = &types.NoSuchTrafficPolicy{}
  20225 	} else {
  20226 		sv = *v
  20227 	}
  20228 
  20229 	for {
  20230 		t, done, err := decoder.Token()
  20231 		if err != nil {
  20232 			return err
  20233 		}
  20234 		if done {
  20235 			break
  20236 		}
  20237 		originalDecoder := decoder
  20238 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20239 		switch {
  20240 		case strings.EqualFold("message", t.Name.Local):
  20241 			val, err := decoder.Value()
  20242 			if err != nil {
  20243 				return err
  20244 			}
  20245 			if val == nil {
  20246 				break
  20247 			}
  20248 			{
  20249 				xtv := string(val)
  20250 				sv.Message = ptr.String(xtv)
  20251 			}
  20252 
  20253 		default:
  20254 			// Do nothing and ignore the unexpected tag element
  20255 			err = decoder.Decoder.Skip()
  20256 			if err != nil {
  20257 				return err
  20258 			}
  20259 
  20260 		}
  20261 		decoder = originalDecoder
  20262 	}
  20263 	*v = sv
  20264 	return nil
  20265 }
  20266 
  20267 func awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(v **types.NoSuchTrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  20268 	if v == nil {
  20269 		return fmt.Errorf("unexpected nil of type %T", v)
  20270 	}
  20271 	var sv *types.NoSuchTrafficPolicyInstance
  20272 	if *v == nil {
  20273 		sv = &types.NoSuchTrafficPolicyInstance{}
  20274 	} else {
  20275 		sv = *v
  20276 	}
  20277 
  20278 	for {
  20279 		t, done, err := decoder.Token()
  20280 		if err != nil {
  20281 			return err
  20282 		}
  20283 		if done {
  20284 			break
  20285 		}
  20286 		originalDecoder := decoder
  20287 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20288 		switch {
  20289 		case strings.EqualFold("message", t.Name.Local):
  20290 			val, err := decoder.Value()
  20291 			if err != nil {
  20292 				return err
  20293 			}
  20294 			if val == nil {
  20295 				break
  20296 			}
  20297 			{
  20298 				xtv := string(val)
  20299 				sv.Message = ptr.String(xtv)
  20300 			}
  20301 
  20302 		default:
  20303 			// Do nothing and ignore the unexpected tag element
  20304 			err = decoder.Decoder.Skip()
  20305 			if err != nil {
  20306 				return err
  20307 			}
  20308 
  20309 		}
  20310 		decoder = originalDecoder
  20311 	}
  20312 	*v = sv
  20313 	return nil
  20314 }
  20315 
  20316 func awsRestxml_deserializeDocumentNotAuthorizedException(v **types.NotAuthorizedException, decoder smithyxml.NodeDecoder) error {
  20317 	if v == nil {
  20318 		return fmt.Errorf("unexpected nil of type %T", v)
  20319 	}
  20320 	var sv *types.NotAuthorizedException
  20321 	if *v == nil {
  20322 		sv = &types.NotAuthorizedException{}
  20323 	} else {
  20324 		sv = *v
  20325 	}
  20326 
  20327 	for {
  20328 		t, done, err := decoder.Token()
  20329 		if err != nil {
  20330 			return err
  20331 		}
  20332 		if done {
  20333 			break
  20334 		}
  20335 		originalDecoder := decoder
  20336 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20337 		switch {
  20338 		case strings.EqualFold("message", t.Name.Local):
  20339 			val, err := decoder.Value()
  20340 			if err != nil {
  20341 				return err
  20342 			}
  20343 			if val == nil {
  20344 				break
  20345 			}
  20346 			{
  20347 				xtv := string(val)
  20348 				sv.Message = ptr.String(xtv)
  20349 			}
  20350 
  20351 		default:
  20352 			// Do nothing and ignore the unexpected tag element
  20353 			err = decoder.Decoder.Skip()
  20354 			if err != nil {
  20355 				return err
  20356 			}
  20357 
  20358 		}
  20359 		decoder = originalDecoder
  20360 	}
  20361 	*v = sv
  20362 	return nil
  20363 }
  20364 
  20365 func awsRestxml_deserializeDocumentPriorRequestNotComplete(v **types.PriorRequestNotComplete, decoder smithyxml.NodeDecoder) error {
  20366 	if v == nil {
  20367 		return fmt.Errorf("unexpected nil of type %T", v)
  20368 	}
  20369 	var sv *types.PriorRequestNotComplete
  20370 	if *v == nil {
  20371 		sv = &types.PriorRequestNotComplete{}
  20372 	} else {
  20373 		sv = *v
  20374 	}
  20375 
  20376 	for {
  20377 		t, done, err := decoder.Token()
  20378 		if err != nil {
  20379 			return err
  20380 		}
  20381 		if done {
  20382 			break
  20383 		}
  20384 		originalDecoder := decoder
  20385 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20386 		switch {
  20387 		case strings.EqualFold("message", t.Name.Local):
  20388 			val, err := decoder.Value()
  20389 			if err != nil {
  20390 				return err
  20391 			}
  20392 			if val == nil {
  20393 				break
  20394 			}
  20395 			{
  20396 				xtv := string(val)
  20397 				sv.Message = ptr.String(xtv)
  20398 			}
  20399 
  20400 		default:
  20401 			// Do nothing and ignore the unexpected tag element
  20402 			err = decoder.Decoder.Skip()
  20403 			if err != nil {
  20404 				return err
  20405 			}
  20406 
  20407 		}
  20408 		decoder = originalDecoder
  20409 	}
  20410 	*v = sv
  20411 	return nil
  20412 }
  20413 
  20414 func awsRestxml_deserializeDocumentPublicZoneVPCAssociation(v **types.PublicZoneVPCAssociation, decoder smithyxml.NodeDecoder) error {
  20415 	if v == nil {
  20416 		return fmt.Errorf("unexpected nil of type %T", v)
  20417 	}
  20418 	var sv *types.PublicZoneVPCAssociation
  20419 	if *v == nil {
  20420 		sv = &types.PublicZoneVPCAssociation{}
  20421 	} else {
  20422 		sv = *v
  20423 	}
  20424 
  20425 	for {
  20426 		t, done, err := decoder.Token()
  20427 		if err != nil {
  20428 			return err
  20429 		}
  20430 		if done {
  20431 			break
  20432 		}
  20433 		originalDecoder := decoder
  20434 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20435 		switch {
  20436 		case strings.EqualFold("message", t.Name.Local):
  20437 			val, err := decoder.Value()
  20438 			if err != nil {
  20439 				return err
  20440 			}
  20441 			if val == nil {
  20442 				break
  20443 			}
  20444 			{
  20445 				xtv := string(val)
  20446 				sv.Message = ptr.String(xtv)
  20447 			}
  20448 
  20449 		default:
  20450 			// Do nothing and ignore the unexpected tag element
  20451 			err = decoder.Decoder.Skip()
  20452 			if err != nil {
  20453 				return err
  20454 			}
  20455 
  20456 		}
  20457 		decoder = originalDecoder
  20458 	}
  20459 	*v = sv
  20460 	return nil
  20461 }
  20462 
  20463 func awsRestxml_deserializeDocumentQueryLoggingConfig(v **types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  20464 	if v == nil {
  20465 		return fmt.Errorf("unexpected nil of type %T", v)
  20466 	}
  20467 	var sv *types.QueryLoggingConfig
  20468 	if *v == nil {
  20469 		sv = &types.QueryLoggingConfig{}
  20470 	} else {
  20471 		sv = *v
  20472 	}
  20473 
  20474 	for {
  20475 		t, done, err := decoder.Token()
  20476 		if err != nil {
  20477 			return err
  20478 		}
  20479 		if done {
  20480 			break
  20481 		}
  20482 		originalDecoder := decoder
  20483 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20484 		switch {
  20485 		case strings.EqualFold("CloudWatchLogsLogGroupArn", t.Name.Local):
  20486 			val, err := decoder.Value()
  20487 			if err != nil {
  20488 				return err
  20489 			}
  20490 			if val == nil {
  20491 				break
  20492 			}
  20493 			{
  20494 				xtv := string(val)
  20495 				sv.CloudWatchLogsLogGroupArn = ptr.String(xtv)
  20496 			}
  20497 
  20498 		case strings.EqualFold("HostedZoneId", 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.HostedZoneId = ptr.String(xtv)
  20509 			}
  20510 
  20511 		case strings.EqualFold("Id", t.Name.Local):
  20512 			val, err := decoder.Value()
  20513 			if err != nil {
  20514 				return err
  20515 			}
  20516 			if val == nil {
  20517 				break
  20518 			}
  20519 			{
  20520 				xtv := string(val)
  20521 				sv.Id = ptr.String(xtv)
  20522 			}
  20523 
  20524 		default:
  20525 			// Do nothing and ignore the unexpected tag element
  20526 			err = decoder.Decoder.Skip()
  20527 			if err != nil {
  20528 				return err
  20529 			}
  20530 
  20531 		}
  20532 		decoder = originalDecoder
  20533 	}
  20534 	*v = sv
  20535 	return nil
  20536 }
  20537 
  20538 func awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(v **types.QueryLoggingConfigAlreadyExists, decoder smithyxml.NodeDecoder) error {
  20539 	if v == nil {
  20540 		return fmt.Errorf("unexpected nil of type %T", v)
  20541 	}
  20542 	var sv *types.QueryLoggingConfigAlreadyExists
  20543 	if *v == nil {
  20544 		sv = &types.QueryLoggingConfigAlreadyExists{}
  20545 	} else {
  20546 		sv = *v
  20547 	}
  20548 
  20549 	for {
  20550 		t, done, err := decoder.Token()
  20551 		if err != nil {
  20552 			return err
  20553 		}
  20554 		if done {
  20555 			break
  20556 		}
  20557 		originalDecoder := decoder
  20558 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20559 		switch {
  20560 		case strings.EqualFold("message", t.Name.Local):
  20561 			val, err := decoder.Value()
  20562 			if err != nil {
  20563 				return err
  20564 			}
  20565 			if val == nil {
  20566 				break
  20567 			}
  20568 			{
  20569 				xtv := string(val)
  20570 				sv.Message = ptr.String(xtv)
  20571 			}
  20572 
  20573 		default:
  20574 			// Do nothing and ignore the unexpected tag element
  20575 			err = decoder.Decoder.Skip()
  20576 			if err != nil {
  20577 				return err
  20578 			}
  20579 
  20580 		}
  20581 		decoder = originalDecoder
  20582 	}
  20583 	*v = sv
  20584 	return nil
  20585 }
  20586 
  20587 func awsRestxml_deserializeDocumentQueryLoggingConfigs(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  20588 	if v == nil {
  20589 		return fmt.Errorf("unexpected nil of type %T", v)
  20590 	}
  20591 	var sv []types.QueryLoggingConfig
  20592 	if *v == nil {
  20593 		sv = make([]types.QueryLoggingConfig, 0)
  20594 	} else {
  20595 		sv = *v
  20596 	}
  20597 
  20598 	originalDecoder := decoder
  20599 	for {
  20600 		t, done, err := decoder.Token()
  20601 		if err != nil {
  20602 			return err
  20603 		}
  20604 		if done {
  20605 			break
  20606 		}
  20607 		switch {
  20608 		case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
  20609 			var col types.QueryLoggingConfig
  20610 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20611 			destAddr := &col
  20612 			if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil {
  20613 				return err
  20614 			}
  20615 			col = *destAddr
  20616 			sv = append(sv, col)
  20617 
  20618 		default:
  20619 			err = decoder.Decoder.Skip()
  20620 			if err != nil {
  20621 				return err
  20622 			}
  20623 
  20624 		}
  20625 		decoder = originalDecoder
  20626 	}
  20627 	*v = sv
  20628 	return nil
  20629 }
  20630 
  20631 func awsRestxml_deserializeDocumentQueryLoggingConfigsUnwrapped(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  20632 	var sv []types.QueryLoggingConfig
  20633 	if *v == nil {
  20634 		sv = make([]types.QueryLoggingConfig, 0)
  20635 	} else {
  20636 		sv = *v
  20637 	}
  20638 
  20639 	switch {
  20640 	default:
  20641 		var mv types.QueryLoggingConfig
  20642 		t := decoder.StartEl
  20643 		_ = t
  20644 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20645 		destAddr := &mv
  20646 		if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil {
  20647 			return err
  20648 		}
  20649 		mv = *destAddr
  20650 		sv = append(sv, mv)
  20651 	}
  20652 	*v = sv
  20653 	return nil
  20654 }
  20655 func awsRestxml_deserializeDocumentRecordData(v *[]string, decoder smithyxml.NodeDecoder) error {
  20656 	if v == nil {
  20657 		return fmt.Errorf("unexpected nil of type %T", v)
  20658 	}
  20659 	var sv []string
  20660 	if *v == nil {
  20661 		sv = make([]string, 0)
  20662 	} else {
  20663 		sv = *v
  20664 	}
  20665 
  20666 	originalDecoder := decoder
  20667 	for {
  20668 		t, done, err := decoder.Token()
  20669 		if err != nil {
  20670 			return err
  20671 		}
  20672 		if done {
  20673 			break
  20674 		}
  20675 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20676 		decoder = memberDecoder
  20677 		switch {
  20678 		case strings.EqualFold("RecordDataEntry", t.Name.Local):
  20679 			var col string
  20680 			val, err := decoder.Value()
  20681 			if err != nil {
  20682 				return err
  20683 			}
  20684 			if val == nil {
  20685 				break
  20686 			}
  20687 			{
  20688 				xtv := string(val)
  20689 				col = xtv
  20690 			}
  20691 			sv = append(sv, col)
  20692 
  20693 		default:
  20694 			err = decoder.Decoder.Skip()
  20695 			if err != nil {
  20696 				return err
  20697 			}
  20698 
  20699 		}
  20700 		decoder = originalDecoder
  20701 	}
  20702 	*v = sv
  20703 	return nil
  20704 }
  20705 
  20706 func awsRestxml_deserializeDocumentRecordDataUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  20707 	var sv []string
  20708 	if *v == nil {
  20709 		sv = make([]string, 0)
  20710 	} else {
  20711 		sv = *v
  20712 	}
  20713 
  20714 	switch {
  20715 	default:
  20716 		var mv string
  20717 		t := decoder.StartEl
  20718 		_ = t
  20719 		val, err := decoder.Value()
  20720 		if err != nil {
  20721 			return err
  20722 		}
  20723 		if val == nil {
  20724 			break
  20725 		}
  20726 		{
  20727 			xtv := string(val)
  20728 			mv = xtv
  20729 		}
  20730 		sv = append(sv, mv)
  20731 	}
  20732 	*v = sv
  20733 	return nil
  20734 }
  20735 func awsRestxml_deserializeDocumentResourceRecord(v **types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
  20736 	if v == nil {
  20737 		return fmt.Errorf("unexpected nil of type %T", v)
  20738 	}
  20739 	var sv *types.ResourceRecord
  20740 	if *v == nil {
  20741 		sv = &types.ResourceRecord{}
  20742 	} else {
  20743 		sv = *v
  20744 	}
  20745 
  20746 	for {
  20747 		t, done, err := decoder.Token()
  20748 		if err != nil {
  20749 			return err
  20750 		}
  20751 		if done {
  20752 			break
  20753 		}
  20754 		originalDecoder := decoder
  20755 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20756 		switch {
  20757 		case strings.EqualFold("Value", t.Name.Local):
  20758 			val, err := decoder.Value()
  20759 			if err != nil {
  20760 				return err
  20761 			}
  20762 			if val == nil {
  20763 				break
  20764 			}
  20765 			{
  20766 				xtv := string(val)
  20767 				sv.Value = ptr.String(xtv)
  20768 			}
  20769 
  20770 		default:
  20771 			// Do nothing and ignore the unexpected tag element
  20772 			err = decoder.Decoder.Skip()
  20773 			if err != nil {
  20774 				return err
  20775 			}
  20776 
  20777 		}
  20778 		decoder = originalDecoder
  20779 	}
  20780 	*v = sv
  20781 	return nil
  20782 }
  20783 
  20784 func awsRestxml_deserializeDocumentResourceRecords(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
  20785 	if v == nil {
  20786 		return fmt.Errorf("unexpected nil of type %T", v)
  20787 	}
  20788 	var sv []types.ResourceRecord
  20789 	if *v == nil {
  20790 		sv = make([]types.ResourceRecord, 0)
  20791 	} else {
  20792 		sv = *v
  20793 	}
  20794 
  20795 	originalDecoder := decoder
  20796 	for {
  20797 		t, done, err := decoder.Token()
  20798 		if err != nil {
  20799 			return err
  20800 		}
  20801 		if done {
  20802 			break
  20803 		}
  20804 		switch {
  20805 		case strings.EqualFold("ResourceRecord", t.Name.Local):
  20806 			var col types.ResourceRecord
  20807 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20808 			destAddr := &col
  20809 			if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil {
  20810 				return err
  20811 			}
  20812 			col = *destAddr
  20813 			sv = append(sv, col)
  20814 
  20815 		default:
  20816 			err = decoder.Decoder.Skip()
  20817 			if err != nil {
  20818 				return err
  20819 			}
  20820 
  20821 		}
  20822 		decoder = originalDecoder
  20823 	}
  20824 	*v = sv
  20825 	return nil
  20826 }
  20827 
  20828 func awsRestxml_deserializeDocumentResourceRecordsUnwrapped(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
  20829 	var sv []types.ResourceRecord
  20830 	if *v == nil {
  20831 		sv = make([]types.ResourceRecord, 0)
  20832 	} else {
  20833 		sv = *v
  20834 	}
  20835 
  20836 	switch {
  20837 	default:
  20838 		var mv types.ResourceRecord
  20839 		t := decoder.StartEl
  20840 		_ = t
  20841 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20842 		destAddr := &mv
  20843 		if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil {
  20844 			return err
  20845 		}
  20846 		mv = *destAddr
  20847 		sv = append(sv, mv)
  20848 	}
  20849 	*v = sv
  20850 	return nil
  20851 }
  20852 func awsRestxml_deserializeDocumentResourceRecordSet(v **types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
  20853 	if v == nil {
  20854 		return fmt.Errorf("unexpected nil of type %T", v)
  20855 	}
  20856 	var sv *types.ResourceRecordSet
  20857 	if *v == nil {
  20858 		sv = &types.ResourceRecordSet{}
  20859 	} else {
  20860 		sv = *v
  20861 	}
  20862 
  20863 	for {
  20864 		t, done, err := decoder.Token()
  20865 		if err != nil {
  20866 			return err
  20867 		}
  20868 		if done {
  20869 			break
  20870 		}
  20871 		originalDecoder := decoder
  20872 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20873 		switch {
  20874 		case strings.EqualFold("AliasTarget", t.Name.Local):
  20875 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20876 			if err := awsRestxml_deserializeDocumentAliasTarget(&sv.AliasTarget, nodeDecoder); err != nil {
  20877 				return err
  20878 			}
  20879 
  20880 		case strings.EqualFold("CidrRoutingConfig", t.Name.Local):
  20881 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20882 			if err := awsRestxml_deserializeDocumentCidrRoutingConfig(&sv.CidrRoutingConfig, nodeDecoder); err != nil {
  20883 				return err
  20884 			}
  20885 
  20886 		case strings.EqualFold("Failover", t.Name.Local):
  20887 			val, err := decoder.Value()
  20888 			if err != nil {
  20889 				return err
  20890 			}
  20891 			if val == nil {
  20892 				break
  20893 			}
  20894 			{
  20895 				xtv := string(val)
  20896 				sv.Failover = types.ResourceRecordSetFailover(xtv)
  20897 			}
  20898 
  20899 		case strings.EqualFold("GeoLocation", t.Name.Local):
  20900 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20901 			if err := awsRestxml_deserializeDocumentGeoLocation(&sv.GeoLocation, nodeDecoder); err != nil {
  20902 				return err
  20903 			}
  20904 
  20905 		case strings.EqualFold("GeoProximityLocation", t.Name.Local):
  20906 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20907 			if err := awsRestxml_deserializeDocumentGeoProximityLocation(&sv.GeoProximityLocation, nodeDecoder); err != nil {
  20908 				return err
  20909 			}
  20910 
  20911 		case strings.EqualFold("HealthCheckId", t.Name.Local):
  20912 			val, err := decoder.Value()
  20913 			if err != nil {
  20914 				return err
  20915 			}
  20916 			if val == nil {
  20917 				break
  20918 			}
  20919 			{
  20920 				xtv := string(val)
  20921 				sv.HealthCheckId = ptr.String(xtv)
  20922 			}
  20923 
  20924 		case strings.EqualFold("MultiValueAnswer", t.Name.Local):
  20925 			val, err := decoder.Value()
  20926 			if err != nil {
  20927 				return err
  20928 			}
  20929 			if val == nil {
  20930 				break
  20931 			}
  20932 			{
  20933 				xtv, err := strconv.ParseBool(string(val))
  20934 				if err != nil {
  20935 					return fmt.Errorf("expected ResourceRecordSetMultiValueAnswer to be of type *bool, got %T instead", val)
  20936 				}
  20937 				sv.MultiValueAnswer = ptr.Bool(xtv)
  20938 			}
  20939 
  20940 		case strings.EqualFold("Name", t.Name.Local):
  20941 			val, err := decoder.Value()
  20942 			if err != nil {
  20943 				return err
  20944 			}
  20945 			if val == nil {
  20946 				break
  20947 			}
  20948 			{
  20949 				xtv := string(val)
  20950 				sv.Name = ptr.String(xtv)
  20951 			}
  20952 
  20953 		case strings.EqualFold("Region", t.Name.Local):
  20954 			val, err := decoder.Value()
  20955 			if err != nil {
  20956 				return err
  20957 			}
  20958 			if val == nil {
  20959 				break
  20960 			}
  20961 			{
  20962 				xtv := string(val)
  20963 				sv.Region = types.ResourceRecordSetRegion(xtv)
  20964 			}
  20965 
  20966 		case strings.EqualFold("ResourceRecords", t.Name.Local):
  20967 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20968 			if err := awsRestxml_deserializeDocumentResourceRecords(&sv.ResourceRecords, nodeDecoder); err != nil {
  20969 				return err
  20970 			}
  20971 
  20972 		case strings.EqualFold("SetIdentifier", t.Name.Local):
  20973 			val, err := decoder.Value()
  20974 			if err != nil {
  20975 				return err
  20976 			}
  20977 			if val == nil {
  20978 				break
  20979 			}
  20980 			{
  20981 				xtv := string(val)
  20982 				sv.SetIdentifier = ptr.String(xtv)
  20983 			}
  20984 
  20985 		case strings.EqualFold("TrafficPolicyInstanceId", t.Name.Local):
  20986 			val, err := decoder.Value()
  20987 			if err != nil {
  20988 				return err
  20989 			}
  20990 			if val == nil {
  20991 				break
  20992 			}
  20993 			{
  20994 				xtv := string(val)
  20995 				sv.TrafficPolicyInstanceId = ptr.String(xtv)
  20996 			}
  20997 
  20998 		case strings.EqualFold("TTL", t.Name.Local):
  20999 			val, err := decoder.Value()
  21000 			if err != nil {
  21001 				return err
  21002 			}
  21003 			if val == nil {
  21004 				break
  21005 			}
  21006 			{
  21007 				xtv := string(val)
  21008 				i64, err := strconv.ParseInt(xtv, 10, 64)
  21009 				if err != nil {
  21010 					return err
  21011 				}
  21012 				sv.TTL = ptr.Int64(i64)
  21013 			}
  21014 
  21015 		case strings.EqualFold("Type", t.Name.Local):
  21016 			val, err := decoder.Value()
  21017 			if err != nil {
  21018 				return err
  21019 			}
  21020 			if val == nil {
  21021 				break
  21022 			}
  21023 			{
  21024 				xtv := string(val)
  21025 				sv.Type = types.RRType(xtv)
  21026 			}
  21027 
  21028 		case strings.EqualFold("Weight", t.Name.Local):
  21029 			val, err := decoder.Value()
  21030 			if err != nil {
  21031 				return err
  21032 			}
  21033 			if val == nil {
  21034 				break
  21035 			}
  21036 			{
  21037 				xtv := string(val)
  21038 				i64, err := strconv.ParseInt(xtv, 10, 64)
  21039 				if err != nil {
  21040 					return err
  21041 				}
  21042 				sv.Weight = ptr.Int64(i64)
  21043 			}
  21044 
  21045 		default:
  21046 			// Do nothing and ignore the unexpected tag element
  21047 			err = decoder.Decoder.Skip()
  21048 			if err != nil {
  21049 				return err
  21050 			}
  21051 
  21052 		}
  21053 		decoder = originalDecoder
  21054 	}
  21055 	*v = sv
  21056 	return nil
  21057 }
  21058 
  21059 func awsRestxml_deserializeDocumentResourceRecordSets(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
  21060 	if v == nil {
  21061 		return fmt.Errorf("unexpected nil of type %T", v)
  21062 	}
  21063 	var sv []types.ResourceRecordSet
  21064 	if *v == nil {
  21065 		sv = make([]types.ResourceRecordSet, 0)
  21066 	} else {
  21067 		sv = *v
  21068 	}
  21069 
  21070 	originalDecoder := decoder
  21071 	for {
  21072 		t, done, err := decoder.Token()
  21073 		if err != nil {
  21074 			return err
  21075 		}
  21076 		if done {
  21077 			break
  21078 		}
  21079 		switch {
  21080 		case strings.EqualFold("ResourceRecordSet", t.Name.Local):
  21081 			var col types.ResourceRecordSet
  21082 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21083 			destAddr := &col
  21084 			if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil {
  21085 				return err
  21086 			}
  21087 			col = *destAddr
  21088 			sv = append(sv, col)
  21089 
  21090 		default:
  21091 			err = decoder.Decoder.Skip()
  21092 			if err != nil {
  21093 				return err
  21094 			}
  21095 
  21096 		}
  21097 		decoder = originalDecoder
  21098 	}
  21099 	*v = sv
  21100 	return nil
  21101 }
  21102 
  21103 func awsRestxml_deserializeDocumentResourceRecordSetsUnwrapped(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
  21104 	var sv []types.ResourceRecordSet
  21105 	if *v == nil {
  21106 		sv = make([]types.ResourceRecordSet, 0)
  21107 	} else {
  21108 		sv = *v
  21109 	}
  21110 
  21111 	switch {
  21112 	default:
  21113 		var mv types.ResourceRecordSet
  21114 		t := decoder.StartEl
  21115 		_ = t
  21116 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21117 		destAddr := &mv
  21118 		if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil {
  21119 			return err
  21120 		}
  21121 		mv = *destAddr
  21122 		sv = append(sv, mv)
  21123 	}
  21124 	*v = sv
  21125 	return nil
  21126 }
  21127 func awsRestxml_deserializeDocumentResourceTagSet(v **types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
  21128 	if v == nil {
  21129 		return fmt.Errorf("unexpected nil of type %T", v)
  21130 	}
  21131 	var sv *types.ResourceTagSet
  21132 	if *v == nil {
  21133 		sv = &types.ResourceTagSet{}
  21134 	} else {
  21135 		sv = *v
  21136 	}
  21137 
  21138 	for {
  21139 		t, done, err := decoder.Token()
  21140 		if err != nil {
  21141 			return err
  21142 		}
  21143 		if done {
  21144 			break
  21145 		}
  21146 		originalDecoder := decoder
  21147 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21148 		switch {
  21149 		case strings.EqualFold("ResourceId", t.Name.Local):
  21150 			val, err := decoder.Value()
  21151 			if err != nil {
  21152 				return err
  21153 			}
  21154 			if val == nil {
  21155 				break
  21156 			}
  21157 			{
  21158 				xtv := string(val)
  21159 				sv.ResourceId = ptr.String(xtv)
  21160 			}
  21161 
  21162 		case strings.EqualFold("ResourceType", 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.ResourceType = types.TagResourceType(xtv)
  21173 			}
  21174 
  21175 		case strings.EqualFold("Tags", t.Name.Local):
  21176 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21177 			if err := awsRestxml_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil {
  21178 				return err
  21179 			}
  21180 
  21181 		default:
  21182 			// Do nothing and ignore the unexpected tag element
  21183 			err = decoder.Decoder.Skip()
  21184 			if err != nil {
  21185 				return err
  21186 			}
  21187 
  21188 		}
  21189 		decoder = originalDecoder
  21190 	}
  21191 	*v = sv
  21192 	return nil
  21193 }
  21194 
  21195 func awsRestxml_deserializeDocumentResourceTagSetList(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
  21196 	if v == nil {
  21197 		return fmt.Errorf("unexpected nil of type %T", v)
  21198 	}
  21199 	var sv []types.ResourceTagSet
  21200 	if *v == nil {
  21201 		sv = make([]types.ResourceTagSet, 0)
  21202 	} else {
  21203 		sv = *v
  21204 	}
  21205 
  21206 	originalDecoder := decoder
  21207 	for {
  21208 		t, done, err := decoder.Token()
  21209 		if err != nil {
  21210 			return err
  21211 		}
  21212 		if done {
  21213 			break
  21214 		}
  21215 		switch {
  21216 		case strings.EqualFold("ResourceTagSet", t.Name.Local):
  21217 			var col types.ResourceTagSet
  21218 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21219 			destAddr := &col
  21220 			if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil {
  21221 				return err
  21222 			}
  21223 			col = *destAddr
  21224 			sv = append(sv, col)
  21225 
  21226 		default:
  21227 			err = decoder.Decoder.Skip()
  21228 			if err != nil {
  21229 				return err
  21230 			}
  21231 
  21232 		}
  21233 		decoder = originalDecoder
  21234 	}
  21235 	*v = sv
  21236 	return nil
  21237 }
  21238 
  21239 func awsRestxml_deserializeDocumentResourceTagSetListUnwrapped(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
  21240 	var sv []types.ResourceTagSet
  21241 	if *v == nil {
  21242 		sv = make([]types.ResourceTagSet, 0)
  21243 	} else {
  21244 		sv = *v
  21245 	}
  21246 
  21247 	switch {
  21248 	default:
  21249 		var mv types.ResourceTagSet
  21250 		t := decoder.StartEl
  21251 		_ = t
  21252 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21253 		destAddr := &mv
  21254 		if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil {
  21255 			return err
  21256 		}
  21257 		mv = *destAddr
  21258 		sv = append(sv, mv)
  21259 	}
  21260 	*v = sv
  21261 	return nil
  21262 }
  21263 func awsRestxml_deserializeDocumentReusableDelegationSetLimit(v **types.ReusableDelegationSetLimit, decoder smithyxml.NodeDecoder) error {
  21264 	if v == nil {
  21265 		return fmt.Errorf("unexpected nil of type %T", v)
  21266 	}
  21267 	var sv *types.ReusableDelegationSetLimit
  21268 	if *v == nil {
  21269 		sv = &types.ReusableDelegationSetLimit{}
  21270 	} else {
  21271 		sv = *v
  21272 	}
  21273 
  21274 	for {
  21275 		t, done, err := decoder.Token()
  21276 		if err != nil {
  21277 			return err
  21278 		}
  21279 		if done {
  21280 			break
  21281 		}
  21282 		originalDecoder := decoder
  21283 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21284 		switch {
  21285 		case strings.EqualFold("Type", t.Name.Local):
  21286 			val, err := decoder.Value()
  21287 			if err != nil {
  21288 				return err
  21289 			}
  21290 			if val == nil {
  21291 				break
  21292 			}
  21293 			{
  21294 				xtv := string(val)
  21295 				sv.Type = types.ReusableDelegationSetLimitType(xtv)
  21296 			}
  21297 
  21298 		case strings.EqualFold("Value", t.Name.Local):
  21299 			val, err := decoder.Value()
  21300 			if err != nil {
  21301 				return err
  21302 			}
  21303 			if val == nil {
  21304 				break
  21305 			}
  21306 			{
  21307 				xtv := string(val)
  21308 				i64, err := strconv.ParseInt(xtv, 10, 64)
  21309 				if err != nil {
  21310 					return err
  21311 				}
  21312 				sv.Value = ptr.Int64(i64)
  21313 			}
  21314 
  21315 		default:
  21316 			// Do nothing and ignore the unexpected tag element
  21317 			err = decoder.Decoder.Skip()
  21318 			if err != nil {
  21319 				return err
  21320 			}
  21321 
  21322 		}
  21323 		decoder = originalDecoder
  21324 	}
  21325 	*v = sv
  21326 	return nil
  21327 }
  21328 
  21329 func awsRestxml_deserializeDocumentStatusReport(v **types.StatusReport, decoder smithyxml.NodeDecoder) error {
  21330 	if v == nil {
  21331 		return fmt.Errorf("unexpected nil of type %T", v)
  21332 	}
  21333 	var sv *types.StatusReport
  21334 	if *v == nil {
  21335 		sv = &types.StatusReport{}
  21336 	} else {
  21337 		sv = *v
  21338 	}
  21339 
  21340 	for {
  21341 		t, done, err := decoder.Token()
  21342 		if err != nil {
  21343 			return err
  21344 		}
  21345 		if done {
  21346 			break
  21347 		}
  21348 		originalDecoder := decoder
  21349 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21350 		switch {
  21351 		case strings.EqualFold("CheckedTime", t.Name.Local):
  21352 			val, err := decoder.Value()
  21353 			if err != nil {
  21354 				return err
  21355 			}
  21356 			if val == nil {
  21357 				break
  21358 			}
  21359 			{
  21360 				xtv := string(val)
  21361 				t, err := smithytime.ParseDateTime(xtv)
  21362 				if err != nil {
  21363 					return err
  21364 				}
  21365 				sv.CheckedTime = ptr.Time(t)
  21366 			}
  21367 
  21368 		case strings.EqualFold("Status", t.Name.Local):
  21369 			val, err := decoder.Value()
  21370 			if err != nil {
  21371 				return err
  21372 			}
  21373 			if val == nil {
  21374 				break
  21375 			}
  21376 			{
  21377 				xtv := string(val)
  21378 				sv.Status = ptr.String(xtv)
  21379 			}
  21380 
  21381 		default:
  21382 			// Do nothing and ignore the unexpected tag element
  21383 			err = decoder.Decoder.Skip()
  21384 			if err != nil {
  21385 				return err
  21386 			}
  21387 
  21388 		}
  21389 		decoder = originalDecoder
  21390 	}
  21391 	*v = sv
  21392 	return nil
  21393 }
  21394 
  21395 func awsRestxml_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error {
  21396 	if v == nil {
  21397 		return fmt.Errorf("unexpected nil of type %T", v)
  21398 	}
  21399 	var sv *types.Tag
  21400 	if *v == nil {
  21401 		sv = &types.Tag{}
  21402 	} else {
  21403 		sv = *v
  21404 	}
  21405 
  21406 	for {
  21407 		t, done, err := decoder.Token()
  21408 		if err != nil {
  21409 			return err
  21410 		}
  21411 		if done {
  21412 			break
  21413 		}
  21414 		originalDecoder := decoder
  21415 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21416 		switch {
  21417 		case strings.EqualFold("Key", t.Name.Local):
  21418 			val, err := decoder.Value()
  21419 			if err != nil {
  21420 				return err
  21421 			}
  21422 			if val == nil {
  21423 				break
  21424 			}
  21425 			{
  21426 				xtv := string(val)
  21427 				sv.Key = ptr.String(xtv)
  21428 			}
  21429 
  21430 		case strings.EqualFold("Value", t.Name.Local):
  21431 			val, err := decoder.Value()
  21432 			if err != nil {
  21433 				return err
  21434 			}
  21435 			if val == nil {
  21436 				break
  21437 			}
  21438 			{
  21439 				xtv := string(val)
  21440 				sv.Value = ptr.String(xtv)
  21441 			}
  21442 
  21443 		default:
  21444 			// Do nothing and ignore the unexpected tag element
  21445 			err = decoder.Decoder.Skip()
  21446 			if err != nil {
  21447 				return err
  21448 			}
  21449 
  21450 		}
  21451 		decoder = originalDecoder
  21452 	}
  21453 	*v = sv
  21454 	return nil
  21455 }
  21456 
  21457 func awsRestxml_deserializeDocumentTagList(v *[]types.Tag, decoder smithyxml.NodeDecoder) error {
  21458 	if v == nil {
  21459 		return fmt.Errorf("unexpected nil of type %T", v)
  21460 	}
  21461 	var sv []types.Tag
  21462 	if *v == nil {
  21463 		sv = make([]types.Tag, 0)
  21464 	} else {
  21465 		sv = *v
  21466 	}
  21467 
  21468 	originalDecoder := decoder
  21469 	for {
  21470 		t, done, err := decoder.Token()
  21471 		if err != nil {
  21472 			return err
  21473 		}
  21474 		if done {
  21475 			break
  21476 		}
  21477 		switch {
  21478 		case strings.EqualFold("Tag", t.Name.Local):
  21479 			var col types.Tag
  21480 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21481 			destAddr := &col
  21482 			if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil {
  21483 				return err
  21484 			}
  21485 			col = *destAddr
  21486 			sv = append(sv, col)
  21487 
  21488 		default:
  21489 			err = decoder.Decoder.Skip()
  21490 			if err != nil {
  21491 				return err
  21492 			}
  21493 
  21494 		}
  21495 		decoder = originalDecoder
  21496 	}
  21497 	*v = sv
  21498 	return nil
  21499 }
  21500 
  21501 func awsRestxml_deserializeDocumentTagListUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error {
  21502 	var sv []types.Tag
  21503 	if *v == nil {
  21504 		sv = make([]types.Tag, 0)
  21505 	} else {
  21506 		sv = *v
  21507 	}
  21508 
  21509 	switch {
  21510 	default:
  21511 		var mv types.Tag
  21512 		t := decoder.StartEl
  21513 		_ = t
  21514 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21515 		destAddr := &mv
  21516 		if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil {
  21517 			return err
  21518 		}
  21519 		mv = *destAddr
  21520 		sv = append(sv, mv)
  21521 	}
  21522 	*v = sv
  21523 	return nil
  21524 }
  21525 func awsRestxml_deserializeDocumentThrottlingException(v **types.ThrottlingException, decoder smithyxml.NodeDecoder) error {
  21526 	if v == nil {
  21527 		return fmt.Errorf("unexpected nil of type %T", v)
  21528 	}
  21529 	var sv *types.ThrottlingException
  21530 	if *v == nil {
  21531 		sv = &types.ThrottlingException{}
  21532 	} else {
  21533 		sv = *v
  21534 	}
  21535 
  21536 	for {
  21537 		t, done, err := decoder.Token()
  21538 		if err != nil {
  21539 			return err
  21540 		}
  21541 		if done {
  21542 			break
  21543 		}
  21544 		originalDecoder := decoder
  21545 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21546 		switch {
  21547 		case strings.EqualFold("message", t.Name.Local):
  21548 			val, err := decoder.Value()
  21549 			if err != nil {
  21550 				return err
  21551 			}
  21552 			if val == nil {
  21553 				break
  21554 			}
  21555 			{
  21556 				xtv := string(val)
  21557 				sv.Message = ptr.String(xtv)
  21558 			}
  21559 
  21560 		default:
  21561 			// Do nothing and ignore the unexpected tag element
  21562 			err = decoder.Decoder.Skip()
  21563 			if err != nil {
  21564 				return err
  21565 			}
  21566 
  21567 		}
  21568 		decoder = originalDecoder
  21569 	}
  21570 	*v = sv
  21571 	return nil
  21572 }
  21573 
  21574 func awsRestxml_deserializeDocumentTooManyHealthChecks(v **types.TooManyHealthChecks, decoder smithyxml.NodeDecoder) error {
  21575 	if v == nil {
  21576 		return fmt.Errorf("unexpected nil of type %T", v)
  21577 	}
  21578 	var sv *types.TooManyHealthChecks
  21579 	if *v == nil {
  21580 		sv = &types.TooManyHealthChecks{}
  21581 	} else {
  21582 		sv = *v
  21583 	}
  21584 
  21585 	for {
  21586 		t, done, err := decoder.Token()
  21587 		if err != nil {
  21588 			return err
  21589 		}
  21590 		if done {
  21591 			break
  21592 		}
  21593 		originalDecoder := decoder
  21594 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21595 		switch {
  21596 		case strings.EqualFold("message", t.Name.Local):
  21597 			val, err := decoder.Value()
  21598 			if err != nil {
  21599 				return err
  21600 			}
  21601 			if val == nil {
  21602 				break
  21603 			}
  21604 			{
  21605 				xtv := string(val)
  21606 				sv.Message = ptr.String(xtv)
  21607 			}
  21608 
  21609 		default:
  21610 			// Do nothing and ignore the unexpected tag element
  21611 			err = decoder.Decoder.Skip()
  21612 			if err != nil {
  21613 				return err
  21614 			}
  21615 
  21616 		}
  21617 		decoder = originalDecoder
  21618 	}
  21619 	*v = sv
  21620 	return nil
  21621 }
  21622 
  21623 func awsRestxml_deserializeDocumentTooManyHostedZones(v **types.TooManyHostedZones, decoder smithyxml.NodeDecoder) error {
  21624 	if v == nil {
  21625 		return fmt.Errorf("unexpected nil of type %T", v)
  21626 	}
  21627 	var sv *types.TooManyHostedZones
  21628 	if *v == nil {
  21629 		sv = &types.TooManyHostedZones{}
  21630 	} else {
  21631 		sv = *v
  21632 	}
  21633 
  21634 	for {
  21635 		t, done, err := decoder.Token()
  21636 		if err != nil {
  21637 			return err
  21638 		}
  21639 		if done {
  21640 			break
  21641 		}
  21642 		originalDecoder := decoder
  21643 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21644 		switch {
  21645 		case strings.EqualFold("message", t.Name.Local):
  21646 			val, err := decoder.Value()
  21647 			if err != nil {
  21648 				return err
  21649 			}
  21650 			if val == nil {
  21651 				break
  21652 			}
  21653 			{
  21654 				xtv := string(val)
  21655 				sv.Message = ptr.String(xtv)
  21656 			}
  21657 
  21658 		default:
  21659 			// Do nothing and ignore the unexpected tag element
  21660 			err = decoder.Decoder.Skip()
  21661 			if err != nil {
  21662 				return err
  21663 			}
  21664 
  21665 		}
  21666 		decoder = originalDecoder
  21667 	}
  21668 	*v = sv
  21669 	return nil
  21670 }
  21671 
  21672 func awsRestxml_deserializeDocumentTooManyKeySigningKeys(v **types.TooManyKeySigningKeys, decoder smithyxml.NodeDecoder) error {
  21673 	if v == nil {
  21674 		return fmt.Errorf("unexpected nil of type %T", v)
  21675 	}
  21676 	var sv *types.TooManyKeySigningKeys
  21677 	if *v == nil {
  21678 		sv = &types.TooManyKeySigningKeys{}
  21679 	} else {
  21680 		sv = *v
  21681 	}
  21682 
  21683 	for {
  21684 		t, done, err := decoder.Token()
  21685 		if err != nil {
  21686 			return err
  21687 		}
  21688 		if done {
  21689 			break
  21690 		}
  21691 		originalDecoder := decoder
  21692 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21693 		switch {
  21694 		case strings.EqualFold("message", t.Name.Local):
  21695 			val, err := decoder.Value()
  21696 			if err != nil {
  21697 				return err
  21698 			}
  21699 			if val == nil {
  21700 				break
  21701 			}
  21702 			{
  21703 				xtv := string(val)
  21704 				sv.Message = ptr.String(xtv)
  21705 			}
  21706 
  21707 		default:
  21708 			// Do nothing and ignore the unexpected tag element
  21709 			err = decoder.Decoder.Skip()
  21710 			if err != nil {
  21711 				return err
  21712 			}
  21713 
  21714 		}
  21715 		decoder = originalDecoder
  21716 	}
  21717 	*v = sv
  21718 	return nil
  21719 }
  21720 
  21721 func awsRestxml_deserializeDocumentTooManyTrafficPolicies(v **types.TooManyTrafficPolicies, decoder smithyxml.NodeDecoder) error {
  21722 	if v == nil {
  21723 		return fmt.Errorf("unexpected nil of type %T", v)
  21724 	}
  21725 	var sv *types.TooManyTrafficPolicies
  21726 	if *v == nil {
  21727 		sv = &types.TooManyTrafficPolicies{}
  21728 	} else {
  21729 		sv = *v
  21730 	}
  21731 
  21732 	for {
  21733 		t, done, err := decoder.Token()
  21734 		if err != nil {
  21735 			return err
  21736 		}
  21737 		if done {
  21738 			break
  21739 		}
  21740 		originalDecoder := decoder
  21741 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21742 		switch {
  21743 		case strings.EqualFold("message", t.Name.Local):
  21744 			val, err := decoder.Value()
  21745 			if err != nil {
  21746 				return err
  21747 			}
  21748 			if val == nil {
  21749 				break
  21750 			}
  21751 			{
  21752 				xtv := string(val)
  21753 				sv.Message = ptr.String(xtv)
  21754 			}
  21755 
  21756 		default:
  21757 			// Do nothing and ignore the unexpected tag element
  21758 			err = decoder.Decoder.Skip()
  21759 			if err != nil {
  21760 				return err
  21761 			}
  21762 
  21763 		}
  21764 		decoder = originalDecoder
  21765 	}
  21766 	*v = sv
  21767 	return nil
  21768 }
  21769 
  21770 func awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(v **types.TooManyTrafficPolicyInstances, decoder smithyxml.NodeDecoder) error {
  21771 	if v == nil {
  21772 		return fmt.Errorf("unexpected nil of type %T", v)
  21773 	}
  21774 	var sv *types.TooManyTrafficPolicyInstances
  21775 	if *v == nil {
  21776 		sv = &types.TooManyTrafficPolicyInstances{}
  21777 	} else {
  21778 		sv = *v
  21779 	}
  21780 
  21781 	for {
  21782 		t, done, err := decoder.Token()
  21783 		if err != nil {
  21784 			return err
  21785 		}
  21786 		if done {
  21787 			break
  21788 		}
  21789 		originalDecoder := decoder
  21790 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21791 		switch {
  21792 		case strings.EqualFold("message", t.Name.Local):
  21793 			val, err := decoder.Value()
  21794 			if err != nil {
  21795 				return err
  21796 			}
  21797 			if val == nil {
  21798 				break
  21799 			}
  21800 			{
  21801 				xtv := string(val)
  21802 				sv.Message = ptr.String(xtv)
  21803 			}
  21804 
  21805 		default:
  21806 			// Do nothing and ignore the unexpected tag element
  21807 			err = decoder.Decoder.Skip()
  21808 			if err != nil {
  21809 				return err
  21810 			}
  21811 
  21812 		}
  21813 		decoder = originalDecoder
  21814 	}
  21815 	*v = sv
  21816 	return nil
  21817 }
  21818 
  21819 func awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(v **types.TooManyTrafficPolicyVersionsForCurrentPolicy, decoder smithyxml.NodeDecoder) error {
  21820 	if v == nil {
  21821 		return fmt.Errorf("unexpected nil of type %T", v)
  21822 	}
  21823 	var sv *types.TooManyTrafficPolicyVersionsForCurrentPolicy
  21824 	if *v == nil {
  21825 		sv = &types.TooManyTrafficPolicyVersionsForCurrentPolicy{}
  21826 	} else {
  21827 		sv = *v
  21828 	}
  21829 
  21830 	for {
  21831 		t, done, err := decoder.Token()
  21832 		if err != nil {
  21833 			return err
  21834 		}
  21835 		if done {
  21836 			break
  21837 		}
  21838 		originalDecoder := decoder
  21839 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21840 		switch {
  21841 		case strings.EqualFold("message", t.Name.Local):
  21842 			val, err := decoder.Value()
  21843 			if err != nil {
  21844 				return err
  21845 			}
  21846 			if val == nil {
  21847 				break
  21848 			}
  21849 			{
  21850 				xtv := string(val)
  21851 				sv.Message = ptr.String(xtv)
  21852 			}
  21853 
  21854 		default:
  21855 			// Do nothing and ignore the unexpected tag element
  21856 			err = decoder.Decoder.Skip()
  21857 			if err != nil {
  21858 				return err
  21859 			}
  21860 
  21861 		}
  21862 		decoder = originalDecoder
  21863 	}
  21864 	*v = sv
  21865 	return nil
  21866 }
  21867 
  21868 func awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(v **types.TooManyVPCAssociationAuthorizations, decoder smithyxml.NodeDecoder) error {
  21869 	if v == nil {
  21870 		return fmt.Errorf("unexpected nil of type %T", v)
  21871 	}
  21872 	var sv *types.TooManyVPCAssociationAuthorizations
  21873 	if *v == nil {
  21874 		sv = &types.TooManyVPCAssociationAuthorizations{}
  21875 	} else {
  21876 		sv = *v
  21877 	}
  21878 
  21879 	for {
  21880 		t, done, err := decoder.Token()
  21881 		if err != nil {
  21882 			return err
  21883 		}
  21884 		if done {
  21885 			break
  21886 		}
  21887 		originalDecoder := decoder
  21888 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21889 		switch {
  21890 		case strings.EqualFold("message", t.Name.Local):
  21891 			val, err := decoder.Value()
  21892 			if err != nil {
  21893 				return err
  21894 			}
  21895 			if val == nil {
  21896 				break
  21897 			}
  21898 			{
  21899 				xtv := string(val)
  21900 				sv.Message = ptr.String(xtv)
  21901 			}
  21902 
  21903 		default:
  21904 			// Do nothing and ignore the unexpected tag element
  21905 			err = decoder.Decoder.Skip()
  21906 			if err != nil {
  21907 				return err
  21908 			}
  21909 
  21910 		}
  21911 		decoder = originalDecoder
  21912 	}
  21913 	*v = sv
  21914 	return nil
  21915 }
  21916 
  21917 func awsRestxml_deserializeDocumentTrafficPolicies(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
  21918 	if v == nil {
  21919 		return fmt.Errorf("unexpected nil of type %T", v)
  21920 	}
  21921 	var sv []types.TrafficPolicy
  21922 	if *v == nil {
  21923 		sv = make([]types.TrafficPolicy, 0)
  21924 	} else {
  21925 		sv = *v
  21926 	}
  21927 
  21928 	originalDecoder := decoder
  21929 	for {
  21930 		t, done, err := decoder.Token()
  21931 		if err != nil {
  21932 			return err
  21933 		}
  21934 		if done {
  21935 			break
  21936 		}
  21937 		switch {
  21938 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
  21939 			var col types.TrafficPolicy
  21940 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21941 			destAddr := &col
  21942 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil {
  21943 				return err
  21944 			}
  21945 			col = *destAddr
  21946 			sv = append(sv, col)
  21947 
  21948 		default:
  21949 			err = decoder.Decoder.Skip()
  21950 			if err != nil {
  21951 				return err
  21952 			}
  21953 
  21954 		}
  21955 		decoder = originalDecoder
  21956 	}
  21957 	*v = sv
  21958 	return nil
  21959 }
  21960 
  21961 func awsRestxml_deserializeDocumentTrafficPoliciesUnwrapped(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
  21962 	var sv []types.TrafficPolicy
  21963 	if *v == nil {
  21964 		sv = make([]types.TrafficPolicy, 0)
  21965 	} else {
  21966 		sv = *v
  21967 	}
  21968 
  21969 	switch {
  21970 	default:
  21971 		var mv types.TrafficPolicy
  21972 		t := decoder.StartEl
  21973 		_ = t
  21974 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21975 		destAddr := &mv
  21976 		if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil {
  21977 			return err
  21978 		}
  21979 		mv = *destAddr
  21980 		sv = append(sv, mv)
  21981 	}
  21982 	*v = sv
  21983 	return nil
  21984 }
  21985 func awsRestxml_deserializeDocumentTrafficPolicy(v **types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
  21986 	if v == nil {
  21987 		return fmt.Errorf("unexpected nil of type %T", v)
  21988 	}
  21989 	var sv *types.TrafficPolicy
  21990 	if *v == nil {
  21991 		sv = &types.TrafficPolicy{}
  21992 	} else {
  21993 		sv = *v
  21994 	}
  21995 
  21996 	for {
  21997 		t, done, err := decoder.Token()
  21998 		if err != nil {
  21999 			return err
  22000 		}
  22001 		if done {
  22002 			break
  22003 		}
  22004 		originalDecoder := decoder
  22005 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22006 		switch {
  22007 		case strings.EqualFold("Comment", t.Name.Local):
  22008 			val, err := decoder.Value()
  22009 			if err != nil {
  22010 				return err
  22011 			}
  22012 			if val == nil {
  22013 				break
  22014 			}
  22015 			{
  22016 				xtv := string(val)
  22017 				sv.Comment = ptr.String(xtv)
  22018 			}
  22019 
  22020 		case strings.EqualFold("Document", t.Name.Local):
  22021 			val, err := decoder.Value()
  22022 			if err != nil {
  22023 				return err
  22024 			}
  22025 			if val == nil {
  22026 				break
  22027 			}
  22028 			{
  22029 				xtv := string(val)
  22030 				sv.Document = ptr.String(xtv)
  22031 			}
  22032 
  22033 		case strings.EqualFold("Id", t.Name.Local):
  22034 			val, err := decoder.Value()
  22035 			if err != nil {
  22036 				return err
  22037 			}
  22038 			if val == nil {
  22039 				break
  22040 			}
  22041 			{
  22042 				xtv := string(val)
  22043 				sv.Id = ptr.String(xtv)
  22044 			}
  22045 
  22046 		case strings.EqualFold("Name", t.Name.Local):
  22047 			val, err := decoder.Value()
  22048 			if err != nil {
  22049 				return err
  22050 			}
  22051 			if val == nil {
  22052 				break
  22053 			}
  22054 			{
  22055 				xtv := string(val)
  22056 				sv.Name = ptr.String(xtv)
  22057 			}
  22058 
  22059 		case strings.EqualFold("Type", t.Name.Local):
  22060 			val, err := decoder.Value()
  22061 			if err != nil {
  22062 				return err
  22063 			}
  22064 			if val == nil {
  22065 				break
  22066 			}
  22067 			{
  22068 				xtv := string(val)
  22069 				sv.Type = types.RRType(xtv)
  22070 			}
  22071 
  22072 		case strings.EqualFold("Version", t.Name.Local):
  22073 			val, err := decoder.Value()
  22074 			if err != nil {
  22075 				return err
  22076 			}
  22077 			if val == nil {
  22078 				break
  22079 			}
  22080 			{
  22081 				xtv := string(val)
  22082 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22083 				if err != nil {
  22084 					return err
  22085 				}
  22086 				sv.Version = ptr.Int32(int32(i64))
  22087 			}
  22088 
  22089 		default:
  22090 			// Do nothing and ignore the unexpected tag element
  22091 			err = decoder.Decoder.Skip()
  22092 			if err != nil {
  22093 				return err
  22094 			}
  22095 
  22096 		}
  22097 		decoder = originalDecoder
  22098 	}
  22099 	*v = sv
  22100 	return nil
  22101 }
  22102 
  22103 func awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(v **types.TrafficPolicyAlreadyExists, decoder smithyxml.NodeDecoder) error {
  22104 	if v == nil {
  22105 		return fmt.Errorf("unexpected nil of type %T", v)
  22106 	}
  22107 	var sv *types.TrafficPolicyAlreadyExists
  22108 	if *v == nil {
  22109 		sv = &types.TrafficPolicyAlreadyExists{}
  22110 	} else {
  22111 		sv = *v
  22112 	}
  22113 
  22114 	for {
  22115 		t, done, err := decoder.Token()
  22116 		if err != nil {
  22117 			return err
  22118 		}
  22119 		if done {
  22120 			break
  22121 		}
  22122 		originalDecoder := decoder
  22123 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22124 		switch {
  22125 		case strings.EqualFold("message", t.Name.Local):
  22126 			val, err := decoder.Value()
  22127 			if err != nil {
  22128 				return err
  22129 			}
  22130 			if val == nil {
  22131 				break
  22132 			}
  22133 			{
  22134 				xtv := string(val)
  22135 				sv.Message = ptr.String(xtv)
  22136 			}
  22137 
  22138 		default:
  22139 			// Do nothing and ignore the unexpected tag element
  22140 			err = decoder.Decoder.Skip()
  22141 			if err != nil {
  22142 				return err
  22143 			}
  22144 
  22145 		}
  22146 		decoder = originalDecoder
  22147 	}
  22148 	*v = sv
  22149 	return nil
  22150 }
  22151 
  22152 func awsRestxml_deserializeDocumentTrafficPolicyInstance(v **types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  22153 	if v == nil {
  22154 		return fmt.Errorf("unexpected nil of type %T", v)
  22155 	}
  22156 	var sv *types.TrafficPolicyInstance
  22157 	if *v == nil {
  22158 		sv = &types.TrafficPolicyInstance{}
  22159 	} else {
  22160 		sv = *v
  22161 	}
  22162 
  22163 	for {
  22164 		t, done, err := decoder.Token()
  22165 		if err != nil {
  22166 			return err
  22167 		}
  22168 		if done {
  22169 			break
  22170 		}
  22171 		originalDecoder := decoder
  22172 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22173 		switch {
  22174 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  22175 			val, err := decoder.Value()
  22176 			if err != nil {
  22177 				return err
  22178 			}
  22179 			if val == nil {
  22180 				break
  22181 			}
  22182 			{
  22183 				xtv := string(val)
  22184 				sv.HostedZoneId = ptr.String(xtv)
  22185 			}
  22186 
  22187 		case strings.EqualFold("Id", t.Name.Local):
  22188 			val, err := decoder.Value()
  22189 			if err != nil {
  22190 				return err
  22191 			}
  22192 			if val == nil {
  22193 				break
  22194 			}
  22195 			{
  22196 				xtv := string(val)
  22197 				sv.Id = ptr.String(xtv)
  22198 			}
  22199 
  22200 		case strings.EqualFold("Message", t.Name.Local):
  22201 			val, err := decoder.Value()
  22202 			if err != nil {
  22203 				return err
  22204 			}
  22205 			if val == nil {
  22206 				break
  22207 			}
  22208 			{
  22209 				xtv := string(val)
  22210 				sv.Message = ptr.String(xtv)
  22211 			}
  22212 
  22213 		case strings.EqualFold("Name", t.Name.Local):
  22214 			val, err := decoder.Value()
  22215 			if err != nil {
  22216 				return err
  22217 			}
  22218 			if val == nil {
  22219 				break
  22220 			}
  22221 			{
  22222 				xtv := string(val)
  22223 				sv.Name = ptr.String(xtv)
  22224 			}
  22225 
  22226 		case strings.EqualFold("State", t.Name.Local):
  22227 			val, err := decoder.Value()
  22228 			if err != nil {
  22229 				return err
  22230 			}
  22231 			if val == nil {
  22232 				break
  22233 			}
  22234 			{
  22235 				xtv := string(val)
  22236 				sv.State = ptr.String(xtv)
  22237 			}
  22238 
  22239 		case strings.EqualFold("TrafficPolicyId", t.Name.Local):
  22240 			val, err := decoder.Value()
  22241 			if err != nil {
  22242 				return err
  22243 			}
  22244 			if val == nil {
  22245 				break
  22246 			}
  22247 			{
  22248 				xtv := string(val)
  22249 				sv.TrafficPolicyId = ptr.String(xtv)
  22250 			}
  22251 
  22252 		case strings.EqualFold("TrafficPolicyType", t.Name.Local):
  22253 			val, err := decoder.Value()
  22254 			if err != nil {
  22255 				return err
  22256 			}
  22257 			if val == nil {
  22258 				break
  22259 			}
  22260 			{
  22261 				xtv := string(val)
  22262 				sv.TrafficPolicyType = types.RRType(xtv)
  22263 			}
  22264 
  22265 		case strings.EqualFold("TrafficPolicyVersion", t.Name.Local):
  22266 			val, err := decoder.Value()
  22267 			if err != nil {
  22268 				return err
  22269 			}
  22270 			if val == nil {
  22271 				break
  22272 			}
  22273 			{
  22274 				xtv := string(val)
  22275 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22276 				if err != nil {
  22277 					return err
  22278 				}
  22279 				sv.TrafficPolicyVersion = ptr.Int32(int32(i64))
  22280 			}
  22281 
  22282 		case strings.EqualFold("TTL", t.Name.Local):
  22283 			val, err := decoder.Value()
  22284 			if err != nil {
  22285 				return err
  22286 			}
  22287 			if val == nil {
  22288 				break
  22289 			}
  22290 			{
  22291 				xtv := string(val)
  22292 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22293 				if err != nil {
  22294 					return err
  22295 				}
  22296 				sv.TTL = ptr.Int64(i64)
  22297 			}
  22298 
  22299 		default:
  22300 			// Do nothing and ignore the unexpected tag element
  22301 			err = decoder.Decoder.Skip()
  22302 			if err != nil {
  22303 				return err
  22304 			}
  22305 
  22306 		}
  22307 		decoder = originalDecoder
  22308 	}
  22309 	*v = sv
  22310 	return nil
  22311 }
  22312 
  22313 func awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(v **types.TrafficPolicyInstanceAlreadyExists, decoder smithyxml.NodeDecoder) error {
  22314 	if v == nil {
  22315 		return fmt.Errorf("unexpected nil of type %T", v)
  22316 	}
  22317 	var sv *types.TrafficPolicyInstanceAlreadyExists
  22318 	if *v == nil {
  22319 		sv = &types.TrafficPolicyInstanceAlreadyExists{}
  22320 	} else {
  22321 		sv = *v
  22322 	}
  22323 
  22324 	for {
  22325 		t, done, err := decoder.Token()
  22326 		if err != nil {
  22327 			return err
  22328 		}
  22329 		if done {
  22330 			break
  22331 		}
  22332 		originalDecoder := decoder
  22333 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22334 		switch {
  22335 		case strings.EqualFold("message", t.Name.Local):
  22336 			val, err := decoder.Value()
  22337 			if err != nil {
  22338 				return err
  22339 			}
  22340 			if val == nil {
  22341 				break
  22342 			}
  22343 			{
  22344 				xtv := string(val)
  22345 				sv.Message = ptr.String(xtv)
  22346 			}
  22347 
  22348 		default:
  22349 			// Do nothing and ignore the unexpected tag element
  22350 			err = decoder.Decoder.Skip()
  22351 			if err != nil {
  22352 				return err
  22353 			}
  22354 
  22355 		}
  22356 		decoder = originalDecoder
  22357 	}
  22358 	*v = sv
  22359 	return nil
  22360 }
  22361 
  22362 func awsRestxml_deserializeDocumentTrafficPolicyInstances(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  22363 	if v == nil {
  22364 		return fmt.Errorf("unexpected nil of type %T", v)
  22365 	}
  22366 	var sv []types.TrafficPolicyInstance
  22367 	if *v == nil {
  22368 		sv = make([]types.TrafficPolicyInstance, 0)
  22369 	} else {
  22370 		sv = *v
  22371 	}
  22372 
  22373 	originalDecoder := decoder
  22374 	for {
  22375 		t, done, err := decoder.Token()
  22376 		if err != nil {
  22377 			return err
  22378 		}
  22379 		if done {
  22380 			break
  22381 		}
  22382 		switch {
  22383 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
  22384 			var col types.TrafficPolicyInstance
  22385 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22386 			destAddr := &col
  22387 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil {
  22388 				return err
  22389 			}
  22390 			col = *destAddr
  22391 			sv = append(sv, col)
  22392 
  22393 		default:
  22394 			err = decoder.Decoder.Skip()
  22395 			if err != nil {
  22396 				return err
  22397 			}
  22398 
  22399 		}
  22400 		decoder = originalDecoder
  22401 	}
  22402 	*v = sv
  22403 	return nil
  22404 }
  22405 
  22406 func awsRestxml_deserializeDocumentTrafficPolicyInstancesUnwrapped(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  22407 	var sv []types.TrafficPolicyInstance
  22408 	if *v == nil {
  22409 		sv = make([]types.TrafficPolicyInstance, 0)
  22410 	} else {
  22411 		sv = *v
  22412 	}
  22413 
  22414 	switch {
  22415 	default:
  22416 		var mv types.TrafficPolicyInstance
  22417 		t := decoder.StartEl
  22418 		_ = t
  22419 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22420 		destAddr := &mv
  22421 		if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil {
  22422 			return err
  22423 		}
  22424 		mv = *destAddr
  22425 		sv = append(sv, mv)
  22426 	}
  22427 	*v = sv
  22428 	return nil
  22429 }
  22430 func awsRestxml_deserializeDocumentTrafficPolicyInUse(v **types.TrafficPolicyInUse, decoder smithyxml.NodeDecoder) error {
  22431 	if v == nil {
  22432 		return fmt.Errorf("unexpected nil of type %T", v)
  22433 	}
  22434 	var sv *types.TrafficPolicyInUse
  22435 	if *v == nil {
  22436 		sv = &types.TrafficPolicyInUse{}
  22437 	} else {
  22438 		sv = *v
  22439 	}
  22440 
  22441 	for {
  22442 		t, done, err := decoder.Token()
  22443 		if err != nil {
  22444 			return err
  22445 		}
  22446 		if done {
  22447 			break
  22448 		}
  22449 		originalDecoder := decoder
  22450 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22451 		switch {
  22452 		case strings.EqualFold("message", t.Name.Local):
  22453 			val, err := decoder.Value()
  22454 			if err != nil {
  22455 				return err
  22456 			}
  22457 			if val == nil {
  22458 				break
  22459 			}
  22460 			{
  22461 				xtv := string(val)
  22462 				sv.Message = ptr.String(xtv)
  22463 			}
  22464 
  22465 		default:
  22466 			// Do nothing and ignore the unexpected tag element
  22467 			err = decoder.Decoder.Skip()
  22468 			if err != nil {
  22469 				return err
  22470 			}
  22471 
  22472 		}
  22473 		decoder = originalDecoder
  22474 	}
  22475 	*v = sv
  22476 	return nil
  22477 }
  22478 
  22479 func awsRestxml_deserializeDocumentTrafficPolicySummaries(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
  22480 	if v == nil {
  22481 		return fmt.Errorf("unexpected nil of type %T", v)
  22482 	}
  22483 	var sv []types.TrafficPolicySummary
  22484 	if *v == nil {
  22485 		sv = make([]types.TrafficPolicySummary, 0)
  22486 	} else {
  22487 		sv = *v
  22488 	}
  22489 
  22490 	originalDecoder := decoder
  22491 	for {
  22492 		t, done, err := decoder.Token()
  22493 		if err != nil {
  22494 			return err
  22495 		}
  22496 		if done {
  22497 			break
  22498 		}
  22499 		switch {
  22500 		case strings.EqualFold("TrafficPolicySummary", t.Name.Local):
  22501 			var col types.TrafficPolicySummary
  22502 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22503 			destAddr := &col
  22504 			if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil {
  22505 				return err
  22506 			}
  22507 			col = *destAddr
  22508 			sv = append(sv, col)
  22509 
  22510 		default:
  22511 			err = decoder.Decoder.Skip()
  22512 			if err != nil {
  22513 				return err
  22514 			}
  22515 
  22516 		}
  22517 		decoder = originalDecoder
  22518 	}
  22519 	*v = sv
  22520 	return nil
  22521 }
  22522 
  22523 func awsRestxml_deserializeDocumentTrafficPolicySummariesUnwrapped(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
  22524 	var sv []types.TrafficPolicySummary
  22525 	if *v == nil {
  22526 		sv = make([]types.TrafficPolicySummary, 0)
  22527 	} else {
  22528 		sv = *v
  22529 	}
  22530 
  22531 	switch {
  22532 	default:
  22533 		var mv types.TrafficPolicySummary
  22534 		t := decoder.StartEl
  22535 		_ = t
  22536 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22537 		destAddr := &mv
  22538 		if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil {
  22539 			return err
  22540 		}
  22541 		mv = *destAddr
  22542 		sv = append(sv, mv)
  22543 	}
  22544 	*v = sv
  22545 	return nil
  22546 }
  22547 func awsRestxml_deserializeDocumentTrafficPolicySummary(v **types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
  22548 	if v == nil {
  22549 		return fmt.Errorf("unexpected nil of type %T", v)
  22550 	}
  22551 	var sv *types.TrafficPolicySummary
  22552 	if *v == nil {
  22553 		sv = &types.TrafficPolicySummary{}
  22554 	} else {
  22555 		sv = *v
  22556 	}
  22557 
  22558 	for {
  22559 		t, done, err := decoder.Token()
  22560 		if err != nil {
  22561 			return err
  22562 		}
  22563 		if done {
  22564 			break
  22565 		}
  22566 		originalDecoder := decoder
  22567 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22568 		switch {
  22569 		case strings.EqualFold("Id", t.Name.Local):
  22570 			val, err := decoder.Value()
  22571 			if err != nil {
  22572 				return err
  22573 			}
  22574 			if val == nil {
  22575 				break
  22576 			}
  22577 			{
  22578 				xtv := string(val)
  22579 				sv.Id = ptr.String(xtv)
  22580 			}
  22581 
  22582 		case strings.EqualFold("LatestVersion", t.Name.Local):
  22583 			val, err := decoder.Value()
  22584 			if err != nil {
  22585 				return err
  22586 			}
  22587 			if val == nil {
  22588 				break
  22589 			}
  22590 			{
  22591 				xtv := string(val)
  22592 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22593 				if err != nil {
  22594 					return err
  22595 				}
  22596 				sv.LatestVersion = ptr.Int32(int32(i64))
  22597 			}
  22598 
  22599 		case strings.EqualFold("Name", t.Name.Local):
  22600 			val, err := decoder.Value()
  22601 			if err != nil {
  22602 				return err
  22603 			}
  22604 			if val == nil {
  22605 				break
  22606 			}
  22607 			{
  22608 				xtv := string(val)
  22609 				sv.Name = ptr.String(xtv)
  22610 			}
  22611 
  22612 		case strings.EqualFold("TrafficPolicyCount", t.Name.Local):
  22613 			val, err := decoder.Value()
  22614 			if err != nil {
  22615 				return err
  22616 			}
  22617 			if val == nil {
  22618 				break
  22619 			}
  22620 			{
  22621 				xtv := string(val)
  22622 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22623 				if err != nil {
  22624 					return err
  22625 				}
  22626 				sv.TrafficPolicyCount = ptr.Int32(int32(i64))
  22627 			}
  22628 
  22629 		case strings.EqualFold("Type", t.Name.Local):
  22630 			val, err := decoder.Value()
  22631 			if err != nil {
  22632 				return err
  22633 			}
  22634 			if val == nil {
  22635 				break
  22636 			}
  22637 			{
  22638 				xtv := string(val)
  22639 				sv.Type = types.RRType(xtv)
  22640 			}
  22641 
  22642 		default:
  22643 			// Do nothing and ignore the unexpected tag element
  22644 			err = decoder.Decoder.Skip()
  22645 			if err != nil {
  22646 				return err
  22647 			}
  22648 
  22649 		}
  22650 		decoder = originalDecoder
  22651 	}
  22652 	*v = sv
  22653 	return nil
  22654 }
  22655 
  22656 func awsRestxml_deserializeDocumentVPC(v **types.VPC, decoder smithyxml.NodeDecoder) error {
  22657 	if v == nil {
  22658 		return fmt.Errorf("unexpected nil of type %T", v)
  22659 	}
  22660 	var sv *types.VPC
  22661 	if *v == nil {
  22662 		sv = &types.VPC{}
  22663 	} else {
  22664 		sv = *v
  22665 	}
  22666 
  22667 	for {
  22668 		t, done, err := decoder.Token()
  22669 		if err != nil {
  22670 			return err
  22671 		}
  22672 		if done {
  22673 			break
  22674 		}
  22675 		originalDecoder := decoder
  22676 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22677 		switch {
  22678 		case strings.EqualFold("VPCId", t.Name.Local):
  22679 			val, err := decoder.Value()
  22680 			if err != nil {
  22681 				return err
  22682 			}
  22683 			if val == nil {
  22684 				break
  22685 			}
  22686 			{
  22687 				xtv := string(val)
  22688 				sv.VPCId = ptr.String(xtv)
  22689 			}
  22690 
  22691 		case strings.EqualFold("VPCRegion", t.Name.Local):
  22692 			val, err := decoder.Value()
  22693 			if err != nil {
  22694 				return err
  22695 			}
  22696 			if val == nil {
  22697 				break
  22698 			}
  22699 			{
  22700 				xtv := string(val)
  22701 				sv.VPCRegion = types.VPCRegion(xtv)
  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_deserializeDocumentVPCAssociationAuthorizationNotFound(v **types.VPCAssociationAuthorizationNotFound, decoder smithyxml.NodeDecoder) error {
  22719 	if v == nil {
  22720 		return fmt.Errorf("unexpected nil of type %T", v)
  22721 	}
  22722 	var sv *types.VPCAssociationAuthorizationNotFound
  22723 	if *v == nil {
  22724 		sv = &types.VPCAssociationAuthorizationNotFound{}
  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_deserializeDocumentVPCAssociationNotFound(v **types.VPCAssociationNotFound, decoder smithyxml.NodeDecoder) error {
  22768 	if v == nil {
  22769 		return fmt.Errorf("unexpected nil of type %T", v)
  22770 	}
  22771 	var sv *types.VPCAssociationNotFound
  22772 	if *v == nil {
  22773 		sv = &types.VPCAssociationNotFound{}
  22774 	} else {
  22775 		sv = *v
  22776 	}
  22777 
  22778 	for {
  22779 		t, done, err := decoder.Token()
  22780 		if err != nil {
  22781 			return err
  22782 		}
  22783 		if done {
  22784 			break
  22785 		}
  22786 		originalDecoder := decoder
  22787 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22788 		switch {
  22789 		case strings.EqualFold("message", t.Name.Local):
  22790 			val, err := decoder.Value()
  22791 			if err != nil {
  22792 				return err
  22793 			}
  22794 			if val == nil {
  22795 				break
  22796 			}
  22797 			{
  22798 				xtv := string(val)
  22799 				sv.Message = ptr.String(xtv)
  22800 			}
  22801 
  22802 		default:
  22803 			// Do nothing and ignore the unexpected tag element
  22804 			err = decoder.Decoder.Skip()
  22805 			if err != nil {
  22806 				return err
  22807 			}
  22808 
  22809 		}
  22810 		decoder = originalDecoder
  22811 	}
  22812 	*v = sv
  22813 	return nil
  22814 }
  22815 
  22816 func awsRestxml_deserializeDocumentVPCs(v *[]types.VPC, decoder smithyxml.NodeDecoder) error {
  22817 	if v == nil {
  22818 		return fmt.Errorf("unexpected nil of type %T", v)
  22819 	}
  22820 	var sv []types.VPC
  22821 	if *v == nil {
  22822 		sv = make([]types.VPC, 0)
  22823 	} else {
  22824 		sv = *v
  22825 	}
  22826 
  22827 	originalDecoder := decoder
  22828 	for {
  22829 		t, done, err := decoder.Token()
  22830 		if err != nil {
  22831 			return err
  22832 		}
  22833 		if done {
  22834 			break
  22835 		}
  22836 		switch {
  22837 		case strings.EqualFold("VPC", t.Name.Local):
  22838 			var col types.VPC
  22839 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22840 			destAddr := &col
  22841 			if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil {
  22842 				return err
  22843 			}
  22844 			col = *destAddr
  22845 			sv = append(sv, col)
  22846 
  22847 		default:
  22848 			err = decoder.Decoder.Skip()
  22849 			if err != nil {
  22850 				return err
  22851 			}
  22852 
  22853 		}
  22854 		decoder = originalDecoder
  22855 	}
  22856 	*v = sv
  22857 	return nil
  22858 }
  22859 
  22860 func awsRestxml_deserializeDocumentVPCsUnwrapped(v *[]types.VPC, decoder smithyxml.NodeDecoder) error {
  22861 	var sv []types.VPC
  22862 	if *v == nil {
  22863 		sv = make([]types.VPC, 0)
  22864 	} else {
  22865 		sv = *v
  22866 	}
  22867 
  22868 	switch {
  22869 	default:
  22870 		var mv types.VPC
  22871 		t := decoder.StartEl
  22872 		_ = t
  22873 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22874 		destAddr := &mv
  22875 		if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil {
  22876 			return err
  22877 		}
  22878 		mv = *destAddr
  22879 		sv = append(sv, mv)
  22880 	}
  22881 	*v = sv
  22882 	return nil
  22883 }