deserializers.go - code.dwrz.net

deserializers.go (571424B)
      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 	smithyhttp "github.com/aws/smithy-go/transport/http"
     20 	"io"
     21 	"strconv"
     22 	"strings"
     23 )
     24 
     25 type awsRestxml_deserializeOpActivateKeySigningKey struct {
     26 }
     27 
     28 func (*awsRestxml_deserializeOpActivateKeySigningKey) ID() string {
     29 	return "OperationDeserializer"
     30 }
     31 
     32 func (m *awsRestxml_deserializeOpActivateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
     33 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
     34 ) {
     35 	out, metadata, err = next.HandleDeserialize(ctx, in)
     36 	if err != nil {
     37 		return out, metadata, err
     38 	}
     39 
     40 	response, ok := out.RawResponse.(*smithyhttp.Response)
     41 	if !ok {
     42 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
     43 	}
     44 
     45 	if response.StatusCode < 200 || response.StatusCode >= 300 {
     46 		return out, metadata, awsRestxml_deserializeOpErrorActivateKeySigningKey(response, &metadata)
     47 	}
     48 	output := &ActivateKeySigningKeyOutput{}
     49 	out.Result = output
     50 
     51 	var buff [1024]byte
     52 	ringBuffer := smithyio.NewRingBuffer(buff[:])
     53 	body := io.TeeReader(response.Body, ringBuffer)
     54 	rootDecoder := xml.NewDecoder(body)
     55 	t, err := smithyxml.FetchRootElement(rootDecoder)
     56 	if err == io.EOF {
     57 		return out, metadata, nil
     58 	}
     59 	if err != nil {
     60 		var snapshot bytes.Buffer
     61 		io.Copy(&snapshot, ringBuffer)
     62 		return out, metadata, &smithy.DeserializationError{
     63 			Err:      fmt.Errorf("failed to decode response body, %w", err),
     64 			Snapshot: snapshot.Bytes(),
     65 		}
     66 	}
     67 
     68 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
     69 	err = awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(&output, decoder)
     70 	if err != nil {
     71 		var snapshot bytes.Buffer
     72 		io.Copy(&snapshot, ringBuffer)
     73 		return out, metadata, &smithy.DeserializationError{
     74 			Err:      fmt.Errorf("failed to decode response body, %w", err),
     75 			Snapshot: snapshot.Bytes(),
     76 		}
     77 	}
     78 
     79 	return out, metadata, err
     80 }
     81 
     82 func awsRestxml_deserializeOpErrorActivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
     83 	var errorBuffer bytes.Buffer
     84 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
     85 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
     86 	}
     87 	errorBody := bytes.NewReader(errorBuffer.Bytes())
     88 
     89 	errorCode := "UnknownError"
     90 	errorMessage := errorCode
     91 
     92 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
     93 	if err != nil {
     94 		return err
     95 	}
     96 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
     97 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
     98 	}
     99 	if len(errorComponents.Code) != 0 {
    100 		errorCode = errorComponents.Code
    101 	}
    102 	if len(errorComponents.Message) != 0 {
    103 		errorMessage = errorComponents.Message
    104 	}
    105 	errorBody.Seek(0, io.SeekStart)
    106 	switch {
    107 	case strings.EqualFold("ConcurrentModification", errorCode):
    108 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
    109 
    110 	case strings.EqualFold("InvalidInput", errorCode):
    111 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    112 
    113 	case strings.EqualFold("InvalidKMSArn", errorCode):
    114 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
    115 
    116 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
    117 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
    118 
    119 	case strings.EqualFold("InvalidSigningStatus", errorCode):
    120 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
    121 
    122 	case strings.EqualFold("NoSuchKeySigningKey", errorCode):
    123 		return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
    124 
    125 	default:
    126 		genericError := &smithy.GenericAPIError{
    127 			Code:    errorCode,
    128 			Message: errorMessage,
    129 		}
    130 		return genericError
    131 
    132 	}
    133 }
    134 
    135 func awsRestxml_deserializeOpDocumentActivateKeySigningKeyOutput(v **ActivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
    136 	if v == nil {
    137 		return fmt.Errorf("unexpected nil of type %T", v)
    138 	}
    139 	var sv *ActivateKeySigningKeyOutput
    140 	if *v == nil {
    141 		sv = &ActivateKeySigningKeyOutput{}
    142 	} else {
    143 		sv = *v
    144 	}
    145 
    146 	for {
    147 		t, done, err := decoder.Token()
    148 		if err != nil {
    149 			return err
    150 		}
    151 		if done {
    152 			break
    153 		}
    154 		originalDecoder := decoder
    155 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    156 		switch {
    157 		case strings.EqualFold("ChangeInfo", t.Name.Local):
    158 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    159 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
    160 				return err
    161 			}
    162 
    163 		default:
    164 			// Do nothing and ignore the unexpected tag element
    165 			err = decoder.Decoder.Skip()
    166 			if err != nil {
    167 				return err
    168 			}
    169 
    170 		}
    171 		decoder = originalDecoder
    172 	}
    173 	*v = sv
    174 	return nil
    175 }
    176 
    177 type awsRestxml_deserializeOpAssociateVPCWithHostedZone struct {
    178 }
    179 
    180 func (*awsRestxml_deserializeOpAssociateVPCWithHostedZone) ID() string {
    181 	return "OperationDeserializer"
    182 }
    183 
    184 func (m *awsRestxml_deserializeOpAssociateVPCWithHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    185 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    186 ) {
    187 	out, metadata, err = next.HandleDeserialize(ctx, in)
    188 	if err != nil {
    189 		return out, metadata, err
    190 	}
    191 
    192 	response, ok := out.RawResponse.(*smithyhttp.Response)
    193 	if !ok {
    194 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    195 	}
    196 
    197 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    198 		return out, metadata, awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response, &metadata)
    199 	}
    200 	output := &AssociateVPCWithHostedZoneOutput{}
    201 	out.Result = output
    202 
    203 	var buff [1024]byte
    204 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    205 	body := io.TeeReader(response.Body, ringBuffer)
    206 	rootDecoder := xml.NewDecoder(body)
    207 	t, err := smithyxml.FetchRootElement(rootDecoder)
    208 	if err == io.EOF {
    209 		return out, metadata, nil
    210 	}
    211 	if err != nil {
    212 		var snapshot bytes.Buffer
    213 		io.Copy(&snapshot, ringBuffer)
    214 		return out, metadata, &smithy.DeserializationError{
    215 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    216 			Snapshot: snapshot.Bytes(),
    217 		}
    218 	}
    219 
    220 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    221 	err = awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(&output, decoder)
    222 	if err != nil {
    223 		var snapshot bytes.Buffer
    224 		io.Copy(&snapshot, ringBuffer)
    225 		return out, metadata, &smithy.DeserializationError{
    226 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    227 			Snapshot: snapshot.Bytes(),
    228 		}
    229 	}
    230 
    231 	return out, metadata, err
    232 }
    233 
    234 func awsRestxml_deserializeOpErrorAssociateVPCWithHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    235 	var errorBuffer bytes.Buffer
    236 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    237 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    238 	}
    239 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    240 
    241 	errorCode := "UnknownError"
    242 	errorMessage := errorCode
    243 
    244 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    245 	if err != nil {
    246 		return err
    247 	}
    248 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    249 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    250 	}
    251 	if len(errorComponents.Code) != 0 {
    252 		errorCode = errorComponents.Code
    253 	}
    254 	if len(errorComponents.Message) != 0 {
    255 		errorMessage = errorComponents.Message
    256 	}
    257 	errorBody.Seek(0, io.SeekStart)
    258 	switch {
    259 	case strings.EqualFold("ConflictingDomainExists", errorCode):
    260 		return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody)
    261 
    262 	case strings.EqualFold("InvalidInput", errorCode):
    263 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    264 
    265 	case strings.EqualFold("InvalidVPCId", errorCode):
    266 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
    267 
    268 	case strings.EqualFold("LimitsExceeded", errorCode):
    269 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
    270 
    271 	case strings.EqualFold("NoSuchHostedZone", errorCode):
    272 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
    273 
    274 	case strings.EqualFold("NotAuthorizedException", errorCode):
    275 		return awsRestxml_deserializeErrorNotAuthorizedException(response, errorBody)
    276 
    277 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
    278 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
    279 
    280 	case strings.EqualFold("PublicZoneVPCAssociation", errorCode):
    281 		return awsRestxml_deserializeErrorPublicZoneVPCAssociation(response, errorBody)
    282 
    283 	default:
    284 		genericError := &smithy.GenericAPIError{
    285 			Code:    errorCode,
    286 			Message: errorMessage,
    287 		}
    288 		return genericError
    289 
    290 	}
    291 }
    292 
    293 func awsRestxml_deserializeOpDocumentAssociateVPCWithHostedZoneOutput(v **AssociateVPCWithHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
    294 	if v == nil {
    295 		return fmt.Errorf("unexpected nil of type %T", v)
    296 	}
    297 	var sv *AssociateVPCWithHostedZoneOutput
    298 	if *v == nil {
    299 		sv = &AssociateVPCWithHostedZoneOutput{}
    300 	} else {
    301 		sv = *v
    302 	}
    303 
    304 	for {
    305 		t, done, err := decoder.Token()
    306 		if err != nil {
    307 			return err
    308 		}
    309 		if done {
    310 			break
    311 		}
    312 		originalDecoder := decoder
    313 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    314 		switch {
    315 		case strings.EqualFold("ChangeInfo", t.Name.Local):
    316 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    317 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
    318 				return err
    319 			}
    320 
    321 		default:
    322 			// Do nothing and ignore the unexpected tag element
    323 			err = decoder.Decoder.Skip()
    324 			if err != nil {
    325 				return err
    326 			}
    327 
    328 		}
    329 		decoder = originalDecoder
    330 	}
    331 	*v = sv
    332 	return nil
    333 }
    334 
    335 type awsRestxml_deserializeOpChangeCidrCollection struct {
    336 }
    337 
    338 func (*awsRestxml_deserializeOpChangeCidrCollection) ID() string {
    339 	return "OperationDeserializer"
    340 }
    341 
    342 func (m *awsRestxml_deserializeOpChangeCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    343 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    344 ) {
    345 	out, metadata, err = next.HandleDeserialize(ctx, in)
    346 	if err != nil {
    347 		return out, metadata, err
    348 	}
    349 
    350 	response, ok := out.RawResponse.(*smithyhttp.Response)
    351 	if !ok {
    352 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    353 	}
    354 
    355 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    356 		return out, metadata, awsRestxml_deserializeOpErrorChangeCidrCollection(response, &metadata)
    357 	}
    358 	output := &ChangeCidrCollectionOutput{}
    359 	out.Result = output
    360 
    361 	var buff [1024]byte
    362 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    363 	body := io.TeeReader(response.Body, ringBuffer)
    364 	rootDecoder := xml.NewDecoder(body)
    365 	t, err := smithyxml.FetchRootElement(rootDecoder)
    366 	if err == io.EOF {
    367 		return out, metadata, nil
    368 	}
    369 	if err != nil {
    370 		var snapshot bytes.Buffer
    371 		io.Copy(&snapshot, ringBuffer)
    372 		return out, metadata, &smithy.DeserializationError{
    373 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    374 			Snapshot: snapshot.Bytes(),
    375 		}
    376 	}
    377 
    378 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    379 	err = awsRestxml_deserializeOpDocumentChangeCidrCollectionOutput(&output, decoder)
    380 	if err != nil {
    381 		var snapshot bytes.Buffer
    382 		io.Copy(&snapshot, ringBuffer)
    383 		return out, metadata, &smithy.DeserializationError{
    384 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    385 			Snapshot: snapshot.Bytes(),
    386 		}
    387 	}
    388 
    389 	return out, metadata, err
    390 }
    391 
    392 func awsRestxml_deserializeOpErrorChangeCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    393 	var errorBuffer bytes.Buffer
    394 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    395 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    396 	}
    397 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    398 
    399 	errorCode := "UnknownError"
    400 	errorMessage := errorCode
    401 
    402 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    403 	if err != nil {
    404 		return err
    405 	}
    406 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    407 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    408 	}
    409 	if len(errorComponents.Code) != 0 {
    410 		errorCode = errorComponents.Code
    411 	}
    412 	if len(errorComponents.Message) != 0 {
    413 		errorMessage = errorComponents.Message
    414 	}
    415 	errorBody.Seek(0, io.SeekStart)
    416 	switch {
    417 	case strings.EqualFold("CidrBlockInUseException", errorCode):
    418 		return awsRestxml_deserializeErrorCidrBlockInUseException(response, errorBody)
    419 
    420 	case strings.EqualFold("CidrCollectionVersionMismatchException", errorCode):
    421 		return awsRestxml_deserializeErrorCidrCollectionVersionMismatchException(response, errorBody)
    422 
    423 	case strings.EqualFold("ConcurrentModification", errorCode):
    424 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
    425 
    426 	case strings.EqualFold("InvalidInput", errorCode):
    427 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    428 
    429 	case strings.EqualFold("LimitsExceeded", errorCode):
    430 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
    431 
    432 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
    433 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
    434 
    435 	default:
    436 		genericError := &smithy.GenericAPIError{
    437 			Code:    errorCode,
    438 			Message: errorMessage,
    439 		}
    440 		return genericError
    441 
    442 	}
    443 }
    444 
    445 func awsRestxml_deserializeOpDocumentChangeCidrCollectionOutput(v **ChangeCidrCollectionOutput, decoder smithyxml.NodeDecoder) error {
    446 	if v == nil {
    447 		return fmt.Errorf("unexpected nil of type %T", v)
    448 	}
    449 	var sv *ChangeCidrCollectionOutput
    450 	if *v == nil {
    451 		sv = &ChangeCidrCollectionOutput{}
    452 	} else {
    453 		sv = *v
    454 	}
    455 
    456 	for {
    457 		t, done, err := decoder.Token()
    458 		if err != nil {
    459 			return err
    460 		}
    461 		if done {
    462 			break
    463 		}
    464 		originalDecoder := decoder
    465 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    466 		switch {
    467 		case strings.EqualFold("Id", t.Name.Local):
    468 			val, err := decoder.Value()
    469 			if err != nil {
    470 				return err
    471 			}
    472 			if val == nil {
    473 				break
    474 			}
    475 			{
    476 				xtv := string(val)
    477 				sv.Id = ptr.String(xtv)
    478 			}
    479 
    480 		default:
    481 			// Do nothing and ignore the unexpected tag element
    482 			err = decoder.Decoder.Skip()
    483 			if err != nil {
    484 				return err
    485 			}
    486 
    487 		}
    488 		decoder = originalDecoder
    489 	}
    490 	*v = sv
    491 	return nil
    492 }
    493 
    494 type awsRestxml_deserializeOpChangeResourceRecordSets struct {
    495 }
    496 
    497 func (*awsRestxml_deserializeOpChangeResourceRecordSets) ID() string {
    498 	return "OperationDeserializer"
    499 }
    500 
    501 func (m *awsRestxml_deserializeOpChangeResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    502 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    503 ) {
    504 	out, metadata, err = next.HandleDeserialize(ctx, in)
    505 	if err != nil {
    506 		return out, metadata, err
    507 	}
    508 
    509 	response, ok := out.RawResponse.(*smithyhttp.Response)
    510 	if !ok {
    511 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    512 	}
    513 
    514 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    515 		return out, metadata, awsRestxml_deserializeOpErrorChangeResourceRecordSets(response, &metadata)
    516 	}
    517 	output := &ChangeResourceRecordSetsOutput{}
    518 	out.Result = output
    519 
    520 	var buff [1024]byte
    521 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    522 	body := io.TeeReader(response.Body, ringBuffer)
    523 	rootDecoder := xml.NewDecoder(body)
    524 	t, err := smithyxml.FetchRootElement(rootDecoder)
    525 	if err == io.EOF {
    526 		return out, metadata, nil
    527 	}
    528 	if err != nil {
    529 		var snapshot bytes.Buffer
    530 		io.Copy(&snapshot, ringBuffer)
    531 		return out, metadata, &smithy.DeserializationError{
    532 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    533 			Snapshot: snapshot.Bytes(),
    534 		}
    535 	}
    536 
    537 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    538 	err = awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(&output, decoder)
    539 	if err != nil {
    540 		var snapshot bytes.Buffer
    541 		io.Copy(&snapshot, ringBuffer)
    542 		return out, metadata, &smithy.DeserializationError{
    543 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    544 			Snapshot: snapshot.Bytes(),
    545 		}
    546 	}
    547 
    548 	return out, metadata, err
    549 }
    550 
    551 func awsRestxml_deserializeOpErrorChangeResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    552 	var errorBuffer bytes.Buffer
    553 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    554 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    555 	}
    556 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    557 
    558 	errorCode := "UnknownError"
    559 	errorMessage := errorCode
    560 
    561 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    562 	if err != nil {
    563 		return err
    564 	}
    565 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    566 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    567 	}
    568 	if len(errorComponents.Code) != 0 {
    569 		errorCode = errorComponents.Code
    570 	}
    571 	if len(errorComponents.Message) != 0 {
    572 		errorMessage = errorComponents.Message
    573 	}
    574 	errorBody.Seek(0, io.SeekStart)
    575 	switch {
    576 	case strings.EqualFold("InvalidChangeBatch", errorCode):
    577 		return awsRestxml_deserializeErrorInvalidChangeBatch(response, errorBody)
    578 
    579 	case strings.EqualFold("InvalidInput", errorCode):
    580 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    581 
    582 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
    583 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
    584 
    585 	case strings.EqualFold("NoSuchHostedZone", errorCode):
    586 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
    587 
    588 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
    589 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
    590 
    591 	default:
    592 		genericError := &smithy.GenericAPIError{
    593 			Code:    errorCode,
    594 			Message: errorMessage,
    595 		}
    596 		return genericError
    597 
    598 	}
    599 }
    600 
    601 func awsRestxml_deserializeOpDocumentChangeResourceRecordSetsOutput(v **ChangeResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error {
    602 	if v == nil {
    603 		return fmt.Errorf("unexpected nil of type %T", v)
    604 	}
    605 	var sv *ChangeResourceRecordSetsOutput
    606 	if *v == nil {
    607 		sv = &ChangeResourceRecordSetsOutput{}
    608 	} else {
    609 		sv = *v
    610 	}
    611 
    612 	for {
    613 		t, done, err := decoder.Token()
    614 		if err != nil {
    615 			return err
    616 		}
    617 		if done {
    618 			break
    619 		}
    620 		originalDecoder := decoder
    621 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    622 		switch {
    623 		case strings.EqualFold("ChangeInfo", t.Name.Local):
    624 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    625 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
    626 				return err
    627 			}
    628 
    629 		default:
    630 			// Do nothing and ignore the unexpected tag element
    631 			err = decoder.Decoder.Skip()
    632 			if err != nil {
    633 				return err
    634 			}
    635 
    636 		}
    637 		decoder = originalDecoder
    638 	}
    639 	*v = sv
    640 	return nil
    641 }
    642 
    643 type awsRestxml_deserializeOpChangeTagsForResource struct {
    644 }
    645 
    646 func (*awsRestxml_deserializeOpChangeTagsForResource) ID() string {
    647 	return "OperationDeserializer"
    648 }
    649 
    650 func (m *awsRestxml_deserializeOpChangeTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    651 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    652 ) {
    653 	out, metadata, err = next.HandleDeserialize(ctx, in)
    654 	if err != nil {
    655 		return out, metadata, err
    656 	}
    657 
    658 	response, ok := out.RawResponse.(*smithyhttp.Response)
    659 	if !ok {
    660 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    661 	}
    662 
    663 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    664 		return out, metadata, awsRestxml_deserializeOpErrorChangeTagsForResource(response, &metadata)
    665 	}
    666 	output := &ChangeTagsForResourceOutput{}
    667 	out.Result = output
    668 
    669 	return out, metadata, err
    670 }
    671 
    672 func awsRestxml_deserializeOpErrorChangeTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    673 	var errorBuffer bytes.Buffer
    674 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    675 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    676 	}
    677 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    678 
    679 	errorCode := "UnknownError"
    680 	errorMessage := errorCode
    681 
    682 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    683 	if err != nil {
    684 		return err
    685 	}
    686 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    687 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    688 	}
    689 	if len(errorComponents.Code) != 0 {
    690 		errorCode = errorComponents.Code
    691 	}
    692 	if len(errorComponents.Message) != 0 {
    693 		errorMessage = errorComponents.Message
    694 	}
    695 	errorBody.Seek(0, io.SeekStart)
    696 	switch {
    697 	case strings.EqualFold("InvalidInput", errorCode):
    698 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    699 
    700 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
    701 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
    702 
    703 	case strings.EqualFold("NoSuchHostedZone", errorCode):
    704 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
    705 
    706 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
    707 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
    708 
    709 	case strings.EqualFold("ThrottlingException", errorCode):
    710 		return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
    711 
    712 	default:
    713 		genericError := &smithy.GenericAPIError{
    714 			Code:    errorCode,
    715 			Message: errorMessage,
    716 		}
    717 		return genericError
    718 
    719 	}
    720 }
    721 
    722 type awsRestxml_deserializeOpCreateCidrCollection struct {
    723 }
    724 
    725 func (*awsRestxml_deserializeOpCreateCidrCollection) ID() string {
    726 	return "OperationDeserializer"
    727 }
    728 
    729 func (m *awsRestxml_deserializeOpCreateCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    730 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    731 ) {
    732 	out, metadata, err = next.HandleDeserialize(ctx, in)
    733 	if err != nil {
    734 		return out, metadata, err
    735 	}
    736 
    737 	response, ok := out.RawResponse.(*smithyhttp.Response)
    738 	if !ok {
    739 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    740 	}
    741 
    742 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    743 		return out, metadata, awsRestxml_deserializeOpErrorCreateCidrCollection(response, &metadata)
    744 	}
    745 	output := &CreateCidrCollectionOutput{}
    746 	out.Result = output
    747 
    748 	err = awsRestxml_deserializeOpHttpBindingsCreateCidrCollectionOutput(output, response)
    749 	if err != nil {
    750 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
    751 	}
    752 
    753 	var buff [1024]byte
    754 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    755 	body := io.TeeReader(response.Body, ringBuffer)
    756 	rootDecoder := xml.NewDecoder(body)
    757 	t, err := smithyxml.FetchRootElement(rootDecoder)
    758 	if err == io.EOF {
    759 		return out, metadata, nil
    760 	}
    761 	if err != nil {
    762 		var snapshot bytes.Buffer
    763 		io.Copy(&snapshot, ringBuffer)
    764 		return out, metadata, &smithy.DeserializationError{
    765 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    766 			Snapshot: snapshot.Bytes(),
    767 		}
    768 	}
    769 
    770 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    771 	err = awsRestxml_deserializeOpDocumentCreateCidrCollectionOutput(&output, decoder)
    772 	if err != nil {
    773 		var snapshot bytes.Buffer
    774 		io.Copy(&snapshot, ringBuffer)
    775 		return out, metadata, &smithy.DeserializationError{
    776 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    777 			Snapshot: snapshot.Bytes(),
    778 		}
    779 	}
    780 
    781 	return out, metadata, err
    782 }
    783 
    784 func awsRestxml_deserializeOpErrorCreateCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    785 	var errorBuffer bytes.Buffer
    786 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    787 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    788 	}
    789 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    790 
    791 	errorCode := "UnknownError"
    792 	errorMessage := errorCode
    793 
    794 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    795 	if err != nil {
    796 		return err
    797 	}
    798 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    799 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    800 	}
    801 	if len(errorComponents.Code) != 0 {
    802 		errorCode = errorComponents.Code
    803 	}
    804 	if len(errorComponents.Message) != 0 {
    805 		errorMessage = errorComponents.Message
    806 	}
    807 	errorBody.Seek(0, io.SeekStart)
    808 	switch {
    809 	case strings.EqualFold("CidrCollectionAlreadyExistsException", errorCode):
    810 		return awsRestxml_deserializeErrorCidrCollectionAlreadyExistsException(response, errorBody)
    811 
    812 	case strings.EqualFold("ConcurrentModification", errorCode):
    813 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
    814 
    815 	case strings.EqualFold("InvalidInput", errorCode):
    816 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    817 
    818 	case strings.EqualFold("LimitsExceeded", errorCode):
    819 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
    820 
    821 	default:
    822 		genericError := &smithy.GenericAPIError{
    823 			Code:    errorCode,
    824 			Message: errorMessage,
    825 		}
    826 		return genericError
    827 
    828 	}
    829 }
    830 
    831 func awsRestxml_deserializeOpHttpBindingsCreateCidrCollectionOutput(v *CreateCidrCollectionOutput, response *smithyhttp.Response) error {
    832 	if v == nil {
    833 		return fmt.Errorf("unsupported deserialization for nil %T", v)
    834 	}
    835 
    836 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
    837 		headerValues[0] = strings.TrimSpace(headerValues[0])
    838 		v.Location = ptr.String(headerValues[0])
    839 	}
    840 
    841 	return nil
    842 }
    843 func awsRestxml_deserializeOpDocumentCreateCidrCollectionOutput(v **CreateCidrCollectionOutput, decoder smithyxml.NodeDecoder) error {
    844 	if v == nil {
    845 		return fmt.Errorf("unexpected nil of type %T", v)
    846 	}
    847 	var sv *CreateCidrCollectionOutput
    848 	if *v == nil {
    849 		sv = &CreateCidrCollectionOutput{}
    850 	} else {
    851 		sv = *v
    852 	}
    853 
    854 	for {
    855 		t, done, err := decoder.Token()
    856 		if err != nil {
    857 			return err
    858 		}
    859 		if done {
    860 			break
    861 		}
    862 		originalDecoder := decoder
    863 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
    864 		switch {
    865 		case strings.EqualFold("Collection", t.Name.Local):
    866 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
    867 			if err := awsRestxml_deserializeDocumentCidrCollection(&sv.Collection, nodeDecoder); err != nil {
    868 				return err
    869 			}
    870 
    871 		default:
    872 			// Do nothing and ignore the unexpected tag element
    873 			err = decoder.Decoder.Skip()
    874 			if err != nil {
    875 				return err
    876 			}
    877 
    878 		}
    879 		decoder = originalDecoder
    880 	}
    881 	*v = sv
    882 	return nil
    883 }
    884 
    885 type awsRestxml_deserializeOpCreateHealthCheck struct {
    886 }
    887 
    888 func (*awsRestxml_deserializeOpCreateHealthCheck) ID() string {
    889 	return "OperationDeserializer"
    890 }
    891 
    892 func (m *awsRestxml_deserializeOpCreateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    893 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    894 ) {
    895 	out, metadata, err = next.HandleDeserialize(ctx, in)
    896 	if err != nil {
    897 		return out, metadata, err
    898 	}
    899 
    900 	response, ok := out.RawResponse.(*smithyhttp.Response)
    901 	if !ok {
    902 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    903 	}
    904 
    905 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    906 		return out, metadata, awsRestxml_deserializeOpErrorCreateHealthCheck(response, &metadata)
    907 	}
    908 	output := &CreateHealthCheckOutput{}
    909 	out.Result = output
    910 
    911 	err = awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(output, response)
    912 	if err != nil {
    913 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
    914 	}
    915 
    916 	var buff [1024]byte
    917 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    918 	body := io.TeeReader(response.Body, ringBuffer)
    919 	rootDecoder := xml.NewDecoder(body)
    920 	t, err := smithyxml.FetchRootElement(rootDecoder)
    921 	if err == io.EOF {
    922 		return out, metadata, nil
    923 	}
    924 	if err != nil {
    925 		var snapshot bytes.Buffer
    926 		io.Copy(&snapshot, ringBuffer)
    927 		return out, metadata, &smithy.DeserializationError{
    928 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    929 			Snapshot: snapshot.Bytes(),
    930 		}
    931 	}
    932 
    933 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
    934 	err = awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(&output, decoder)
    935 	if err != nil {
    936 		var snapshot bytes.Buffer
    937 		io.Copy(&snapshot, ringBuffer)
    938 		return out, metadata, &smithy.DeserializationError{
    939 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    940 			Snapshot: snapshot.Bytes(),
    941 		}
    942 	}
    943 
    944 	return out, metadata, err
    945 }
    946 
    947 func awsRestxml_deserializeOpErrorCreateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    948 	var errorBuffer bytes.Buffer
    949 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    950 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    951 	}
    952 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    953 
    954 	errorCode := "UnknownError"
    955 	errorMessage := errorCode
    956 
    957 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
    958 	if err != nil {
    959 		return err
    960 	}
    961 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
    962 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
    963 	}
    964 	if len(errorComponents.Code) != 0 {
    965 		errorCode = errorComponents.Code
    966 	}
    967 	if len(errorComponents.Message) != 0 {
    968 		errorMessage = errorComponents.Message
    969 	}
    970 	errorBody.Seek(0, io.SeekStart)
    971 	switch {
    972 	case strings.EqualFold("HealthCheckAlreadyExists", errorCode):
    973 		return awsRestxml_deserializeErrorHealthCheckAlreadyExists(response, errorBody)
    974 
    975 	case strings.EqualFold("InvalidInput", errorCode):
    976 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
    977 
    978 	case strings.EqualFold("TooManyHealthChecks", errorCode):
    979 		return awsRestxml_deserializeErrorTooManyHealthChecks(response, errorBody)
    980 
    981 	default:
    982 		genericError := &smithy.GenericAPIError{
    983 			Code:    errorCode,
    984 			Message: errorMessage,
    985 		}
    986 		return genericError
    987 
    988 	}
    989 }
    990 
    991 func awsRestxml_deserializeOpHttpBindingsCreateHealthCheckOutput(v *CreateHealthCheckOutput, response *smithyhttp.Response) error {
    992 	if v == nil {
    993 		return fmt.Errorf("unsupported deserialization for nil %T", v)
    994 	}
    995 
    996 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
    997 		headerValues[0] = strings.TrimSpace(headerValues[0])
    998 		v.Location = ptr.String(headerValues[0])
    999 	}
   1000 
   1001 	return nil
   1002 }
   1003 func awsRestxml_deserializeOpDocumentCreateHealthCheckOutput(v **CreateHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
   1004 	if v == nil {
   1005 		return fmt.Errorf("unexpected nil of type %T", v)
   1006 	}
   1007 	var sv *CreateHealthCheckOutput
   1008 	if *v == nil {
   1009 		sv = &CreateHealthCheckOutput{}
   1010 	} else {
   1011 		sv = *v
   1012 	}
   1013 
   1014 	for {
   1015 		t, done, err := decoder.Token()
   1016 		if err != nil {
   1017 			return err
   1018 		}
   1019 		if done {
   1020 			break
   1021 		}
   1022 		originalDecoder := decoder
   1023 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1024 		switch {
   1025 		case strings.EqualFold("HealthCheck", t.Name.Local):
   1026 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1027 			if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
   1028 				return err
   1029 			}
   1030 
   1031 		default:
   1032 			// Do nothing and ignore the unexpected tag element
   1033 			err = decoder.Decoder.Skip()
   1034 			if err != nil {
   1035 				return err
   1036 			}
   1037 
   1038 		}
   1039 		decoder = originalDecoder
   1040 	}
   1041 	*v = sv
   1042 	return nil
   1043 }
   1044 
   1045 type awsRestxml_deserializeOpCreateHostedZone struct {
   1046 }
   1047 
   1048 func (*awsRestxml_deserializeOpCreateHostedZone) ID() string {
   1049 	return "OperationDeserializer"
   1050 }
   1051 
   1052 func (m *awsRestxml_deserializeOpCreateHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1053 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1054 ) {
   1055 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1056 	if err != nil {
   1057 		return out, metadata, err
   1058 	}
   1059 
   1060 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1061 	if !ok {
   1062 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1063 	}
   1064 
   1065 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1066 		return out, metadata, awsRestxml_deserializeOpErrorCreateHostedZone(response, &metadata)
   1067 	}
   1068 	output := &CreateHostedZoneOutput{}
   1069 	out.Result = output
   1070 
   1071 	err = awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(output, response)
   1072 	if err != nil {
   1073 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1074 	}
   1075 
   1076 	var buff [1024]byte
   1077 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1078 	body := io.TeeReader(response.Body, ringBuffer)
   1079 	rootDecoder := xml.NewDecoder(body)
   1080 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1081 	if err == io.EOF {
   1082 		return out, metadata, nil
   1083 	}
   1084 	if err != nil {
   1085 		var snapshot bytes.Buffer
   1086 		io.Copy(&snapshot, ringBuffer)
   1087 		return out, metadata, &smithy.DeserializationError{
   1088 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1089 			Snapshot: snapshot.Bytes(),
   1090 		}
   1091 	}
   1092 
   1093 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1094 	err = awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(&output, decoder)
   1095 	if err != nil {
   1096 		var snapshot bytes.Buffer
   1097 		io.Copy(&snapshot, ringBuffer)
   1098 		return out, metadata, &smithy.DeserializationError{
   1099 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1100 			Snapshot: snapshot.Bytes(),
   1101 		}
   1102 	}
   1103 
   1104 	return out, metadata, err
   1105 }
   1106 
   1107 func awsRestxml_deserializeOpErrorCreateHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1108 	var errorBuffer bytes.Buffer
   1109 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1110 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1111 	}
   1112 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1113 
   1114 	errorCode := "UnknownError"
   1115 	errorMessage := errorCode
   1116 
   1117 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1118 	if err != nil {
   1119 		return err
   1120 	}
   1121 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1122 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1123 	}
   1124 	if len(errorComponents.Code) != 0 {
   1125 		errorCode = errorComponents.Code
   1126 	}
   1127 	if len(errorComponents.Message) != 0 {
   1128 		errorMessage = errorComponents.Message
   1129 	}
   1130 	errorBody.Seek(0, io.SeekStart)
   1131 	switch {
   1132 	case strings.EqualFold("ConflictingDomainExists", errorCode):
   1133 		return awsRestxml_deserializeErrorConflictingDomainExists(response, errorBody)
   1134 
   1135 	case strings.EqualFold("DelegationSetNotAvailable", errorCode):
   1136 		return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody)
   1137 
   1138 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   1139 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   1140 
   1141 	case strings.EqualFold("HostedZoneAlreadyExists", errorCode):
   1142 		return awsRestxml_deserializeErrorHostedZoneAlreadyExists(response, errorBody)
   1143 
   1144 	case strings.EqualFold("InvalidDomainName", errorCode):
   1145 		return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
   1146 
   1147 	case strings.EqualFold("InvalidInput", errorCode):
   1148 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1149 
   1150 	case strings.EqualFold("InvalidVPCId", errorCode):
   1151 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   1152 
   1153 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   1154 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   1155 
   1156 	case strings.EqualFold("TooManyHostedZones", errorCode):
   1157 		return awsRestxml_deserializeErrorTooManyHostedZones(response, errorBody)
   1158 
   1159 	default:
   1160 		genericError := &smithy.GenericAPIError{
   1161 			Code:    errorCode,
   1162 			Message: errorMessage,
   1163 		}
   1164 		return genericError
   1165 
   1166 	}
   1167 }
   1168 
   1169 func awsRestxml_deserializeOpHttpBindingsCreateHostedZoneOutput(v *CreateHostedZoneOutput, response *smithyhttp.Response) error {
   1170 	if v == nil {
   1171 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1172 	}
   1173 
   1174 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1175 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1176 		v.Location = ptr.String(headerValues[0])
   1177 	}
   1178 
   1179 	return nil
   1180 }
   1181 func awsRestxml_deserializeOpDocumentCreateHostedZoneOutput(v **CreateHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   1182 	if v == nil {
   1183 		return fmt.Errorf("unexpected nil of type %T", v)
   1184 	}
   1185 	var sv *CreateHostedZoneOutput
   1186 	if *v == nil {
   1187 		sv = &CreateHostedZoneOutput{}
   1188 	} else {
   1189 		sv = *v
   1190 	}
   1191 
   1192 	for {
   1193 		t, done, err := decoder.Token()
   1194 		if err != nil {
   1195 			return err
   1196 		}
   1197 		if done {
   1198 			break
   1199 		}
   1200 		originalDecoder := decoder
   1201 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1202 		switch {
   1203 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   1204 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1205 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   1206 				return err
   1207 			}
   1208 
   1209 		case strings.EqualFold("DelegationSet", t.Name.Local):
   1210 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1211 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   1212 				return err
   1213 			}
   1214 
   1215 		case strings.EqualFold("HostedZone", t.Name.Local):
   1216 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1217 			if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
   1218 				return err
   1219 			}
   1220 
   1221 		case strings.EqualFold("VPC", t.Name.Local):
   1222 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1223 			if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil {
   1224 				return err
   1225 			}
   1226 
   1227 		default:
   1228 			// Do nothing and ignore the unexpected tag element
   1229 			err = decoder.Decoder.Skip()
   1230 			if err != nil {
   1231 				return err
   1232 			}
   1233 
   1234 		}
   1235 		decoder = originalDecoder
   1236 	}
   1237 	*v = sv
   1238 	return nil
   1239 }
   1240 
   1241 type awsRestxml_deserializeOpCreateKeySigningKey struct {
   1242 }
   1243 
   1244 func (*awsRestxml_deserializeOpCreateKeySigningKey) ID() string {
   1245 	return "OperationDeserializer"
   1246 }
   1247 
   1248 func (m *awsRestxml_deserializeOpCreateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1249 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1250 ) {
   1251 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1252 	if err != nil {
   1253 		return out, metadata, err
   1254 	}
   1255 
   1256 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1257 	if !ok {
   1258 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1259 	}
   1260 
   1261 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1262 		return out, metadata, awsRestxml_deserializeOpErrorCreateKeySigningKey(response, &metadata)
   1263 	}
   1264 	output := &CreateKeySigningKeyOutput{}
   1265 	out.Result = output
   1266 
   1267 	err = awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(output, response)
   1268 	if err != nil {
   1269 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1270 	}
   1271 
   1272 	var buff [1024]byte
   1273 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1274 	body := io.TeeReader(response.Body, ringBuffer)
   1275 	rootDecoder := xml.NewDecoder(body)
   1276 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1277 	if err == io.EOF {
   1278 		return out, metadata, nil
   1279 	}
   1280 	if err != nil {
   1281 		var snapshot bytes.Buffer
   1282 		io.Copy(&snapshot, ringBuffer)
   1283 		return out, metadata, &smithy.DeserializationError{
   1284 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1285 			Snapshot: snapshot.Bytes(),
   1286 		}
   1287 	}
   1288 
   1289 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1290 	err = awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(&output, decoder)
   1291 	if err != nil {
   1292 		var snapshot bytes.Buffer
   1293 		io.Copy(&snapshot, ringBuffer)
   1294 		return out, metadata, &smithy.DeserializationError{
   1295 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1296 			Snapshot: snapshot.Bytes(),
   1297 		}
   1298 	}
   1299 
   1300 	return out, metadata, err
   1301 }
   1302 
   1303 func awsRestxml_deserializeOpErrorCreateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1304 	var errorBuffer bytes.Buffer
   1305 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1306 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1307 	}
   1308 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1309 
   1310 	errorCode := "UnknownError"
   1311 	errorMessage := errorCode
   1312 
   1313 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1314 	if err != nil {
   1315 		return err
   1316 	}
   1317 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1318 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1319 	}
   1320 	if len(errorComponents.Code) != 0 {
   1321 		errorCode = errorComponents.Code
   1322 	}
   1323 	if len(errorComponents.Message) != 0 {
   1324 		errorMessage = errorComponents.Message
   1325 	}
   1326 	errorBody.Seek(0, io.SeekStart)
   1327 	switch {
   1328 	case strings.EqualFold("ConcurrentModification", errorCode):
   1329 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   1330 
   1331 	case strings.EqualFold("InvalidArgument", errorCode):
   1332 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   1333 
   1334 	case strings.EqualFold("InvalidInput", errorCode):
   1335 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1336 
   1337 	case strings.EqualFold("InvalidKMSArn", errorCode):
   1338 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   1339 
   1340 	case strings.EqualFold("InvalidKeySigningKeyName", errorCode):
   1341 		return awsRestxml_deserializeErrorInvalidKeySigningKeyName(response, errorBody)
   1342 
   1343 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   1344 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   1345 
   1346 	case strings.EqualFold("InvalidSigningStatus", errorCode):
   1347 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
   1348 
   1349 	case strings.EqualFold("KeySigningKeyAlreadyExists", errorCode):
   1350 		return awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response, errorBody)
   1351 
   1352 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   1353 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   1354 
   1355 	case strings.EqualFold("TooManyKeySigningKeys", errorCode):
   1356 		return awsRestxml_deserializeErrorTooManyKeySigningKeys(response, errorBody)
   1357 
   1358 	default:
   1359 		genericError := &smithy.GenericAPIError{
   1360 			Code:    errorCode,
   1361 			Message: errorMessage,
   1362 		}
   1363 		return genericError
   1364 
   1365 	}
   1366 }
   1367 
   1368 func awsRestxml_deserializeOpHttpBindingsCreateKeySigningKeyOutput(v *CreateKeySigningKeyOutput, response *smithyhttp.Response) error {
   1369 	if v == nil {
   1370 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1371 	}
   1372 
   1373 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1374 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1375 		v.Location = ptr.String(headerValues[0])
   1376 	}
   1377 
   1378 	return nil
   1379 }
   1380 func awsRestxml_deserializeOpDocumentCreateKeySigningKeyOutput(v **CreateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
   1381 	if v == nil {
   1382 		return fmt.Errorf("unexpected nil of type %T", v)
   1383 	}
   1384 	var sv *CreateKeySigningKeyOutput
   1385 	if *v == nil {
   1386 		sv = &CreateKeySigningKeyOutput{}
   1387 	} else {
   1388 		sv = *v
   1389 	}
   1390 
   1391 	for {
   1392 		t, done, err := decoder.Token()
   1393 		if err != nil {
   1394 			return err
   1395 		}
   1396 		if done {
   1397 			break
   1398 		}
   1399 		originalDecoder := decoder
   1400 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1401 		switch {
   1402 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   1403 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1404 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   1405 				return err
   1406 			}
   1407 
   1408 		case strings.EqualFold("KeySigningKey", t.Name.Local):
   1409 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1410 			if err := awsRestxml_deserializeDocumentKeySigningKey(&sv.KeySigningKey, nodeDecoder); err != nil {
   1411 				return err
   1412 			}
   1413 
   1414 		default:
   1415 			// Do nothing and ignore the unexpected tag element
   1416 			err = decoder.Decoder.Skip()
   1417 			if err != nil {
   1418 				return err
   1419 			}
   1420 
   1421 		}
   1422 		decoder = originalDecoder
   1423 	}
   1424 	*v = sv
   1425 	return nil
   1426 }
   1427 
   1428 type awsRestxml_deserializeOpCreateQueryLoggingConfig struct {
   1429 }
   1430 
   1431 func (*awsRestxml_deserializeOpCreateQueryLoggingConfig) ID() string {
   1432 	return "OperationDeserializer"
   1433 }
   1434 
   1435 func (m *awsRestxml_deserializeOpCreateQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1436 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1437 ) {
   1438 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1439 	if err != nil {
   1440 		return out, metadata, err
   1441 	}
   1442 
   1443 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1444 	if !ok {
   1445 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1446 	}
   1447 
   1448 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1449 		return out, metadata, awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response, &metadata)
   1450 	}
   1451 	output := &CreateQueryLoggingConfigOutput{}
   1452 	out.Result = output
   1453 
   1454 	err = awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(output, response)
   1455 	if err != nil {
   1456 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1457 	}
   1458 
   1459 	var buff [1024]byte
   1460 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1461 	body := io.TeeReader(response.Body, ringBuffer)
   1462 	rootDecoder := xml.NewDecoder(body)
   1463 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1464 	if err == io.EOF {
   1465 		return out, metadata, nil
   1466 	}
   1467 	if err != nil {
   1468 		var snapshot bytes.Buffer
   1469 		io.Copy(&snapshot, ringBuffer)
   1470 		return out, metadata, &smithy.DeserializationError{
   1471 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1472 			Snapshot: snapshot.Bytes(),
   1473 		}
   1474 	}
   1475 
   1476 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1477 	err = awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(&output, decoder)
   1478 	if err != nil {
   1479 		var snapshot bytes.Buffer
   1480 		io.Copy(&snapshot, ringBuffer)
   1481 		return out, metadata, &smithy.DeserializationError{
   1482 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1483 			Snapshot: snapshot.Bytes(),
   1484 		}
   1485 	}
   1486 
   1487 	return out, metadata, err
   1488 }
   1489 
   1490 func awsRestxml_deserializeOpErrorCreateQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1491 	var errorBuffer bytes.Buffer
   1492 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1493 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1494 	}
   1495 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1496 
   1497 	errorCode := "UnknownError"
   1498 	errorMessage := errorCode
   1499 
   1500 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1501 	if err != nil {
   1502 		return err
   1503 	}
   1504 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1505 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1506 	}
   1507 	if len(errorComponents.Code) != 0 {
   1508 		errorCode = errorComponents.Code
   1509 	}
   1510 	if len(errorComponents.Message) != 0 {
   1511 		errorMessage = errorComponents.Message
   1512 	}
   1513 	errorBody.Seek(0, io.SeekStart)
   1514 	switch {
   1515 	case strings.EqualFold("ConcurrentModification", errorCode):
   1516 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   1517 
   1518 	case strings.EqualFold("InsufficientCloudWatchLogsResourcePolicy", errorCode):
   1519 		return awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response, errorBody)
   1520 
   1521 	case strings.EqualFold("InvalidInput", errorCode):
   1522 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1523 
   1524 	case strings.EqualFold("NoSuchCloudWatchLogsLogGroup", errorCode):
   1525 		return awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response, errorBody)
   1526 
   1527 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   1528 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   1529 
   1530 	case strings.EqualFold("QueryLoggingConfigAlreadyExists", errorCode):
   1531 		return awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response, errorBody)
   1532 
   1533 	default:
   1534 		genericError := &smithy.GenericAPIError{
   1535 			Code:    errorCode,
   1536 			Message: errorMessage,
   1537 		}
   1538 		return genericError
   1539 
   1540 	}
   1541 }
   1542 
   1543 func awsRestxml_deserializeOpHttpBindingsCreateQueryLoggingConfigOutput(v *CreateQueryLoggingConfigOutput, response *smithyhttp.Response) error {
   1544 	if v == nil {
   1545 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1546 	}
   1547 
   1548 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1549 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1550 		v.Location = ptr.String(headerValues[0])
   1551 	}
   1552 
   1553 	return nil
   1554 }
   1555 func awsRestxml_deserializeOpDocumentCreateQueryLoggingConfigOutput(v **CreateQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error {
   1556 	if v == nil {
   1557 		return fmt.Errorf("unexpected nil of type %T", v)
   1558 	}
   1559 	var sv *CreateQueryLoggingConfigOutput
   1560 	if *v == nil {
   1561 		sv = &CreateQueryLoggingConfigOutput{}
   1562 	} else {
   1563 		sv = *v
   1564 	}
   1565 
   1566 	for {
   1567 		t, done, err := decoder.Token()
   1568 		if err != nil {
   1569 			return err
   1570 		}
   1571 		if done {
   1572 			break
   1573 		}
   1574 		originalDecoder := decoder
   1575 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1576 		switch {
   1577 		case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
   1578 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1579 			if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil {
   1580 				return err
   1581 			}
   1582 
   1583 		default:
   1584 			// Do nothing and ignore the unexpected tag element
   1585 			err = decoder.Decoder.Skip()
   1586 			if err != nil {
   1587 				return err
   1588 			}
   1589 
   1590 		}
   1591 		decoder = originalDecoder
   1592 	}
   1593 	*v = sv
   1594 	return nil
   1595 }
   1596 
   1597 type awsRestxml_deserializeOpCreateReusableDelegationSet struct {
   1598 }
   1599 
   1600 func (*awsRestxml_deserializeOpCreateReusableDelegationSet) ID() string {
   1601 	return "OperationDeserializer"
   1602 }
   1603 
   1604 func (m *awsRestxml_deserializeOpCreateReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1605 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1606 ) {
   1607 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1608 	if err != nil {
   1609 		return out, metadata, err
   1610 	}
   1611 
   1612 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1613 	if !ok {
   1614 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1615 	}
   1616 
   1617 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1618 		return out, metadata, awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response, &metadata)
   1619 	}
   1620 	output := &CreateReusableDelegationSetOutput{}
   1621 	out.Result = output
   1622 
   1623 	err = awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(output, response)
   1624 	if err != nil {
   1625 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1626 	}
   1627 
   1628 	var buff [1024]byte
   1629 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1630 	body := io.TeeReader(response.Body, ringBuffer)
   1631 	rootDecoder := xml.NewDecoder(body)
   1632 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1633 	if err == io.EOF {
   1634 		return out, metadata, nil
   1635 	}
   1636 	if err != nil {
   1637 		var snapshot bytes.Buffer
   1638 		io.Copy(&snapshot, ringBuffer)
   1639 		return out, metadata, &smithy.DeserializationError{
   1640 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1641 			Snapshot: snapshot.Bytes(),
   1642 		}
   1643 	}
   1644 
   1645 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1646 	err = awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(&output, decoder)
   1647 	if err != nil {
   1648 		var snapshot bytes.Buffer
   1649 		io.Copy(&snapshot, ringBuffer)
   1650 		return out, metadata, &smithy.DeserializationError{
   1651 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1652 			Snapshot: snapshot.Bytes(),
   1653 		}
   1654 	}
   1655 
   1656 	return out, metadata, err
   1657 }
   1658 
   1659 func awsRestxml_deserializeOpErrorCreateReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1660 	var errorBuffer bytes.Buffer
   1661 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1662 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1663 	}
   1664 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1665 
   1666 	errorCode := "UnknownError"
   1667 	errorMessage := errorCode
   1668 
   1669 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1670 	if err != nil {
   1671 		return err
   1672 	}
   1673 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1674 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1675 	}
   1676 	if len(errorComponents.Code) != 0 {
   1677 		errorCode = errorComponents.Code
   1678 	}
   1679 	if len(errorComponents.Message) != 0 {
   1680 		errorMessage = errorComponents.Message
   1681 	}
   1682 	errorBody.Seek(0, io.SeekStart)
   1683 	switch {
   1684 	case strings.EqualFold("DelegationSetAlreadyCreated", errorCode):
   1685 		return awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response, errorBody)
   1686 
   1687 	case strings.EqualFold("DelegationSetAlreadyReusable", errorCode):
   1688 		return awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response, errorBody)
   1689 
   1690 	case strings.EqualFold("DelegationSetNotAvailable", errorCode):
   1691 		return awsRestxml_deserializeErrorDelegationSetNotAvailable(response, errorBody)
   1692 
   1693 	case strings.EqualFold("HostedZoneNotFound", errorCode):
   1694 		return awsRestxml_deserializeErrorHostedZoneNotFound(response, errorBody)
   1695 
   1696 	case strings.EqualFold("InvalidArgument", errorCode):
   1697 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   1698 
   1699 	case strings.EqualFold("InvalidInput", errorCode):
   1700 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1701 
   1702 	case strings.EqualFold("LimitsExceeded", errorCode):
   1703 		return awsRestxml_deserializeErrorLimitsExceeded(response, errorBody)
   1704 
   1705 	default:
   1706 		genericError := &smithy.GenericAPIError{
   1707 			Code:    errorCode,
   1708 			Message: errorMessage,
   1709 		}
   1710 		return genericError
   1711 
   1712 	}
   1713 }
   1714 
   1715 func awsRestxml_deserializeOpHttpBindingsCreateReusableDelegationSetOutput(v *CreateReusableDelegationSetOutput, response *smithyhttp.Response) error {
   1716 	if v == nil {
   1717 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1718 	}
   1719 
   1720 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1721 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1722 		v.Location = ptr.String(headerValues[0])
   1723 	}
   1724 
   1725 	return nil
   1726 }
   1727 func awsRestxml_deserializeOpDocumentCreateReusableDelegationSetOutput(v **CreateReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error {
   1728 	if v == nil {
   1729 		return fmt.Errorf("unexpected nil of type %T", v)
   1730 	}
   1731 	var sv *CreateReusableDelegationSetOutput
   1732 	if *v == nil {
   1733 		sv = &CreateReusableDelegationSetOutput{}
   1734 	} else {
   1735 		sv = *v
   1736 	}
   1737 
   1738 	for {
   1739 		t, done, err := decoder.Token()
   1740 		if err != nil {
   1741 			return err
   1742 		}
   1743 		if done {
   1744 			break
   1745 		}
   1746 		originalDecoder := decoder
   1747 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1748 		switch {
   1749 		case strings.EqualFold("DelegationSet", t.Name.Local):
   1750 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1751 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   1752 				return err
   1753 			}
   1754 
   1755 		default:
   1756 			// Do nothing and ignore the unexpected tag element
   1757 			err = decoder.Decoder.Skip()
   1758 			if err != nil {
   1759 				return err
   1760 			}
   1761 
   1762 		}
   1763 		decoder = originalDecoder
   1764 	}
   1765 	*v = sv
   1766 	return nil
   1767 }
   1768 
   1769 type awsRestxml_deserializeOpCreateTrafficPolicy struct {
   1770 }
   1771 
   1772 func (*awsRestxml_deserializeOpCreateTrafficPolicy) ID() string {
   1773 	return "OperationDeserializer"
   1774 }
   1775 
   1776 func (m *awsRestxml_deserializeOpCreateTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1777 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1778 ) {
   1779 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1780 	if err != nil {
   1781 		return out, metadata, err
   1782 	}
   1783 
   1784 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1785 	if !ok {
   1786 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1787 	}
   1788 
   1789 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1790 		return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicy(response, &metadata)
   1791 	}
   1792 	output := &CreateTrafficPolicyOutput{}
   1793 	out.Result = output
   1794 
   1795 	err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(output, response)
   1796 	if err != nil {
   1797 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1798 	}
   1799 
   1800 	var buff [1024]byte
   1801 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1802 	body := io.TeeReader(response.Body, ringBuffer)
   1803 	rootDecoder := xml.NewDecoder(body)
   1804 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1805 	if err == io.EOF {
   1806 		return out, metadata, nil
   1807 	}
   1808 	if err != nil {
   1809 		var snapshot bytes.Buffer
   1810 		io.Copy(&snapshot, ringBuffer)
   1811 		return out, metadata, &smithy.DeserializationError{
   1812 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1813 			Snapshot: snapshot.Bytes(),
   1814 		}
   1815 	}
   1816 
   1817 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1818 	err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(&output, decoder)
   1819 	if err != nil {
   1820 		var snapshot bytes.Buffer
   1821 		io.Copy(&snapshot, ringBuffer)
   1822 		return out, metadata, &smithy.DeserializationError{
   1823 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1824 			Snapshot: snapshot.Bytes(),
   1825 		}
   1826 	}
   1827 
   1828 	return out, metadata, err
   1829 }
   1830 
   1831 func awsRestxml_deserializeOpErrorCreateTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1832 	var errorBuffer bytes.Buffer
   1833 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1834 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1835 	}
   1836 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1837 
   1838 	errorCode := "UnknownError"
   1839 	errorMessage := errorCode
   1840 
   1841 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   1842 	if err != nil {
   1843 		return err
   1844 	}
   1845 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   1846 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   1847 	}
   1848 	if len(errorComponents.Code) != 0 {
   1849 		errorCode = errorComponents.Code
   1850 	}
   1851 	if len(errorComponents.Message) != 0 {
   1852 		errorMessage = errorComponents.Message
   1853 	}
   1854 	errorBody.Seek(0, io.SeekStart)
   1855 	switch {
   1856 	case strings.EqualFold("InvalidInput", errorCode):
   1857 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   1858 
   1859 	case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode):
   1860 		return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody)
   1861 
   1862 	case strings.EqualFold("TooManyTrafficPolicies", errorCode):
   1863 		return awsRestxml_deserializeErrorTooManyTrafficPolicies(response, errorBody)
   1864 
   1865 	case strings.EqualFold("TrafficPolicyAlreadyExists", errorCode):
   1866 		return awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response, errorBody)
   1867 
   1868 	default:
   1869 		genericError := &smithy.GenericAPIError{
   1870 			Code:    errorCode,
   1871 			Message: errorMessage,
   1872 		}
   1873 		return genericError
   1874 
   1875 	}
   1876 }
   1877 
   1878 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyOutput(v *CreateTrafficPolicyOutput, response *smithyhttp.Response) error {
   1879 	if v == nil {
   1880 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   1881 	}
   1882 
   1883 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   1884 		headerValues[0] = strings.TrimSpace(headerValues[0])
   1885 		v.Location = ptr.String(headerValues[0])
   1886 	}
   1887 
   1888 	return nil
   1889 }
   1890 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyOutput(v **CreateTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error {
   1891 	if v == nil {
   1892 		return fmt.Errorf("unexpected nil of type %T", v)
   1893 	}
   1894 	var sv *CreateTrafficPolicyOutput
   1895 	if *v == nil {
   1896 		sv = &CreateTrafficPolicyOutput{}
   1897 	} else {
   1898 		sv = *v
   1899 	}
   1900 
   1901 	for {
   1902 		t, done, err := decoder.Token()
   1903 		if err != nil {
   1904 			return err
   1905 		}
   1906 		if done {
   1907 			break
   1908 		}
   1909 		originalDecoder := decoder
   1910 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   1911 		switch {
   1912 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
   1913 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   1914 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
   1915 				return err
   1916 			}
   1917 
   1918 		default:
   1919 			// Do nothing and ignore the unexpected tag element
   1920 			err = decoder.Decoder.Skip()
   1921 			if err != nil {
   1922 				return err
   1923 			}
   1924 
   1925 		}
   1926 		decoder = originalDecoder
   1927 	}
   1928 	*v = sv
   1929 	return nil
   1930 }
   1931 
   1932 type awsRestxml_deserializeOpCreateTrafficPolicyInstance struct {
   1933 }
   1934 
   1935 func (*awsRestxml_deserializeOpCreateTrafficPolicyInstance) ID() string {
   1936 	return "OperationDeserializer"
   1937 }
   1938 
   1939 func (m *awsRestxml_deserializeOpCreateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1940 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1941 ) {
   1942 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1943 	if err != nil {
   1944 		return out, metadata, err
   1945 	}
   1946 
   1947 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1948 	if !ok {
   1949 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1950 	}
   1951 
   1952 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1953 		return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response, &metadata)
   1954 	}
   1955 	output := &CreateTrafficPolicyInstanceOutput{}
   1956 	out.Result = output
   1957 
   1958 	err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(output, response)
   1959 	if err != nil {
   1960 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   1961 	}
   1962 
   1963 	var buff [1024]byte
   1964 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1965 	body := io.TeeReader(response.Body, ringBuffer)
   1966 	rootDecoder := xml.NewDecoder(body)
   1967 	t, err := smithyxml.FetchRootElement(rootDecoder)
   1968 	if err == io.EOF {
   1969 		return out, metadata, nil
   1970 	}
   1971 	if err != nil {
   1972 		var snapshot bytes.Buffer
   1973 		io.Copy(&snapshot, ringBuffer)
   1974 		return out, metadata, &smithy.DeserializationError{
   1975 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1976 			Snapshot: snapshot.Bytes(),
   1977 		}
   1978 	}
   1979 
   1980 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   1981 	err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(&output, decoder)
   1982 	if err != nil {
   1983 		var snapshot bytes.Buffer
   1984 		io.Copy(&snapshot, ringBuffer)
   1985 		return out, metadata, &smithy.DeserializationError{
   1986 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1987 			Snapshot: snapshot.Bytes(),
   1988 		}
   1989 	}
   1990 
   1991 	return out, metadata, err
   1992 }
   1993 
   1994 func awsRestxml_deserializeOpErrorCreateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1995 	var errorBuffer bytes.Buffer
   1996 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1997 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1998 	}
   1999 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2000 
   2001 	errorCode := "UnknownError"
   2002 	errorMessage := errorCode
   2003 
   2004 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2005 	if err != nil {
   2006 		return err
   2007 	}
   2008 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2009 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2010 	}
   2011 	if len(errorComponents.Code) != 0 {
   2012 		errorCode = errorComponents.Code
   2013 	}
   2014 	if len(errorComponents.Message) != 0 {
   2015 		errorMessage = errorComponents.Message
   2016 	}
   2017 	errorBody.Seek(0, io.SeekStart)
   2018 	switch {
   2019 	case strings.EqualFold("InvalidInput", errorCode):
   2020 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2021 
   2022 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   2023 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   2024 
   2025 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   2026 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   2027 
   2028 	case strings.EqualFold("TooManyTrafficPolicyInstances", errorCode):
   2029 		return awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response, errorBody)
   2030 
   2031 	case strings.EqualFold("TrafficPolicyInstanceAlreadyExists", errorCode):
   2032 		return awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response, errorBody)
   2033 
   2034 	default:
   2035 		genericError := &smithy.GenericAPIError{
   2036 			Code:    errorCode,
   2037 			Message: errorMessage,
   2038 		}
   2039 		return genericError
   2040 
   2041 	}
   2042 }
   2043 
   2044 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyInstanceOutput(v *CreateTrafficPolicyInstanceOutput, response *smithyhttp.Response) error {
   2045 	if v == nil {
   2046 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   2047 	}
   2048 
   2049 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   2050 		headerValues[0] = strings.TrimSpace(headerValues[0])
   2051 		v.Location = ptr.String(headerValues[0])
   2052 	}
   2053 
   2054 	return nil
   2055 }
   2056 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyInstanceOutput(v **CreateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
   2057 	if v == nil {
   2058 		return fmt.Errorf("unexpected nil of type %T", v)
   2059 	}
   2060 	var sv *CreateTrafficPolicyInstanceOutput
   2061 	if *v == nil {
   2062 		sv = &CreateTrafficPolicyInstanceOutput{}
   2063 	} else {
   2064 		sv = *v
   2065 	}
   2066 
   2067 	for {
   2068 		t, done, err := decoder.Token()
   2069 		if err != nil {
   2070 			return err
   2071 		}
   2072 		if done {
   2073 			break
   2074 		}
   2075 		originalDecoder := decoder
   2076 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2077 		switch {
   2078 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
   2079 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2080 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
   2081 				return err
   2082 			}
   2083 
   2084 		default:
   2085 			// Do nothing and ignore the unexpected tag element
   2086 			err = decoder.Decoder.Skip()
   2087 			if err != nil {
   2088 				return err
   2089 			}
   2090 
   2091 		}
   2092 		decoder = originalDecoder
   2093 	}
   2094 	*v = sv
   2095 	return nil
   2096 }
   2097 
   2098 type awsRestxml_deserializeOpCreateTrafficPolicyVersion struct {
   2099 }
   2100 
   2101 func (*awsRestxml_deserializeOpCreateTrafficPolicyVersion) ID() string {
   2102 	return "OperationDeserializer"
   2103 }
   2104 
   2105 func (m *awsRestxml_deserializeOpCreateTrafficPolicyVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2106 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2107 ) {
   2108 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2109 	if err != nil {
   2110 		return out, metadata, err
   2111 	}
   2112 
   2113 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2114 	if !ok {
   2115 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2116 	}
   2117 
   2118 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2119 		return out, metadata, awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response, &metadata)
   2120 	}
   2121 	output := &CreateTrafficPolicyVersionOutput{}
   2122 	out.Result = output
   2123 
   2124 	err = awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(output, response)
   2125 	if err != nil {
   2126 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
   2127 	}
   2128 
   2129 	var buff [1024]byte
   2130 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2131 	body := io.TeeReader(response.Body, ringBuffer)
   2132 	rootDecoder := xml.NewDecoder(body)
   2133 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2134 	if err == io.EOF {
   2135 		return out, metadata, nil
   2136 	}
   2137 	if err != nil {
   2138 		var snapshot bytes.Buffer
   2139 		io.Copy(&snapshot, ringBuffer)
   2140 		return out, metadata, &smithy.DeserializationError{
   2141 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2142 			Snapshot: snapshot.Bytes(),
   2143 		}
   2144 	}
   2145 
   2146 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2147 	err = awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(&output, decoder)
   2148 	if err != nil {
   2149 		var snapshot bytes.Buffer
   2150 		io.Copy(&snapshot, ringBuffer)
   2151 		return out, metadata, &smithy.DeserializationError{
   2152 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2153 			Snapshot: snapshot.Bytes(),
   2154 		}
   2155 	}
   2156 
   2157 	return out, metadata, err
   2158 }
   2159 
   2160 func awsRestxml_deserializeOpErrorCreateTrafficPolicyVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2161 	var errorBuffer bytes.Buffer
   2162 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2163 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2164 	}
   2165 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2166 
   2167 	errorCode := "UnknownError"
   2168 	errorMessage := errorCode
   2169 
   2170 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2171 	if err != nil {
   2172 		return err
   2173 	}
   2174 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2175 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2176 	}
   2177 	if len(errorComponents.Code) != 0 {
   2178 		errorCode = errorComponents.Code
   2179 	}
   2180 	if len(errorComponents.Message) != 0 {
   2181 		errorMessage = errorComponents.Message
   2182 	}
   2183 	errorBody.Seek(0, io.SeekStart)
   2184 	switch {
   2185 	case strings.EqualFold("ConcurrentModification", errorCode):
   2186 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2187 
   2188 	case strings.EqualFold("InvalidInput", errorCode):
   2189 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2190 
   2191 	case strings.EqualFold("InvalidTrafficPolicyDocument", errorCode):
   2192 		return awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response, errorBody)
   2193 
   2194 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   2195 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   2196 
   2197 	case strings.EqualFold("TooManyTrafficPolicyVersionsForCurrentPolicy", errorCode):
   2198 		return awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response, errorBody)
   2199 
   2200 	default:
   2201 		genericError := &smithy.GenericAPIError{
   2202 			Code:    errorCode,
   2203 			Message: errorMessage,
   2204 		}
   2205 		return genericError
   2206 
   2207 	}
   2208 }
   2209 
   2210 func awsRestxml_deserializeOpHttpBindingsCreateTrafficPolicyVersionOutput(v *CreateTrafficPolicyVersionOutput, response *smithyhttp.Response) error {
   2211 	if v == nil {
   2212 		return fmt.Errorf("unsupported deserialization for nil %T", v)
   2213 	}
   2214 
   2215 	if headerValues := response.Header.Values("Location"); len(headerValues) != 0 {
   2216 		headerValues[0] = strings.TrimSpace(headerValues[0])
   2217 		v.Location = ptr.String(headerValues[0])
   2218 	}
   2219 
   2220 	return nil
   2221 }
   2222 func awsRestxml_deserializeOpDocumentCreateTrafficPolicyVersionOutput(v **CreateTrafficPolicyVersionOutput, decoder smithyxml.NodeDecoder) error {
   2223 	if v == nil {
   2224 		return fmt.Errorf("unexpected nil of type %T", v)
   2225 	}
   2226 	var sv *CreateTrafficPolicyVersionOutput
   2227 	if *v == nil {
   2228 		sv = &CreateTrafficPolicyVersionOutput{}
   2229 	} else {
   2230 		sv = *v
   2231 	}
   2232 
   2233 	for {
   2234 		t, done, err := decoder.Token()
   2235 		if err != nil {
   2236 			return err
   2237 		}
   2238 		if done {
   2239 			break
   2240 		}
   2241 		originalDecoder := decoder
   2242 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2243 		switch {
   2244 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
   2245 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2246 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
   2247 				return err
   2248 			}
   2249 
   2250 		default:
   2251 			// Do nothing and ignore the unexpected tag element
   2252 			err = decoder.Decoder.Skip()
   2253 			if err != nil {
   2254 				return err
   2255 			}
   2256 
   2257 		}
   2258 		decoder = originalDecoder
   2259 	}
   2260 	*v = sv
   2261 	return nil
   2262 }
   2263 
   2264 type awsRestxml_deserializeOpCreateVPCAssociationAuthorization struct {
   2265 }
   2266 
   2267 func (*awsRestxml_deserializeOpCreateVPCAssociationAuthorization) ID() string {
   2268 	return "OperationDeserializer"
   2269 }
   2270 
   2271 func (m *awsRestxml_deserializeOpCreateVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2272 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2273 ) {
   2274 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2275 	if err != nil {
   2276 		return out, metadata, err
   2277 	}
   2278 
   2279 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2280 	if !ok {
   2281 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2282 	}
   2283 
   2284 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2285 		return out, metadata, awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response, &metadata)
   2286 	}
   2287 	output := &CreateVPCAssociationAuthorizationOutput{}
   2288 	out.Result = output
   2289 
   2290 	var buff [1024]byte
   2291 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2292 	body := io.TeeReader(response.Body, ringBuffer)
   2293 	rootDecoder := xml.NewDecoder(body)
   2294 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2295 	if err == io.EOF {
   2296 		return out, metadata, nil
   2297 	}
   2298 	if err != nil {
   2299 		var snapshot bytes.Buffer
   2300 		io.Copy(&snapshot, ringBuffer)
   2301 		return out, metadata, &smithy.DeserializationError{
   2302 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2303 			Snapshot: snapshot.Bytes(),
   2304 		}
   2305 	}
   2306 
   2307 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2308 	err = awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(&output, decoder)
   2309 	if err != nil {
   2310 		var snapshot bytes.Buffer
   2311 		io.Copy(&snapshot, ringBuffer)
   2312 		return out, metadata, &smithy.DeserializationError{
   2313 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2314 			Snapshot: snapshot.Bytes(),
   2315 		}
   2316 	}
   2317 
   2318 	return out, metadata, err
   2319 }
   2320 
   2321 func awsRestxml_deserializeOpErrorCreateVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2322 	var errorBuffer bytes.Buffer
   2323 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2324 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2325 	}
   2326 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2327 
   2328 	errorCode := "UnknownError"
   2329 	errorMessage := errorCode
   2330 
   2331 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2332 	if err != nil {
   2333 		return err
   2334 	}
   2335 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2336 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2337 	}
   2338 	if len(errorComponents.Code) != 0 {
   2339 		errorCode = errorComponents.Code
   2340 	}
   2341 	if len(errorComponents.Message) != 0 {
   2342 		errorMessage = errorComponents.Message
   2343 	}
   2344 	errorBody.Seek(0, io.SeekStart)
   2345 	switch {
   2346 	case strings.EqualFold("ConcurrentModification", errorCode):
   2347 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2348 
   2349 	case strings.EqualFold("InvalidInput", errorCode):
   2350 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2351 
   2352 	case strings.EqualFold("InvalidVPCId", errorCode):
   2353 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   2354 
   2355 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   2356 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   2357 
   2358 	case strings.EqualFold("TooManyVPCAssociationAuthorizations", errorCode):
   2359 		return awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response, errorBody)
   2360 
   2361 	default:
   2362 		genericError := &smithy.GenericAPIError{
   2363 			Code:    errorCode,
   2364 			Message: errorMessage,
   2365 		}
   2366 		return genericError
   2367 
   2368 	}
   2369 }
   2370 
   2371 func awsRestxml_deserializeOpDocumentCreateVPCAssociationAuthorizationOutput(v **CreateVPCAssociationAuthorizationOutput, decoder smithyxml.NodeDecoder) error {
   2372 	if v == nil {
   2373 		return fmt.Errorf("unexpected nil of type %T", v)
   2374 	}
   2375 	var sv *CreateVPCAssociationAuthorizationOutput
   2376 	if *v == nil {
   2377 		sv = &CreateVPCAssociationAuthorizationOutput{}
   2378 	} else {
   2379 		sv = *v
   2380 	}
   2381 
   2382 	for {
   2383 		t, done, err := decoder.Token()
   2384 		if err != nil {
   2385 			return err
   2386 		}
   2387 		if done {
   2388 			break
   2389 		}
   2390 		originalDecoder := decoder
   2391 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2392 		switch {
   2393 		case strings.EqualFold("HostedZoneId", t.Name.Local):
   2394 			val, err := decoder.Value()
   2395 			if err != nil {
   2396 				return err
   2397 			}
   2398 			if val == nil {
   2399 				break
   2400 			}
   2401 			{
   2402 				xtv := string(val)
   2403 				sv.HostedZoneId = ptr.String(xtv)
   2404 			}
   2405 
   2406 		case strings.EqualFold("VPC", t.Name.Local):
   2407 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2408 			if err := awsRestxml_deserializeDocumentVPC(&sv.VPC, nodeDecoder); err != nil {
   2409 				return err
   2410 			}
   2411 
   2412 		default:
   2413 			// Do nothing and ignore the unexpected tag element
   2414 			err = decoder.Decoder.Skip()
   2415 			if err != nil {
   2416 				return err
   2417 			}
   2418 
   2419 		}
   2420 		decoder = originalDecoder
   2421 	}
   2422 	*v = sv
   2423 	return nil
   2424 }
   2425 
   2426 type awsRestxml_deserializeOpDeactivateKeySigningKey struct {
   2427 }
   2428 
   2429 func (*awsRestxml_deserializeOpDeactivateKeySigningKey) ID() string {
   2430 	return "OperationDeserializer"
   2431 }
   2432 
   2433 func (m *awsRestxml_deserializeOpDeactivateKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2434 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2435 ) {
   2436 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2437 	if err != nil {
   2438 		return out, metadata, err
   2439 	}
   2440 
   2441 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2442 	if !ok {
   2443 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2444 	}
   2445 
   2446 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2447 		return out, metadata, awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response, &metadata)
   2448 	}
   2449 	output := &DeactivateKeySigningKeyOutput{}
   2450 	out.Result = output
   2451 
   2452 	var buff [1024]byte
   2453 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2454 	body := io.TeeReader(response.Body, ringBuffer)
   2455 	rootDecoder := xml.NewDecoder(body)
   2456 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2457 	if err == io.EOF {
   2458 		return out, metadata, nil
   2459 	}
   2460 	if err != nil {
   2461 		var snapshot bytes.Buffer
   2462 		io.Copy(&snapshot, ringBuffer)
   2463 		return out, metadata, &smithy.DeserializationError{
   2464 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2465 			Snapshot: snapshot.Bytes(),
   2466 		}
   2467 	}
   2468 
   2469 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2470 	err = awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(&output, decoder)
   2471 	if err != nil {
   2472 		var snapshot bytes.Buffer
   2473 		io.Copy(&snapshot, ringBuffer)
   2474 		return out, metadata, &smithy.DeserializationError{
   2475 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2476 			Snapshot: snapshot.Bytes(),
   2477 		}
   2478 	}
   2479 
   2480 	return out, metadata, err
   2481 }
   2482 
   2483 func awsRestxml_deserializeOpErrorDeactivateKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2484 	var errorBuffer bytes.Buffer
   2485 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2486 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2487 	}
   2488 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2489 
   2490 	errorCode := "UnknownError"
   2491 	errorMessage := errorCode
   2492 
   2493 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2494 	if err != nil {
   2495 		return err
   2496 	}
   2497 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2498 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2499 	}
   2500 	if len(errorComponents.Code) != 0 {
   2501 		errorCode = errorComponents.Code
   2502 	}
   2503 	if len(errorComponents.Message) != 0 {
   2504 		errorMessage = errorComponents.Message
   2505 	}
   2506 	errorBody.Seek(0, io.SeekStart)
   2507 	switch {
   2508 	case strings.EqualFold("ConcurrentModification", errorCode):
   2509 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2510 
   2511 	case strings.EqualFold("InvalidInput", errorCode):
   2512 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2513 
   2514 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   2515 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   2516 
   2517 	case strings.EqualFold("InvalidSigningStatus", errorCode):
   2518 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
   2519 
   2520 	case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode):
   2521 		return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody)
   2522 
   2523 	case strings.EqualFold("KeySigningKeyInUse", errorCode):
   2524 		return awsRestxml_deserializeErrorKeySigningKeyInUse(response, errorBody)
   2525 
   2526 	case strings.EqualFold("NoSuchKeySigningKey", errorCode):
   2527 		return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
   2528 
   2529 	default:
   2530 		genericError := &smithy.GenericAPIError{
   2531 			Code:    errorCode,
   2532 			Message: errorMessage,
   2533 		}
   2534 		return genericError
   2535 
   2536 	}
   2537 }
   2538 
   2539 func awsRestxml_deserializeOpDocumentDeactivateKeySigningKeyOutput(v **DeactivateKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
   2540 	if v == nil {
   2541 		return fmt.Errorf("unexpected nil of type %T", v)
   2542 	}
   2543 	var sv *DeactivateKeySigningKeyOutput
   2544 	if *v == nil {
   2545 		sv = &DeactivateKeySigningKeyOutput{}
   2546 	} else {
   2547 		sv = *v
   2548 	}
   2549 
   2550 	for {
   2551 		t, done, err := decoder.Token()
   2552 		if err != nil {
   2553 			return err
   2554 		}
   2555 		if done {
   2556 			break
   2557 		}
   2558 		originalDecoder := decoder
   2559 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2560 		switch {
   2561 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   2562 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2563 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   2564 				return err
   2565 			}
   2566 
   2567 		default:
   2568 			// Do nothing and ignore the unexpected tag element
   2569 			err = decoder.Decoder.Skip()
   2570 			if err != nil {
   2571 				return err
   2572 			}
   2573 
   2574 		}
   2575 		decoder = originalDecoder
   2576 	}
   2577 	*v = sv
   2578 	return nil
   2579 }
   2580 
   2581 type awsRestxml_deserializeOpDeleteCidrCollection struct {
   2582 }
   2583 
   2584 func (*awsRestxml_deserializeOpDeleteCidrCollection) ID() string {
   2585 	return "OperationDeserializer"
   2586 }
   2587 
   2588 func (m *awsRestxml_deserializeOpDeleteCidrCollection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2589 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2590 ) {
   2591 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2592 	if err != nil {
   2593 		return out, metadata, err
   2594 	}
   2595 
   2596 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2597 	if !ok {
   2598 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2599 	}
   2600 
   2601 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2602 		return out, metadata, awsRestxml_deserializeOpErrorDeleteCidrCollection(response, &metadata)
   2603 	}
   2604 	output := &DeleteCidrCollectionOutput{}
   2605 	out.Result = output
   2606 
   2607 	return out, metadata, err
   2608 }
   2609 
   2610 func awsRestxml_deserializeOpErrorDeleteCidrCollection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2611 	var errorBuffer bytes.Buffer
   2612 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2613 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2614 	}
   2615 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2616 
   2617 	errorCode := "UnknownError"
   2618 	errorMessage := errorCode
   2619 
   2620 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2621 	if err != nil {
   2622 		return err
   2623 	}
   2624 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2625 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2626 	}
   2627 	if len(errorComponents.Code) != 0 {
   2628 		errorCode = errorComponents.Code
   2629 	}
   2630 	if len(errorComponents.Message) != 0 {
   2631 		errorMessage = errorComponents.Message
   2632 	}
   2633 	errorBody.Seek(0, io.SeekStart)
   2634 	switch {
   2635 	case strings.EqualFold("CidrCollectionInUseException", errorCode):
   2636 		return awsRestxml_deserializeErrorCidrCollectionInUseException(response, errorBody)
   2637 
   2638 	case strings.EqualFold("ConcurrentModification", errorCode):
   2639 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2640 
   2641 	case strings.EqualFold("InvalidInput", errorCode):
   2642 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2643 
   2644 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
   2645 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
   2646 
   2647 	default:
   2648 		genericError := &smithy.GenericAPIError{
   2649 			Code:    errorCode,
   2650 			Message: errorMessage,
   2651 		}
   2652 		return genericError
   2653 
   2654 	}
   2655 }
   2656 
   2657 type awsRestxml_deserializeOpDeleteHealthCheck struct {
   2658 }
   2659 
   2660 func (*awsRestxml_deserializeOpDeleteHealthCheck) ID() string {
   2661 	return "OperationDeserializer"
   2662 }
   2663 
   2664 func (m *awsRestxml_deserializeOpDeleteHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2665 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2666 ) {
   2667 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2668 	if err != nil {
   2669 		return out, metadata, err
   2670 	}
   2671 
   2672 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2673 	if !ok {
   2674 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2675 	}
   2676 
   2677 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2678 		return out, metadata, awsRestxml_deserializeOpErrorDeleteHealthCheck(response, &metadata)
   2679 	}
   2680 	output := &DeleteHealthCheckOutput{}
   2681 	out.Result = output
   2682 
   2683 	return out, metadata, err
   2684 }
   2685 
   2686 func awsRestxml_deserializeOpErrorDeleteHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2687 	var errorBuffer bytes.Buffer
   2688 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2689 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2690 	}
   2691 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2692 
   2693 	errorCode := "UnknownError"
   2694 	errorMessage := errorCode
   2695 
   2696 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2697 	if err != nil {
   2698 		return err
   2699 	}
   2700 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2701 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2702 	}
   2703 	if len(errorComponents.Code) != 0 {
   2704 		errorCode = errorComponents.Code
   2705 	}
   2706 	if len(errorComponents.Message) != 0 {
   2707 		errorMessage = errorComponents.Message
   2708 	}
   2709 	errorBody.Seek(0, io.SeekStart)
   2710 	switch {
   2711 	case strings.EqualFold("HealthCheckInUse", errorCode):
   2712 		return awsRestxml_deserializeErrorHealthCheckInUse(response, errorBody)
   2713 
   2714 	case strings.EqualFold("InvalidInput", errorCode):
   2715 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2716 
   2717 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   2718 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   2719 
   2720 	default:
   2721 		genericError := &smithy.GenericAPIError{
   2722 			Code:    errorCode,
   2723 			Message: errorMessage,
   2724 		}
   2725 		return genericError
   2726 
   2727 	}
   2728 }
   2729 
   2730 type awsRestxml_deserializeOpDeleteHostedZone struct {
   2731 }
   2732 
   2733 func (*awsRestxml_deserializeOpDeleteHostedZone) ID() string {
   2734 	return "OperationDeserializer"
   2735 }
   2736 
   2737 func (m *awsRestxml_deserializeOpDeleteHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2738 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2739 ) {
   2740 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2741 	if err != nil {
   2742 		return out, metadata, err
   2743 	}
   2744 
   2745 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2746 	if !ok {
   2747 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2748 	}
   2749 
   2750 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2751 		return out, metadata, awsRestxml_deserializeOpErrorDeleteHostedZone(response, &metadata)
   2752 	}
   2753 	output := &DeleteHostedZoneOutput{}
   2754 	out.Result = output
   2755 
   2756 	var buff [1024]byte
   2757 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2758 	body := io.TeeReader(response.Body, ringBuffer)
   2759 	rootDecoder := xml.NewDecoder(body)
   2760 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2761 	if err == io.EOF {
   2762 		return out, metadata, nil
   2763 	}
   2764 	if err != nil {
   2765 		var snapshot bytes.Buffer
   2766 		io.Copy(&snapshot, ringBuffer)
   2767 		return out, metadata, &smithy.DeserializationError{
   2768 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2769 			Snapshot: snapshot.Bytes(),
   2770 		}
   2771 	}
   2772 
   2773 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2774 	err = awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(&output, decoder)
   2775 	if err != nil {
   2776 		var snapshot bytes.Buffer
   2777 		io.Copy(&snapshot, ringBuffer)
   2778 		return out, metadata, &smithy.DeserializationError{
   2779 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2780 			Snapshot: snapshot.Bytes(),
   2781 		}
   2782 	}
   2783 
   2784 	return out, metadata, err
   2785 }
   2786 
   2787 func awsRestxml_deserializeOpErrorDeleteHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2788 	var errorBuffer bytes.Buffer
   2789 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2790 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2791 	}
   2792 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2793 
   2794 	errorCode := "UnknownError"
   2795 	errorMessage := errorCode
   2796 
   2797 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2798 	if err != nil {
   2799 		return err
   2800 	}
   2801 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2802 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2803 	}
   2804 	if len(errorComponents.Code) != 0 {
   2805 		errorCode = errorComponents.Code
   2806 	}
   2807 	if len(errorComponents.Message) != 0 {
   2808 		errorMessage = errorComponents.Message
   2809 	}
   2810 	errorBody.Seek(0, io.SeekStart)
   2811 	switch {
   2812 	case strings.EqualFold("HostedZoneNotEmpty", errorCode):
   2813 		return awsRestxml_deserializeErrorHostedZoneNotEmpty(response, errorBody)
   2814 
   2815 	case strings.EqualFold("InvalidDomainName", errorCode):
   2816 		return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
   2817 
   2818 	case strings.EqualFold("InvalidInput", errorCode):
   2819 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2820 
   2821 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   2822 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   2823 
   2824 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   2825 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   2826 
   2827 	default:
   2828 		genericError := &smithy.GenericAPIError{
   2829 			Code:    errorCode,
   2830 			Message: errorMessage,
   2831 		}
   2832 		return genericError
   2833 
   2834 	}
   2835 }
   2836 
   2837 func awsRestxml_deserializeOpDocumentDeleteHostedZoneOutput(v **DeleteHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   2838 	if v == nil {
   2839 		return fmt.Errorf("unexpected nil of type %T", v)
   2840 	}
   2841 	var sv *DeleteHostedZoneOutput
   2842 	if *v == nil {
   2843 		sv = &DeleteHostedZoneOutput{}
   2844 	} else {
   2845 		sv = *v
   2846 	}
   2847 
   2848 	for {
   2849 		t, done, err := decoder.Token()
   2850 		if err != nil {
   2851 			return err
   2852 		}
   2853 		if done {
   2854 			break
   2855 		}
   2856 		originalDecoder := decoder
   2857 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   2858 		switch {
   2859 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   2860 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   2861 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   2862 				return err
   2863 			}
   2864 
   2865 		default:
   2866 			// Do nothing and ignore the unexpected tag element
   2867 			err = decoder.Decoder.Skip()
   2868 			if err != nil {
   2869 				return err
   2870 			}
   2871 
   2872 		}
   2873 		decoder = originalDecoder
   2874 	}
   2875 	*v = sv
   2876 	return nil
   2877 }
   2878 
   2879 type awsRestxml_deserializeOpDeleteKeySigningKey struct {
   2880 }
   2881 
   2882 func (*awsRestxml_deserializeOpDeleteKeySigningKey) ID() string {
   2883 	return "OperationDeserializer"
   2884 }
   2885 
   2886 func (m *awsRestxml_deserializeOpDeleteKeySigningKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   2887 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   2888 ) {
   2889 	out, metadata, err = next.HandleDeserialize(ctx, in)
   2890 	if err != nil {
   2891 		return out, metadata, err
   2892 	}
   2893 
   2894 	response, ok := out.RawResponse.(*smithyhttp.Response)
   2895 	if !ok {
   2896 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   2897 	}
   2898 
   2899 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   2900 		return out, metadata, awsRestxml_deserializeOpErrorDeleteKeySigningKey(response, &metadata)
   2901 	}
   2902 	output := &DeleteKeySigningKeyOutput{}
   2903 	out.Result = output
   2904 
   2905 	var buff [1024]byte
   2906 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2907 	body := io.TeeReader(response.Body, ringBuffer)
   2908 	rootDecoder := xml.NewDecoder(body)
   2909 	t, err := smithyxml.FetchRootElement(rootDecoder)
   2910 	if err == io.EOF {
   2911 		return out, metadata, nil
   2912 	}
   2913 	if err != nil {
   2914 		var snapshot bytes.Buffer
   2915 		io.Copy(&snapshot, ringBuffer)
   2916 		return out, metadata, &smithy.DeserializationError{
   2917 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2918 			Snapshot: snapshot.Bytes(),
   2919 		}
   2920 	}
   2921 
   2922 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   2923 	err = awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(&output, decoder)
   2924 	if err != nil {
   2925 		var snapshot bytes.Buffer
   2926 		io.Copy(&snapshot, ringBuffer)
   2927 		return out, metadata, &smithy.DeserializationError{
   2928 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2929 			Snapshot: snapshot.Bytes(),
   2930 		}
   2931 	}
   2932 
   2933 	return out, metadata, err
   2934 }
   2935 
   2936 func awsRestxml_deserializeOpErrorDeleteKeySigningKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   2937 	var errorBuffer bytes.Buffer
   2938 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   2939 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   2940 	}
   2941 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   2942 
   2943 	errorCode := "UnknownError"
   2944 	errorMessage := errorCode
   2945 
   2946 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   2947 	if err != nil {
   2948 		return err
   2949 	}
   2950 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   2951 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   2952 	}
   2953 	if len(errorComponents.Code) != 0 {
   2954 		errorCode = errorComponents.Code
   2955 	}
   2956 	if len(errorComponents.Message) != 0 {
   2957 		errorMessage = errorComponents.Message
   2958 	}
   2959 	errorBody.Seek(0, io.SeekStart)
   2960 	switch {
   2961 	case strings.EqualFold("ConcurrentModification", errorCode):
   2962 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   2963 
   2964 	case strings.EqualFold("InvalidInput", errorCode):
   2965 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   2966 
   2967 	case strings.EqualFold("InvalidKMSArn", errorCode):
   2968 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   2969 
   2970 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   2971 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   2972 
   2973 	case strings.EqualFold("InvalidSigningStatus", errorCode):
   2974 		return awsRestxml_deserializeErrorInvalidSigningStatus(response, errorBody)
   2975 
   2976 	case strings.EqualFold("NoSuchKeySigningKey", errorCode):
   2977 		return awsRestxml_deserializeErrorNoSuchKeySigningKey(response, errorBody)
   2978 
   2979 	default:
   2980 		genericError := &smithy.GenericAPIError{
   2981 			Code:    errorCode,
   2982 			Message: errorMessage,
   2983 		}
   2984 		return genericError
   2985 
   2986 	}
   2987 }
   2988 
   2989 func awsRestxml_deserializeOpDocumentDeleteKeySigningKeyOutput(v **DeleteKeySigningKeyOutput, decoder smithyxml.NodeDecoder) error {
   2990 	if v == nil {
   2991 		return fmt.Errorf("unexpected nil of type %T", v)
   2992 	}
   2993 	var sv *DeleteKeySigningKeyOutput
   2994 	if *v == nil {
   2995 		sv = &DeleteKeySigningKeyOutput{}
   2996 	} else {
   2997 		sv = *v
   2998 	}
   2999 
   3000 	for {
   3001 		t, done, err := decoder.Token()
   3002 		if err != nil {
   3003 			return err
   3004 		}
   3005 		if done {
   3006 			break
   3007 		}
   3008 		originalDecoder := decoder
   3009 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3010 		switch {
   3011 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3012 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3013 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3014 				return err
   3015 			}
   3016 
   3017 		default:
   3018 			// Do nothing and ignore the unexpected tag element
   3019 			err = decoder.Decoder.Skip()
   3020 			if err != nil {
   3021 				return err
   3022 			}
   3023 
   3024 		}
   3025 		decoder = originalDecoder
   3026 	}
   3027 	*v = sv
   3028 	return nil
   3029 }
   3030 
   3031 type awsRestxml_deserializeOpDeleteQueryLoggingConfig struct {
   3032 }
   3033 
   3034 func (*awsRestxml_deserializeOpDeleteQueryLoggingConfig) ID() string {
   3035 	return "OperationDeserializer"
   3036 }
   3037 
   3038 func (m *awsRestxml_deserializeOpDeleteQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3039 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3040 ) {
   3041 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3042 	if err != nil {
   3043 		return out, metadata, err
   3044 	}
   3045 
   3046 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3047 	if !ok {
   3048 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3049 	}
   3050 
   3051 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3052 		return out, metadata, awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response, &metadata)
   3053 	}
   3054 	output := &DeleteQueryLoggingConfigOutput{}
   3055 	out.Result = output
   3056 
   3057 	return out, metadata, err
   3058 }
   3059 
   3060 func awsRestxml_deserializeOpErrorDeleteQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3061 	var errorBuffer bytes.Buffer
   3062 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3063 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3064 	}
   3065 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3066 
   3067 	errorCode := "UnknownError"
   3068 	errorMessage := errorCode
   3069 
   3070 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3071 	if err != nil {
   3072 		return err
   3073 	}
   3074 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3075 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3076 	}
   3077 	if len(errorComponents.Code) != 0 {
   3078 		errorCode = errorComponents.Code
   3079 	}
   3080 	if len(errorComponents.Message) != 0 {
   3081 		errorMessage = errorComponents.Message
   3082 	}
   3083 	errorBody.Seek(0, io.SeekStart)
   3084 	switch {
   3085 	case strings.EqualFold("ConcurrentModification", errorCode):
   3086 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3087 
   3088 	case strings.EqualFold("InvalidInput", errorCode):
   3089 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3090 
   3091 	case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode):
   3092 		return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody)
   3093 
   3094 	default:
   3095 		genericError := &smithy.GenericAPIError{
   3096 			Code:    errorCode,
   3097 			Message: errorMessage,
   3098 		}
   3099 		return genericError
   3100 
   3101 	}
   3102 }
   3103 
   3104 type awsRestxml_deserializeOpDeleteReusableDelegationSet struct {
   3105 }
   3106 
   3107 func (*awsRestxml_deserializeOpDeleteReusableDelegationSet) ID() string {
   3108 	return "OperationDeserializer"
   3109 }
   3110 
   3111 func (m *awsRestxml_deserializeOpDeleteReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3112 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3113 ) {
   3114 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3115 	if err != nil {
   3116 		return out, metadata, err
   3117 	}
   3118 
   3119 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3120 	if !ok {
   3121 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3122 	}
   3123 
   3124 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3125 		return out, metadata, awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response, &metadata)
   3126 	}
   3127 	output := &DeleteReusableDelegationSetOutput{}
   3128 	out.Result = output
   3129 
   3130 	return out, metadata, err
   3131 }
   3132 
   3133 func awsRestxml_deserializeOpErrorDeleteReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3134 	var errorBuffer bytes.Buffer
   3135 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3136 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3137 	}
   3138 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3139 
   3140 	errorCode := "UnknownError"
   3141 	errorMessage := errorCode
   3142 
   3143 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3144 	if err != nil {
   3145 		return err
   3146 	}
   3147 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3148 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3149 	}
   3150 	if len(errorComponents.Code) != 0 {
   3151 		errorCode = errorComponents.Code
   3152 	}
   3153 	if len(errorComponents.Message) != 0 {
   3154 		errorMessage = errorComponents.Message
   3155 	}
   3156 	errorBody.Seek(0, io.SeekStart)
   3157 	switch {
   3158 	case strings.EqualFold("DelegationSetInUse", errorCode):
   3159 		return awsRestxml_deserializeErrorDelegationSetInUse(response, errorBody)
   3160 
   3161 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   3162 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   3163 
   3164 	case strings.EqualFold("InvalidInput", errorCode):
   3165 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3166 
   3167 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   3168 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   3169 
   3170 	default:
   3171 		genericError := &smithy.GenericAPIError{
   3172 			Code:    errorCode,
   3173 			Message: errorMessage,
   3174 		}
   3175 		return genericError
   3176 
   3177 	}
   3178 }
   3179 
   3180 type awsRestxml_deserializeOpDeleteTrafficPolicy struct {
   3181 }
   3182 
   3183 func (*awsRestxml_deserializeOpDeleteTrafficPolicy) ID() string {
   3184 	return "OperationDeserializer"
   3185 }
   3186 
   3187 func (m *awsRestxml_deserializeOpDeleteTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3188 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3189 ) {
   3190 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3191 	if err != nil {
   3192 		return out, metadata, err
   3193 	}
   3194 
   3195 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3196 	if !ok {
   3197 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3198 	}
   3199 
   3200 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3201 		return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response, &metadata)
   3202 	}
   3203 	output := &DeleteTrafficPolicyOutput{}
   3204 	out.Result = output
   3205 
   3206 	return out, metadata, err
   3207 }
   3208 
   3209 func awsRestxml_deserializeOpErrorDeleteTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3210 	var errorBuffer bytes.Buffer
   3211 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3212 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3213 	}
   3214 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3215 
   3216 	errorCode := "UnknownError"
   3217 	errorMessage := errorCode
   3218 
   3219 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3220 	if err != nil {
   3221 		return err
   3222 	}
   3223 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3224 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3225 	}
   3226 	if len(errorComponents.Code) != 0 {
   3227 		errorCode = errorComponents.Code
   3228 	}
   3229 	if len(errorComponents.Message) != 0 {
   3230 		errorMessage = errorComponents.Message
   3231 	}
   3232 	errorBody.Seek(0, io.SeekStart)
   3233 	switch {
   3234 	case strings.EqualFold("ConcurrentModification", errorCode):
   3235 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3236 
   3237 	case strings.EqualFold("InvalidInput", errorCode):
   3238 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3239 
   3240 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   3241 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   3242 
   3243 	case strings.EqualFold("TrafficPolicyInUse", errorCode):
   3244 		return awsRestxml_deserializeErrorTrafficPolicyInUse(response, errorBody)
   3245 
   3246 	default:
   3247 		genericError := &smithy.GenericAPIError{
   3248 			Code:    errorCode,
   3249 			Message: errorMessage,
   3250 		}
   3251 		return genericError
   3252 
   3253 	}
   3254 }
   3255 
   3256 type awsRestxml_deserializeOpDeleteTrafficPolicyInstance struct {
   3257 }
   3258 
   3259 func (*awsRestxml_deserializeOpDeleteTrafficPolicyInstance) ID() string {
   3260 	return "OperationDeserializer"
   3261 }
   3262 
   3263 func (m *awsRestxml_deserializeOpDeleteTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3264 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3265 ) {
   3266 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3267 	if err != nil {
   3268 		return out, metadata, err
   3269 	}
   3270 
   3271 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3272 	if !ok {
   3273 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3274 	}
   3275 
   3276 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3277 		return out, metadata, awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response, &metadata)
   3278 	}
   3279 	output := &DeleteTrafficPolicyInstanceOutput{}
   3280 	out.Result = output
   3281 
   3282 	return out, metadata, err
   3283 }
   3284 
   3285 func awsRestxml_deserializeOpErrorDeleteTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3286 	var errorBuffer bytes.Buffer
   3287 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3288 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3289 	}
   3290 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3291 
   3292 	errorCode := "UnknownError"
   3293 	errorMessage := errorCode
   3294 
   3295 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3296 	if err != nil {
   3297 		return err
   3298 	}
   3299 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3300 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3301 	}
   3302 	if len(errorComponents.Code) != 0 {
   3303 		errorCode = errorComponents.Code
   3304 	}
   3305 	if len(errorComponents.Message) != 0 {
   3306 		errorMessage = errorComponents.Message
   3307 	}
   3308 	errorBody.Seek(0, io.SeekStart)
   3309 	switch {
   3310 	case strings.EqualFold("InvalidInput", errorCode):
   3311 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3312 
   3313 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   3314 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   3315 
   3316 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   3317 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   3318 
   3319 	default:
   3320 		genericError := &smithy.GenericAPIError{
   3321 			Code:    errorCode,
   3322 			Message: errorMessage,
   3323 		}
   3324 		return genericError
   3325 
   3326 	}
   3327 }
   3328 
   3329 type awsRestxml_deserializeOpDeleteVPCAssociationAuthorization struct {
   3330 }
   3331 
   3332 func (*awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) ID() string {
   3333 	return "OperationDeserializer"
   3334 }
   3335 
   3336 func (m *awsRestxml_deserializeOpDeleteVPCAssociationAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3337 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3338 ) {
   3339 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3340 	if err != nil {
   3341 		return out, metadata, err
   3342 	}
   3343 
   3344 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3345 	if !ok {
   3346 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3347 	}
   3348 
   3349 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3350 		return out, metadata, awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response, &metadata)
   3351 	}
   3352 	output := &DeleteVPCAssociationAuthorizationOutput{}
   3353 	out.Result = output
   3354 
   3355 	return out, metadata, err
   3356 }
   3357 
   3358 func awsRestxml_deserializeOpErrorDeleteVPCAssociationAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3359 	var errorBuffer bytes.Buffer
   3360 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3361 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3362 	}
   3363 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3364 
   3365 	errorCode := "UnknownError"
   3366 	errorMessage := errorCode
   3367 
   3368 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3369 	if err != nil {
   3370 		return err
   3371 	}
   3372 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3373 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3374 	}
   3375 	if len(errorComponents.Code) != 0 {
   3376 		errorCode = errorComponents.Code
   3377 	}
   3378 	if len(errorComponents.Message) != 0 {
   3379 		errorMessage = errorComponents.Message
   3380 	}
   3381 	errorBody.Seek(0, io.SeekStart)
   3382 	switch {
   3383 	case strings.EqualFold("ConcurrentModification", errorCode):
   3384 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3385 
   3386 	case strings.EqualFold("InvalidInput", errorCode):
   3387 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3388 
   3389 	case strings.EqualFold("InvalidVPCId", errorCode):
   3390 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   3391 
   3392 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3393 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3394 
   3395 	case strings.EqualFold("VPCAssociationAuthorizationNotFound", errorCode):
   3396 		return awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response, errorBody)
   3397 
   3398 	default:
   3399 		genericError := &smithy.GenericAPIError{
   3400 			Code:    errorCode,
   3401 			Message: errorMessage,
   3402 		}
   3403 		return genericError
   3404 
   3405 	}
   3406 }
   3407 
   3408 type awsRestxml_deserializeOpDisableHostedZoneDNSSEC struct {
   3409 }
   3410 
   3411 func (*awsRestxml_deserializeOpDisableHostedZoneDNSSEC) ID() string {
   3412 	return "OperationDeserializer"
   3413 }
   3414 
   3415 func (m *awsRestxml_deserializeOpDisableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3416 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3417 ) {
   3418 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3419 	if err != nil {
   3420 		return out, metadata, err
   3421 	}
   3422 
   3423 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3424 	if !ok {
   3425 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3426 	}
   3427 
   3428 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3429 		return out, metadata, awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response, &metadata)
   3430 	}
   3431 	output := &DisableHostedZoneDNSSECOutput{}
   3432 	out.Result = output
   3433 
   3434 	var buff [1024]byte
   3435 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3436 	body := io.TeeReader(response.Body, ringBuffer)
   3437 	rootDecoder := xml.NewDecoder(body)
   3438 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3439 	if err == io.EOF {
   3440 		return out, metadata, nil
   3441 	}
   3442 	if err != nil {
   3443 		var snapshot bytes.Buffer
   3444 		io.Copy(&snapshot, ringBuffer)
   3445 		return out, metadata, &smithy.DeserializationError{
   3446 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3447 			Snapshot: snapshot.Bytes(),
   3448 		}
   3449 	}
   3450 
   3451 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3452 	err = awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(&output, decoder)
   3453 	if err != nil {
   3454 		var snapshot bytes.Buffer
   3455 		io.Copy(&snapshot, ringBuffer)
   3456 		return out, metadata, &smithy.DeserializationError{
   3457 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3458 			Snapshot: snapshot.Bytes(),
   3459 		}
   3460 	}
   3461 
   3462 	return out, metadata, err
   3463 }
   3464 
   3465 func awsRestxml_deserializeOpErrorDisableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3466 	var errorBuffer bytes.Buffer
   3467 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3468 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3469 	}
   3470 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3471 
   3472 	errorCode := "UnknownError"
   3473 	errorMessage := errorCode
   3474 
   3475 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3476 	if err != nil {
   3477 		return err
   3478 	}
   3479 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3480 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3481 	}
   3482 	if len(errorComponents.Code) != 0 {
   3483 		errorCode = errorComponents.Code
   3484 	}
   3485 	if len(errorComponents.Message) != 0 {
   3486 		errorMessage = errorComponents.Message
   3487 	}
   3488 	errorBody.Seek(0, io.SeekStart)
   3489 	switch {
   3490 	case strings.EqualFold("ConcurrentModification", errorCode):
   3491 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3492 
   3493 	case strings.EqualFold("DNSSECNotFound", errorCode):
   3494 		return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody)
   3495 
   3496 	case strings.EqualFold("InvalidArgument", errorCode):
   3497 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   3498 
   3499 	case strings.EqualFold("InvalidInput", errorCode):
   3500 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3501 
   3502 	case strings.EqualFold("InvalidKMSArn", errorCode):
   3503 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   3504 
   3505 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   3506 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   3507 
   3508 	case strings.EqualFold("KeySigningKeyInParentDSRecord", errorCode):
   3509 		return awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response, errorBody)
   3510 
   3511 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3512 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3513 
   3514 	default:
   3515 		genericError := &smithy.GenericAPIError{
   3516 			Code:    errorCode,
   3517 			Message: errorMessage,
   3518 		}
   3519 		return genericError
   3520 
   3521 	}
   3522 }
   3523 
   3524 func awsRestxml_deserializeOpDocumentDisableHostedZoneDNSSECOutput(v **DisableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error {
   3525 	if v == nil {
   3526 		return fmt.Errorf("unexpected nil of type %T", v)
   3527 	}
   3528 	var sv *DisableHostedZoneDNSSECOutput
   3529 	if *v == nil {
   3530 		sv = &DisableHostedZoneDNSSECOutput{}
   3531 	} else {
   3532 		sv = *v
   3533 	}
   3534 
   3535 	for {
   3536 		t, done, err := decoder.Token()
   3537 		if err != nil {
   3538 			return err
   3539 		}
   3540 		if done {
   3541 			break
   3542 		}
   3543 		originalDecoder := decoder
   3544 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3545 		switch {
   3546 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3547 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3548 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3549 				return err
   3550 			}
   3551 
   3552 		default:
   3553 			// Do nothing and ignore the unexpected tag element
   3554 			err = decoder.Decoder.Skip()
   3555 			if err != nil {
   3556 				return err
   3557 			}
   3558 
   3559 		}
   3560 		decoder = originalDecoder
   3561 	}
   3562 	*v = sv
   3563 	return nil
   3564 }
   3565 
   3566 type awsRestxml_deserializeOpDisassociateVPCFromHostedZone struct {
   3567 }
   3568 
   3569 func (*awsRestxml_deserializeOpDisassociateVPCFromHostedZone) ID() string {
   3570 	return "OperationDeserializer"
   3571 }
   3572 
   3573 func (m *awsRestxml_deserializeOpDisassociateVPCFromHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3574 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3575 ) {
   3576 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3577 	if err != nil {
   3578 		return out, metadata, err
   3579 	}
   3580 
   3581 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3582 	if !ok {
   3583 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3584 	}
   3585 
   3586 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3587 		return out, metadata, awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response, &metadata)
   3588 	}
   3589 	output := &DisassociateVPCFromHostedZoneOutput{}
   3590 	out.Result = output
   3591 
   3592 	var buff [1024]byte
   3593 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3594 	body := io.TeeReader(response.Body, ringBuffer)
   3595 	rootDecoder := xml.NewDecoder(body)
   3596 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3597 	if err == io.EOF {
   3598 		return out, metadata, nil
   3599 	}
   3600 	if err != nil {
   3601 		var snapshot bytes.Buffer
   3602 		io.Copy(&snapshot, ringBuffer)
   3603 		return out, metadata, &smithy.DeserializationError{
   3604 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3605 			Snapshot: snapshot.Bytes(),
   3606 		}
   3607 	}
   3608 
   3609 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3610 	err = awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(&output, decoder)
   3611 	if err != nil {
   3612 		var snapshot bytes.Buffer
   3613 		io.Copy(&snapshot, ringBuffer)
   3614 		return out, metadata, &smithy.DeserializationError{
   3615 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3616 			Snapshot: snapshot.Bytes(),
   3617 		}
   3618 	}
   3619 
   3620 	return out, metadata, err
   3621 }
   3622 
   3623 func awsRestxml_deserializeOpErrorDisassociateVPCFromHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3624 	var errorBuffer bytes.Buffer
   3625 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3626 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3627 	}
   3628 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3629 
   3630 	errorCode := "UnknownError"
   3631 	errorMessage := errorCode
   3632 
   3633 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3634 	if err != nil {
   3635 		return err
   3636 	}
   3637 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3638 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3639 	}
   3640 	if len(errorComponents.Code) != 0 {
   3641 		errorCode = errorComponents.Code
   3642 	}
   3643 	if len(errorComponents.Message) != 0 {
   3644 		errorMessage = errorComponents.Message
   3645 	}
   3646 	errorBody.Seek(0, io.SeekStart)
   3647 	switch {
   3648 	case strings.EqualFold("InvalidInput", errorCode):
   3649 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3650 
   3651 	case strings.EqualFold("InvalidVPCId", errorCode):
   3652 		return awsRestxml_deserializeErrorInvalidVPCId(response, errorBody)
   3653 
   3654 	case strings.EqualFold("LastVPCAssociation", errorCode):
   3655 		return awsRestxml_deserializeErrorLastVPCAssociation(response, errorBody)
   3656 
   3657 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3658 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3659 
   3660 	case strings.EqualFold("VPCAssociationNotFound", errorCode):
   3661 		return awsRestxml_deserializeErrorVPCAssociationNotFound(response, errorBody)
   3662 
   3663 	default:
   3664 		genericError := &smithy.GenericAPIError{
   3665 			Code:    errorCode,
   3666 			Message: errorMessage,
   3667 		}
   3668 		return genericError
   3669 
   3670 	}
   3671 }
   3672 
   3673 func awsRestxml_deserializeOpDocumentDisassociateVPCFromHostedZoneOutput(v **DisassociateVPCFromHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   3674 	if v == nil {
   3675 		return fmt.Errorf("unexpected nil of type %T", v)
   3676 	}
   3677 	var sv *DisassociateVPCFromHostedZoneOutput
   3678 	if *v == nil {
   3679 		sv = &DisassociateVPCFromHostedZoneOutput{}
   3680 	} else {
   3681 		sv = *v
   3682 	}
   3683 
   3684 	for {
   3685 		t, done, err := decoder.Token()
   3686 		if err != nil {
   3687 			return err
   3688 		}
   3689 		if done {
   3690 			break
   3691 		}
   3692 		originalDecoder := decoder
   3693 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3694 		switch {
   3695 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3696 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3697 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3698 				return err
   3699 			}
   3700 
   3701 		default:
   3702 			// Do nothing and ignore the unexpected tag element
   3703 			err = decoder.Decoder.Skip()
   3704 			if err != nil {
   3705 				return err
   3706 			}
   3707 
   3708 		}
   3709 		decoder = originalDecoder
   3710 	}
   3711 	*v = sv
   3712 	return nil
   3713 }
   3714 
   3715 type awsRestxml_deserializeOpEnableHostedZoneDNSSEC struct {
   3716 }
   3717 
   3718 func (*awsRestxml_deserializeOpEnableHostedZoneDNSSEC) ID() string {
   3719 	return "OperationDeserializer"
   3720 }
   3721 
   3722 func (m *awsRestxml_deserializeOpEnableHostedZoneDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3723 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3724 ) {
   3725 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3726 	if err != nil {
   3727 		return out, metadata, err
   3728 	}
   3729 
   3730 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3731 	if !ok {
   3732 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3733 	}
   3734 
   3735 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3736 		return out, metadata, awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response, &metadata)
   3737 	}
   3738 	output := &EnableHostedZoneDNSSECOutput{}
   3739 	out.Result = output
   3740 
   3741 	var buff [1024]byte
   3742 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3743 	body := io.TeeReader(response.Body, ringBuffer)
   3744 	rootDecoder := xml.NewDecoder(body)
   3745 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3746 	if err == io.EOF {
   3747 		return out, metadata, nil
   3748 	}
   3749 	if err != nil {
   3750 		var snapshot bytes.Buffer
   3751 		io.Copy(&snapshot, ringBuffer)
   3752 		return out, metadata, &smithy.DeserializationError{
   3753 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3754 			Snapshot: snapshot.Bytes(),
   3755 		}
   3756 	}
   3757 
   3758 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3759 	err = awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(&output, decoder)
   3760 	if err != nil {
   3761 		var snapshot bytes.Buffer
   3762 		io.Copy(&snapshot, ringBuffer)
   3763 		return out, metadata, &smithy.DeserializationError{
   3764 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3765 			Snapshot: snapshot.Bytes(),
   3766 		}
   3767 	}
   3768 
   3769 	return out, metadata, err
   3770 }
   3771 
   3772 func awsRestxml_deserializeOpErrorEnableHostedZoneDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3773 	var errorBuffer bytes.Buffer
   3774 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3775 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3776 	}
   3777 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3778 
   3779 	errorCode := "UnknownError"
   3780 	errorMessage := errorCode
   3781 
   3782 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3783 	if err != nil {
   3784 		return err
   3785 	}
   3786 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3787 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3788 	}
   3789 	if len(errorComponents.Code) != 0 {
   3790 		errorCode = errorComponents.Code
   3791 	}
   3792 	if len(errorComponents.Message) != 0 {
   3793 		errorMessage = errorComponents.Message
   3794 	}
   3795 	errorBody.Seek(0, io.SeekStart)
   3796 	switch {
   3797 	case strings.EqualFold("ConcurrentModification", errorCode):
   3798 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
   3799 
   3800 	case strings.EqualFold("DNSSECNotFound", errorCode):
   3801 		return awsRestxml_deserializeErrorDNSSECNotFound(response, errorBody)
   3802 
   3803 	case strings.EqualFold("HostedZonePartiallyDelegated", errorCode):
   3804 		return awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response, errorBody)
   3805 
   3806 	case strings.EqualFold("InvalidArgument", errorCode):
   3807 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   3808 
   3809 	case strings.EqualFold("InvalidInput", errorCode):
   3810 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3811 
   3812 	case strings.EqualFold("InvalidKMSArn", errorCode):
   3813 		return awsRestxml_deserializeErrorInvalidKMSArn(response, errorBody)
   3814 
   3815 	case strings.EqualFold("InvalidKeySigningKeyStatus", errorCode):
   3816 		return awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response, errorBody)
   3817 
   3818 	case strings.EqualFold("KeySigningKeyWithActiveStatusNotFound", errorCode):
   3819 		return awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response, errorBody)
   3820 
   3821 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   3822 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   3823 
   3824 	default:
   3825 		genericError := &smithy.GenericAPIError{
   3826 			Code:    errorCode,
   3827 			Message: errorMessage,
   3828 		}
   3829 		return genericError
   3830 
   3831 	}
   3832 }
   3833 
   3834 func awsRestxml_deserializeOpDocumentEnableHostedZoneDNSSECOutput(v **EnableHostedZoneDNSSECOutput, decoder smithyxml.NodeDecoder) error {
   3835 	if v == nil {
   3836 		return fmt.Errorf("unexpected nil of type %T", v)
   3837 	}
   3838 	var sv *EnableHostedZoneDNSSECOutput
   3839 	if *v == nil {
   3840 		sv = &EnableHostedZoneDNSSECOutput{}
   3841 	} else {
   3842 		sv = *v
   3843 	}
   3844 
   3845 	for {
   3846 		t, done, err := decoder.Token()
   3847 		if err != nil {
   3848 			return err
   3849 		}
   3850 		if done {
   3851 			break
   3852 		}
   3853 		originalDecoder := decoder
   3854 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3855 		switch {
   3856 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   3857 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   3858 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   3859 				return err
   3860 			}
   3861 
   3862 		default:
   3863 			// Do nothing and ignore the unexpected tag element
   3864 			err = decoder.Decoder.Skip()
   3865 			if err != nil {
   3866 				return err
   3867 			}
   3868 
   3869 		}
   3870 		decoder = originalDecoder
   3871 	}
   3872 	*v = sv
   3873 	return nil
   3874 }
   3875 
   3876 type awsRestxml_deserializeOpGetAccountLimit struct {
   3877 }
   3878 
   3879 func (*awsRestxml_deserializeOpGetAccountLimit) ID() string {
   3880 	return "OperationDeserializer"
   3881 }
   3882 
   3883 func (m *awsRestxml_deserializeOpGetAccountLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   3884 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   3885 ) {
   3886 	out, metadata, err = next.HandleDeserialize(ctx, in)
   3887 	if err != nil {
   3888 		return out, metadata, err
   3889 	}
   3890 
   3891 	response, ok := out.RawResponse.(*smithyhttp.Response)
   3892 	if !ok {
   3893 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   3894 	}
   3895 
   3896 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   3897 		return out, metadata, awsRestxml_deserializeOpErrorGetAccountLimit(response, &metadata)
   3898 	}
   3899 	output := &GetAccountLimitOutput{}
   3900 	out.Result = output
   3901 
   3902 	var buff [1024]byte
   3903 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   3904 	body := io.TeeReader(response.Body, ringBuffer)
   3905 	rootDecoder := xml.NewDecoder(body)
   3906 	t, err := smithyxml.FetchRootElement(rootDecoder)
   3907 	if err == io.EOF {
   3908 		return out, metadata, nil
   3909 	}
   3910 	if err != nil {
   3911 		var snapshot bytes.Buffer
   3912 		io.Copy(&snapshot, ringBuffer)
   3913 		return out, metadata, &smithy.DeserializationError{
   3914 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3915 			Snapshot: snapshot.Bytes(),
   3916 		}
   3917 	}
   3918 
   3919 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   3920 	err = awsRestxml_deserializeOpDocumentGetAccountLimitOutput(&output, decoder)
   3921 	if err != nil {
   3922 		var snapshot bytes.Buffer
   3923 		io.Copy(&snapshot, ringBuffer)
   3924 		return out, metadata, &smithy.DeserializationError{
   3925 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   3926 			Snapshot: snapshot.Bytes(),
   3927 		}
   3928 	}
   3929 
   3930 	return out, metadata, err
   3931 }
   3932 
   3933 func awsRestxml_deserializeOpErrorGetAccountLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   3934 	var errorBuffer bytes.Buffer
   3935 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   3936 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   3937 	}
   3938 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   3939 
   3940 	errorCode := "UnknownError"
   3941 	errorMessage := errorCode
   3942 
   3943 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   3944 	if err != nil {
   3945 		return err
   3946 	}
   3947 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   3948 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   3949 	}
   3950 	if len(errorComponents.Code) != 0 {
   3951 		errorCode = errorComponents.Code
   3952 	}
   3953 	if len(errorComponents.Message) != 0 {
   3954 		errorMessage = errorComponents.Message
   3955 	}
   3956 	errorBody.Seek(0, io.SeekStart)
   3957 	switch {
   3958 	case strings.EqualFold("InvalidInput", errorCode):
   3959 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   3960 
   3961 	default:
   3962 		genericError := &smithy.GenericAPIError{
   3963 			Code:    errorCode,
   3964 			Message: errorMessage,
   3965 		}
   3966 		return genericError
   3967 
   3968 	}
   3969 }
   3970 
   3971 func awsRestxml_deserializeOpDocumentGetAccountLimitOutput(v **GetAccountLimitOutput, decoder smithyxml.NodeDecoder) error {
   3972 	if v == nil {
   3973 		return fmt.Errorf("unexpected nil of type %T", v)
   3974 	}
   3975 	var sv *GetAccountLimitOutput
   3976 	if *v == nil {
   3977 		sv = &GetAccountLimitOutput{}
   3978 	} else {
   3979 		sv = *v
   3980 	}
   3981 
   3982 	for {
   3983 		t, done, err := decoder.Token()
   3984 		if err != nil {
   3985 			return err
   3986 		}
   3987 		if done {
   3988 			break
   3989 		}
   3990 		originalDecoder := decoder
   3991 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   3992 		switch {
   3993 		case strings.EqualFold("Count", t.Name.Local):
   3994 			val, err := decoder.Value()
   3995 			if err != nil {
   3996 				return err
   3997 			}
   3998 			if val == nil {
   3999 				break
   4000 			}
   4001 			{
   4002 				xtv := string(val)
   4003 				i64, err := strconv.ParseInt(xtv, 10, 64)
   4004 				if err != nil {
   4005 					return err
   4006 				}
   4007 				sv.Count = i64
   4008 			}
   4009 
   4010 		case strings.EqualFold("Limit", t.Name.Local):
   4011 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4012 			if err := awsRestxml_deserializeDocumentAccountLimit(&sv.Limit, nodeDecoder); err != nil {
   4013 				return err
   4014 			}
   4015 
   4016 		default:
   4017 			// Do nothing and ignore the unexpected tag element
   4018 			err = decoder.Decoder.Skip()
   4019 			if err != nil {
   4020 				return err
   4021 			}
   4022 
   4023 		}
   4024 		decoder = originalDecoder
   4025 	}
   4026 	*v = sv
   4027 	return nil
   4028 }
   4029 
   4030 type awsRestxml_deserializeOpGetChange struct {
   4031 }
   4032 
   4033 func (*awsRestxml_deserializeOpGetChange) ID() string {
   4034 	return "OperationDeserializer"
   4035 }
   4036 
   4037 func (m *awsRestxml_deserializeOpGetChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4038 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4039 ) {
   4040 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4041 	if err != nil {
   4042 		return out, metadata, err
   4043 	}
   4044 
   4045 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4046 	if !ok {
   4047 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4048 	}
   4049 
   4050 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4051 		return out, metadata, awsRestxml_deserializeOpErrorGetChange(response, &metadata)
   4052 	}
   4053 	output := &GetChangeOutput{}
   4054 	out.Result = output
   4055 
   4056 	var buff [1024]byte
   4057 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4058 	body := io.TeeReader(response.Body, ringBuffer)
   4059 	rootDecoder := xml.NewDecoder(body)
   4060 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4061 	if err == io.EOF {
   4062 		return out, metadata, nil
   4063 	}
   4064 	if err != nil {
   4065 		var snapshot bytes.Buffer
   4066 		io.Copy(&snapshot, ringBuffer)
   4067 		return out, metadata, &smithy.DeserializationError{
   4068 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4069 			Snapshot: snapshot.Bytes(),
   4070 		}
   4071 	}
   4072 
   4073 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4074 	err = awsRestxml_deserializeOpDocumentGetChangeOutput(&output, decoder)
   4075 	if err != nil {
   4076 		var snapshot bytes.Buffer
   4077 		io.Copy(&snapshot, ringBuffer)
   4078 		return out, metadata, &smithy.DeserializationError{
   4079 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4080 			Snapshot: snapshot.Bytes(),
   4081 		}
   4082 	}
   4083 
   4084 	return out, metadata, err
   4085 }
   4086 
   4087 func awsRestxml_deserializeOpErrorGetChange(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4088 	var errorBuffer bytes.Buffer
   4089 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4090 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4091 	}
   4092 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4093 
   4094 	errorCode := "UnknownError"
   4095 	errorMessage := errorCode
   4096 
   4097 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4098 	if err != nil {
   4099 		return err
   4100 	}
   4101 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4102 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4103 	}
   4104 	if len(errorComponents.Code) != 0 {
   4105 		errorCode = errorComponents.Code
   4106 	}
   4107 	if len(errorComponents.Message) != 0 {
   4108 		errorMessage = errorComponents.Message
   4109 	}
   4110 	errorBody.Seek(0, io.SeekStart)
   4111 	switch {
   4112 	case strings.EqualFold("InvalidInput", errorCode):
   4113 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4114 
   4115 	case strings.EqualFold("NoSuchChange", errorCode):
   4116 		return awsRestxml_deserializeErrorNoSuchChange(response, errorBody)
   4117 
   4118 	default:
   4119 		genericError := &smithy.GenericAPIError{
   4120 			Code:    errorCode,
   4121 			Message: errorMessage,
   4122 		}
   4123 		return genericError
   4124 
   4125 	}
   4126 }
   4127 
   4128 func awsRestxml_deserializeOpDocumentGetChangeOutput(v **GetChangeOutput, decoder smithyxml.NodeDecoder) error {
   4129 	if v == nil {
   4130 		return fmt.Errorf("unexpected nil of type %T", v)
   4131 	}
   4132 	var sv *GetChangeOutput
   4133 	if *v == nil {
   4134 		sv = &GetChangeOutput{}
   4135 	} else {
   4136 		sv = *v
   4137 	}
   4138 
   4139 	for {
   4140 		t, done, err := decoder.Token()
   4141 		if err != nil {
   4142 			return err
   4143 		}
   4144 		if done {
   4145 			break
   4146 		}
   4147 		originalDecoder := decoder
   4148 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4149 		switch {
   4150 		case strings.EqualFold("ChangeInfo", t.Name.Local):
   4151 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4152 			if err := awsRestxml_deserializeDocumentChangeInfo(&sv.ChangeInfo, nodeDecoder); err != nil {
   4153 				return err
   4154 			}
   4155 
   4156 		default:
   4157 			// Do nothing and ignore the unexpected tag element
   4158 			err = decoder.Decoder.Skip()
   4159 			if err != nil {
   4160 				return err
   4161 			}
   4162 
   4163 		}
   4164 		decoder = originalDecoder
   4165 	}
   4166 	*v = sv
   4167 	return nil
   4168 }
   4169 
   4170 type awsRestxml_deserializeOpGetCheckerIpRanges struct {
   4171 }
   4172 
   4173 func (*awsRestxml_deserializeOpGetCheckerIpRanges) ID() string {
   4174 	return "OperationDeserializer"
   4175 }
   4176 
   4177 func (m *awsRestxml_deserializeOpGetCheckerIpRanges) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4178 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4179 ) {
   4180 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4181 	if err != nil {
   4182 		return out, metadata, err
   4183 	}
   4184 
   4185 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4186 	if !ok {
   4187 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4188 	}
   4189 
   4190 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4191 		return out, metadata, awsRestxml_deserializeOpErrorGetCheckerIpRanges(response, &metadata)
   4192 	}
   4193 	output := &GetCheckerIpRangesOutput{}
   4194 	out.Result = output
   4195 
   4196 	var buff [1024]byte
   4197 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4198 	body := io.TeeReader(response.Body, ringBuffer)
   4199 	rootDecoder := xml.NewDecoder(body)
   4200 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4201 	if err == io.EOF {
   4202 		return out, metadata, nil
   4203 	}
   4204 	if err != nil {
   4205 		var snapshot bytes.Buffer
   4206 		io.Copy(&snapshot, ringBuffer)
   4207 		return out, metadata, &smithy.DeserializationError{
   4208 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4209 			Snapshot: snapshot.Bytes(),
   4210 		}
   4211 	}
   4212 
   4213 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4214 	err = awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(&output, decoder)
   4215 	if err != nil {
   4216 		var snapshot bytes.Buffer
   4217 		io.Copy(&snapshot, ringBuffer)
   4218 		return out, metadata, &smithy.DeserializationError{
   4219 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4220 			Snapshot: snapshot.Bytes(),
   4221 		}
   4222 	}
   4223 
   4224 	return out, metadata, err
   4225 }
   4226 
   4227 func awsRestxml_deserializeOpErrorGetCheckerIpRanges(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4228 	var errorBuffer bytes.Buffer
   4229 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4230 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4231 	}
   4232 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4233 
   4234 	errorCode := "UnknownError"
   4235 	errorMessage := errorCode
   4236 
   4237 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4238 	if err != nil {
   4239 		return err
   4240 	}
   4241 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4242 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4243 	}
   4244 	if len(errorComponents.Code) != 0 {
   4245 		errorCode = errorComponents.Code
   4246 	}
   4247 	if len(errorComponents.Message) != 0 {
   4248 		errorMessage = errorComponents.Message
   4249 	}
   4250 	errorBody.Seek(0, io.SeekStart)
   4251 	switch {
   4252 	default:
   4253 		genericError := &smithy.GenericAPIError{
   4254 			Code:    errorCode,
   4255 			Message: errorMessage,
   4256 		}
   4257 		return genericError
   4258 
   4259 	}
   4260 }
   4261 
   4262 func awsRestxml_deserializeOpDocumentGetCheckerIpRangesOutput(v **GetCheckerIpRangesOutput, decoder smithyxml.NodeDecoder) error {
   4263 	if v == nil {
   4264 		return fmt.Errorf("unexpected nil of type %T", v)
   4265 	}
   4266 	var sv *GetCheckerIpRangesOutput
   4267 	if *v == nil {
   4268 		sv = &GetCheckerIpRangesOutput{}
   4269 	} else {
   4270 		sv = *v
   4271 	}
   4272 
   4273 	for {
   4274 		t, done, err := decoder.Token()
   4275 		if err != nil {
   4276 			return err
   4277 		}
   4278 		if done {
   4279 			break
   4280 		}
   4281 		originalDecoder := decoder
   4282 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4283 		switch {
   4284 		case strings.EqualFold("CheckerIpRanges", t.Name.Local):
   4285 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4286 			if err := awsRestxml_deserializeDocumentCheckerIpRanges(&sv.CheckerIpRanges, nodeDecoder); err != nil {
   4287 				return err
   4288 			}
   4289 
   4290 		default:
   4291 			// Do nothing and ignore the unexpected tag element
   4292 			err = decoder.Decoder.Skip()
   4293 			if err != nil {
   4294 				return err
   4295 			}
   4296 
   4297 		}
   4298 		decoder = originalDecoder
   4299 	}
   4300 	*v = sv
   4301 	return nil
   4302 }
   4303 
   4304 type awsRestxml_deserializeOpGetDNSSEC struct {
   4305 }
   4306 
   4307 func (*awsRestxml_deserializeOpGetDNSSEC) ID() string {
   4308 	return "OperationDeserializer"
   4309 }
   4310 
   4311 func (m *awsRestxml_deserializeOpGetDNSSEC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4312 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4313 ) {
   4314 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4315 	if err != nil {
   4316 		return out, metadata, err
   4317 	}
   4318 
   4319 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4320 	if !ok {
   4321 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4322 	}
   4323 
   4324 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4325 		return out, metadata, awsRestxml_deserializeOpErrorGetDNSSEC(response, &metadata)
   4326 	}
   4327 	output := &GetDNSSECOutput{}
   4328 	out.Result = output
   4329 
   4330 	var buff [1024]byte
   4331 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4332 	body := io.TeeReader(response.Body, ringBuffer)
   4333 	rootDecoder := xml.NewDecoder(body)
   4334 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4335 	if err == io.EOF {
   4336 		return out, metadata, nil
   4337 	}
   4338 	if err != nil {
   4339 		var snapshot bytes.Buffer
   4340 		io.Copy(&snapshot, ringBuffer)
   4341 		return out, metadata, &smithy.DeserializationError{
   4342 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4343 			Snapshot: snapshot.Bytes(),
   4344 		}
   4345 	}
   4346 
   4347 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4348 	err = awsRestxml_deserializeOpDocumentGetDNSSECOutput(&output, decoder)
   4349 	if err != nil {
   4350 		var snapshot bytes.Buffer
   4351 		io.Copy(&snapshot, ringBuffer)
   4352 		return out, metadata, &smithy.DeserializationError{
   4353 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4354 			Snapshot: snapshot.Bytes(),
   4355 		}
   4356 	}
   4357 
   4358 	return out, metadata, err
   4359 }
   4360 
   4361 func awsRestxml_deserializeOpErrorGetDNSSEC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4362 	var errorBuffer bytes.Buffer
   4363 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4364 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4365 	}
   4366 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4367 
   4368 	errorCode := "UnknownError"
   4369 	errorMessage := errorCode
   4370 
   4371 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4372 	if err != nil {
   4373 		return err
   4374 	}
   4375 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4376 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4377 	}
   4378 	if len(errorComponents.Code) != 0 {
   4379 		errorCode = errorComponents.Code
   4380 	}
   4381 	if len(errorComponents.Message) != 0 {
   4382 		errorMessage = errorComponents.Message
   4383 	}
   4384 	errorBody.Seek(0, io.SeekStart)
   4385 	switch {
   4386 	case strings.EqualFold("InvalidArgument", errorCode):
   4387 		return awsRestxml_deserializeErrorInvalidArgument(response, errorBody)
   4388 
   4389 	case strings.EqualFold("InvalidInput", errorCode):
   4390 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4391 
   4392 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   4393 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   4394 
   4395 	default:
   4396 		genericError := &smithy.GenericAPIError{
   4397 			Code:    errorCode,
   4398 			Message: errorMessage,
   4399 		}
   4400 		return genericError
   4401 
   4402 	}
   4403 }
   4404 
   4405 func awsRestxml_deserializeOpDocumentGetDNSSECOutput(v **GetDNSSECOutput, decoder smithyxml.NodeDecoder) error {
   4406 	if v == nil {
   4407 		return fmt.Errorf("unexpected nil of type %T", v)
   4408 	}
   4409 	var sv *GetDNSSECOutput
   4410 	if *v == nil {
   4411 		sv = &GetDNSSECOutput{}
   4412 	} else {
   4413 		sv = *v
   4414 	}
   4415 
   4416 	for {
   4417 		t, done, err := decoder.Token()
   4418 		if err != nil {
   4419 			return err
   4420 		}
   4421 		if done {
   4422 			break
   4423 		}
   4424 		originalDecoder := decoder
   4425 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4426 		switch {
   4427 		case strings.EqualFold("KeySigningKeys", t.Name.Local):
   4428 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4429 			if err := awsRestxml_deserializeDocumentKeySigningKeys(&sv.KeySigningKeys, nodeDecoder); err != nil {
   4430 				return err
   4431 			}
   4432 
   4433 		case strings.EqualFold("Status", t.Name.Local):
   4434 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4435 			if err := awsRestxml_deserializeDocumentDNSSECStatus(&sv.Status, nodeDecoder); err != nil {
   4436 				return err
   4437 			}
   4438 
   4439 		default:
   4440 			// Do nothing and ignore the unexpected tag element
   4441 			err = decoder.Decoder.Skip()
   4442 			if err != nil {
   4443 				return err
   4444 			}
   4445 
   4446 		}
   4447 		decoder = originalDecoder
   4448 	}
   4449 	*v = sv
   4450 	return nil
   4451 }
   4452 
   4453 type awsRestxml_deserializeOpGetGeoLocation struct {
   4454 }
   4455 
   4456 func (*awsRestxml_deserializeOpGetGeoLocation) ID() string {
   4457 	return "OperationDeserializer"
   4458 }
   4459 
   4460 func (m *awsRestxml_deserializeOpGetGeoLocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4461 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4462 ) {
   4463 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4464 	if err != nil {
   4465 		return out, metadata, err
   4466 	}
   4467 
   4468 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4469 	if !ok {
   4470 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4471 	}
   4472 
   4473 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4474 		return out, metadata, awsRestxml_deserializeOpErrorGetGeoLocation(response, &metadata)
   4475 	}
   4476 	output := &GetGeoLocationOutput{}
   4477 	out.Result = output
   4478 
   4479 	var buff [1024]byte
   4480 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4481 	body := io.TeeReader(response.Body, ringBuffer)
   4482 	rootDecoder := xml.NewDecoder(body)
   4483 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4484 	if err == io.EOF {
   4485 		return out, metadata, nil
   4486 	}
   4487 	if err != nil {
   4488 		var snapshot bytes.Buffer
   4489 		io.Copy(&snapshot, ringBuffer)
   4490 		return out, metadata, &smithy.DeserializationError{
   4491 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4492 			Snapshot: snapshot.Bytes(),
   4493 		}
   4494 	}
   4495 
   4496 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4497 	err = awsRestxml_deserializeOpDocumentGetGeoLocationOutput(&output, decoder)
   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 	return out, metadata, err
   4508 }
   4509 
   4510 func awsRestxml_deserializeOpErrorGetGeoLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4511 	var errorBuffer bytes.Buffer
   4512 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4513 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4514 	}
   4515 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4516 
   4517 	errorCode := "UnknownError"
   4518 	errorMessage := errorCode
   4519 
   4520 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4521 	if err != nil {
   4522 		return err
   4523 	}
   4524 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4525 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4526 	}
   4527 	if len(errorComponents.Code) != 0 {
   4528 		errorCode = errorComponents.Code
   4529 	}
   4530 	if len(errorComponents.Message) != 0 {
   4531 		errorMessage = errorComponents.Message
   4532 	}
   4533 	errorBody.Seek(0, io.SeekStart)
   4534 	switch {
   4535 	case strings.EqualFold("InvalidInput", errorCode):
   4536 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4537 
   4538 	case strings.EqualFold("NoSuchGeoLocation", errorCode):
   4539 		return awsRestxml_deserializeErrorNoSuchGeoLocation(response, errorBody)
   4540 
   4541 	default:
   4542 		genericError := &smithy.GenericAPIError{
   4543 			Code:    errorCode,
   4544 			Message: errorMessage,
   4545 		}
   4546 		return genericError
   4547 
   4548 	}
   4549 }
   4550 
   4551 func awsRestxml_deserializeOpDocumentGetGeoLocationOutput(v **GetGeoLocationOutput, decoder smithyxml.NodeDecoder) error {
   4552 	if v == nil {
   4553 		return fmt.Errorf("unexpected nil of type %T", v)
   4554 	}
   4555 	var sv *GetGeoLocationOutput
   4556 	if *v == nil {
   4557 		sv = &GetGeoLocationOutput{}
   4558 	} else {
   4559 		sv = *v
   4560 	}
   4561 
   4562 	for {
   4563 		t, done, err := decoder.Token()
   4564 		if err != nil {
   4565 			return err
   4566 		}
   4567 		if done {
   4568 			break
   4569 		}
   4570 		originalDecoder := decoder
   4571 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4572 		switch {
   4573 		case strings.EqualFold("GeoLocationDetails", t.Name.Local):
   4574 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4575 			if err := awsRestxml_deserializeDocumentGeoLocationDetails(&sv.GeoLocationDetails, nodeDecoder); err != nil {
   4576 				return err
   4577 			}
   4578 
   4579 		default:
   4580 			// Do nothing and ignore the unexpected tag element
   4581 			err = decoder.Decoder.Skip()
   4582 			if err != nil {
   4583 				return err
   4584 			}
   4585 
   4586 		}
   4587 		decoder = originalDecoder
   4588 	}
   4589 	*v = sv
   4590 	return nil
   4591 }
   4592 
   4593 type awsRestxml_deserializeOpGetHealthCheck struct {
   4594 }
   4595 
   4596 func (*awsRestxml_deserializeOpGetHealthCheck) ID() string {
   4597 	return "OperationDeserializer"
   4598 }
   4599 
   4600 func (m *awsRestxml_deserializeOpGetHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4601 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4602 ) {
   4603 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4604 	if err != nil {
   4605 		return out, metadata, err
   4606 	}
   4607 
   4608 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4609 	if !ok {
   4610 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4611 	}
   4612 
   4613 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4614 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheck(response, &metadata)
   4615 	}
   4616 	output := &GetHealthCheckOutput{}
   4617 	out.Result = output
   4618 
   4619 	var buff [1024]byte
   4620 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4621 	body := io.TeeReader(response.Body, ringBuffer)
   4622 	rootDecoder := xml.NewDecoder(body)
   4623 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4624 	if err == io.EOF {
   4625 		return out, metadata, nil
   4626 	}
   4627 	if err != nil {
   4628 		var snapshot bytes.Buffer
   4629 		io.Copy(&snapshot, ringBuffer)
   4630 		return out, metadata, &smithy.DeserializationError{
   4631 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4632 			Snapshot: snapshot.Bytes(),
   4633 		}
   4634 	}
   4635 
   4636 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4637 	err = awsRestxml_deserializeOpDocumentGetHealthCheckOutput(&output, decoder)
   4638 	if err != nil {
   4639 		var snapshot bytes.Buffer
   4640 		io.Copy(&snapshot, ringBuffer)
   4641 		return out, metadata, &smithy.DeserializationError{
   4642 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4643 			Snapshot: snapshot.Bytes(),
   4644 		}
   4645 	}
   4646 
   4647 	return out, metadata, err
   4648 }
   4649 
   4650 func awsRestxml_deserializeOpErrorGetHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4651 	var errorBuffer bytes.Buffer
   4652 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4653 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4654 	}
   4655 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4656 
   4657 	errorCode := "UnknownError"
   4658 	errorMessage := errorCode
   4659 
   4660 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4661 	if err != nil {
   4662 		return err
   4663 	}
   4664 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4665 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4666 	}
   4667 	if len(errorComponents.Code) != 0 {
   4668 		errorCode = errorComponents.Code
   4669 	}
   4670 	if len(errorComponents.Message) != 0 {
   4671 		errorMessage = errorComponents.Message
   4672 	}
   4673 	errorBody.Seek(0, io.SeekStart)
   4674 	switch {
   4675 	case strings.EqualFold("IncompatibleVersion", errorCode):
   4676 		return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody)
   4677 
   4678 	case strings.EqualFold("InvalidInput", errorCode):
   4679 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4680 
   4681 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   4682 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   4683 
   4684 	default:
   4685 		genericError := &smithy.GenericAPIError{
   4686 			Code:    errorCode,
   4687 			Message: errorMessage,
   4688 		}
   4689 		return genericError
   4690 
   4691 	}
   4692 }
   4693 
   4694 func awsRestxml_deserializeOpDocumentGetHealthCheckOutput(v **GetHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
   4695 	if v == nil {
   4696 		return fmt.Errorf("unexpected nil of type %T", v)
   4697 	}
   4698 	var sv *GetHealthCheckOutput
   4699 	if *v == nil {
   4700 		sv = &GetHealthCheckOutput{}
   4701 	} else {
   4702 		sv = *v
   4703 	}
   4704 
   4705 	for {
   4706 		t, done, err := decoder.Token()
   4707 		if err != nil {
   4708 			return err
   4709 		}
   4710 		if done {
   4711 			break
   4712 		}
   4713 		originalDecoder := decoder
   4714 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4715 		switch {
   4716 		case strings.EqualFold("HealthCheck", t.Name.Local):
   4717 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   4718 			if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
   4719 				return err
   4720 			}
   4721 
   4722 		default:
   4723 			// Do nothing and ignore the unexpected tag element
   4724 			err = decoder.Decoder.Skip()
   4725 			if err != nil {
   4726 				return err
   4727 			}
   4728 
   4729 		}
   4730 		decoder = originalDecoder
   4731 	}
   4732 	*v = sv
   4733 	return nil
   4734 }
   4735 
   4736 type awsRestxml_deserializeOpGetHealthCheckCount struct {
   4737 }
   4738 
   4739 func (*awsRestxml_deserializeOpGetHealthCheckCount) ID() string {
   4740 	return "OperationDeserializer"
   4741 }
   4742 
   4743 func (m *awsRestxml_deserializeOpGetHealthCheckCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4744 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4745 ) {
   4746 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4747 	if err != nil {
   4748 		return out, metadata, err
   4749 	}
   4750 
   4751 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4752 	if !ok {
   4753 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4754 	}
   4755 
   4756 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4757 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckCount(response, &metadata)
   4758 	}
   4759 	output := &GetHealthCheckCountOutput{}
   4760 	out.Result = output
   4761 
   4762 	var buff [1024]byte
   4763 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4764 	body := io.TeeReader(response.Body, ringBuffer)
   4765 	rootDecoder := xml.NewDecoder(body)
   4766 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4767 	if err == io.EOF {
   4768 		return out, metadata, nil
   4769 	}
   4770 	if err != nil {
   4771 		var snapshot bytes.Buffer
   4772 		io.Copy(&snapshot, ringBuffer)
   4773 		return out, metadata, &smithy.DeserializationError{
   4774 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4775 			Snapshot: snapshot.Bytes(),
   4776 		}
   4777 	}
   4778 
   4779 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4780 	err = awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(&output, decoder)
   4781 	if err != nil {
   4782 		var snapshot bytes.Buffer
   4783 		io.Copy(&snapshot, ringBuffer)
   4784 		return out, metadata, &smithy.DeserializationError{
   4785 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4786 			Snapshot: snapshot.Bytes(),
   4787 		}
   4788 	}
   4789 
   4790 	return out, metadata, err
   4791 }
   4792 
   4793 func awsRestxml_deserializeOpErrorGetHealthCheckCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4794 	var errorBuffer bytes.Buffer
   4795 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4796 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4797 	}
   4798 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4799 
   4800 	errorCode := "UnknownError"
   4801 	errorMessage := errorCode
   4802 
   4803 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4804 	if err != nil {
   4805 		return err
   4806 	}
   4807 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4808 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4809 	}
   4810 	if len(errorComponents.Code) != 0 {
   4811 		errorCode = errorComponents.Code
   4812 	}
   4813 	if len(errorComponents.Message) != 0 {
   4814 		errorMessage = errorComponents.Message
   4815 	}
   4816 	errorBody.Seek(0, io.SeekStart)
   4817 	switch {
   4818 	default:
   4819 		genericError := &smithy.GenericAPIError{
   4820 			Code:    errorCode,
   4821 			Message: errorMessage,
   4822 		}
   4823 		return genericError
   4824 
   4825 	}
   4826 }
   4827 
   4828 func awsRestxml_deserializeOpDocumentGetHealthCheckCountOutput(v **GetHealthCheckCountOutput, decoder smithyxml.NodeDecoder) error {
   4829 	if v == nil {
   4830 		return fmt.Errorf("unexpected nil of type %T", v)
   4831 	}
   4832 	var sv *GetHealthCheckCountOutput
   4833 	if *v == nil {
   4834 		sv = &GetHealthCheckCountOutput{}
   4835 	} else {
   4836 		sv = *v
   4837 	}
   4838 
   4839 	for {
   4840 		t, done, err := decoder.Token()
   4841 		if err != nil {
   4842 			return err
   4843 		}
   4844 		if done {
   4845 			break
   4846 		}
   4847 		originalDecoder := decoder
   4848 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   4849 		switch {
   4850 		case strings.EqualFold("HealthCheckCount", t.Name.Local):
   4851 			val, err := decoder.Value()
   4852 			if err != nil {
   4853 				return err
   4854 			}
   4855 			if val == nil {
   4856 				break
   4857 			}
   4858 			{
   4859 				xtv := string(val)
   4860 				i64, err := strconv.ParseInt(xtv, 10, 64)
   4861 				if err != nil {
   4862 					return err
   4863 				}
   4864 				sv.HealthCheckCount = ptr.Int64(i64)
   4865 			}
   4866 
   4867 		default:
   4868 			// Do nothing and ignore the unexpected tag element
   4869 			err = decoder.Decoder.Skip()
   4870 			if err != nil {
   4871 				return err
   4872 			}
   4873 
   4874 		}
   4875 		decoder = originalDecoder
   4876 	}
   4877 	*v = sv
   4878 	return nil
   4879 }
   4880 
   4881 type awsRestxml_deserializeOpGetHealthCheckLastFailureReason struct {
   4882 }
   4883 
   4884 func (*awsRestxml_deserializeOpGetHealthCheckLastFailureReason) ID() string {
   4885 	return "OperationDeserializer"
   4886 }
   4887 
   4888 func (m *awsRestxml_deserializeOpGetHealthCheckLastFailureReason) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   4889 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   4890 ) {
   4891 	out, metadata, err = next.HandleDeserialize(ctx, in)
   4892 	if err != nil {
   4893 		return out, metadata, err
   4894 	}
   4895 
   4896 	response, ok := out.RawResponse.(*smithyhttp.Response)
   4897 	if !ok {
   4898 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   4899 	}
   4900 
   4901 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   4902 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response, &metadata)
   4903 	}
   4904 	output := &GetHealthCheckLastFailureReasonOutput{}
   4905 	out.Result = output
   4906 
   4907 	var buff [1024]byte
   4908 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   4909 	body := io.TeeReader(response.Body, ringBuffer)
   4910 	rootDecoder := xml.NewDecoder(body)
   4911 	t, err := smithyxml.FetchRootElement(rootDecoder)
   4912 	if err == io.EOF {
   4913 		return out, metadata, nil
   4914 	}
   4915 	if err != nil {
   4916 		var snapshot bytes.Buffer
   4917 		io.Copy(&snapshot, ringBuffer)
   4918 		return out, metadata, &smithy.DeserializationError{
   4919 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4920 			Snapshot: snapshot.Bytes(),
   4921 		}
   4922 	}
   4923 
   4924 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   4925 	err = awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(&output, decoder)
   4926 	if err != nil {
   4927 		var snapshot bytes.Buffer
   4928 		io.Copy(&snapshot, ringBuffer)
   4929 		return out, metadata, &smithy.DeserializationError{
   4930 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   4931 			Snapshot: snapshot.Bytes(),
   4932 		}
   4933 	}
   4934 
   4935 	return out, metadata, err
   4936 }
   4937 
   4938 func awsRestxml_deserializeOpErrorGetHealthCheckLastFailureReason(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   4939 	var errorBuffer bytes.Buffer
   4940 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   4941 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   4942 	}
   4943 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   4944 
   4945 	errorCode := "UnknownError"
   4946 	errorMessage := errorCode
   4947 
   4948 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   4949 	if err != nil {
   4950 		return err
   4951 	}
   4952 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   4953 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   4954 	}
   4955 	if len(errorComponents.Code) != 0 {
   4956 		errorCode = errorComponents.Code
   4957 	}
   4958 	if len(errorComponents.Message) != 0 {
   4959 		errorMessage = errorComponents.Message
   4960 	}
   4961 	errorBody.Seek(0, io.SeekStart)
   4962 	switch {
   4963 	case strings.EqualFold("InvalidInput", errorCode):
   4964 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   4965 
   4966 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   4967 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   4968 
   4969 	default:
   4970 		genericError := &smithy.GenericAPIError{
   4971 			Code:    errorCode,
   4972 			Message: errorMessage,
   4973 		}
   4974 		return genericError
   4975 
   4976 	}
   4977 }
   4978 
   4979 func awsRestxml_deserializeOpDocumentGetHealthCheckLastFailureReasonOutput(v **GetHealthCheckLastFailureReasonOutput, decoder smithyxml.NodeDecoder) error {
   4980 	if v == nil {
   4981 		return fmt.Errorf("unexpected nil of type %T", v)
   4982 	}
   4983 	var sv *GetHealthCheckLastFailureReasonOutput
   4984 	if *v == nil {
   4985 		sv = &GetHealthCheckLastFailureReasonOutput{}
   4986 	} else {
   4987 		sv = *v
   4988 	}
   4989 
   4990 	for {
   4991 		t, done, err := decoder.Token()
   4992 		if err != nil {
   4993 			return err
   4994 		}
   4995 		if done {
   4996 			break
   4997 		}
   4998 		originalDecoder := decoder
   4999 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5000 		switch {
   5001 		case strings.EqualFold("HealthCheckObservations", t.Name.Local):
   5002 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5003 			if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil {
   5004 				return err
   5005 			}
   5006 
   5007 		default:
   5008 			// Do nothing and ignore the unexpected tag element
   5009 			err = decoder.Decoder.Skip()
   5010 			if err != nil {
   5011 				return err
   5012 			}
   5013 
   5014 		}
   5015 		decoder = originalDecoder
   5016 	}
   5017 	*v = sv
   5018 	return nil
   5019 }
   5020 
   5021 type awsRestxml_deserializeOpGetHealthCheckStatus struct {
   5022 }
   5023 
   5024 func (*awsRestxml_deserializeOpGetHealthCheckStatus) ID() string {
   5025 	return "OperationDeserializer"
   5026 }
   5027 
   5028 func (m *awsRestxml_deserializeOpGetHealthCheckStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5029 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5030 ) {
   5031 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5032 	if err != nil {
   5033 		return out, metadata, err
   5034 	}
   5035 
   5036 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5037 	if !ok {
   5038 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5039 	}
   5040 
   5041 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5042 		return out, metadata, awsRestxml_deserializeOpErrorGetHealthCheckStatus(response, &metadata)
   5043 	}
   5044 	output := &GetHealthCheckStatusOutput{}
   5045 	out.Result = output
   5046 
   5047 	var buff [1024]byte
   5048 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5049 	body := io.TeeReader(response.Body, ringBuffer)
   5050 	rootDecoder := xml.NewDecoder(body)
   5051 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5052 	if err == io.EOF {
   5053 		return out, metadata, nil
   5054 	}
   5055 	if err != nil {
   5056 		var snapshot bytes.Buffer
   5057 		io.Copy(&snapshot, ringBuffer)
   5058 		return out, metadata, &smithy.DeserializationError{
   5059 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5060 			Snapshot: snapshot.Bytes(),
   5061 		}
   5062 	}
   5063 
   5064 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5065 	err = awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(&output, decoder)
   5066 	if err != nil {
   5067 		var snapshot bytes.Buffer
   5068 		io.Copy(&snapshot, ringBuffer)
   5069 		return out, metadata, &smithy.DeserializationError{
   5070 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5071 			Snapshot: snapshot.Bytes(),
   5072 		}
   5073 	}
   5074 
   5075 	return out, metadata, err
   5076 }
   5077 
   5078 func awsRestxml_deserializeOpErrorGetHealthCheckStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5079 	var errorBuffer bytes.Buffer
   5080 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5081 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5082 	}
   5083 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5084 
   5085 	errorCode := "UnknownError"
   5086 	errorMessage := errorCode
   5087 
   5088 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5089 	if err != nil {
   5090 		return err
   5091 	}
   5092 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5093 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5094 	}
   5095 	if len(errorComponents.Code) != 0 {
   5096 		errorCode = errorComponents.Code
   5097 	}
   5098 	if len(errorComponents.Message) != 0 {
   5099 		errorMessage = errorComponents.Message
   5100 	}
   5101 	errorBody.Seek(0, io.SeekStart)
   5102 	switch {
   5103 	case strings.EqualFold("InvalidInput", errorCode):
   5104 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5105 
   5106 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   5107 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   5108 
   5109 	default:
   5110 		genericError := &smithy.GenericAPIError{
   5111 			Code:    errorCode,
   5112 			Message: errorMessage,
   5113 		}
   5114 		return genericError
   5115 
   5116 	}
   5117 }
   5118 
   5119 func awsRestxml_deserializeOpDocumentGetHealthCheckStatusOutput(v **GetHealthCheckStatusOutput, decoder smithyxml.NodeDecoder) error {
   5120 	if v == nil {
   5121 		return fmt.Errorf("unexpected nil of type %T", v)
   5122 	}
   5123 	var sv *GetHealthCheckStatusOutput
   5124 	if *v == nil {
   5125 		sv = &GetHealthCheckStatusOutput{}
   5126 	} else {
   5127 		sv = *v
   5128 	}
   5129 
   5130 	for {
   5131 		t, done, err := decoder.Token()
   5132 		if err != nil {
   5133 			return err
   5134 		}
   5135 		if done {
   5136 			break
   5137 		}
   5138 		originalDecoder := decoder
   5139 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5140 		switch {
   5141 		case strings.EqualFold("HealthCheckObservations", t.Name.Local):
   5142 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5143 			if err := awsRestxml_deserializeDocumentHealthCheckObservations(&sv.HealthCheckObservations, nodeDecoder); err != nil {
   5144 				return err
   5145 			}
   5146 
   5147 		default:
   5148 			// Do nothing and ignore the unexpected tag element
   5149 			err = decoder.Decoder.Skip()
   5150 			if err != nil {
   5151 				return err
   5152 			}
   5153 
   5154 		}
   5155 		decoder = originalDecoder
   5156 	}
   5157 	*v = sv
   5158 	return nil
   5159 }
   5160 
   5161 type awsRestxml_deserializeOpGetHostedZone struct {
   5162 }
   5163 
   5164 func (*awsRestxml_deserializeOpGetHostedZone) ID() string {
   5165 	return "OperationDeserializer"
   5166 }
   5167 
   5168 func (m *awsRestxml_deserializeOpGetHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5169 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5170 ) {
   5171 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5172 	if err != nil {
   5173 		return out, metadata, err
   5174 	}
   5175 
   5176 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5177 	if !ok {
   5178 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5179 	}
   5180 
   5181 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5182 		return out, metadata, awsRestxml_deserializeOpErrorGetHostedZone(response, &metadata)
   5183 	}
   5184 	output := &GetHostedZoneOutput{}
   5185 	out.Result = output
   5186 
   5187 	var buff [1024]byte
   5188 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5189 	body := io.TeeReader(response.Body, ringBuffer)
   5190 	rootDecoder := xml.NewDecoder(body)
   5191 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5192 	if err == io.EOF {
   5193 		return out, metadata, nil
   5194 	}
   5195 	if err != nil {
   5196 		var snapshot bytes.Buffer
   5197 		io.Copy(&snapshot, ringBuffer)
   5198 		return out, metadata, &smithy.DeserializationError{
   5199 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5200 			Snapshot: snapshot.Bytes(),
   5201 		}
   5202 	}
   5203 
   5204 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5205 	err = awsRestxml_deserializeOpDocumentGetHostedZoneOutput(&output, decoder)
   5206 	if err != nil {
   5207 		var snapshot bytes.Buffer
   5208 		io.Copy(&snapshot, ringBuffer)
   5209 		return out, metadata, &smithy.DeserializationError{
   5210 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5211 			Snapshot: snapshot.Bytes(),
   5212 		}
   5213 	}
   5214 
   5215 	return out, metadata, err
   5216 }
   5217 
   5218 func awsRestxml_deserializeOpErrorGetHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5219 	var errorBuffer bytes.Buffer
   5220 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5221 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5222 	}
   5223 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5224 
   5225 	errorCode := "UnknownError"
   5226 	errorMessage := errorCode
   5227 
   5228 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5229 	if err != nil {
   5230 		return err
   5231 	}
   5232 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5233 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5234 	}
   5235 	if len(errorComponents.Code) != 0 {
   5236 		errorCode = errorComponents.Code
   5237 	}
   5238 	if len(errorComponents.Message) != 0 {
   5239 		errorMessage = errorComponents.Message
   5240 	}
   5241 	errorBody.Seek(0, io.SeekStart)
   5242 	switch {
   5243 	case strings.EqualFold("InvalidInput", errorCode):
   5244 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5245 
   5246 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   5247 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   5248 
   5249 	default:
   5250 		genericError := &smithy.GenericAPIError{
   5251 			Code:    errorCode,
   5252 			Message: errorMessage,
   5253 		}
   5254 		return genericError
   5255 
   5256 	}
   5257 }
   5258 
   5259 func awsRestxml_deserializeOpDocumentGetHostedZoneOutput(v **GetHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   5260 	if v == nil {
   5261 		return fmt.Errorf("unexpected nil of type %T", v)
   5262 	}
   5263 	var sv *GetHostedZoneOutput
   5264 	if *v == nil {
   5265 		sv = &GetHostedZoneOutput{}
   5266 	} else {
   5267 		sv = *v
   5268 	}
   5269 
   5270 	for {
   5271 		t, done, err := decoder.Token()
   5272 		if err != nil {
   5273 			return err
   5274 		}
   5275 		if done {
   5276 			break
   5277 		}
   5278 		originalDecoder := decoder
   5279 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5280 		switch {
   5281 		case strings.EqualFold("DelegationSet", t.Name.Local):
   5282 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5283 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   5284 				return err
   5285 			}
   5286 
   5287 		case strings.EqualFold("HostedZone", t.Name.Local):
   5288 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5289 			if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
   5290 				return err
   5291 			}
   5292 
   5293 		case strings.EqualFold("VPCs", t.Name.Local):
   5294 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5295 			if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil {
   5296 				return err
   5297 			}
   5298 
   5299 		default:
   5300 			// Do nothing and ignore the unexpected tag element
   5301 			err = decoder.Decoder.Skip()
   5302 			if err != nil {
   5303 				return err
   5304 			}
   5305 
   5306 		}
   5307 		decoder = originalDecoder
   5308 	}
   5309 	*v = sv
   5310 	return nil
   5311 }
   5312 
   5313 type awsRestxml_deserializeOpGetHostedZoneCount struct {
   5314 }
   5315 
   5316 func (*awsRestxml_deserializeOpGetHostedZoneCount) ID() string {
   5317 	return "OperationDeserializer"
   5318 }
   5319 
   5320 func (m *awsRestxml_deserializeOpGetHostedZoneCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5321 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5322 ) {
   5323 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5324 	if err != nil {
   5325 		return out, metadata, err
   5326 	}
   5327 
   5328 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5329 	if !ok {
   5330 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5331 	}
   5332 
   5333 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5334 		return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneCount(response, &metadata)
   5335 	}
   5336 	output := &GetHostedZoneCountOutput{}
   5337 	out.Result = output
   5338 
   5339 	var buff [1024]byte
   5340 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5341 	body := io.TeeReader(response.Body, ringBuffer)
   5342 	rootDecoder := xml.NewDecoder(body)
   5343 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5344 	if err == io.EOF {
   5345 		return out, metadata, nil
   5346 	}
   5347 	if err != nil {
   5348 		var snapshot bytes.Buffer
   5349 		io.Copy(&snapshot, ringBuffer)
   5350 		return out, metadata, &smithy.DeserializationError{
   5351 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5352 			Snapshot: snapshot.Bytes(),
   5353 		}
   5354 	}
   5355 
   5356 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5357 	err = awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(&output, decoder)
   5358 	if err != nil {
   5359 		var snapshot bytes.Buffer
   5360 		io.Copy(&snapshot, ringBuffer)
   5361 		return out, metadata, &smithy.DeserializationError{
   5362 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5363 			Snapshot: snapshot.Bytes(),
   5364 		}
   5365 	}
   5366 
   5367 	return out, metadata, err
   5368 }
   5369 
   5370 func awsRestxml_deserializeOpErrorGetHostedZoneCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5371 	var errorBuffer bytes.Buffer
   5372 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5373 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5374 	}
   5375 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5376 
   5377 	errorCode := "UnknownError"
   5378 	errorMessage := errorCode
   5379 
   5380 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5381 	if err != nil {
   5382 		return err
   5383 	}
   5384 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5385 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5386 	}
   5387 	if len(errorComponents.Code) != 0 {
   5388 		errorCode = errorComponents.Code
   5389 	}
   5390 	if len(errorComponents.Message) != 0 {
   5391 		errorMessage = errorComponents.Message
   5392 	}
   5393 	errorBody.Seek(0, io.SeekStart)
   5394 	switch {
   5395 	case strings.EqualFold("InvalidInput", errorCode):
   5396 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5397 
   5398 	default:
   5399 		genericError := &smithy.GenericAPIError{
   5400 			Code:    errorCode,
   5401 			Message: errorMessage,
   5402 		}
   5403 		return genericError
   5404 
   5405 	}
   5406 }
   5407 
   5408 func awsRestxml_deserializeOpDocumentGetHostedZoneCountOutput(v **GetHostedZoneCountOutput, decoder smithyxml.NodeDecoder) error {
   5409 	if v == nil {
   5410 		return fmt.Errorf("unexpected nil of type %T", v)
   5411 	}
   5412 	var sv *GetHostedZoneCountOutput
   5413 	if *v == nil {
   5414 		sv = &GetHostedZoneCountOutput{}
   5415 	} else {
   5416 		sv = *v
   5417 	}
   5418 
   5419 	for {
   5420 		t, done, err := decoder.Token()
   5421 		if err != nil {
   5422 			return err
   5423 		}
   5424 		if done {
   5425 			break
   5426 		}
   5427 		originalDecoder := decoder
   5428 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5429 		switch {
   5430 		case strings.EqualFold("HostedZoneCount", t.Name.Local):
   5431 			val, err := decoder.Value()
   5432 			if err != nil {
   5433 				return err
   5434 			}
   5435 			if val == nil {
   5436 				break
   5437 			}
   5438 			{
   5439 				xtv := string(val)
   5440 				i64, err := strconv.ParseInt(xtv, 10, 64)
   5441 				if err != nil {
   5442 					return err
   5443 				}
   5444 				sv.HostedZoneCount = ptr.Int64(i64)
   5445 			}
   5446 
   5447 		default:
   5448 			// Do nothing and ignore the unexpected tag element
   5449 			err = decoder.Decoder.Skip()
   5450 			if err != nil {
   5451 				return err
   5452 			}
   5453 
   5454 		}
   5455 		decoder = originalDecoder
   5456 	}
   5457 	*v = sv
   5458 	return nil
   5459 }
   5460 
   5461 type awsRestxml_deserializeOpGetHostedZoneLimit struct {
   5462 }
   5463 
   5464 func (*awsRestxml_deserializeOpGetHostedZoneLimit) ID() string {
   5465 	return "OperationDeserializer"
   5466 }
   5467 
   5468 func (m *awsRestxml_deserializeOpGetHostedZoneLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5469 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5470 ) {
   5471 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5472 	if err != nil {
   5473 		return out, metadata, err
   5474 	}
   5475 
   5476 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5477 	if !ok {
   5478 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5479 	}
   5480 
   5481 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5482 		return out, metadata, awsRestxml_deserializeOpErrorGetHostedZoneLimit(response, &metadata)
   5483 	}
   5484 	output := &GetHostedZoneLimitOutput{}
   5485 	out.Result = output
   5486 
   5487 	var buff [1024]byte
   5488 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5489 	body := io.TeeReader(response.Body, ringBuffer)
   5490 	rootDecoder := xml.NewDecoder(body)
   5491 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5492 	if err == io.EOF {
   5493 		return out, metadata, nil
   5494 	}
   5495 	if err != nil {
   5496 		var snapshot bytes.Buffer
   5497 		io.Copy(&snapshot, ringBuffer)
   5498 		return out, metadata, &smithy.DeserializationError{
   5499 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5500 			Snapshot: snapshot.Bytes(),
   5501 		}
   5502 	}
   5503 
   5504 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5505 	err = awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(&output, decoder)
   5506 	if err != nil {
   5507 		var snapshot bytes.Buffer
   5508 		io.Copy(&snapshot, ringBuffer)
   5509 		return out, metadata, &smithy.DeserializationError{
   5510 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5511 			Snapshot: snapshot.Bytes(),
   5512 		}
   5513 	}
   5514 
   5515 	return out, metadata, err
   5516 }
   5517 
   5518 func awsRestxml_deserializeOpErrorGetHostedZoneLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5519 	var errorBuffer bytes.Buffer
   5520 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5521 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5522 	}
   5523 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5524 
   5525 	errorCode := "UnknownError"
   5526 	errorMessage := errorCode
   5527 
   5528 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5529 	if err != nil {
   5530 		return err
   5531 	}
   5532 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5533 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5534 	}
   5535 	if len(errorComponents.Code) != 0 {
   5536 		errorCode = errorComponents.Code
   5537 	}
   5538 	if len(errorComponents.Message) != 0 {
   5539 		errorMessage = errorComponents.Message
   5540 	}
   5541 	errorBody.Seek(0, io.SeekStart)
   5542 	switch {
   5543 	case strings.EqualFold("HostedZoneNotPrivate", errorCode):
   5544 		return awsRestxml_deserializeErrorHostedZoneNotPrivate(response, errorBody)
   5545 
   5546 	case strings.EqualFold("InvalidInput", errorCode):
   5547 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5548 
   5549 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   5550 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   5551 
   5552 	default:
   5553 		genericError := &smithy.GenericAPIError{
   5554 			Code:    errorCode,
   5555 			Message: errorMessage,
   5556 		}
   5557 		return genericError
   5558 
   5559 	}
   5560 }
   5561 
   5562 func awsRestxml_deserializeOpDocumentGetHostedZoneLimitOutput(v **GetHostedZoneLimitOutput, decoder smithyxml.NodeDecoder) error {
   5563 	if v == nil {
   5564 		return fmt.Errorf("unexpected nil of type %T", v)
   5565 	}
   5566 	var sv *GetHostedZoneLimitOutput
   5567 	if *v == nil {
   5568 		sv = &GetHostedZoneLimitOutput{}
   5569 	} else {
   5570 		sv = *v
   5571 	}
   5572 
   5573 	for {
   5574 		t, done, err := decoder.Token()
   5575 		if err != nil {
   5576 			return err
   5577 		}
   5578 		if done {
   5579 			break
   5580 		}
   5581 		originalDecoder := decoder
   5582 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5583 		switch {
   5584 		case strings.EqualFold("Count", t.Name.Local):
   5585 			val, err := decoder.Value()
   5586 			if err != nil {
   5587 				return err
   5588 			}
   5589 			if val == nil {
   5590 				break
   5591 			}
   5592 			{
   5593 				xtv := string(val)
   5594 				i64, err := strconv.ParseInt(xtv, 10, 64)
   5595 				if err != nil {
   5596 					return err
   5597 				}
   5598 				sv.Count = i64
   5599 			}
   5600 
   5601 		case strings.EqualFold("Limit", t.Name.Local):
   5602 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5603 			if err := awsRestxml_deserializeDocumentHostedZoneLimit(&sv.Limit, nodeDecoder); err != nil {
   5604 				return err
   5605 			}
   5606 
   5607 		default:
   5608 			// Do nothing and ignore the unexpected tag element
   5609 			err = decoder.Decoder.Skip()
   5610 			if err != nil {
   5611 				return err
   5612 			}
   5613 
   5614 		}
   5615 		decoder = originalDecoder
   5616 	}
   5617 	*v = sv
   5618 	return nil
   5619 }
   5620 
   5621 type awsRestxml_deserializeOpGetQueryLoggingConfig struct {
   5622 }
   5623 
   5624 func (*awsRestxml_deserializeOpGetQueryLoggingConfig) ID() string {
   5625 	return "OperationDeserializer"
   5626 }
   5627 
   5628 func (m *awsRestxml_deserializeOpGetQueryLoggingConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5629 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5630 ) {
   5631 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5632 	if err != nil {
   5633 		return out, metadata, err
   5634 	}
   5635 
   5636 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5637 	if !ok {
   5638 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5639 	}
   5640 
   5641 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5642 		return out, metadata, awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response, &metadata)
   5643 	}
   5644 	output := &GetQueryLoggingConfigOutput{}
   5645 	out.Result = output
   5646 
   5647 	var buff [1024]byte
   5648 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5649 	body := io.TeeReader(response.Body, ringBuffer)
   5650 	rootDecoder := xml.NewDecoder(body)
   5651 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5652 	if err == io.EOF {
   5653 		return out, metadata, nil
   5654 	}
   5655 	if err != nil {
   5656 		var snapshot bytes.Buffer
   5657 		io.Copy(&snapshot, ringBuffer)
   5658 		return out, metadata, &smithy.DeserializationError{
   5659 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5660 			Snapshot: snapshot.Bytes(),
   5661 		}
   5662 	}
   5663 
   5664 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5665 	err = awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(&output, decoder)
   5666 	if err != nil {
   5667 		var snapshot bytes.Buffer
   5668 		io.Copy(&snapshot, ringBuffer)
   5669 		return out, metadata, &smithy.DeserializationError{
   5670 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5671 			Snapshot: snapshot.Bytes(),
   5672 		}
   5673 	}
   5674 
   5675 	return out, metadata, err
   5676 }
   5677 
   5678 func awsRestxml_deserializeOpErrorGetQueryLoggingConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5679 	var errorBuffer bytes.Buffer
   5680 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5681 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5682 	}
   5683 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5684 
   5685 	errorCode := "UnknownError"
   5686 	errorMessage := errorCode
   5687 
   5688 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5689 	if err != nil {
   5690 		return err
   5691 	}
   5692 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5693 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5694 	}
   5695 	if len(errorComponents.Code) != 0 {
   5696 		errorCode = errorComponents.Code
   5697 	}
   5698 	if len(errorComponents.Message) != 0 {
   5699 		errorMessage = errorComponents.Message
   5700 	}
   5701 	errorBody.Seek(0, io.SeekStart)
   5702 	switch {
   5703 	case strings.EqualFold("InvalidInput", errorCode):
   5704 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5705 
   5706 	case strings.EqualFold("NoSuchQueryLoggingConfig", errorCode):
   5707 		return awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response, errorBody)
   5708 
   5709 	default:
   5710 		genericError := &smithy.GenericAPIError{
   5711 			Code:    errorCode,
   5712 			Message: errorMessage,
   5713 		}
   5714 		return genericError
   5715 
   5716 	}
   5717 }
   5718 
   5719 func awsRestxml_deserializeOpDocumentGetQueryLoggingConfigOutput(v **GetQueryLoggingConfigOutput, decoder smithyxml.NodeDecoder) error {
   5720 	if v == nil {
   5721 		return fmt.Errorf("unexpected nil of type %T", v)
   5722 	}
   5723 	var sv *GetQueryLoggingConfigOutput
   5724 	if *v == nil {
   5725 		sv = &GetQueryLoggingConfigOutput{}
   5726 	} else {
   5727 		sv = *v
   5728 	}
   5729 
   5730 	for {
   5731 		t, done, err := decoder.Token()
   5732 		if err != nil {
   5733 			return err
   5734 		}
   5735 		if done {
   5736 			break
   5737 		}
   5738 		originalDecoder := decoder
   5739 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5740 		switch {
   5741 		case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
   5742 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5743 			if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&sv.QueryLoggingConfig, nodeDecoder); err != nil {
   5744 				return err
   5745 			}
   5746 
   5747 		default:
   5748 			// Do nothing and ignore the unexpected tag element
   5749 			err = decoder.Decoder.Skip()
   5750 			if err != nil {
   5751 				return err
   5752 			}
   5753 
   5754 		}
   5755 		decoder = originalDecoder
   5756 	}
   5757 	*v = sv
   5758 	return nil
   5759 }
   5760 
   5761 type awsRestxml_deserializeOpGetReusableDelegationSet struct {
   5762 }
   5763 
   5764 func (*awsRestxml_deserializeOpGetReusableDelegationSet) ID() string {
   5765 	return "OperationDeserializer"
   5766 }
   5767 
   5768 func (m *awsRestxml_deserializeOpGetReusableDelegationSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5769 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5770 ) {
   5771 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5772 	if err != nil {
   5773 		return out, metadata, err
   5774 	}
   5775 
   5776 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5777 	if !ok {
   5778 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5779 	}
   5780 
   5781 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5782 		return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSet(response, &metadata)
   5783 	}
   5784 	output := &GetReusableDelegationSetOutput{}
   5785 	out.Result = output
   5786 
   5787 	var buff [1024]byte
   5788 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5789 	body := io.TeeReader(response.Body, ringBuffer)
   5790 	rootDecoder := xml.NewDecoder(body)
   5791 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5792 	if err == io.EOF {
   5793 		return out, metadata, nil
   5794 	}
   5795 	if err != nil {
   5796 		var snapshot bytes.Buffer
   5797 		io.Copy(&snapshot, ringBuffer)
   5798 		return out, metadata, &smithy.DeserializationError{
   5799 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5800 			Snapshot: snapshot.Bytes(),
   5801 		}
   5802 	}
   5803 
   5804 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5805 	err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(&output, decoder)
   5806 	if err != nil {
   5807 		var snapshot bytes.Buffer
   5808 		io.Copy(&snapshot, ringBuffer)
   5809 		return out, metadata, &smithy.DeserializationError{
   5810 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5811 			Snapshot: snapshot.Bytes(),
   5812 		}
   5813 	}
   5814 
   5815 	return out, metadata, err
   5816 }
   5817 
   5818 func awsRestxml_deserializeOpErrorGetReusableDelegationSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5819 	var errorBuffer bytes.Buffer
   5820 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5821 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5822 	}
   5823 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5824 
   5825 	errorCode := "UnknownError"
   5826 	errorMessage := errorCode
   5827 
   5828 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5829 	if err != nil {
   5830 		return err
   5831 	}
   5832 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5833 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5834 	}
   5835 	if len(errorComponents.Code) != 0 {
   5836 		errorCode = errorComponents.Code
   5837 	}
   5838 	if len(errorComponents.Message) != 0 {
   5839 		errorMessage = errorComponents.Message
   5840 	}
   5841 	errorBody.Seek(0, io.SeekStart)
   5842 	switch {
   5843 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   5844 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   5845 
   5846 	case strings.EqualFold("InvalidInput", errorCode):
   5847 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5848 
   5849 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   5850 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   5851 
   5852 	default:
   5853 		genericError := &smithy.GenericAPIError{
   5854 			Code:    errorCode,
   5855 			Message: errorMessage,
   5856 		}
   5857 		return genericError
   5858 
   5859 	}
   5860 }
   5861 
   5862 func awsRestxml_deserializeOpDocumentGetReusableDelegationSetOutput(v **GetReusableDelegationSetOutput, decoder smithyxml.NodeDecoder) error {
   5863 	if v == nil {
   5864 		return fmt.Errorf("unexpected nil of type %T", v)
   5865 	}
   5866 	var sv *GetReusableDelegationSetOutput
   5867 	if *v == nil {
   5868 		sv = &GetReusableDelegationSetOutput{}
   5869 	} else {
   5870 		sv = *v
   5871 	}
   5872 
   5873 	for {
   5874 		t, done, err := decoder.Token()
   5875 		if err != nil {
   5876 			return err
   5877 		}
   5878 		if done {
   5879 			break
   5880 		}
   5881 		originalDecoder := decoder
   5882 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   5883 		switch {
   5884 		case strings.EqualFold("DelegationSet", t.Name.Local):
   5885 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   5886 			if err := awsRestxml_deserializeDocumentDelegationSet(&sv.DelegationSet, nodeDecoder); err != nil {
   5887 				return err
   5888 			}
   5889 
   5890 		default:
   5891 			// Do nothing and ignore the unexpected tag element
   5892 			err = decoder.Decoder.Skip()
   5893 			if err != nil {
   5894 				return err
   5895 			}
   5896 
   5897 		}
   5898 		decoder = originalDecoder
   5899 	}
   5900 	*v = sv
   5901 	return nil
   5902 }
   5903 
   5904 type awsRestxml_deserializeOpGetReusableDelegationSetLimit struct {
   5905 }
   5906 
   5907 func (*awsRestxml_deserializeOpGetReusableDelegationSetLimit) ID() string {
   5908 	return "OperationDeserializer"
   5909 }
   5910 
   5911 func (m *awsRestxml_deserializeOpGetReusableDelegationSetLimit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   5912 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   5913 ) {
   5914 	out, metadata, err = next.HandleDeserialize(ctx, in)
   5915 	if err != nil {
   5916 		return out, metadata, err
   5917 	}
   5918 
   5919 	response, ok := out.RawResponse.(*smithyhttp.Response)
   5920 	if !ok {
   5921 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   5922 	}
   5923 
   5924 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   5925 		return out, metadata, awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response, &metadata)
   5926 	}
   5927 	output := &GetReusableDelegationSetLimitOutput{}
   5928 	out.Result = output
   5929 
   5930 	var buff [1024]byte
   5931 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   5932 	body := io.TeeReader(response.Body, ringBuffer)
   5933 	rootDecoder := xml.NewDecoder(body)
   5934 	t, err := smithyxml.FetchRootElement(rootDecoder)
   5935 	if err == io.EOF {
   5936 		return out, metadata, nil
   5937 	}
   5938 	if err != nil {
   5939 		var snapshot bytes.Buffer
   5940 		io.Copy(&snapshot, ringBuffer)
   5941 		return out, metadata, &smithy.DeserializationError{
   5942 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5943 			Snapshot: snapshot.Bytes(),
   5944 		}
   5945 	}
   5946 
   5947 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   5948 	err = awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(&output, decoder)
   5949 	if err != nil {
   5950 		var snapshot bytes.Buffer
   5951 		io.Copy(&snapshot, ringBuffer)
   5952 		return out, metadata, &smithy.DeserializationError{
   5953 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   5954 			Snapshot: snapshot.Bytes(),
   5955 		}
   5956 	}
   5957 
   5958 	return out, metadata, err
   5959 }
   5960 
   5961 func awsRestxml_deserializeOpErrorGetReusableDelegationSetLimit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   5962 	var errorBuffer bytes.Buffer
   5963 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   5964 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   5965 	}
   5966 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   5967 
   5968 	errorCode := "UnknownError"
   5969 	errorMessage := errorCode
   5970 
   5971 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   5972 	if err != nil {
   5973 		return err
   5974 	}
   5975 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   5976 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   5977 	}
   5978 	if len(errorComponents.Code) != 0 {
   5979 		errorCode = errorComponents.Code
   5980 	}
   5981 	if len(errorComponents.Message) != 0 {
   5982 		errorMessage = errorComponents.Message
   5983 	}
   5984 	errorBody.Seek(0, io.SeekStart)
   5985 	switch {
   5986 	case strings.EqualFold("InvalidInput", errorCode):
   5987 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   5988 
   5989 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   5990 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   5991 
   5992 	default:
   5993 		genericError := &smithy.GenericAPIError{
   5994 			Code:    errorCode,
   5995 			Message: errorMessage,
   5996 		}
   5997 		return genericError
   5998 
   5999 	}
   6000 }
   6001 
   6002 func awsRestxml_deserializeOpDocumentGetReusableDelegationSetLimitOutput(v **GetReusableDelegationSetLimitOutput, decoder smithyxml.NodeDecoder) error {
   6003 	if v == nil {
   6004 		return fmt.Errorf("unexpected nil of type %T", v)
   6005 	}
   6006 	var sv *GetReusableDelegationSetLimitOutput
   6007 	if *v == nil {
   6008 		sv = &GetReusableDelegationSetLimitOutput{}
   6009 	} else {
   6010 		sv = *v
   6011 	}
   6012 
   6013 	for {
   6014 		t, done, err := decoder.Token()
   6015 		if err != nil {
   6016 			return err
   6017 		}
   6018 		if done {
   6019 			break
   6020 		}
   6021 		originalDecoder := decoder
   6022 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6023 		switch {
   6024 		case strings.EqualFold("Count", t.Name.Local):
   6025 			val, err := decoder.Value()
   6026 			if err != nil {
   6027 				return err
   6028 			}
   6029 			if val == nil {
   6030 				break
   6031 			}
   6032 			{
   6033 				xtv := string(val)
   6034 				i64, err := strconv.ParseInt(xtv, 10, 64)
   6035 				if err != nil {
   6036 					return err
   6037 				}
   6038 				sv.Count = i64
   6039 			}
   6040 
   6041 		case strings.EqualFold("Limit", t.Name.Local):
   6042 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6043 			if err := awsRestxml_deserializeDocumentReusableDelegationSetLimit(&sv.Limit, nodeDecoder); err != nil {
   6044 				return err
   6045 			}
   6046 
   6047 		default:
   6048 			// Do nothing and ignore the unexpected tag element
   6049 			err = decoder.Decoder.Skip()
   6050 			if err != nil {
   6051 				return err
   6052 			}
   6053 
   6054 		}
   6055 		decoder = originalDecoder
   6056 	}
   6057 	*v = sv
   6058 	return nil
   6059 }
   6060 
   6061 type awsRestxml_deserializeOpGetTrafficPolicy struct {
   6062 }
   6063 
   6064 func (*awsRestxml_deserializeOpGetTrafficPolicy) ID() string {
   6065 	return "OperationDeserializer"
   6066 }
   6067 
   6068 func (m *awsRestxml_deserializeOpGetTrafficPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6069 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6070 ) {
   6071 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6072 	if err != nil {
   6073 		return out, metadata, err
   6074 	}
   6075 
   6076 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6077 	if !ok {
   6078 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6079 	}
   6080 
   6081 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6082 		return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicy(response, &metadata)
   6083 	}
   6084 	output := &GetTrafficPolicyOutput{}
   6085 	out.Result = output
   6086 
   6087 	var buff [1024]byte
   6088 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6089 	body := io.TeeReader(response.Body, ringBuffer)
   6090 	rootDecoder := xml.NewDecoder(body)
   6091 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6092 	if err == io.EOF {
   6093 		return out, metadata, nil
   6094 	}
   6095 	if err != nil {
   6096 		var snapshot bytes.Buffer
   6097 		io.Copy(&snapshot, ringBuffer)
   6098 		return out, metadata, &smithy.DeserializationError{
   6099 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6100 			Snapshot: snapshot.Bytes(),
   6101 		}
   6102 	}
   6103 
   6104 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6105 	err = awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(&output, decoder)
   6106 	if err != nil {
   6107 		var snapshot bytes.Buffer
   6108 		io.Copy(&snapshot, ringBuffer)
   6109 		return out, metadata, &smithy.DeserializationError{
   6110 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6111 			Snapshot: snapshot.Bytes(),
   6112 		}
   6113 	}
   6114 
   6115 	return out, metadata, err
   6116 }
   6117 
   6118 func awsRestxml_deserializeOpErrorGetTrafficPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6119 	var errorBuffer bytes.Buffer
   6120 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6121 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6122 	}
   6123 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6124 
   6125 	errorCode := "UnknownError"
   6126 	errorMessage := errorCode
   6127 
   6128 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6129 	if err != nil {
   6130 		return err
   6131 	}
   6132 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6133 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6134 	}
   6135 	if len(errorComponents.Code) != 0 {
   6136 		errorCode = errorComponents.Code
   6137 	}
   6138 	if len(errorComponents.Message) != 0 {
   6139 		errorMessage = errorComponents.Message
   6140 	}
   6141 	errorBody.Seek(0, io.SeekStart)
   6142 	switch {
   6143 	case strings.EqualFold("InvalidInput", errorCode):
   6144 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6145 
   6146 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   6147 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   6148 
   6149 	default:
   6150 		genericError := &smithy.GenericAPIError{
   6151 			Code:    errorCode,
   6152 			Message: errorMessage,
   6153 		}
   6154 		return genericError
   6155 
   6156 	}
   6157 }
   6158 
   6159 func awsRestxml_deserializeOpDocumentGetTrafficPolicyOutput(v **GetTrafficPolicyOutput, decoder smithyxml.NodeDecoder) error {
   6160 	if v == nil {
   6161 		return fmt.Errorf("unexpected nil of type %T", v)
   6162 	}
   6163 	var sv *GetTrafficPolicyOutput
   6164 	if *v == nil {
   6165 		sv = &GetTrafficPolicyOutput{}
   6166 	} else {
   6167 		sv = *v
   6168 	}
   6169 
   6170 	for {
   6171 		t, done, err := decoder.Token()
   6172 		if err != nil {
   6173 			return err
   6174 		}
   6175 		if done {
   6176 			break
   6177 		}
   6178 		originalDecoder := decoder
   6179 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6180 		switch {
   6181 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
   6182 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6183 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
   6184 				return err
   6185 			}
   6186 
   6187 		default:
   6188 			// Do nothing and ignore the unexpected tag element
   6189 			err = decoder.Decoder.Skip()
   6190 			if err != nil {
   6191 				return err
   6192 			}
   6193 
   6194 		}
   6195 		decoder = originalDecoder
   6196 	}
   6197 	*v = sv
   6198 	return nil
   6199 }
   6200 
   6201 type awsRestxml_deserializeOpGetTrafficPolicyInstance struct {
   6202 }
   6203 
   6204 func (*awsRestxml_deserializeOpGetTrafficPolicyInstance) ID() string {
   6205 	return "OperationDeserializer"
   6206 }
   6207 
   6208 func (m *awsRestxml_deserializeOpGetTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6209 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6210 ) {
   6211 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6212 	if err != nil {
   6213 		return out, metadata, err
   6214 	}
   6215 
   6216 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6217 	if !ok {
   6218 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6219 	}
   6220 
   6221 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6222 		return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response, &metadata)
   6223 	}
   6224 	output := &GetTrafficPolicyInstanceOutput{}
   6225 	out.Result = output
   6226 
   6227 	var buff [1024]byte
   6228 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6229 	body := io.TeeReader(response.Body, ringBuffer)
   6230 	rootDecoder := xml.NewDecoder(body)
   6231 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6232 	if err == io.EOF {
   6233 		return out, metadata, nil
   6234 	}
   6235 	if err != nil {
   6236 		var snapshot bytes.Buffer
   6237 		io.Copy(&snapshot, ringBuffer)
   6238 		return out, metadata, &smithy.DeserializationError{
   6239 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6240 			Snapshot: snapshot.Bytes(),
   6241 		}
   6242 	}
   6243 
   6244 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6245 	err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(&output, decoder)
   6246 	if err != nil {
   6247 		var snapshot bytes.Buffer
   6248 		io.Copy(&snapshot, ringBuffer)
   6249 		return out, metadata, &smithy.DeserializationError{
   6250 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6251 			Snapshot: snapshot.Bytes(),
   6252 		}
   6253 	}
   6254 
   6255 	return out, metadata, err
   6256 }
   6257 
   6258 func awsRestxml_deserializeOpErrorGetTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6259 	var errorBuffer bytes.Buffer
   6260 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6261 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6262 	}
   6263 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6264 
   6265 	errorCode := "UnknownError"
   6266 	errorMessage := errorCode
   6267 
   6268 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6269 	if err != nil {
   6270 		return err
   6271 	}
   6272 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6273 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6274 	}
   6275 	if len(errorComponents.Code) != 0 {
   6276 		errorCode = errorComponents.Code
   6277 	}
   6278 	if len(errorComponents.Message) != 0 {
   6279 		errorMessage = errorComponents.Message
   6280 	}
   6281 	errorBody.Seek(0, io.SeekStart)
   6282 	switch {
   6283 	case strings.EqualFold("InvalidInput", errorCode):
   6284 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6285 
   6286 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   6287 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   6288 
   6289 	default:
   6290 		genericError := &smithy.GenericAPIError{
   6291 			Code:    errorCode,
   6292 			Message: errorMessage,
   6293 		}
   6294 		return genericError
   6295 
   6296 	}
   6297 }
   6298 
   6299 func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceOutput(v **GetTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
   6300 	if v == nil {
   6301 		return fmt.Errorf("unexpected nil of type %T", v)
   6302 	}
   6303 	var sv *GetTrafficPolicyInstanceOutput
   6304 	if *v == nil {
   6305 		sv = &GetTrafficPolicyInstanceOutput{}
   6306 	} else {
   6307 		sv = *v
   6308 	}
   6309 
   6310 	for {
   6311 		t, done, err := decoder.Token()
   6312 		if err != nil {
   6313 			return err
   6314 		}
   6315 		if done {
   6316 			break
   6317 		}
   6318 		originalDecoder := decoder
   6319 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6320 		switch {
   6321 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
   6322 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6323 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
   6324 				return err
   6325 			}
   6326 
   6327 		default:
   6328 			// Do nothing and ignore the unexpected tag element
   6329 			err = decoder.Decoder.Skip()
   6330 			if err != nil {
   6331 				return err
   6332 			}
   6333 
   6334 		}
   6335 		decoder = originalDecoder
   6336 	}
   6337 	*v = sv
   6338 	return nil
   6339 }
   6340 
   6341 type awsRestxml_deserializeOpGetTrafficPolicyInstanceCount struct {
   6342 }
   6343 
   6344 func (*awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) ID() string {
   6345 	return "OperationDeserializer"
   6346 }
   6347 
   6348 func (m *awsRestxml_deserializeOpGetTrafficPolicyInstanceCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6349 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6350 ) {
   6351 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6352 	if err != nil {
   6353 		return out, metadata, err
   6354 	}
   6355 
   6356 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6357 	if !ok {
   6358 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6359 	}
   6360 
   6361 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6362 		return out, metadata, awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response, &metadata)
   6363 	}
   6364 	output := &GetTrafficPolicyInstanceCountOutput{}
   6365 	out.Result = output
   6366 
   6367 	var buff [1024]byte
   6368 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6369 	body := io.TeeReader(response.Body, ringBuffer)
   6370 	rootDecoder := xml.NewDecoder(body)
   6371 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6372 	if err == io.EOF {
   6373 		return out, metadata, nil
   6374 	}
   6375 	if err != nil {
   6376 		var snapshot bytes.Buffer
   6377 		io.Copy(&snapshot, ringBuffer)
   6378 		return out, metadata, &smithy.DeserializationError{
   6379 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6380 			Snapshot: snapshot.Bytes(),
   6381 		}
   6382 	}
   6383 
   6384 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6385 	err = awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(&output, decoder)
   6386 	if err != nil {
   6387 		var snapshot bytes.Buffer
   6388 		io.Copy(&snapshot, ringBuffer)
   6389 		return out, metadata, &smithy.DeserializationError{
   6390 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6391 			Snapshot: snapshot.Bytes(),
   6392 		}
   6393 	}
   6394 
   6395 	return out, metadata, err
   6396 }
   6397 
   6398 func awsRestxml_deserializeOpErrorGetTrafficPolicyInstanceCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6399 	var errorBuffer bytes.Buffer
   6400 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6401 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6402 	}
   6403 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6404 
   6405 	errorCode := "UnknownError"
   6406 	errorMessage := errorCode
   6407 
   6408 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6409 	if err != nil {
   6410 		return err
   6411 	}
   6412 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6413 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6414 	}
   6415 	if len(errorComponents.Code) != 0 {
   6416 		errorCode = errorComponents.Code
   6417 	}
   6418 	if len(errorComponents.Message) != 0 {
   6419 		errorMessage = errorComponents.Message
   6420 	}
   6421 	errorBody.Seek(0, io.SeekStart)
   6422 	switch {
   6423 	default:
   6424 		genericError := &smithy.GenericAPIError{
   6425 			Code:    errorCode,
   6426 			Message: errorMessage,
   6427 		}
   6428 		return genericError
   6429 
   6430 	}
   6431 }
   6432 
   6433 func awsRestxml_deserializeOpDocumentGetTrafficPolicyInstanceCountOutput(v **GetTrafficPolicyInstanceCountOutput, decoder smithyxml.NodeDecoder) error {
   6434 	if v == nil {
   6435 		return fmt.Errorf("unexpected nil of type %T", v)
   6436 	}
   6437 	var sv *GetTrafficPolicyInstanceCountOutput
   6438 	if *v == nil {
   6439 		sv = &GetTrafficPolicyInstanceCountOutput{}
   6440 	} else {
   6441 		sv = *v
   6442 	}
   6443 
   6444 	for {
   6445 		t, done, err := decoder.Token()
   6446 		if err != nil {
   6447 			return err
   6448 		}
   6449 		if done {
   6450 			break
   6451 		}
   6452 		originalDecoder := decoder
   6453 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6454 		switch {
   6455 		case strings.EqualFold("TrafficPolicyInstanceCount", t.Name.Local):
   6456 			val, err := decoder.Value()
   6457 			if err != nil {
   6458 				return err
   6459 			}
   6460 			if val == nil {
   6461 				break
   6462 			}
   6463 			{
   6464 				xtv := string(val)
   6465 				i64, err := strconv.ParseInt(xtv, 10, 64)
   6466 				if err != nil {
   6467 					return err
   6468 				}
   6469 				sv.TrafficPolicyInstanceCount = ptr.Int32(int32(i64))
   6470 			}
   6471 
   6472 		default:
   6473 			// Do nothing and ignore the unexpected tag element
   6474 			err = decoder.Decoder.Skip()
   6475 			if err != nil {
   6476 				return err
   6477 			}
   6478 
   6479 		}
   6480 		decoder = originalDecoder
   6481 	}
   6482 	*v = sv
   6483 	return nil
   6484 }
   6485 
   6486 type awsRestxml_deserializeOpListCidrBlocks struct {
   6487 }
   6488 
   6489 func (*awsRestxml_deserializeOpListCidrBlocks) ID() string {
   6490 	return "OperationDeserializer"
   6491 }
   6492 
   6493 func (m *awsRestxml_deserializeOpListCidrBlocks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6494 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6495 ) {
   6496 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6497 	if err != nil {
   6498 		return out, metadata, err
   6499 	}
   6500 
   6501 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6502 	if !ok {
   6503 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6504 	}
   6505 
   6506 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6507 		return out, metadata, awsRestxml_deserializeOpErrorListCidrBlocks(response, &metadata)
   6508 	}
   6509 	output := &ListCidrBlocksOutput{}
   6510 	out.Result = output
   6511 
   6512 	var buff [1024]byte
   6513 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6514 	body := io.TeeReader(response.Body, ringBuffer)
   6515 	rootDecoder := xml.NewDecoder(body)
   6516 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6517 	if err == io.EOF {
   6518 		return out, metadata, nil
   6519 	}
   6520 	if err != nil {
   6521 		var snapshot bytes.Buffer
   6522 		io.Copy(&snapshot, ringBuffer)
   6523 		return out, metadata, &smithy.DeserializationError{
   6524 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6525 			Snapshot: snapshot.Bytes(),
   6526 		}
   6527 	}
   6528 
   6529 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6530 	err = awsRestxml_deserializeOpDocumentListCidrBlocksOutput(&output, decoder)
   6531 	if err != nil {
   6532 		var snapshot bytes.Buffer
   6533 		io.Copy(&snapshot, ringBuffer)
   6534 		return out, metadata, &smithy.DeserializationError{
   6535 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6536 			Snapshot: snapshot.Bytes(),
   6537 		}
   6538 	}
   6539 
   6540 	return out, metadata, err
   6541 }
   6542 
   6543 func awsRestxml_deserializeOpErrorListCidrBlocks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6544 	var errorBuffer bytes.Buffer
   6545 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6546 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6547 	}
   6548 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6549 
   6550 	errorCode := "UnknownError"
   6551 	errorMessage := errorCode
   6552 
   6553 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6554 	if err != nil {
   6555 		return err
   6556 	}
   6557 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6558 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6559 	}
   6560 	if len(errorComponents.Code) != 0 {
   6561 		errorCode = errorComponents.Code
   6562 	}
   6563 	if len(errorComponents.Message) != 0 {
   6564 		errorMessage = errorComponents.Message
   6565 	}
   6566 	errorBody.Seek(0, io.SeekStart)
   6567 	switch {
   6568 	case strings.EqualFold("InvalidInput", errorCode):
   6569 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6570 
   6571 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
   6572 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
   6573 
   6574 	case strings.EqualFold("NoSuchCidrLocationException", errorCode):
   6575 		return awsRestxml_deserializeErrorNoSuchCidrLocationException(response, errorBody)
   6576 
   6577 	default:
   6578 		genericError := &smithy.GenericAPIError{
   6579 			Code:    errorCode,
   6580 			Message: errorMessage,
   6581 		}
   6582 		return genericError
   6583 
   6584 	}
   6585 }
   6586 
   6587 func awsRestxml_deserializeOpDocumentListCidrBlocksOutput(v **ListCidrBlocksOutput, decoder smithyxml.NodeDecoder) error {
   6588 	if v == nil {
   6589 		return fmt.Errorf("unexpected nil of type %T", v)
   6590 	}
   6591 	var sv *ListCidrBlocksOutput
   6592 	if *v == nil {
   6593 		sv = &ListCidrBlocksOutput{}
   6594 	} else {
   6595 		sv = *v
   6596 	}
   6597 
   6598 	for {
   6599 		t, done, err := decoder.Token()
   6600 		if err != nil {
   6601 			return err
   6602 		}
   6603 		if done {
   6604 			break
   6605 		}
   6606 		originalDecoder := decoder
   6607 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6608 		switch {
   6609 		case strings.EqualFold("CidrBlocks", t.Name.Local):
   6610 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6611 			if err := awsRestxml_deserializeDocumentCidrBlockSummaries(&sv.CidrBlocks, nodeDecoder); err != nil {
   6612 				return err
   6613 			}
   6614 
   6615 		case strings.EqualFold("NextToken", t.Name.Local):
   6616 			val, err := decoder.Value()
   6617 			if err != nil {
   6618 				return err
   6619 			}
   6620 			if val == nil {
   6621 				break
   6622 			}
   6623 			{
   6624 				xtv := string(val)
   6625 				sv.NextToken = ptr.String(xtv)
   6626 			}
   6627 
   6628 		default:
   6629 			// Do nothing and ignore the unexpected tag element
   6630 			err = decoder.Decoder.Skip()
   6631 			if err != nil {
   6632 				return err
   6633 			}
   6634 
   6635 		}
   6636 		decoder = originalDecoder
   6637 	}
   6638 	*v = sv
   6639 	return nil
   6640 }
   6641 
   6642 type awsRestxml_deserializeOpListCidrCollections struct {
   6643 }
   6644 
   6645 func (*awsRestxml_deserializeOpListCidrCollections) ID() string {
   6646 	return "OperationDeserializer"
   6647 }
   6648 
   6649 func (m *awsRestxml_deserializeOpListCidrCollections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6650 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6651 ) {
   6652 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6653 	if err != nil {
   6654 		return out, metadata, err
   6655 	}
   6656 
   6657 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6658 	if !ok {
   6659 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6660 	}
   6661 
   6662 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6663 		return out, metadata, awsRestxml_deserializeOpErrorListCidrCollections(response, &metadata)
   6664 	}
   6665 	output := &ListCidrCollectionsOutput{}
   6666 	out.Result = output
   6667 
   6668 	var buff [1024]byte
   6669 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6670 	body := io.TeeReader(response.Body, ringBuffer)
   6671 	rootDecoder := xml.NewDecoder(body)
   6672 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6673 	if err == io.EOF {
   6674 		return out, metadata, nil
   6675 	}
   6676 	if err != nil {
   6677 		var snapshot bytes.Buffer
   6678 		io.Copy(&snapshot, ringBuffer)
   6679 		return out, metadata, &smithy.DeserializationError{
   6680 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6681 			Snapshot: snapshot.Bytes(),
   6682 		}
   6683 	}
   6684 
   6685 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6686 	err = awsRestxml_deserializeOpDocumentListCidrCollectionsOutput(&output, decoder)
   6687 	if err != nil {
   6688 		var snapshot bytes.Buffer
   6689 		io.Copy(&snapshot, ringBuffer)
   6690 		return out, metadata, &smithy.DeserializationError{
   6691 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6692 			Snapshot: snapshot.Bytes(),
   6693 		}
   6694 	}
   6695 
   6696 	return out, metadata, err
   6697 }
   6698 
   6699 func awsRestxml_deserializeOpErrorListCidrCollections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6700 	var errorBuffer bytes.Buffer
   6701 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6702 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6703 	}
   6704 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6705 
   6706 	errorCode := "UnknownError"
   6707 	errorMessage := errorCode
   6708 
   6709 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6710 	if err != nil {
   6711 		return err
   6712 	}
   6713 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6714 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6715 	}
   6716 	if len(errorComponents.Code) != 0 {
   6717 		errorCode = errorComponents.Code
   6718 	}
   6719 	if len(errorComponents.Message) != 0 {
   6720 		errorMessage = errorComponents.Message
   6721 	}
   6722 	errorBody.Seek(0, io.SeekStart)
   6723 	switch {
   6724 	case strings.EqualFold("InvalidInput", errorCode):
   6725 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6726 
   6727 	default:
   6728 		genericError := &smithy.GenericAPIError{
   6729 			Code:    errorCode,
   6730 			Message: errorMessage,
   6731 		}
   6732 		return genericError
   6733 
   6734 	}
   6735 }
   6736 
   6737 func awsRestxml_deserializeOpDocumentListCidrCollectionsOutput(v **ListCidrCollectionsOutput, decoder smithyxml.NodeDecoder) error {
   6738 	if v == nil {
   6739 		return fmt.Errorf("unexpected nil of type %T", v)
   6740 	}
   6741 	var sv *ListCidrCollectionsOutput
   6742 	if *v == nil {
   6743 		sv = &ListCidrCollectionsOutput{}
   6744 	} else {
   6745 		sv = *v
   6746 	}
   6747 
   6748 	for {
   6749 		t, done, err := decoder.Token()
   6750 		if err != nil {
   6751 			return err
   6752 		}
   6753 		if done {
   6754 			break
   6755 		}
   6756 		originalDecoder := decoder
   6757 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6758 		switch {
   6759 		case strings.EqualFold("CidrCollections", t.Name.Local):
   6760 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6761 			if err := awsRestxml_deserializeDocumentCollectionSummaries(&sv.CidrCollections, nodeDecoder); err != nil {
   6762 				return err
   6763 			}
   6764 
   6765 		case strings.EqualFold("NextToken", t.Name.Local):
   6766 			val, err := decoder.Value()
   6767 			if err != nil {
   6768 				return err
   6769 			}
   6770 			if val == nil {
   6771 				break
   6772 			}
   6773 			{
   6774 				xtv := string(val)
   6775 				sv.NextToken = ptr.String(xtv)
   6776 			}
   6777 
   6778 		default:
   6779 			// Do nothing and ignore the unexpected tag element
   6780 			err = decoder.Decoder.Skip()
   6781 			if err != nil {
   6782 				return err
   6783 			}
   6784 
   6785 		}
   6786 		decoder = originalDecoder
   6787 	}
   6788 	*v = sv
   6789 	return nil
   6790 }
   6791 
   6792 type awsRestxml_deserializeOpListCidrLocations struct {
   6793 }
   6794 
   6795 func (*awsRestxml_deserializeOpListCidrLocations) ID() string {
   6796 	return "OperationDeserializer"
   6797 }
   6798 
   6799 func (m *awsRestxml_deserializeOpListCidrLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6800 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6801 ) {
   6802 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6803 	if err != nil {
   6804 		return out, metadata, err
   6805 	}
   6806 
   6807 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6808 	if !ok {
   6809 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6810 	}
   6811 
   6812 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6813 		return out, metadata, awsRestxml_deserializeOpErrorListCidrLocations(response, &metadata)
   6814 	}
   6815 	output := &ListCidrLocationsOutput{}
   6816 	out.Result = output
   6817 
   6818 	var buff [1024]byte
   6819 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6820 	body := io.TeeReader(response.Body, ringBuffer)
   6821 	rootDecoder := xml.NewDecoder(body)
   6822 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6823 	if err == io.EOF {
   6824 		return out, metadata, nil
   6825 	}
   6826 	if err != nil {
   6827 		var snapshot bytes.Buffer
   6828 		io.Copy(&snapshot, ringBuffer)
   6829 		return out, metadata, &smithy.DeserializationError{
   6830 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6831 			Snapshot: snapshot.Bytes(),
   6832 		}
   6833 	}
   6834 
   6835 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6836 	err = awsRestxml_deserializeOpDocumentListCidrLocationsOutput(&output, decoder)
   6837 	if err != nil {
   6838 		var snapshot bytes.Buffer
   6839 		io.Copy(&snapshot, ringBuffer)
   6840 		return out, metadata, &smithy.DeserializationError{
   6841 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6842 			Snapshot: snapshot.Bytes(),
   6843 		}
   6844 	}
   6845 
   6846 	return out, metadata, err
   6847 }
   6848 
   6849 func awsRestxml_deserializeOpErrorListCidrLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   6850 	var errorBuffer bytes.Buffer
   6851 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   6852 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   6853 	}
   6854 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   6855 
   6856 	errorCode := "UnknownError"
   6857 	errorMessage := errorCode
   6858 
   6859 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   6860 	if err != nil {
   6861 		return err
   6862 	}
   6863 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   6864 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   6865 	}
   6866 	if len(errorComponents.Code) != 0 {
   6867 		errorCode = errorComponents.Code
   6868 	}
   6869 	if len(errorComponents.Message) != 0 {
   6870 		errorMessage = errorComponents.Message
   6871 	}
   6872 	errorBody.Seek(0, io.SeekStart)
   6873 	switch {
   6874 	case strings.EqualFold("InvalidInput", errorCode):
   6875 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   6876 
   6877 	case strings.EqualFold("NoSuchCidrCollectionException", errorCode):
   6878 		return awsRestxml_deserializeErrorNoSuchCidrCollectionException(response, errorBody)
   6879 
   6880 	default:
   6881 		genericError := &smithy.GenericAPIError{
   6882 			Code:    errorCode,
   6883 			Message: errorMessage,
   6884 		}
   6885 		return genericError
   6886 
   6887 	}
   6888 }
   6889 
   6890 func awsRestxml_deserializeOpDocumentListCidrLocationsOutput(v **ListCidrLocationsOutput, decoder smithyxml.NodeDecoder) error {
   6891 	if v == nil {
   6892 		return fmt.Errorf("unexpected nil of type %T", v)
   6893 	}
   6894 	var sv *ListCidrLocationsOutput
   6895 	if *v == nil {
   6896 		sv = &ListCidrLocationsOutput{}
   6897 	} else {
   6898 		sv = *v
   6899 	}
   6900 
   6901 	for {
   6902 		t, done, err := decoder.Token()
   6903 		if err != nil {
   6904 			return err
   6905 		}
   6906 		if done {
   6907 			break
   6908 		}
   6909 		originalDecoder := decoder
   6910 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   6911 		switch {
   6912 		case strings.EqualFold("CidrLocations", t.Name.Local):
   6913 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   6914 			if err := awsRestxml_deserializeDocumentLocationSummaries(&sv.CidrLocations, nodeDecoder); err != nil {
   6915 				return err
   6916 			}
   6917 
   6918 		case strings.EqualFold("NextToken", t.Name.Local):
   6919 			val, err := decoder.Value()
   6920 			if err != nil {
   6921 				return err
   6922 			}
   6923 			if val == nil {
   6924 				break
   6925 			}
   6926 			{
   6927 				xtv := string(val)
   6928 				sv.NextToken = ptr.String(xtv)
   6929 			}
   6930 
   6931 		default:
   6932 			// Do nothing and ignore the unexpected tag element
   6933 			err = decoder.Decoder.Skip()
   6934 			if err != nil {
   6935 				return err
   6936 			}
   6937 
   6938 		}
   6939 		decoder = originalDecoder
   6940 	}
   6941 	*v = sv
   6942 	return nil
   6943 }
   6944 
   6945 type awsRestxml_deserializeOpListGeoLocations struct {
   6946 }
   6947 
   6948 func (*awsRestxml_deserializeOpListGeoLocations) ID() string {
   6949 	return "OperationDeserializer"
   6950 }
   6951 
   6952 func (m *awsRestxml_deserializeOpListGeoLocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   6953 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   6954 ) {
   6955 	out, metadata, err = next.HandleDeserialize(ctx, in)
   6956 	if err != nil {
   6957 		return out, metadata, err
   6958 	}
   6959 
   6960 	response, ok := out.RawResponse.(*smithyhttp.Response)
   6961 	if !ok {
   6962 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   6963 	}
   6964 
   6965 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   6966 		return out, metadata, awsRestxml_deserializeOpErrorListGeoLocations(response, &metadata)
   6967 	}
   6968 	output := &ListGeoLocationsOutput{}
   6969 	out.Result = output
   6970 
   6971 	var buff [1024]byte
   6972 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   6973 	body := io.TeeReader(response.Body, ringBuffer)
   6974 	rootDecoder := xml.NewDecoder(body)
   6975 	t, err := smithyxml.FetchRootElement(rootDecoder)
   6976 	if err == io.EOF {
   6977 		return out, metadata, nil
   6978 	}
   6979 	if err != nil {
   6980 		var snapshot bytes.Buffer
   6981 		io.Copy(&snapshot, ringBuffer)
   6982 		return out, metadata, &smithy.DeserializationError{
   6983 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6984 			Snapshot: snapshot.Bytes(),
   6985 		}
   6986 	}
   6987 
   6988 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   6989 	err = awsRestxml_deserializeOpDocumentListGeoLocationsOutput(&output, decoder)
   6990 	if err != nil {
   6991 		var snapshot bytes.Buffer
   6992 		io.Copy(&snapshot, ringBuffer)
   6993 		return out, metadata, &smithy.DeserializationError{
   6994 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   6995 			Snapshot: snapshot.Bytes(),
   6996 		}
   6997 	}
   6998 
   6999 	return out, metadata, err
   7000 }
   7001 
   7002 func awsRestxml_deserializeOpErrorListGeoLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7003 	var errorBuffer bytes.Buffer
   7004 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7005 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7006 	}
   7007 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7008 
   7009 	errorCode := "UnknownError"
   7010 	errorMessage := errorCode
   7011 
   7012 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7013 	if err != nil {
   7014 		return err
   7015 	}
   7016 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7017 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7018 	}
   7019 	if len(errorComponents.Code) != 0 {
   7020 		errorCode = errorComponents.Code
   7021 	}
   7022 	if len(errorComponents.Message) != 0 {
   7023 		errorMessage = errorComponents.Message
   7024 	}
   7025 	errorBody.Seek(0, io.SeekStart)
   7026 	switch {
   7027 	case strings.EqualFold("InvalidInput", errorCode):
   7028 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7029 
   7030 	default:
   7031 		genericError := &smithy.GenericAPIError{
   7032 			Code:    errorCode,
   7033 			Message: errorMessage,
   7034 		}
   7035 		return genericError
   7036 
   7037 	}
   7038 }
   7039 
   7040 func awsRestxml_deserializeOpDocumentListGeoLocationsOutput(v **ListGeoLocationsOutput, decoder smithyxml.NodeDecoder) error {
   7041 	if v == nil {
   7042 		return fmt.Errorf("unexpected nil of type %T", v)
   7043 	}
   7044 	var sv *ListGeoLocationsOutput
   7045 	if *v == nil {
   7046 		sv = &ListGeoLocationsOutput{}
   7047 	} else {
   7048 		sv = *v
   7049 	}
   7050 
   7051 	for {
   7052 		t, done, err := decoder.Token()
   7053 		if err != nil {
   7054 			return err
   7055 		}
   7056 		if done {
   7057 			break
   7058 		}
   7059 		originalDecoder := decoder
   7060 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7061 		switch {
   7062 		case strings.EqualFold("GeoLocationDetailsList", t.Name.Local):
   7063 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7064 			if err := awsRestxml_deserializeDocumentGeoLocationDetailsList(&sv.GeoLocationDetailsList, nodeDecoder); err != nil {
   7065 				return err
   7066 			}
   7067 
   7068 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7069 			val, err := decoder.Value()
   7070 			if err != nil {
   7071 				return err
   7072 			}
   7073 			if val == nil {
   7074 				break
   7075 			}
   7076 			{
   7077 				xtv, err := strconv.ParseBool(string(val))
   7078 				if err != nil {
   7079 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7080 				}
   7081 				sv.IsTruncated = xtv
   7082 			}
   7083 
   7084 		case strings.EqualFold("MaxItems", t.Name.Local):
   7085 			val, err := decoder.Value()
   7086 			if err != nil {
   7087 				return err
   7088 			}
   7089 			if val == nil {
   7090 				break
   7091 			}
   7092 			{
   7093 				xtv := string(val)
   7094 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7095 				if err != nil {
   7096 					return err
   7097 				}
   7098 				sv.MaxItems = ptr.Int32(int32(i64))
   7099 			}
   7100 
   7101 		case strings.EqualFold("NextContinentCode", t.Name.Local):
   7102 			val, err := decoder.Value()
   7103 			if err != nil {
   7104 				return err
   7105 			}
   7106 			if val == nil {
   7107 				break
   7108 			}
   7109 			{
   7110 				xtv := string(val)
   7111 				sv.NextContinentCode = ptr.String(xtv)
   7112 			}
   7113 
   7114 		case strings.EqualFold("NextCountryCode", t.Name.Local):
   7115 			val, err := decoder.Value()
   7116 			if err != nil {
   7117 				return err
   7118 			}
   7119 			if val == nil {
   7120 				break
   7121 			}
   7122 			{
   7123 				xtv := string(val)
   7124 				sv.NextCountryCode = ptr.String(xtv)
   7125 			}
   7126 
   7127 		case strings.EqualFold("NextSubdivisionCode", t.Name.Local):
   7128 			val, err := decoder.Value()
   7129 			if err != nil {
   7130 				return err
   7131 			}
   7132 			if val == nil {
   7133 				break
   7134 			}
   7135 			{
   7136 				xtv := string(val)
   7137 				sv.NextSubdivisionCode = ptr.String(xtv)
   7138 			}
   7139 
   7140 		default:
   7141 			// Do nothing and ignore the unexpected tag element
   7142 			err = decoder.Decoder.Skip()
   7143 			if err != nil {
   7144 				return err
   7145 			}
   7146 
   7147 		}
   7148 		decoder = originalDecoder
   7149 	}
   7150 	*v = sv
   7151 	return nil
   7152 }
   7153 
   7154 type awsRestxml_deserializeOpListHealthChecks struct {
   7155 }
   7156 
   7157 func (*awsRestxml_deserializeOpListHealthChecks) ID() string {
   7158 	return "OperationDeserializer"
   7159 }
   7160 
   7161 func (m *awsRestxml_deserializeOpListHealthChecks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7162 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7163 ) {
   7164 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7165 	if err != nil {
   7166 		return out, metadata, err
   7167 	}
   7168 
   7169 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7170 	if !ok {
   7171 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7172 	}
   7173 
   7174 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7175 		return out, metadata, awsRestxml_deserializeOpErrorListHealthChecks(response, &metadata)
   7176 	}
   7177 	output := &ListHealthChecksOutput{}
   7178 	out.Result = output
   7179 
   7180 	var buff [1024]byte
   7181 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7182 	body := io.TeeReader(response.Body, ringBuffer)
   7183 	rootDecoder := xml.NewDecoder(body)
   7184 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7185 	if err == io.EOF {
   7186 		return out, metadata, nil
   7187 	}
   7188 	if err != nil {
   7189 		var snapshot bytes.Buffer
   7190 		io.Copy(&snapshot, ringBuffer)
   7191 		return out, metadata, &smithy.DeserializationError{
   7192 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7193 			Snapshot: snapshot.Bytes(),
   7194 		}
   7195 	}
   7196 
   7197 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7198 	err = awsRestxml_deserializeOpDocumentListHealthChecksOutput(&output, decoder)
   7199 	if err != nil {
   7200 		var snapshot bytes.Buffer
   7201 		io.Copy(&snapshot, ringBuffer)
   7202 		return out, metadata, &smithy.DeserializationError{
   7203 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7204 			Snapshot: snapshot.Bytes(),
   7205 		}
   7206 	}
   7207 
   7208 	return out, metadata, err
   7209 }
   7210 
   7211 func awsRestxml_deserializeOpErrorListHealthChecks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7212 	var errorBuffer bytes.Buffer
   7213 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7214 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7215 	}
   7216 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7217 
   7218 	errorCode := "UnknownError"
   7219 	errorMessage := errorCode
   7220 
   7221 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7222 	if err != nil {
   7223 		return err
   7224 	}
   7225 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7226 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7227 	}
   7228 	if len(errorComponents.Code) != 0 {
   7229 		errorCode = errorComponents.Code
   7230 	}
   7231 	if len(errorComponents.Message) != 0 {
   7232 		errorMessage = errorComponents.Message
   7233 	}
   7234 	errorBody.Seek(0, io.SeekStart)
   7235 	switch {
   7236 	case strings.EqualFold("IncompatibleVersion", errorCode):
   7237 		return awsRestxml_deserializeErrorIncompatibleVersion(response, errorBody)
   7238 
   7239 	case strings.EqualFold("InvalidInput", errorCode):
   7240 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7241 
   7242 	default:
   7243 		genericError := &smithy.GenericAPIError{
   7244 			Code:    errorCode,
   7245 			Message: errorMessage,
   7246 		}
   7247 		return genericError
   7248 
   7249 	}
   7250 }
   7251 
   7252 func awsRestxml_deserializeOpDocumentListHealthChecksOutput(v **ListHealthChecksOutput, decoder smithyxml.NodeDecoder) error {
   7253 	if v == nil {
   7254 		return fmt.Errorf("unexpected nil of type %T", v)
   7255 	}
   7256 	var sv *ListHealthChecksOutput
   7257 	if *v == nil {
   7258 		sv = &ListHealthChecksOutput{}
   7259 	} else {
   7260 		sv = *v
   7261 	}
   7262 
   7263 	for {
   7264 		t, done, err := decoder.Token()
   7265 		if err != nil {
   7266 			return err
   7267 		}
   7268 		if done {
   7269 			break
   7270 		}
   7271 		originalDecoder := decoder
   7272 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7273 		switch {
   7274 		case strings.EqualFold("HealthChecks", t.Name.Local):
   7275 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7276 			if err := awsRestxml_deserializeDocumentHealthChecks(&sv.HealthChecks, nodeDecoder); err != nil {
   7277 				return err
   7278 			}
   7279 
   7280 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7281 			val, err := decoder.Value()
   7282 			if err != nil {
   7283 				return err
   7284 			}
   7285 			if val == nil {
   7286 				break
   7287 			}
   7288 			{
   7289 				xtv, err := strconv.ParseBool(string(val))
   7290 				if err != nil {
   7291 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7292 				}
   7293 				sv.IsTruncated = xtv
   7294 			}
   7295 
   7296 		case strings.EqualFold("Marker", t.Name.Local):
   7297 			val, err := decoder.Value()
   7298 			if err != nil {
   7299 				return err
   7300 			}
   7301 			if val == nil {
   7302 				break
   7303 			}
   7304 			{
   7305 				xtv := string(val)
   7306 				sv.Marker = ptr.String(xtv)
   7307 			}
   7308 
   7309 		case strings.EqualFold("MaxItems", t.Name.Local):
   7310 			val, err := decoder.Value()
   7311 			if err != nil {
   7312 				return err
   7313 			}
   7314 			if val == nil {
   7315 				break
   7316 			}
   7317 			{
   7318 				xtv := string(val)
   7319 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7320 				if err != nil {
   7321 					return err
   7322 				}
   7323 				sv.MaxItems = ptr.Int32(int32(i64))
   7324 			}
   7325 
   7326 		case strings.EqualFold("NextMarker", t.Name.Local):
   7327 			val, err := decoder.Value()
   7328 			if err != nil {
   7329 				return err
   7330 			}
   7331 			if val == nil {
   7332 				break
   7333 			}
   7334 			{
   7335 				xtv := string(val)
   7336 				sv.NextMarker = ptr.String(xtv)
   7337 			}
   7338 
   7339 		default:
   7340 			// Do nothing and ignore the unexpected tag element
   7341 			err = decoder.Decoder.Skip()
   7342 			if err != nil {
   7343 				return err
   7344 			}
   7345 
   7346 		}
   7347 		decoder = originalDecoder
   7348 	}
   7349 	*v = sv
   7350 	return nil
   7351 }
   7352 
   7353 type awsRestxml_deserializeOpListHostedZones struct {
   7354 }
   7355 
   7356 func (*awsRestxml_deserializeOpListHostedZones) ID() string {
   7357 	return "OperationDeserializer"
   7358 }
   7359 
   7360 func (m *awsRestxml_deserializeOpListHostedZones) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7361 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7362 ) {
   7363 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7364 	if err != nil {
   7365 		return out, metadata, err
   7366 	}
   7367 
   7368 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7369 	if !ok {
   7370 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7371 	}
   7372 
   7373 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7374 		return out, metadata, awsRestxml_deserializeOpErrorListHostedZones(response, &metadata)
   7375 	}
   7376 	output := &ListHostedZonesOutput{}
   7377 	out.Result = output
   7378 
   7379 	var buff [1024]byte
   7380 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7381 	body := io.TeeReader(response.Body, ringBuffer)
   7382 	rootDecoder := xml.NewDecoder(body)
   7383 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7384 	if err == io.EOF {
   7385 		return out, metadata, nil
   7386 	}
   7387 	if err != nil {
   7388 		var snapshot bytes.Buffer
   7389 		io.Copy(&snapshot, ringBuffer)
   7390 		return out, metadata, &smithy.DeserializationError{
   7391 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7392 			Snapshot: snapshot.Bytes(),
   7393 		}
   7394 	}
   7395 
   7396 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7397 	err = awsRestxml_deserializeOpDocumentListHostedZonesOutput(&output, decoder)
   7398 	if err != nil {
   7399 		var snapshot bytes.Buffer
   7400 		io.Copy(&snapshot, ringBuffer)
   7401 		return out, metadata, &smithy.DeserializationError{
   7402 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7403 			Snapshot: snapshot.Bytes(),
   7404 		}
   7405 	}
   7406 
   7407 	return out, metadata, err
   7408 }
   7409 
   7410 func awsRestxml_deserializeOpErrorListHostedZones(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7411 	var errorBuffer bytes.Buffer
   7412 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7413 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7414 	}
   7415 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7416 
   7417 	errorCode := "UnknownError"
   7418 	errorMessage := errorCode
   7419 
   7420 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7421 	if err != nil {
   7422 		return err
   7423 	}
   7424 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7425 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7426 	}
   7427 	if len(errorComponents.Code) != 0 {
   7428 		errorCode = errorComponents.Code
   7429 	}
   7430 	if len(errorComponents.Message) != 0 {
   7431 		errorMessage = errorComponents.Message
   7432 	}
   7433 	errorBody.Seek(0, io.SeekStart)
   7434 	switch {
   7435 	case strings.EqualFold("DelegationSetNotReusable", errorCode):
   7436 		return awsRestxml_deserializeErrorDelegationSetNotReusable(response, errorBody)
   7437 
   7438 	case strings.EqualFold("InvalidInput", errorCode):
   7439 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7440 
   7441 	case strings.EqualFold("NoSuchDelegationSet", errorCode):
   7442 		return awsRestxml_deserializeErrorNoSuchDelegationSet(response, errorBody)
   7443 
   7444 	default:
   7445 		genericError := &smithy.GenericAPIError{
   7446 			Code:    errorCode,
   7447 			Message: errorMessage,
   7448 		}
   7449 		return genericError
   7450 
   7451 	}
   7452 }
   7453 
   7454 func awsRestxml_deserializeOpDocumentListHostedZonesOutput(v **ListHostedZonesOutput, decoder smithyxml.NodeDecoder) error {
   7455 	if v == nil {
   7456 		return fmt.Errorf("unexpected nil of type %T", v)
   7457 	}
   7458 	var sv *ListHostedZonesOutput
   7459 	if *v == nil {
   7460 		sv = &ListHostedZonesOutput{}
   7461 	} else {
   7462 		sv = *v
   7463 	}
   7464 
   7465 	for {
   7466 		t, done, err := decoder.Token()
   7467 		if err != nil {
   7468 			return err
   7469 		}
   7470 		if done {
   7471 			break
   7472 		}
   7473 		originalDecoder := decoder
   7474 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7475 		switch {
   7476 		case strings.EqualFold("HostedZones", t.Name.Local):
   7477 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7478 			if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil {
   7479 				return err
   7480 			}
   7481 
   7482 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7483 			val, err := decoder.Value()
   7484 			if err != nil {
   7485 				return err
   7486 			}
   7487 			if val == nil {
   7488 				break
   7489 			}
   7490 			{
   7491 				xtv, err := strconv.ParseBool(string(val))
   7492 				if err != nil {
   7493 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7494 				}
   7495 				sv.IsTruncated = xtv
   7496 			}
   7497 
   7498 		case strings.EqualFold("Marker", t.Name.Local):
   7499 			val, err := decoder.Value()
   7500 			if err != nil {
   7501 				return err
   7502 			}
   7503 			if val == nil {
   7504 				break
   7505 			}
   7506 			{
   7507 				xtv := string(val)
   7508 				sv.Marker = ptr.String(xtv)
   7509 			}
   7510 
   7511 		case strings.EqualFold("MaxItems", t.Name.Local):
   7512 			val, err := decoder.Value()
   7513 			if err != nil {
   7514 				return err
   7515 			}
   7516 			if val == nil {
   7517 				break
   7518 			}
   7519 			{
   7520 				xtv := string(val)
   7521 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7522 				if err != nil {
   7523 					return err
   7524 				}
   7525 				sv.MaxItems = ptr.Int32(int32(i64))
   7526 			}
   7527 
   7528 		case strings.EqualFold("NextMarker", t.Name.Local):
   7529 			val, err := decoder.Value()
   7530 			if err != nil {
   7531 				return err
   7532 			}
   7533 			if val == nil {
   7534 				break
   7535 			}
   7536 			{
   7537 				xtv := string(val)
   7538 				sv.NextMarker = ptr.String(xtv)
   7539 			}
   7540 
   7541 		default:
   7542 			// Do nothing and ignore the unexpected tag element
   7543 			err = decoder.Decoder.Skip()
   7544 			if err != nil {
   7545 				return err
   7546 			}
   7547 
   7548 		}
   7549 		decoder = originalDecoder
   7550 	}
   7551 	*v = sv
   7552 	return nil
   7553 }
   7554 
   7555 type awsRestxml_deserializeOpListHostedZonesByName struct {
   7556 }
   7557 
   7558 func (*awsRestxml_deserializeOpListHostedZonesByName) ID() string {
   7559 	return "OperationDeserializer"
   7560 }
   7561 
   7562 func (m *awsRestxml_deserializeOpListHostedZonesByName) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7563 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7564 ) {
   7565 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7566 	if err != nil {
   7567 		return out, metadata, err
   7568 	}
   7569 
   7570 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7571 	if !ok {
   7572 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7573 	}
   7574 
   7575 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7576 		return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByName(response, &metadata)
   7577 	}
   7578 	output := &ListHostedZonesByNameOutput{}
   7579 	out.Result = output
   7580 
   7581 	var buff [1024]byte
   7582 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7583 	body := io.TeeReader(response.Body, ringBuffer)
   7584 	rootDecoder := xml.NewDecoder(body)
   7585 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7586 	if err == io.EOF {
   7587 		return out, metadata, nil
   7588 	}
   7589 	if err != nil {
   7590 		var snapshot bytes.Buffer
   7591 		io.Copy(&snapshot, ringBuffer)
   7592 		return out, metadata, &smithy.DeserializationError{
   7593 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7594 			Snapshot: snapshot.Bytes(),
   7595 		}
   7596 	}
   7597 
   7598 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7599 	err = awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(&output, decoder)
   7600 	if err != nil {
   7601 		var snapshot bytes.Buffer
   7602 		io.Copy(&snapshot, ringBuffer)
   7603 		return out, metadata, &smithy.DeserializationError{
   7604 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7605 			Snapshot: snapshot.Bytes(),
   7606 		}
   7607 	}
   7608 
   7609 	return out, metadata, err
   7610 }
   7611 
   7612 func awsRestxml_deserializeOpErrorListHostedZonesByName(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7613 	var errorBuffer bytes.Buffer
   7614 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7615 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7616 	}
   7617 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7618 
   7619 	errorCode := "UnknownError"
   7620 	errorMessage := errorCode
   7621 
   7622 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7623 	if err != nil {
   7624 		return err
   7625 	}
   7626 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7627 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7628 	}
   7629 	if len(errorComponents.Code) != 0 {
   7630 		errorCode = errorComponents.Code
   7631 	}
   7632 	if len(errorComponents.Message) != 0 {
   7633 		errorMessage = errorComponents.Message
   7634 	}
   7635 	errorBody.Seek(0, io.SeekStart)
   7636 	switch {
   7637 	case strings.EqualFold("InvalidDomainName", errorCode):
   7638 		return awsRestxml_deserializeErrorInvalidDomainName(response, errorBody)
   7639 
   7640 	case strings.EqualFold("InvalidInput", errorCode):
   7641 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7642 
   7643 	default:
   7644 		genericError := &smithy.GenericAPIError{
   7645 			Code:    errorCode,
   7646 			Message: errorMessage,
   7647 		}
   7648 		return genericError
   7649 
   7650 	}
   7651 }
   7652 
   7653 func awsRestxml_deserializeOpDocumentListHostedZonesByNameOutput(v **ListHostedZonesByNameOutput, decoder smithyxml.NodeDecoder) error {
   7654 	if v == nil {
   7655 		return fmt.Errorf("unexpected nil of type %T", v)
   7656 	}
   7657 	var sv *ListHostedZonesByNameOutput
   7658 	if *v == nil {
   7659 		sv = &ListHostedZonesByNameOutput{}
   7660 	} else {
   7661 		sv = *v
   7662 	}
   7663 
   7664 	for {
   7665 		t, done, err := decoder.Token()
   7666 		if err != nil {
   7667 			return err
   7668 		}
   7669 		if done {
   7670 			break
   7671 		}
   7672 		originalDecoder := decoder
   7673 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7674 		switch {
   7675 		case strings.EqualFold("DNSName", t.Name.Local):
   7676 			val, err := decoder.Value()
   7677 			if err != nil {
   7678 				return err
   7679 			}
   7680 			if val == nil {
   7681 				break
   7682 			}
   7683 			{
   7684 				xtv := string(val)
   7685 				sv.DNSName = ptr.String(xtv)
   7686 			}
   7687 
   7688 		case strings.EqualFold("HostedZoneId", t.Name.Local):
   7689 			val, err := decoder.Value()
   7690 			if err != nil {
   7691 				return err
   7692 			}
   7693 			if val == nil {
   7694 				break
   7695 			}
   7696 			{
   7697 				xtv := string(val)
   7698 				sv.HostedZoneId = ptr.String(xtv)
   7699 			}
   7700 
   7701 		case strings.EqualFold("HostedZones", t.Name.Local):
   7702 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7703 			if err := awsRestxml_deserializeDocumentHostedZones(&sv.HostedZones, nodeDecoder); err != nil {
   7704 				return err
   7705 			}
   7706 
   7707 		case strings.EqualFold("IsTruncated", t.Name.Local):
   7708 			val, err := decoder.Value()
   7709 			if err != nil {
   7710 				return err
   7711 			}
   7712 			if val == nil {
   7713 				break
   7714 			}
   7715 			{
   7716 				xtv, err := strconv.ParseBool(string(val))
   7717 				if err != nil {
   7718 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   7719 				}
   7720 				sv.IsTruncated = xtv
   7721 			}
   7722 
   7723 		case strings.EqualFold("MaxItems", t.Name.Local):
   7724 			val, err := decoder.Value()
   7725 			if err != nil {
   7726 				return err
   7727 			}
   7728 			if val == nil {
   7729 				break
   7730 			}
   7731 			{
   7732 				xtv := string(val)
   7733 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7734 				if err != nil {
   7735 					return err
   7736 				}
   7737 				sv.MaxItems = ptr.Int32(int32(i64))
   7738 			}
   7739 
   7740 		case strings.EqualFold("NextDNSName", t.Name.Local):
   7741 			val, err := decoder.Value()
   7742 			if err != nil {
   7743 				return err
   7744 			}
   7745 			if val == nil {
   7746 				break
   7747 			}
   7748 			{
   7749 				xtv := string(val)
   7750 				sv.NextDNSName = ptr.String(xtv)
   7751 			}
   7752 
   7753 		case strings.EqualFold("NextHostedZoneId", t.Name.Local):
   7754 			val, err := decoder.Value()
   7755 			if err != nil {
   7756 				return err
   7757 			}
   7758 			if val == nil {
   7759 				break
   7760 			}
   7761 			{
   7762 				xtv := string(val)
   7763 				sv.NextHostedZoneId = ptr.String(xtv)
   7764 			}
   7765 
   7766 		default:
   7767 			// Do nothing and ignore the unexpected tag element
   7768 			err = decoder.Decoder.Skip()
   7769 			if err != nil {
   7770 				return err
   7771 			}
   7772 
   7773 		}
   7774 		decoder = originalDecoder
   7775 	}
   7776 	*v = sv
   7777 	return nil
   7778 }
   7779 
   7780 type awsRestxml_deserializeOpListHostedZonesByVPC struct {
   7781 }
   7782 
   7783 func (*awsRestxml_deserializeOpListHostedZonesByVPC) ID() string {
   7784 	return "OperationDeserializer"
   7785 }
   7786 
   7787 func (m *awsRestxml_deserializeOpListHostedZonesByVPC) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7788 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7789 ) {
   7790 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7791 	if err != nil {
   7792 		return out, metadata, err
   7793 	}
   7794 
   7795 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7796 	if !ok {
   7797 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7798 	}
   7799 
   7800 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7801 		return out, metadata, awsRestxml_deserializeOpErrorListHostedZonesByVPC(response, &metadata)
   7802 	}
   7803 	output := &ListHostedZonesByVPCOutput{}
   7804 	out.Result = output
   7805 
   7806 	var buff [1024]byte
   7807 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7808 	body := io.TeeReader(response.Body, ringBuffer)
   7809 	rootDecoder := xml.NewDecoder(body)
   7810 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7811 	if err == io.EOF {
   7812 		return out, metadata, nil
   7813 	}
   7814 	if err != nil {
   7815 		var snapshot bytes.Buffer
   7816 		io.Copy(&snapshot, ringBuffer)
   7817 		return out, metadata, &smithy.DeserializationError{
   7818 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7819 			Snapshot: snapshot.Bytes(),
   7820 		}
   7821 	}
   7822 
   7823 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7824 	err = awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(&output, decoder)
   7825 	if err != nil {
   7826 		var snapshot bytes.Buffer
   7827 		io.Copy(&snapshot, ringBuffer)
   7828 		return out, metadata, &smithy.DeserializationError{
   7829 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7830 			Snapshot: snapshot.Bytes(),
   7831 		}
   7832 	}
   7833 
   7834 	return out, metadata, err
   7835 }
   7836 
   7837 func awsRestxml_deserializeOpErrorListHostedZonesByVPC(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   7838 	var errorBuffer bytes.Buffer
   7839 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   7840 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   7841 	}
   7842 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   7843 
   7844 	errorCode := "UnknownError"
   7845 	errorMessage := errorCode
   7846 
   7847 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   7848 	if err != nil {
   7849 		return err
   7850 	}
   7851 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   7852 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   7853 	}
   7854 	if len(errorComponents.Code) != 0 {
   7855 		errorCode = errorComponents.Code
   7856 	}
   7857 	if len(errorComponents.Message) != 0 {
   7858 		errorMessage = errorComponents.Message
   7859 	}
   7860 	errorBody.Seek(0, io.SeekStart)
   7861 	switch {
   7862 	case strings.EqualFold("InvalidInput", errorCode):
   7863 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   7864 
   7865 	case strings.EqualFold("InvalidPaginationToken", errorCode):
   7866 		return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
   7867 
   7868 	default:
   7869 		genericError := &smithy.GenericAPIError{
   7870 			Code:    errorCode,
   7871 			Message: errorMessage,
   7872 		}
   7873 		return genericError
   7874 
   7875 	}
   7876 }
   7877 
   7878 func awsRestxml_deserializeOpDocumentListHostedZonesByVPCOutput(v **ListHostedZonesByVPCOutput, decoder smithyxml.NodeDecoder) error {
   7879 	if v == nil {
   7880 		return fmt.Errorf("unexpected nil of type %T", v)
   7881 	}
   7882 	var sv *ListHostedZonesByVPCOutput
   7883 	if *v == nil {
   7884 		sv = &ListHostedZonesByVPCOutput{}
   7885 	} else {
   7886 		sv = *v
   7887 	}
   7888 
   7889 	for {
   7890 		t, done, err := decoder.Token()
   7891 		if err != nil {
   7892 			return err
   7893 		}
   7894 		if done {
   7895 			break
   7896 		}
   7897 		originalDecoder := decoder
   7898 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   7899 		switch {
   7900 		case strings.EqualFold("HostedZoneSummaries", t.Name.Local):
   7901 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   7902 			if err := awsRestxml_deserializeDocumentHostedZoneSummaries(&sv.HostedZoneSummaries, nodeDecoder); err != nil {
   7903 				return err
   7904 			}
   7905 
   7906 		case strings.EqualFold("MaxItems", t.Name.Local):
   7907 			val, err := decoder.Value()
   7908 			if err != nil {
   7909 				return err
   7910 			}
   7911 			if val == nil {
   7912 				break
   7913 			}
   7914 			{
   7915 				xtv := string(val)
   7916 				i64, err := strconv.ParseInt(xtv, 10, 64)
   7917 				if err != nil {
   7918 					return err
   7919 				}
   7920 				sv.MaxItems = ptr.Int32(int32(i64))
   7921 			}
   7922 
   7923 		case strings.EqualFold("NextToken", t.Name.Local):
   7924 			val, err := decoder.Value()
   7925 			if err != nil {
   7926 				return err
   7927 			}
   7928 			if val == nil {
   7929 				break
   7930 			}
   7931 			{
   7932 				xtv := string(val)
   7933 				sv.NextToken = ptr.String(xtv)
   7934 			}
   7935 
   7936 		default:
   7937 			// Do nothing and ignore the unexpected tag element
   7938 			err = decoder.Decoder.Skip()
   7939 			if err != nil {
   7940 				return err
   7941 			}
   7942 
   7943 		}
   7944 		decoder = originalDecoder
   7945 	}
   7946 	*v = sv
   7947 	return nil
   7948 }
   7949 
   7950 type awsRestxml_deserializeOpListQueryLoggingConfigs struct {
   7951 }
   7952 
   7953 func (*awsRestxml_deserializeOpListQueryLoggingConfigs) ID() string {
   7954 	return "OperationDeserializer"
   7955 }
   7956 
   7957 func (m *awsRestxml_deserializeOpListQueryLoggingConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   7958 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   7959 ) {
   7960 	out, metadata, err = next.HandleDeserialize(ctx, in)
   7961 	if err != nil {
   7962 		return out, metadata, err
   7963 	}
   7964 
   7965 	response, ok := out.RawResponse.(*smithyhttp.Response)
   7966 	if !ok {
   7967 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   7968 	}
   7969 
   7970 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   7971 		return out, metadata, awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response, &metadata)
   7972 	}
   7973 	output := &ListQueryLoggingConfigsOutput{}
   7974 	out.Result = output
   7975 
   7976 	var buff [1024]byte
   7977 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   7978 	body := io.TeeReader(response.Body, ringBuffer)
   7979 	rootDecoder := xml.NewDecoder(body)
   7980 	t, err := smithyxml.FetchRootElement(rootDecoder)
   7981 	if err == io.EOF {
   7982 		return out, metadata, nil
   7983 	}
   7984 	if err != nil {
   7985 		var snapshot bytes.Buffer
   7986 		io.Copy(&snapshot, ringBuffer)
   7987 		return out, metadata, &smithy.DeserializationError{
   7988 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   7989 			Snapshot: snapshot.Bytes(),
   7990 		}
   7991 	}
   7992 
   7993 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   7994 	err = awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(&output, decoder)
   7995 	if err != nil {
   7996 		var snapshot bytes.Buffer
   7997 		io.Copy(&snapshot, ringBuffer)
   7998 		return out, metadata, &smithy.DeserializationError{
   7999 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8000 			Snapshot: snapshot.Bytes(),
   8001 		}
   8002 	}
   8003 
   8004 	return out, metadata, err
   8005 }
   8006 
   8007 func awsRestxml_deserializeOpErrorListQueryLoggingConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8008 	var errorBuffer bytes.Buffer
   8009 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8010 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8011 	}
   8012 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8013 
   8014 	errorCode := "UnknownError"
   8015 	errorMessage := errorCode
   8016 
   8017 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8018 	if err != nil {
   8019 		return err
   8020 	}
   8021 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8022 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8023 	}
   8024 	if len(errorComponents.Code) != 0 {
   8025 		errorCode = errorComponents.Code
   8026 	}
   8027 	if len(errorComponents.Message) != 0 {
   8028 		errorMessage = errorComponents.Message
   8029 	}
   8030 	errorBody.Seek(0, io.SeekStart)
   8031 	switch {
   8032 	case strings.EqualFold("InvalidInput", errorCode):
   8033 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8034 
   8035 	case strings.EqualFold("InvalidPaginationToken", errorCode):
   8036 		return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
   8037 
   8038 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   8039 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   8040 
   8041 	default:
   8042 		genericError := &smithy.GenericAPIError{
   8043 			Code:    errorCode,
   8044 			Message: errorMessage,
   8045 		}
   8046 		return genericError
   8047 
   8048 	}
   8049 }
   8050 
   8051 func awsRestxml_deserializeOpDocumentListQueryLoggingConfigsOutput(v **ListQueryLoggingConfigsOutput, decoder smithyxml.NodeDecoder) error {
   8052 	if v == nil {
   8053 		return fmt.Errorf("unexpected nil of type %T", v)
   8054 	}
   8055 	var sv *ListQueryLoggingConfigsOutput
   8056 	if *v == nil {
   8057 		sv = &ListQueryLoggingConfigsOutput{}
   8058 	} else {
   8059 		sv = *v
   8060 	}
   8061 
   8062 	for {
   8063 		t, done, err := decoder.Token()
   8064 		if err != nil {
   8065 			return err
   8066 		}
   8067 		if done {
   8068 			break
   8069 		}
   8070 		originalDecoder := decoder
   8071 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8072 		switch {
   8073 		case strings.EqualFold("NextToken", t.Name.Local):
   8074 			val, err := decoder.Value()
   8075 			if err != nil {
   8076 				return err
   8077 			}
   8078 			if val == nil {
   8079 				break
   8080 			}
   8081 			{
   8082 				xtv := string(val)
   8083 				sv.NextToken = ptr.String(xtv)
   8084 			}
   8085 
   8086 		case strings.EqualFold("QueryLoggingConfigs", t.Name.Local):
   8087 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8088 			if err := awsRestxml_deserializeDocumentQueryLoggingConfigs(&sv.QueryLoggingConfigs, nodeDecoder); err != nil {
   8089 				return err
   8090 			}
   8091 
   8092 		default:
   8093 			// Do nothing and ignore the unexpected tag element
   8094 			err = decoder.Decoder.Skip()
   8095 			if err != nil {
   8096 				return err
   8097 			}
   8098 
   8099 		}
   8100 		decoder = originalDecoder
   8101 	}
   8102 	*v = sv
   8103 	return nil
   8104 }
   8105 
   8106 type awsRestxml_deserializeOpListResourceRecordSets struct {
   8107 }
   8108 
   8109 func (*awsRestxml_deserializeOpListResourceRecordSets) ID() string {
   8110 	return "OperationDeserializer"
   8111 }
   8112 
   8113 func (m *awsRestxml_deserializeOpListResourceRecordSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8114 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8115 ) {
   8116 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8117 	if err != nil {
   8118 		return out, metadata, err
   8119 	}
   8120 
   8121 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8122 	if !ok {
   8123 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8124 	}
   8125 
   8126 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8127 		return out, metadata, awsRestxml_deserializeOpErrorListResourceRecordSets(response, &metadata)
   8128 	}
   8129 	output := &ListResourceRecordSetsOutput{}
   8130 	out.Result = output
   8131 
   8132 	var buff [1024]byte
   8133 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8134 	body := io.TeeReader(response.Body, ringBuffer)
   8135 	rootDecoder := xml.NewDecoder(body)
   8136 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8137 	if err == io.EOF {
   8138 		return out, metadata, nil
   8139 	}
   8140 	if err != nil {
   8141 		var snapshot bytes.Buffer
   8142 		io.Copy(&snapshot, ringBuffer)
   8143 		return out, metadata, &smithy.DeserializationError{
   8144 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8145 			Snapshot: snapshot.Bytes(),
   8146 		}
   8147 	}
   8148 
   8149 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8150 	err = awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(&output, decoder)
   8151 	if err != nil {
   8152 		var snapshot bytes.Buffer
   8153 		io.Copy(&snapshot, ringBuffer)
   8154 		return out, metadata, &smithy.DeserializationError{
   8155 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8156 			Snapshot: snapshot.Bytes(),
   8157 		}
   8158 	}
   8159 
   8160 	return out, metadata, err
   8161 }
   8162 
   8163 func awsRestxml_deserializeOpErrorListResourceRecordSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8164 	var errorBuffer bytes.Buffer
   8165 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8166 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8167 	}
   8168 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8169 
   8170 	errorCode := "UnknownError"
   8171 	errorMessage := errorCode
   8172 
   8173 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8174 	if err != nil {
   8175 		return err
   8176 	}
   8177 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8178 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8179 	}
   8180 	if len(errorComponents.Code) != 0 {
   8181 		errorCode = errorComponents.Code
   8182 	}
   8183 	if len(errorComponents.Message) != 0 {
   8184 		errorMessage = errorComponents.Message
   8185 	}
   8186 	errorBody.Seek(0, io.SeekStart)
   8187 	switch {
   8188 	case strings.EqualFold("InvalidInput", errorCode):
   8189 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8190 
   8191 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   8192 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   8193 
   8194 	default:
   8195 		genericError := &smithy.GenericAPIError{
   8196 			Code:    errorCode,
   8197 			Message: errorMessage,
   8198 		}
   8199 		return genericError
   8200 
   8201 	}
   8202 }
   8203 
   8204 func awsRestxml_deserializeOpDocumentListResourceRecordSetsOutput(v **ListResourceRecordSetsOutput, decoder smithyxml.NodeDecoder) error {
   8205 	if v == nil {
   8206 		return fmt.Errorf("unexpected nil of type %T", v)
   8207 	}
   8208 	var sv *ListResourceRecordSetsOutput
   8209 	if *v == nil {
   8210 		sv = &ListResourceRecordSetsOutput{}
   8211 	} else {
   8212 		sv = *v
   8213 	}
   8214 
   8215 	for {
   8216 		t, done, err := decoder.Token()
   8217 		if err != nil {
   8218 			return err
   8219 		}
   8220 		if done {
   8221 			break
   8222 		}
   8223 		originalDecoder := decoder
   8224 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8225 		switch {
   8226 		case strings.EqualFold("IsTruncated", t.Name.Local):
   8227 			val, err := decoder.Value()
   8228 			if err != nil {
   8229 				return err
   8230 			}
   8231 			if val == nil {
   8232 				break
   8233 			}
   8234 			{
   8235 				xtv, err := strconv.ParseBool(string(val))
   8236 				if err != nil {
   8237 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   8238 				}
   8239 				sv.IsTruncated = xtv
   8240 			}
   8241 
   8242 		case strings.EqualFold("MaxItems", t.Name.Local):
   8243 			val, err := decoder.Value()
   8244 			if err != nil {
   8245 				return err
   8246 			}
   8247 			if val == nil {
   8248 				break
   8249 			}
   8250 			{
   8251 				xtv := string(val)
   8252 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8253 				if err != nil {
   8254 					return err
   8255 				}
   8256 				sv.MaxItems = ptr.Int32(int32(i64))
   8257 			}
   8258 
   8259 		case strings.EqualFold("NextRecordIdentifier", t.Name.Local):
   8260 			val, err := decoder.Value()
   8261 			if err != nil {
   8262 				return err
   8263 			}
   8264 			if val == nil {
   8265 				break
   8266 			}
   8267 			{
   8268 				xtv := string(val)
   8269 				sv.NextRecordIdentifier = ptr.String(xtv)
   8270 			}
   8271 
   8272 		case strings.EqualFold("NextRecordName", t.Name.Local):
   8273 			val, err := decoder.Value()
   8274 			if err != nil {
   8275 				return err
   8276 			}
   8277 			if val == nil {
   8278 				break
   8279 			}
   8280 			{
   8281 				xtv := string(val)
   8282 				sv.NextRecordName = ptr.String(xtv)
   8283 			}
   8284 
   8285 		case strings.EqualFold("NextRecordType", t.Name.Local):
   8286 			val, err := decoder.Value()
   8287 			if err != nil {
   8288 				return err
   8289 			}
   8290 			if val == nil {
   8291 				break
   8292 			}
   8293 			{
   8294 				xtv := string(val)
   8295 				sv.NextRecordType = types.RRType(xtv)
   8296 			}
   8297 
   8298 		case strings.EqualFold("ResourceRecordSets", t.Name.Local):
   8299 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8300 			if err := awsRestxml_deserializeDocumentResourceRecordSets(&sv.ResourceRecordSets, nodeDecoder); err != nil {
   8301 				return err
   8302 			}
   8303 
   8304 		default:
   8305 			// Do nothing and ignore the unexpected tag element
   8306 			err = decoder.Decoder.Skip()
   8307 			if err != nil {
   8308 				return err
   8309 			}
   8310 
   8311 		}
   8312 		decoder = originalDecoder
   8313 	}
   8314 	*v = sv
   8315 	return nil
   8316 }
   8317 
   8318 type awsRestxml_deserializeOpListReusableDelegationSets struct {
   8319 }
   8320 
   8321 func (*awsRestxml_deserializeOpListReusableDelegationSets) ID() string {
   8322 	return "OperationDeserializer"
   8323 }
   8324 
   8325 func (m *awsRestxml_deserializeOpListReusableDelegationSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8326 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8327 ) {
   8328 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8329 	if err != nil {
   8330 		return out, metadata, err
   8331 	}
   8332 
   8333 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8334 	if !ok {
   8335 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8336 	}
   8337 
   8338 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8339 		return out, metadata, awsRestxml_deserializeOpErrorListReusableDelegationSets(response, &metadata)
   8340 	}
   8341 	output := &ListReusableDelegationSetsOutput{}
   8342 	out.Result = output
   8343 
   8344 	var buff [1024]byte
   8345 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8346 	body := io.TeeReader(response.Body, ringBuffer)
   8347 	rootDecoder := xml.NewDecoder(body)
   8348 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8349 	if err == io.EOF {
   8350 		return out, metadata, nil
   8351 	}
   8352 	if err != nil {
   8353 		var snapshot bytes.Buffer
   8354 		io.Copy(&snapshot, ringBuffer)
   8355 		return out, metadata, &smithy.DeserializationError{
   8356 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8357 			Snapshot: snapshot.Bytes(),
   8358 		}
   8359 	}
   8360 
   8361 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8362 	err = awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(&output, decoder)
   8363 	if err != nil {
   8364 		var snapshot bytes.Buffer
   8365 		io.Copy(&snapshot, ringBuffer)
   8366 		return out, metadata, &smithy.DeserializationError{
   8367 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8368 			Snapshot: snapshot.Bytes(),
   8369 		}
   8370 	}
   8371 
   8372 	return out, metadata, err
   8373 }
   8374 
   8375 func awsRestxml_deserializeOpErrorListReusableDelegationSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8376 	var errorBuffer bytes.Buffer
   8377 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8378 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8379 	}
   8380 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8381 
   8382 	errorCode := "UnknownError"
   8383 	errorMessage := errorCode
   8384 
   8385 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8386 	if err != nil {
   8387 		return err
   8388 	}
   8389 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8390 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8391 	}
   8392 	if len(errorComponents.Code) != 0 {
   8393 		errorCode = errorComponents.Code
   8394 	}
   8395 	if len(errorComponents.Message) != 0 {
   8396 		errorMessage = errorComponents.Message
   8397 	}
   8398 	errorBody.Seek(0, io.SeekStart)
   8399 	switch {
   8400 	case strings.EqualFold("InvalidInput", errorCode):
   8401 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8402 
   8403 	default:
   8404 		genericError := &smithy.GenericAPIError{
   8405 			Code:    errorCode,
   8406 			Message: errorMessage,
   8407 		}
   8408 		return genericError
   8409 
   8410 	}
   8411 }
   8412 
   8413 func awsRestxml_deserializeOpDocumentListReusableDelegationSetsOutput(v **ListReusableDelegationSetsOutput, decoder smithyxml.NodeDecoder) error {
   8414 	if v == nil {
   8415 		return fmt.Errorf("unexpected nil of type %T", v)
   8416 	}
   8417 	var sv *ListReusableDelegationSetsOutput
   8418 	if *v == nil {
   8419 		sv = &ListReusableDelegationSetsOutput{}
   8420 	} else {
   8421 		sv = *v
   8422 	}
   8423 
   8424 	for {
   8425 		t, done, err := decoder.Token()
   8426 		if err != nil {
   8427 			return err
   8428 		}
   8429 		if done {
   8430 			break
   8431 		}
   8432 		originalDecoder := decoder
   8433 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8434 		switch {
   8435 		case strings.EqualFold("DelegationSets", t.Name.Local):
   8436 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8437 			if err := awsRestxml_deserializeDocumentDelegationSets(&sv.DelegationSets, nodeDecoder); err != nil {
   8438 				return err
   8439 			}
   8440 
   8441 		case strings.EqualFold("IsTruncated", t.Name.Local):
   8442 			val, err := decoder.Value()
   8443 			if err != nil {
   8444 				return err
   8445 			}
   8446 			if val == nil {
   8447 				break
   8448 			}
   8449 			{
   8450 				xtv, err := strconv.ParseBool(string(val))
   8451 				if err != nil {
   8452 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   8453 				}
   8454 				sv.IsTruncated = xtv
   8455 			}
   8456 
   8457 		case strings.EqualFold("Marker", t.Name.Local):
   8458 			val, err := decoder.Value()
   8459 			if err != nil {
   8460 				return err
   8461 			}
   8462 			if val == nil {
   8463 				break
   8464 			}
   8465 			{
   8466 				xtv := string(val)
   8467 				sv.Marker = ptr.String(xtv)
   8468 			}
   8469 
   8470 		case strings.EqualFold("MaxItems", t.Name.Local):
   8471 			val, err := decoder.Value()
   8472 			if err != nil {
   8473 				return err
   8474 			}
   8475 			if val == nil {
   8476 				break
   8477 			}
   8478 			{
   8479 				xtv := string(val)
   8480 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8481 				if err != nil {
   8482 					return err
   8483 				}
   8484 				sv.MaxItems = ptr.Int32(int32(i64))
   8485 			}
   8486 
   8487 		case strings.EqualFold("NextMarker", t.Name.Local):
   8488 			val, err := decoder.Value()
   8489 			if err != nil {
   8490 				return err
   8491 			}
   8492 			if val == nil {
   8493 				break
   8494 			}
   8495 			{
   8496 				xtv := string(val)
   8497 				sv.NextMarker = ptr.String(xtv)
   8498 			}
   8499 
   8500 		default:
   8501 			// Do nothing and ignore the unexpected tag element
   8502 			err = decoder.Decoder.Skip()
   8503 			if err != nil {
   8504 				return err
   8505 			}
   8506 
   8507 		}
   8508 		decoder = originalDecoder
   8509 	}
   8510 	*v = sv
   8511 	return nil
   8512 }
   8513 
   8514 type awsRestxml_deserializeOpListTagsForResource struct {
   8515 }
   8516 
   8517 func (*awsRestxml_deserializeOpListTagsForResource) ID() string {
   8518 	return "OperationDeserializer"
   8519 }
   8520 
   8521 func (m *awsRestxml_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8522 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8523 ) {
   8524 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8525 	if err != nil {
   8526 		return out, metadata, err
   8527 	}
   8528 
   8529 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8530 	if !ok {
   8531 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8532 	}
   8533 
   8534 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8535 		return out, metadata, awsRestxml_deserializeOpErrorListTagsForResource(response, &metadata)
   8536 	}
   8537 	output := &ListTagsForResourceOutput{}
   8538 	out.Result = output
   8539 
   8540 	var buff [1024]byte
   8541 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8542 	body := io.TeeReader(response.Body, ringBuffer)
   8543 	rootDecoder := xml.NewDecoder(body)
   8544 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8545 	if err == io.EOF {
   8546 		return out, metadata, nil
   8547 	}
   8548 	if err != nil {
   8549 		var snapshot bytes.Buffer
   8550 		io.Copy(&snapshot, ringBuffer)
   8551 		return out, metadata, &smithy.DeserializationError{
   8552 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8553 			Snapshot: snapshot.Bytes(),
   8554 		}
   8555 	}
   8556 
   8557 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8558 	err = awsRestxml_deserializeOpDocumentListTagsForResourceOutput(&output, decoder)
   8559 	if err != nil {
   8560 		var snapshot bytes.Buffer
   8561 		io.Copy(&snapshot, ringBuffer)
   8562 		return out, metadata, &smithy.DeserializationError{
   8563 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8564 			Snapshot: snapshot.Bytes(),
   8565 		}
   8566 	}
   8567 
   8568 	return out, metadata, err
   8569 }
   8570 
   8571 func awsRestxml_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8572 	var errorBuffer bytes.Buffer
   8573 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8574 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8575 	}
   8576 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8577 
   8578 	errorCode := "UnknownError"
   8579 	errorMessage := errorCode
   8580 
   8581 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8582 	if err != nil {
   8583 		return err
   8584 	}
   8585 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8586 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8587 	}
   8588 	if len(errorComponents.Code) != 0 {
   8589 		errorCode = errorComponents.Code
   8590 	}
   8591 	if len(errorComponents.Message) != 0 {
   8592 		errorMessage = errorComponents.Message
   8593 	}
   8594 	errorBody.Seek(0, io.SeekStart)
   8595 	switch {
   8596 	case strings.EqualFold("InvalidInput", errorCode):
   8597 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8598 
   8599 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   8600 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   8601 
   8602 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   8603 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   8604 
   8605 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   8606 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   8607 
   8608 	case strings.EqualFold("ThrottlingException", errorCode):
   8609 		return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
   8610 
   8611 	default:
   8612 		genericError := &smithy.GenericAPIError{
   8613 			Code:    errorCode,
   8614 			Message: errorMessage,
   8615 		}
   8616 		return genericError
   8617 
   8618 	}
   8619 }
   8620 
   8621 func awsRestxml_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, decoder smithyxml.NodeDecoder) error {
   8622 	if v == nil {
   8623 		return fmt.Errorf("unexpected nil of type %T", v)
   8624 	}
   8625 	var sv *ListTagsForResourceOutput
   8626 	if *v == nil {
   8627 		sv = &ListTagsForResourceOutput{}
   8628 	} else {
   8629 		sv = *v
   8630 	}
   8631 
   8632 	for {
   8633 		t, done, err := decoder.Token()
   8634 		if err != nil {
   8635 			return err
   8636 		}
   8637 		if done {
   8638 			break
   8639 		}
   8640 		originalDecoder := decoder
   8641 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8642 		switch {
   8643 		case strings.EqualFold("ResourceTagSet", t.Name.Local):
   8644 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8645 			if err := awsRestxml_deserializeDocumentResourceTagSet(&sv.ResourceTagSet, nodeDecoder); err != nil {
   8646 				return err
   8647 			}
   8648 
   8649 		default:
   8650 			// Do nothing and ignore the unexpected tag element
   8651 			err = decoder.Decoder.Skip()
   8652 			if err != nil {
   8653 				return err
   8654 			}
   8655 
   8656 		}
   8657 		decoder = originalDecoder
   8658 	}
   8659 	*v = sv
   8660 	return nil
   8661 }
   8662 
   8663 type awsRestxml_deserializeOpListTagsForResources struct {
   8664 }
   8665 
   8666 func (*awsRestxml_deserializeOpListTagsForResources) ID() string {
   8667 	return "OperationDeserializer"
   8668 }
   8669 
   8670 func (m *awsRestxml_deserializeOpListTagsForResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8671 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8672 ) {
   8673 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8674 	if err != nil {
   8675 		return out, metadata, err
   8676 	}
   8677 
   8678 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8679 	if !ok {
   8680 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8681 	}
   8682 
   8683 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8684 		return out, metadata, awsRestxml_deserializeOpErrorListTagsForResources(response, &metadata)
   8685 	}
   8686 	output := &ListTagsForResourcesOutput{}
   8687 	out.Result = output
   8688 
   8689 	var buff [1024]byte
   8690 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8691 	body := io.TeeReader(response.Body, ringBuffer)
   8692 	rootDecoder := xml.NewDecoder(body)
   8693 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8694 	if err == io.EOF {
   8695 		return out, metadata, nil
   8696 	}
   8697 	if err != nil {
   8698 		var snapshot bytes.Buffer
   8699 		io.Copy(&snapshot, ringBuffer)
   8700 		return out, metadata, &smithy.DeserializationError{
   8701 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8702 			Snapshot: snapshot.Bytes(),
   8703 		}
   8704 	}
   8705 
   8706 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8707 	err = awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(&output, decoder)
   8708 	if err != nil {
   8709 		var snapshot bytes.Buffer
   8710 		io.Copy(&snapshot, ringBuffer)
   8711 		return out, metadata, &smithy.DeserializationError{
   8712 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8713 			Snapshot: snapshot.Bytes(),
   8714 		}
   8715 	}
   8716 
   8717 	return out, metadata, err
   8718 }
   8719 
   8720 func awsRestxml_deserializeOpErrorListTagsForResources(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8721 	var errorBuffer bytes.Buffer
   8722 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8723 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8724 	}
   8725 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8726 
   8727 	errorCode := "UnknownError"
   8728 	errorMessage := errorCode
   8729 
   8730 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8731 	if err != nil {
   8732 		return err
   8733 	}
   8734 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8735 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8736 	}
   8737 	if len(errorComponents.Code) != 0 {
   8738 		errorCode = errorComponents.Code
   8739 	}
   8740 	if len(errorComponents.Message) != 0 {
   8741 		errorMessage = errorComponents.Message
   8742 	}
   8743 	errorBody.Seek(0, io.SeekStart)
   8744 	switch {
   8745 	case strings.EqualFold("InvalidInput", errorCode):
   8746 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8747 
   8748 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
   8749 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
   8750 
   8751 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   8752 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   8753 
   8754 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
   8755 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
   8756 
   8757 	case strings.EqualFold("ThrottlingException", errorCode):
   8758 		return awsRestxml_deserializeErrorThrottlingException(response, errorBody)
   8759 
   8760 	default:
   8761 		genericError := &smithy.GenericAPIError{
   8762 			Code:    errorCode,
   8763 			Message: errorMessage,
   8764 		}
   8765 		return genericError
   8766 
   8767 	}
   8768 }
   8769 
   8770 func awsRestxml_deserializeOpDocumentListTagsForResourcesOutput(v **ListTagsForResourcesOutput, decoder smithyxml.NodeDecoder) error {
   8771 	if v == nil {
   8772 		return fmt.Errorf("unexpected nil of type %T", v)
   8773 	}
   8774 	var sv *ListTagsForResourcesOutput
   8775 	if *v == nil {
   8776 		sv = &ListTagsForResourcesOutput{}
   8777 	} else {
   8778 		sv = *v
   8779 	}
   8780 
   8781 	for {
   8782 		t, done, err := decoder.Token()
   8783 		if err != nil {
   8784 			return err
   8785 		}
   8786 		if done {
   8787 			break
   8788 		}
   8789 		originalDecoder := decoder
   8790 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8791 		switch {
   8792 		case strings.EqualFold("ResourceTagSets", t.Name.Local):
   8793 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8794 			if err := awsRestxml_deserializeDocumentResourceTagSetList(&sv.ResourceTagSets, nodeDecoder); err != nil {
   8795 				return err
   8796 			}
   8797 
   8798 		default:
   8799 			// Do nothing and ignore the unexpected tag element
   8800 			err = decoder.Decoder.Skip()
   8801 			if err != nil {
   8802 				return err
   8803 			}
   8804 
   8805 		}
   8806 		decoder = originalDecoder
   8807 	}
   8808 	*v = sv
   8809 	return nil
   8810 }
   8811 
   8812 type awsRestxml_deserializeOpListTrafficPolicies struct {
   8813 }
   8814 
   8815 func (*awsRestxml_deserializeOpListTrafficPolicies) ID() string {
   8816 	return "OperationDeserializer"
   8817 }
   8818 
   8819 func (m *awsRestxml_deserializeOpListTrafficPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   8820 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   8821 ) {
   8822 	out, metadata, err = next.HandleDeserialize(ctx, in)
   8823 	if err != nil {
   8824 		return out, metadata, err
   8825 	}
   8826 
   8827 	response, ok := out.RawResponse.(*smithyhttp.Response)
   8828 	if !ok {
   8829 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   8830 	}
   8831 
   8832 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   8833 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicies(response, &metadata)
   8834 	}
   8835 	output := &ListTrafficPoliciesOutput{}
   8836 	out.Result = output
   8837 
   8838 	var buff [1024]byte
   8839 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   8840 	body := io.TeeReader(response.Body, ringBuffer)
   8841 	rootDecoder := xml.NewDecoder(body)
   8842 	t, err := smithyxml.FetchRootElement(rootDecoder)
   8843 	if err == io.EOF {
   8844 		return out, metadata, nil
   8845 	}
   8846 	if err != nil {
   8847 		var snapshot bytes.Buffer
   8848 		io.Copy(&snapshot, ringBuffer)
   8849 		return out, metadata, &smithy.DeserializationError{
   8850 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8851 			Snapshot: snapshot.Bytes(),
   8852 		}
   8853 	}
   8854 
   8855 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   8856 	err = awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(&output, decoder)
   8857 	if err != nil {
   8858 		var snapshot bytes.Buffer
   8859 		io.Copy(&snapshot, ringBuffer)
   8860 		return out, metadata, &smithy.DeserializationError{
   8861 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   8862 			Snapshot: snapshot.Bytes(),
   8863 		}
   8864 	}
   8865 
   8866 	return out, metadata, err
   8867 }
   8868 
   8869 func awsRestxml_deserializeOpErrorListTrafficPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   8870 	var errorBuffer bytes.Buffer
   8871 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   8872 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   8873 	}
   8874 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   8875 
   8876 	errorCode := "UnknownError"
   8877 	errorMessage := errorCode
   8878 
   8879 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   8880 	if err != nil {
   8881 		return err
   8882 	}
   8883 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   8884 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   8885 	}
   8886 	if len(errorComponents.Code) != 0 {
   8887 		errorCode = errorComponents.Code
   8888 	}
   8889 	if len(errorComponents.Message) != 0 {
   8890 		errorMessage = errorComponents.Message
   8891 	}
   8892 	errorBody.Seek(0, io.SeekStart)
   8893 	switch {
   8894 	case strings.EqualFold("InvalidInput", errorCode):
   8895 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   8896 
   8897 	default:
   8898 		genericError := &smithy.GenericAPIError{
   8899 			Code:    errorCode,
   8900 			Message: errorMessage,
   8901 		}
   8902 		return genericError
   8903 
   8904 	}
   8905 }
   8906 
   8907 func awsRestxml_deserializeOpDocumentListTrafficPoliciesOutput(v **ListTrafficPoliciesOutput, decoder smithyxml.NodeDecoder) error {
   8908 	if v == nil {
   8909 		return fmt.Errorf("unexpected nil of type %T", v)
   8910 	}
   8911 	var sv *ListTrafficPoliciesOutput
   8912 	if *v == nil {
   8913 		sv = &ListTrafficPoliciesOutput{}
   8914 	} else {
   8915 		sv = *v
   8916 	}
   8917 
   8918 	for {
   8919 		t, done, err := decoder.Token()
   8920 		if err != nil {
   8921 			return err
   8922 		}
   8923 		if done {
   8924 			break
   8925 		}
   8926 		originalDecoder := decoder
   8927 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   8928 		switch {
   8929 		case strings.EqualFold("IsTruncated", t.Name.Local):
   8930 			val, err := decoder.Value()
   8931 			if err != nil {
   8932 				return err
   8933 			}
   8934 			if val == nil {
   8935 				break
   8936 			}
   8937 			{
   8938 				xtv, err := strconv.ParseBool(string(val))
   8939 				if err != nil {
   8940 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   8941 				}
   8942 				sv.IsTruncated = xtv
   8943 			}
   8944 
   8945 		case strings.EqualFold("MaxItems", t.Name.Local):
   8946 			val, err := decoder.Value()
   8947 			if err != nil {
   8948 				return err
   8949 			}
   8950 			if val == nil {
   8951 				break
   8952 			}
   8953 			{
   8954 				xtv := string(val)
   8955 				i64, err := strconv.ParseInt(xtv, 10, 64)
   8956 				if err != nil {
   8957 					return err
   8958 				}
   8959 				sv.MaxItems = ptr.Int32(int32(i64))
   8960 			}
   8961 
   8962 		case strings.EqualFold("TrafficPolicyIdMarker", t.Name.Local):
   8963 			val, err := decoder.Value()
   8964 			if err != nil {
   8965 				return err
   8966 			}
   8967 			if val == nil {
   8968 				break
   8969 			}
   8970 			{
   8971 				xtv := string(val)
   8972 				sv.TrafficPolicyIdMarker = ptr.String(xtv)
   8973 			}
   8974 
   8975 		case strings.EqualFold("TrafficPolicySummaries", t.Name.Local):
   8976 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   8977 			if err := awsRestxml_deserializeDocumentTrafficPolicySummaries(&sv.TrafficPolicySummaries, nodeDecoder); err != nil {
   8978 				return err
   8979 			}
   8980 
   8981 		default:
   8982 			// Do nothing and ignore the unexpected tag element
   8983 			err = decoder.Decoder.Skip()
   8984 			if err != nil {
   8985 				return err
   8986 			}
   8987 
   8988 		}
   8989 		decoder = originalDecoder
   8990 	}
   8991 	*v = sv
   8992 	return nil
   8993 }
   8994 
   8995 type awsRestxml_deserializeOpListTrafficPolicyInstances struct {
   8996 }
   8997 
   8998 func (*awsRestxml_deserializeOpListTrafficPolicyInstances) ID() string {
   8999 	return "OperationDeserializer"
   9000 }
   9001 
   9002 func (m *awsRestxml_deserializeOpListTrafficPolicyInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9003 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9004 ) {
   9005 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9006 	if err != nil {
   9007 		return out, metadata, err
   9008 	}
   9009 
   9010 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9011 	if !ok {
   9012 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9013 	}
   9014 
   9015 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9016 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response, &metadata)
   9017 	}
   9018 	output := &ListTrafficPolicyInstancesOutput{}
   9019 	out.Result = output
   9020 
   9021 	var buff [1024]byte
   9022 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9023 	body := io.TeeReader(response.Body, ringBuffer)
   9024 	rootDecoder := xml.NewDecoder(body)
   9025 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9026 	if err == io.EOF {
   9027 		return out, metadata, nil
   9028 	}
   9029 	if err != nil {
   9030 		var snapshot bytes.Buffer
   9031 		io.Copy(&snapshot, ringBuffer)
   9032 		return out, metadata, &smithy.DeserializationError{
   9033 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9034 			Snapshot: snapshot.Bytes(),
   9035 		}
   9036 	}
   9037 
   9038 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9039 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(&output, decoder)
   9040 	if err != nil {
   9041 		var snapshot bytes.Buffer
   9042 		io.Copy(&snapshot, ringBuffer)
   9043 		return out, metadata, &smithy.DeserializationError{
   9044 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9045 			Snapshot: snapshot.Bytes(),
   9046 		}
   9047 	}
   9048 
   9049 	return out, metadata, err
   9050 }
   9051 
   9052 func awsRestxml_deserializeOpErrorListTrafficPolicyInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9053 	var errorBuffer bytes.Buffer
   9054 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9055 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9056 	}
   9057 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9058 
   9059 	errorCode := "UnknownError"
   9060 	errorMessage := errorCode
   9061 
   9062 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9063 	if err != nil {
   9064 		return err
   9065 	}
   9066 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9067 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9068 	}
   9069 	if len(errorComponents.Code) != 0 {
   9070 		errorCode = errorComponents.Code
   9071 	}
   9072 	if len(errorComponents.Message) != 0 {
   9073 		errorMessage = errorComponents.Message
   9074 	}
   9075 	errorBody.Seek(0, io.SeekStart)
   9076 	switch {
   9077 	case strings.EqualFold("InvalidInput", errorCode):
   9078 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9079 
   9080 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   9081 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   9082 
   9083 	default:
   9084 		genericError := &smithy.GenericAPIError{
   9085 			Code:    errorCode,
   9086 			Message: errorMessage,
   9087 		}
   9088 		return genericError
   9089 
   9090 	}
   9091 }
   9092 
   9093 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesOutput(v **ListTrafficPolicyInstancesOutput, decoder smithyxml.NodeDecoder) error {
   9094 	if v == nil {
   9095 		return fmt.Errorf("unexpected nil of type %T", v)
   9096 	}
   9097 	var sv *ListTrafficPolicyInstancesOutput
   9098 	if *v == nil {
   9099 		sv = &ListTrafficPolicyInstancesOutput{}
   9100 	} else {
   9101 		sv = *v
   9102 	}
   9103 
   9104 	for {
   9105 		t, done, err := decoder.Token()
   9106 		if err != nil {
   9107 			return err
   9108 		}
   9109 		if done {
   9110 			break
   9111 		}
   9112 		originalDecoder := decoder
   9113 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9114 		switch {
   9115 		case strings.EqualFold("HostedZoneIdMarker", t.Name.Local):
   9116 			val, err := decoder.Value()
   9117 			if err != nil {
   9118 				return err
   9119 			}
   9120 			if val == nil {
   9121 				break
   9122 			}
   9123 			{
   9124 				xtv := string(val)
   9125 				sv.HostedZoneIdMarker = ptr.String(xtv)
   9126 			}
   9127 
   9128 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9129 			val, err := decoder.Value()
   9130 			if err != nil {
   9131 				return err
   9132 			}
   9133 			if val == nil {
   9134 				break
   9135 			}
   9136 			{
   9137 				xtv, err := strconv.ParseBool(string(val))
   9138 				if err != nil {
   9139 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9140 				}
   9141 				sv.IsTruncated = xtv
   9142 			}
   9143 
   9144 		case strings.EqualFold("MaxItems", t.Name.Local):
   9145 			val, err := decoder.Value()
   9146 			if err != nil {
   9147 				return err
   9148 			}
   9149 			if val == nil {
   9150 				break
   9151 			}
   9152 			{
   9153 				xtv := string(val)
   9154 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9155 				if err != nil {
   9156 					return err
   9157 				}
   9158 				sv.MaxItems = ptr.Int32(int32(i64))
   9159 			}
   9160 
   9161 		case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
   9162 			val, err := decoder.Value()
   9163 			if err != nil {
   9164 				return err
   9165 			}
   9166 			if val == nil {
   9167 				break
   9168 			}
   9169 			{
   9170 				xtv := string(val)
   9171 				sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
   9172 			}
   9173 
   9174 		case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
   9175 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9176 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
   9177 				return err
   9178 			}
   9179 
   9180 		case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
   9181 			val, err := decoder.Value()
   9182 			if err != nil {
   9183 				return err
   9184 			}
   9185 			if val == nil {
   9186 				break
   9187 			}
   9188 			{
   9189 				xtv := string(val)
   9190 				sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
   9191 			}
   9192 
   9193 		default:
   9194 			// Do nothing and ignore the unexpected tag element
   9195 			err = decoder.Decoder.Skip()
   9196 			if err != nil {
   9197 				return err
   9198 			}
   9199 
   9200 		}
   9201 		decoder = originalDecoder
   9202 	}
   9203 	*v = sv
   9204 	return nil
   9205 }
   9206 
   9207 type awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone struct {
   9208 }
   9209 
   9210 func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) ID() string {
   9211 	return "OperationDeserializer"
   9212 }
   9213 
   9214 func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByHostedZone) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9215 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9216 ) {
   9217 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9218 	if err != nil {
   9219 		return out, metadata, err
   9220 	}
   9221 
   9222 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9223 	if !ok {
   9224 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9225 	}
   9226 
   9227 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9228 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response, &metadata)
   9229 	}
   9230 	output := &ListTrafficPolicyInstancesByHostedZoneOutput{}
   9231 	out.Result = output
   9232 
   9233 	var buff [1024]byte
   9234 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9235 	body := io.TeeReader(response.Body, ringBuffer)
   9236 	rootDecoder := xml.NewDecoder(body)
   9237 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9238 	if err == io.EOF {
   9239 		return out, metadata, nil
   9240 	}
   9241 	if err != nil {
   9242 		var snapshot bytes.Buffer
   9243 		io.Copy(&snapshot, ringBuffer)
   9244 		return out, metadata, &smithy.DeserializationError{
   9245 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9246 			Snapshot: snapshot.Bytes(),
   9247 		}
   9248 	}
   9249 
   9250 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9251 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(&output, decoder)
   9252 	if err != nil {
   9253 		var snapshot bytes.Buffer
   9254 		io.Copy(&snapshot, ringBuffer)
   9255 		return out, metadata, &smithy.DeserializationError{
   9256 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9257 			Snapshot: snapshot.Bytes(),
   9258 		}
   9259 	}
   9260 
   9261 	return out, metadata, err
   9262 }
   9263 
   9264 func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByHostedZone(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9265 	var errorBuffer bytes.Buffer
   9266 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9267 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9268 	}
   9269 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9270 
   9271 	errorCode := "UnknownError"
   9272 	errorMessage := errorCode
   9273 
   9274 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9275 	if err != nil {
   9276 		return err
   9277 	}
   9278 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9279 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9280 	}
   9281 	if len(errorComponents.Code) != 0 {
   9282 		errorCode = errorComponents.Code
   9283 	}
   9284 	if len(errorComponents.Message) != 0 {
   9285 		errorMessage = errorComponents.Message
   9286 	}
   9287 	errorBody.Seek(0, io.SeekStart)
   9288 	switch {
   9289 	case strings.EqualFold("InvalidInput", errorCode):
   9290 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9291 
   9292 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   9293 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   9294 
   9295 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   9296 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   9297 
   9298 	default:
   9299 		genericError := &smithy.GenericAPIError{
   9300 			Code:    errorCode,
   9301 			Message: errorMessage,
   9302 		}
   9303 		return genericError
   9304 
   9305 	}
   9306 }
   9307 
   9308 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByHostedZoneOutput(v **ListTrafficPolicyInstancesByHostedZoneOutput, decoder smithyxml.NodeDecoder) error {
   9309 	if v == nil {
   9310 		return fmt.Errorf("unexpected nil of type %T", v)
   9311 	}
   9312 	var sv *ListTrafficPolicyInstancesByHostedZoneOutput
   9313 	if *v == nil {
   9314 		sv = &ListTrafficPolicyInstancesByHostedZoneOutput{}
   9315 	} else {
   9316 		sv = *v
   9317 	}
   9318 
   9319 	for {
   9320 		t, done, err := decoder.Token()
   9321 		if err != nil {
   9322 			return err
   9323 		}
   9324 		if done {
   9325 			break
   9326 		}
   9327 		originalDecoder := decoder
   9328 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9329 		switch {
   9330 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9331 			val, err := decoder.Value()
   9332 			if err != nil {
   9333 				return err
   9334 			}
   9335 			if val == nil {
   9336 				break
   9337 			}
   9338 			{
   9339 				xtv, err := strconv.ParseBool(string(val))
   9340 				if err != nil {
   9341 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9342 				}
   9343 				sv.IsTruncated = xtv
   9344 			}
   9345 
   9346 		case strings.EqualFold("MaxItems", t.Name.Local):
   9347 			val, err := decoder.Value()
   9348 			if err != nil {
   9349 				return err
   9350 			}
   9351 			if val == nil {
   9352 				break
   9353 			}
   9354 			{
   9355 				xtv := string(val)
   9356 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9357 				if err != nil {
   9358 					return err
   9359 				}
   9360 				sv.MaxItems = ptr.Int32(int32(i64))
   9361 			}
   9362 
   9363 		case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
   9364 			val, err := decoder.Value()
   9365 			if err != nil {
   9366 				return err
   9367 			}
   9368 			if val == nil {
   9369 				break
   9370 			}
   9371 			{
   9372 				xtv := string(val)
   9373 				sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
   9374 			}
   9375 
   9376 		case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
   9377 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9378 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
   9379 				return err
   9380 			}
   9381 
   9382 		case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
   9383 			val, err := decoder.Value()
   9384 			if err != nil {
   9385 				return err
   9386 			}
   9387 			if val == nil {
   9388 				break
   9389 			}
   9390 			{
   9391 				xtv := string(val)
   9392 				sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
   9393 			}
   9394 
   9395 		default:
   9396 			// Do nothing and ignore the unexpected tag element
   9397 			err = decoder.Decoder.Skip()
   9398 			if err != nil {
   9399 				return err
   9400 			}
   9401 
   9402 		}
   9403 		decoder = originalDecoder
   9404 	}
   9405 	*v = sv
   9406 	return nil
   9407 }
   9408 
   9409 type awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy struct {
   9410 }
   9411 
   9412 func (*awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) ID() string {
   9413 	return "OperationDeserializer"
   9414 }
   9415 
   9416 func (m *awsRestxml_deserializeOpListTrafficPolicyInstancesByPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9417 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9418 ) {
   9419 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9420 	if err != nil {
   9421 		return out, metadata, err
   9422 	}
   9423 
   9424 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9425 	if !ok {
   9426 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9427 	}
   9428 
   9429 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9430 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response, &metadata)
   9431 	}
   9432 	output := &ListTrafficPolicyInstancesByPolicyOutput{}
   9433 	out.Result = output
   9434 
   9435 	var buff [1024]byte
   9436 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9437 	body := io.TeeReader(response.Body, ringBuffer)
   9438 	rootDecoder := xml.NewDecoder(body)
   9439 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9440 	if err == io.EOF {
   9441 		return out, metadata, nil
   9442 	}
   9443 	if err != nil {
   9444 		var snapshot bytes.Buffer
   9445 		io.Copy(&snapshot, ringBuffer)
   9446 		return out, metadata, &smithy.DeserializationError{
   9447 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9448 			Snapshot: snapshot.Bytes(),
   9449 		}
   9450 	}
   9451 
   9452 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9453 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(&output, decoder)
   9454 	if err != nil {
   9455 		var snapshot bytes.Buffer
   9456 		io.Copy(&snapshot, ringBuffer)
   9457 		return out, metadata, &smithy.DeserializationError{
   9458 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9459 			Snapshot: snapshot.Bytes(),
   9460 		}
   9461 	}
   9462 
   9463 	return out, metadata, err
   9464 }
   9465 
   9466 func awsRestxml_deserializeOpErrorListTrafficPolicyInstancesByPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9467 	var errorBuffer bytes.Buffer
   9468 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9469 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9470 	}
   9471 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9472 
   9473 	errorCode := "UnknownError"
   9474 	errorMessage := errorCode
   9475 
   9476 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9477 	if err != nil {
   9478 		return err
   9479 	}
   9480 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9481 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9482 	}
   9483 	if len(errorComponents.Code) != 0 {
   9484 		errorCode = errorComponents.Code
   9485 	}
   9486 	if len(errorComponents.Message) != 0 {
   9487 		errorMessage = errorComponents.Message
   9488 	}
   9489 	errorBody.Seek(0, io.SeekStart)
   9490 	switch {
   9491 	case strings.EqualFold("InvalidInput", errorCode):
   9492 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9493 
   9494 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   9495 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   9496 
   9497 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
   9498 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
   9499 
   9500 	default:
   9501 		genericError := &smithy.GenericAPIError{
   9502 			Code:    errorCode,
   9503 			Message: errorMessage,
   9504 		}
   9505 		return genericError
   9506 
   9507 	}
   9508 }
   9509 
   9510 func awsRestxml_deserializeOpDocumentListTrafficPolicyInstancesByPolicyOutput(v **ListTrafficPolicyInstancesByPolicyOutput, decoder smithyxml.NodeDecoder) error {
   9511 	if v == nil {
   9512 		return fmt.Errorf("unexpected nil of type %T", v)
   9513 	}
   9514 	var sv *ListTrafficPolicyInstancesByPolicyOutput
   9515 	if *v == nil {
   9516 		sv = &ListTrafficPolicyInstancesByPolicyOutput{}
   9517 	} else {
   9518 		sv = *v
   9519 	}
   9520 
   9521 	for {
   9522 		t, done, err := decoder.Token()
   9523 		if err != nil {
   9524 			return err
   9525 		}
   9526 		if done {
   9527 			break
   9528 		}
   9529 		originalDecoder := decoder
   9530 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9531 		switch {
   9532 		case strings.EqualFold("HostedZoneIdMarker", t.Name.Local):
   9533 			val, err := decoder.Value()
   9534 			if err != nil {
   9535 				return err
   9536 			}
   9537 			if val == nil {
   9538 				break
   9539 			}
   9540 			{
   9541 				xtv := string(val)
   9542 				sv.HostedZoneIdMarker = ptr.String(xtv)
   9543 			}
   9544 
   9545 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9546 			val, err := decoder.Value()
   9547 			if err != nil {
   9548 				return err
   9549 			}
   9550 			if val == nil {
   9551 				break
   9552 			}
   9553 			{
   9554 				xtv, err := strconv.ParseBool(string(val))
   9555 				if err != nil {
   9556 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9557 				}
   9558 				sv.IsTruncated = xtv
   9559 			}
   9560 
   9561 		case strings.EqualFold("MaxItems", t.Name.Local):
   9562 			val, err := decoder.Value()
   9563 			if err != nil {
   9564 				return err
   9565 			}
   9566 			if val == nil {
   9567 				break
   9568 			}
   9569 			{
   9570 				xtv := string(val)
   9571 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9572 				if err != nil {
   9573 					return err
   9574 				}
   9575 				sv.MaxItems = ptr.Int32(int32(i64))
   9576 			}
   9577 
   9578 		case strings.EqualFold("TrafficPolicyInstanceNameMarker", t.Name.Local):
   9579 			val, err := decoder.Value()
   9580 			if err != nil {
   9581 				return err
   9582 			}
   9583 			if val == nil {
   9584 				break
   9585 			}
   9586 			{
   9587 				xtv := string(val)
   9588 				sv.TrafficPolicyInstanceNameMarker = ptr.String(xtv)
   9589 			}
   9590 
   9591 		case strings.EqualFold("TrafficPolicyInstances", t.Name.Local):
   9592 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9593 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstances(&sv.TrafficPolicyInstances, nodeDecoder); err != nil {
   9594 				return err
   9595 			}
   9596 
   9597 		case strings.EqualFold("TrafficPolicyInstanceTypeMarker", t.Name.Local):
   9598 			val, err := decoder.Value()
   9599 			if err != nil {
   9600 				return err
   9601 			}
   9602 			if val == nil {
   9603 				break
   9604 			}
   9605 			{
   9606 				xtv := string(val)
   9607 				sv.TrafficPolicyInstanceTypeMarker = types.RRType(xtv)
   9608 			}
   9609 
   9610 		default:
   9611 			// Do nothing and ignore the unexpected tag element
   9612 			err = decoder.Decoder.Skip()
   9613 			if err != nil {
   9614 				return err
   9615 			}
   9616 
   9617 		}
   9618 		decoder = originalDecoder
   9619 	}
   9620 	*v = sv
   9621 	return nil
   9622 }
   9623 
   9624 type awsRestxml_deserializeOpListTrafficPolicyVersions struct {
   9625 }
   9626 
   9627 func (*awsRestxml_deserializeOpListTrafficPolicyVersions) ID() string {
   9628 	return "OperationDeserializer"
   9629 }
   9630 
   9631 func (m *awsRestxml_deserializeOpListTrafficPolicyVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9632 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9633 ) {
   9634 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9635 	if err != nil {
   9636 		return out, metadata, err
   9637 	}
   9638 
   9639 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9640 	if !ok {
   9641 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9642 	}
   9643 
   9644 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9645 		return out, metadata, awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response, &metadata)
   9646 	}
   9647 	output := &ListTrafficPolicyVersionsOutput{}
   9648 	out.Result = output
   9649 
   9650 	var buff [1024]byte
   9651 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9652 	body := io.TeeReader(response.Body, ringBuffer)
   9653 	rootDecoder := xml.NewDecoder(body)
   9654 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9655 	if err == io.EOF {
   9656 		return out, metadata, nil
   9657 	}
   9658 	if err != nil {
   9659 		var snapshot bytes.Buffer
   9660 		io.Copy(&snapshot, ringBuffer)
   9661 		return out, metadata, &smithy.DeserializationError{
   9662 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9663 			Snapshot: snapshot.Bytes(),
   9664 		}
   9665 	}
   9666 
   9667 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9668 	err = awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(&output, decoder)
   9669 	if err != nil {
   9670 		var snapshot bytes.Buffer
   9671 		io.Copy(&snapshot, ringBuffer)
   9672 		return out, metadata, &smithy.DeserializationError{
   9673 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9674 			Snapshot: snapshot.Bytes(),
   9675 		}
   9676 	}
   9677 
   9678 	return out, metadata, err
   9679 }
   9680 
   9681 func awsRestxml_deserializeOpErrorListTrafficPolicyVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9682 	var errorBuffer bytes.Buffer
   9683 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9684 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9685 	}
   9686 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9687 
   9688 	errorCode := "UnknownError"
   9689 	errorMessage := errorCode
   9690 
   9691 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9692 	if err != nil {
   9693 		return err
   9694 	}
   9695 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9696 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9697 	}
   9698 	if len(errorComponents.Code) != 0 {
   9699 		errorCode = errorComponents.Code
   9700 	}
   9701 	if len(errorComponents.Message) != 0 {
   9702 		errorMessage = errorComponents.Message
   9703 	}
   9704 	errorBody.Seek(0, io.SeekStart)
   9705 	switch {
   9706 	case strings.EqualFold("InvalidInput", errorCode):
   9707 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9708 
   9709 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
   9710 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
   9711 
   9712 	default:
   9713 		genericError := &smithy.GenericAPIError{
   9714 			Code:    errorCode,
   9715 			Message: errorMessage,
   9716 		}
   9717 		return genericError
   9718 
   9719 	}
   9720 }
   9721 
   9722 func awsRestxml_deserializeOpDocumentListTrafficPolicyVersionsOutput(v **ListTrafficPolicyVersionsOutput, decoder smithyxml.NodeDecoder) error {
   9723 	if v == nil {
   9724 		return fmt.Errorf("unexpected nil of type %T", v)
   9725 	}
   9726 	var sv *ListTrafficPolicyVersionsOutput
   9727 	if *v == nil {
   9728 		sv = &ListTrafficPolicyVersionsOutput{}
   9729 	} else {
   9730 		sv = *v
   9731 	}
   9732 
   9733 	for {
   9734 		t, done, err := decoder.Token()
   9735 		if err != nil {
   9736 			return err
   9737 		}
   9738 		if done {
   9739 			break
   9740 		}
   9741 		originalDecoder := decoder
   9742 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9743 		switch {
   9744 		case strings.EqualFold("IsTruncated", t.Name.Local):
   9745 			val, err := decoder.Value()
   9746 			if err != nil {
   9747 				return err
   9748 			}
   9749 			if val == nil {
   9750 				break
   9751 			}
   9752 			{
   9753 				xtv, err := strconv.ParseBool(string(val))
   9754 				if err != nil {
   9755 					return fmt.Errorf("expected PageTruncated to be of type *bool, got %T instead", val)
   9756 				}
   9757 				sv.IsTruncated = xtv
   9758 			}
   9759 
   9760 		case strings.EqualFold("MaxItems", t.Name.Local):
   9761 			val, err := decoder.Value()
   9762 			if err != nil {
   9763 				return err
   9764 			}
   9765 			if val == nil {
   9766 				break
   9767 			}
   9768 			{
   9769 				xtv := string(val)
   9770 				i64, err := strconv.ParseInt(xtv, 10, 64)
   9771 				if err != nil {
   9772 					return err
   9773 				}
   9774 				sv.MaxItems = ptr.Int32(int32(i64))
   9775 			}
   9776 
   9777 		case strings.EqualFold("TrafficPolicies", t.Name.Local):
   9778 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9779 			if err := awsRestxml_deserializeDocumentTrafficPolicies(&sv.TrafficPolicies, nodeDecoder); err != nil {
   9780 				return err
   9781 			}
   9782 
   9783 		case strings.EqualFold("TrafficPolicyVersionMarker", t.Name.Local):
   9784 			val, err := decoder.Value()
   9785 			if err != nil {
   9786 				return err
   9787 			}
   9788 			if val == nil {
   9789 				break
   9790 			}
   9791 			{
   9792 				xtv := string(val)
   9793 				sv.TrafficPolicyVersionMarker = ptr.String(xtv)
   9794 			}
   9795 
   9796 		default:
   9797 			// Do nothing and ignore the unexpected tag element
   9798 			err = decoder.Decoder.Skip()
   9799 			if err != nil {
   9800 				return err
   9801 			}
   9802 
   9803 		}
   9804 		decoder = originalDecoder
   9805 	}
   9806 	*v = sv
   9807 	return nil
   9808 }
   9809 
   9810 type awsRestxml_deserializeOpListVPCAssociationAuthorizations struct {
   9811 }
   9812 
   9813 func (*awsRestxml_deserializeOpListVPCAssociationAuthorizations) ID() string {
   9814 	return "OperationDeserializer"
   9815 }
   9816 
   9817 func (m *awsRestxml_deserializeOpListVPCAssociationAuthorizations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9818 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9819 ) {
   9820 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9821 	if err != nil {
   9822 		return out, metadata, err
   9823 	}
   9824 
   9825 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9826 	if !ok {
   9827 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9828 	}
   9829 
   9830 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   9831 		return out, metadata, awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response, &metadata)
   9832 	}
   9833 	output := &ListVPCAssociationAuthorizationsOutput{}
   9834 	out.Result = output
   9835 
   9836 	var buff [1024]byte
   9837 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   9838 	body := io.TeeReader(response.Body, ringBuffer)
   9839 	rootDecoder := xml.NewDecoder(body)
   9840 	t, err := smithyxml.FetchRootElement(rootDecoder)
   9841 	if err == io.EOF {
   9842 		return out, metadata, nil
   9843 	}
   9844 	if err != nil {
   9845 		var snapshot bytes.Buffer
   9846 		io.Copy(&snapshot, ringBuffer)
   9847 		return out, metadata, &smithy.DeserializationError{
   9848 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9849 			Snapshot: snapshot.Bytes(),
   9850 		}
   9851 	}
   9852 
   9853 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
   9854 	err = awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(&output, decoder)
   9855 	if err != nil {
   9856 		var snapshot bytes.Buffer
   9857 		io.Copy(&snapshot, ringBuffer)
   9858 		return out, metadata, &smithy.DeserializationError{
   9859 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   9860 			Snapshot: snapshot.Bytes(),
   9861 		}
   9862 	}
   9863 
   9864 	return out, metadata, err
   9865 }
   9866 
   9867 func awsRestxml_deserializeOpErrorListVPCAssociationAuthorizations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   9868 	var errorBuffer bytes.Buffer
   9869 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   9870 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   9871 	}
   9872 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   9873 
   9874 	errorCode := "UnknownError"
   9875 	errorMessage := errorCode
   9876 
   9877 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
   9878 	if err != nil {
   9879 		return err
   9880 	}
   9881 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
   9882 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
   9883 	}
   9884 	if len(errorComponents.Code) != 0 {
   9885 		errorCode = errorComponents.Code
   9886 	}
   9887 	if len(errorComponents.Message) != 0 {
   9888 		errorMessage = errorComponents.Message
   9889 	}
   9890 	errorBody.Seek(0, io.SeekStart)
   9891 	switch {
   9892 	case strings.EqualFold("InvalidInput", errorCode):
   9893 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
   9894 
   9895 	case strings.EqualFold("InvalidPaginationToken", errorCode):
   9896 		return awsRestxml_deserializeErrorInvalidPaginationToken(response, errorBody)
   9897 
   9898 	case strings.EqualFold("NoSuchHostedZone", errorCode):
   9899 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
   9900 
   9901 	default:
   9902 		genericError := &smithy.GenericAPIError{
   9903 			Code:    errorCode,
   9904 			Message: errorMessage,
   9905 		}
   9906 		return genericError
   9907 
   9908 	}
   9909 }
   9910 
   9911 func awsRestxml_deserializeOpDocumentListVPCAssociationAuthorizationsOutput(v **ListVPCAssociationAuthorizationsOutput, decoder smithyxml.NodeDecoder) error {
   9912 	if v == nil {
   9913 		return fmt.Errorf("unexpected nil of type %T", v)
   9914 	}
   9915 	var sv *ListVPCAssociationAuthorizationsOutput
   9916 	if *v == nil {
   9917 		sv = &ListVPCAssociationAuthorizationsOutput{}
   9918 	} else {
   9919 		sv = *v
   9920 	}
   9921 
   9922 	for {
   9923 		t, done, err := decoder.Token()
   9924 		if err != nil {
   9925 			return err
   9926 		}
   9927 		if done {
   9928 			break
   9929 		}
   9930 		originalDecoder := decoder
   9931 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
   9932 		switch {
   9933 		case strings.EqualFold("HostedZoneId", t.Name.Local):
   9934 			val, err := decoder.Value()
   9935 			if err != nil {
   9936 				return err
   9937 			}
   9938 			if val == nil {
   9939 				break
   9940 			}
   9941 			{
   9942 				xtv := string(val)
   9943 				sv.HostedZoneId = ptr.String(xtv)
   9944 			}
   9945 
   9946 		case strings.EqualFold("NextToken", t.Name.Local):
   9947 			val, err := decoder.Value()
   9948 			if err != nil {
   9949 				return err
   9950 			}
   9951 			if val == nil {
   9952 				break
   9953 			}
   9954 			{
   9955 				xtv := string(val)
   9956 				sv.NextToken = ptr.String(xtv)
   9957 			}
   9958 
   9959 		case strings.EqualFold("VPCs", t.Name.Local):
   9960 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
   9961 			if err := awsRestxml_deserializeDocumentVPCs(&sv.VPCs, nodeDecoder); err != nil {
   9962 				return err
   9963 			}
   9964 
   9965 		default:
   9966 			// Do nothing and ignore the unexpected tag element
   9967 			err = decoder.Decoder.Skip()
   9968 			if err != nil {
   9969 				return err
   9970 			}
   9971 
   9972 		}
   9973 		decoder = originalDecoder
   9974 	}
   9975 	*v = sv
   9976 	return nil
   9977 }
   9978 
   9979 type awsRestxml_deserializeOpTestDNSAnswer struct {
   9980 }
   9981 
   9982 func (*awsRestxml_deserializeOpTestDNSAnswer) ID() string {
   9983 	return "OperationDeserializer"
   9984 }
   9985 
   9986 func (m *awsRestxml_deserializeOpTestDNSAnswer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   9987 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   9988 ) {
   9989 	out, metadata, err = next.HandleDeserialize(ctx, in)
   9990 	if err != nil {
   9991 		return out, metadata, err
   9992 	}
   9993 
   9994 	response, ok := out.RawResponse.(*smithyhttp.Response)
   9995 	if !ok {
   9996 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   9997 	}
   9998 
   9999 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10000 		return out, metadata, awsRestxml_deserializeOpErrorTestDNSAnswer(response, &metadata)
  10001 	}
  10002 	output := &TestDNSAnswerOutput{}
  10003 	out.Result = output
  10004 
  10005 	var buff [1024]byte
  10006 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10007 	body := io.TeeReader(response.Body, ringBuffer)
  10008 	rootDecoder := xml.NewDecoder(body)
  10009 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10010 	if err == io.EOF {
  10011 		return out, metadata, nil
  10012 	}
  10013 	if err != nil {
  10014 		var snapshot bytes.Buffer
  10015 		io.Copy(&snapshot, ringBuffer)
  10016 		return out, metadata, &smithy.DeserializationError{
  10017 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10018 			Snapshot: snapshot.Bytes(),
  10019 		}
  10020 	}
  10021 
  10022 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10023 	err = awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(&output, decoder)
  10024 	if err != nil {
  10025 		var snapshot bytes.Buffer
  10026 		io.Copy(&snapshot, ringBuffer)
  10027 		return out, metadata, &smithy.DeserializationError{
  10028 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10029 			Snapshot: snapshot.Bytes(),
  10030 		}
  10031 	}
  10032 
  10033 	return out, metadata, err
  10034 }
  10035 
  10036 func awsRestxml_deserializeOpErrorTestDNSAnswer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10037 	var errorBuffer bytes.Buffer
  10038 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10039 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10040 	}
  10041 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10042 
  10043 	errorCode := "UnknownError"
  10044 	errorMessage := errorCode
  10045 
  10046 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10047 	if err != nil {
  10048 		return err
  10049 	}
  10050 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10051 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10052 	}
  10053 	if len(errorComponents.Code) != 0 {
  10054 		errorCode = errorComponents.Code
  10055 	}
  10056 	if len(errorComponents.Message) != 0 {
  10057 		errorMessage = errorComponents.Message
  10058 	}
  10059 	errorBody.Seek(0, io.SeekStart)
  10060 	switch {
  10061 	case strings.EqualFold("InvalidInput", errorCode):
  10062 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10063 
  10064 	case strings.EqualFold("NoSuchHostedZone", errorCode):
  10065 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
  10066 
  10067 	default:
  10068 		genericError := &smithy.GenericAPIError{
  10069 			Code:    errorCode,
  10070 			Message: errorMessage,
  10071 		}
  10072 		return genericError
  10073 
  10074 	}
  10075 }
  10076 
  10077 func awsRestxml_deserializeOpDocumentTestDNSAnswerOutput(v **TestDNSAnswerOutput, decoder smithyxml.NodeDecoder) error {
  10078 	if v == nil {
  10079 		return fmt.Errorf("unexpected nil of type %T", v)
  10080 	}
  10081 	var sv *TestDNSAnswerOutput
  10082 	if *v == nil {
  10083 		sv = &TestDNSAnswerOutput{}
  10084 	} else {
  10085 		sv = *v
  10086 	}
  10087 
  10088 	for {
  10089 		t, done, err := decoder.Token()
  10090 		if err != nil {
  10091 			return err
  10092 		}
  10093 		if done {
  10094 			break
  10095 		}
  10096 		originalDecoder := decoder
  10097 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10098 		switch {
  10099 		case strings.EqualFold("Nameserver", t.Name.Local):
  10100 			val, err := decoder.Value()
  10101 			if err != nil {
  10102 				return err
  10103 			}
  10104 			if val == nil {
  10105 				break
  10106 			}
  10107 			{
  10108 				xtv := string(val)
  10109 				sv.Nameserver = ptr.String(xtv)
  10110 			}
  10111 
  10112 		case strings.EqualFold("Protocol", t.Name.Local):
  10113 			val, err := decoder.Value()
  10114 			if err != nil {
  10115 				return err
  10116 			}
  10117 			if val == nil {
  10118 				break
  10119 			}
  10120 			{
  10121 				xtv := string(val)
  10122 				sv.Protocol = ptr.String(xtv)
  10123 			}
  10124 
  10125 		case strings.EqualFold("RecordData", t.Name.Local):
  10126 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10127 			if err := awsRestxml_deserializeDocumentRecordData(&sv.RecordData, nodeDecoder); err != nil {
  10128 				return err
  10129 			}
  10130 
  10131 		case strings.EqualFold("RecordName", t.Name.Local):
  10132 			val, err := decoder.Value()
  10133 			if err != nil {
  10134 				return err
  10135 			}
  10136 			if val == nil {
  10137 				break
  10138 			}
  10139 			{
  10140 				xtv := string(val)
  10141 				sv.RecordName = ptr.String(xtv)
  10142 			}
  10143 
  10144 		case strings.EqualFold("RecordType", t.Name.Local):
  10145 			val, err := decoder.Value()
  10146 			if err != nil {
  10147 				return err
  10148 			}
  10149 			if val == nil {
  10150 				break
  10151 			}
  10152 			{
  10153 				xtv := string(val)
  10154 				sv.RecordType = types.RRType(xtv)
  10155 			}
  10156 
  10157 		case strings.EqualFold("ResponseCode", t.Name.Local):
  10158 			val, err := decoder.Value()
  10159 			if err != nil {
  10160 				return err
  10161 			}
  10162 			if val == nil {
  10163 				break
  10164 			}
  10165 			{
  10166 				xtv := string(val)
  10167 				sv.ResponseCode = ptr.String(xtv)
  10168 			}
  10169 
  10170 		default:
  10171 			// Do nothing and ignore the unexpected tag element
  10172 			err = decoder.Decoder.Skip()
  10173 			if err != nil {
  10174 				return err
  10175 			}
  10176 
  10177 		}
  10178 		decoder = originalDecoder
  10179 	}
  10180 	*v = sv
  10181 	return nil
  10182 }
  10183 
  10184 type awsRestxml_deserializeOpUpdateHealthCheck struct {
  10185 }
  10186 
  10187 func (*awsRestxml_deserializeOpUpdateHealthCheck) ID() string {
  10188 	return "OperationDeserializer"
  10189 }
  10190 
  10191 func (m *awsRestxml_deserializeOpUpdateHealthCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10192 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10193 ) {
  10194 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10195 	if err != nil {
  10196 		return out, metadata, err
  10197 	}
  10198 
  10199 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10200 	if !ok {
  10201 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10202 	}
  10203 
  10204 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10205 		return out, metadata, awsRestxml_deserializeOpErrorUpdateHealthCheck(response, &metadata)
  10206 	}
  10207 	output := &UpdateHealthCheckOutput{}
  10208 	out.Result = output
  10209 
  10210 	var buff [1024]byte
  10211 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10212 	body := io.TeeReader(response.Body, ringBuffer)
  10213 	rootDecoder := xml.NewDecoder(body)
  10214 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10215 	if err == io.EOF {
  10216 		return out, metadata, nil
  10217 	}
  10218 	if err != nil {
  10219 		var snapshot bytes.Buffer
  10220 		io.Copy(&snapshot, ringBuffer)
  10221 		return out, metadata, &smithy.DeserializationError{
  10222 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10223 			Snapshot: snapshot.Bytes(),
  10224 		}
  10225 	}
  10226 
  10227 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10228 	err = awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(&output, decoder)
  10229 	if err != nil {
  10230 		var snapshot bytes.Buffer
  10231 		io.Copy(&snapshot, ringBuffer)
  10232 		return out, metadata, &smithy.DeserializationError{
  10233 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10234 			Snapshot: snapshot.Bytes(),
  10235 		}
  10236 	}
  10237 
  10238 	return out, metadata, err
  10239 }
  10240 
  10241 func awsRestxml_deserializeOpErrorUpdateHealthCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10242 	var errorBuffer bytes.Buffer
  10243 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10244 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10245 	}
  10246 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10247 
  10248 	errorCode := "UnknownError"
  10249 	errorMessage := errorCode
  10250 
  10251 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10252 	if err != nil {
  10253 		return err
  10254 	}
  10255 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10256 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10257 	}
  10258 	if len(errorComponents.Code) != 0 {
  10259 		errorCode = errorComponents.Code
  10260 	}
  10261 	if len(errorComponents.Message) != 0 {
  10262 		errorMessage = errorComponents.Message
  10263 	}
  10264 	errorBody.Seek(0, io.SeekStart)
  10265 	switch {
  10266 	case strings.EqualFold("HealthCheckVersionMismatch", errorCode):
  10267 		return awsRestxml_deserializeErrorHealthCheckVersionMismatch(response, errorBody)
  10268 
  10269 	case strings.EqualFold("InvalidInput", errorCode):
  10270 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10271 
  10272 	case strings.EqualFold("NoSuchHealthCheck", errorCode):
  10273 		return awsRestxml_deserializeErrorNoSuchHealthCheck(response, errorBody)
  10274 
  10275 	default:
  10276 		genericError := &smithy.GenericAPIError{
  10277 			Code:    errorCode,
  10278 			Message: errorMessage,
  10279 		}
  10280 		return genericError
  10281 
  10282 	}
  10283 }
  10284 
  10285 func awsRestxml_deserializeOpDocumentUpdateHealthCheckOutput(v **UpdateHealthCheckOutput, decoder smithyxml.NodeDecoder) error {
  10286 	if v == nil {
  10287 		return fmt.Errorf("unexpected nil of type %T", v)
  10288 	}
  10289 	var sv *UpdateHealthCheckOutput
  10290 	if *v == nil {
  10291 		sv = &UpdateHealthCheckOutput{}
  10292 	} else {
  10293 		sv = *v
  10294 	}
  10295 
  10296 	for {
  10297 		t, done, err := decoder.Token()
  10298 		if err != nil {
  10299 			return err
  10300 		}
  10301 		if done {
  10302 			break
  10303 		}
  10304 		originalDecoder := decoder
  10305 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10306 		switch {
  10307 		case strings.EqualFold("HealthCheck", t.Name.Local):
  10308 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10309 			if err := awsRestxml_deserializeDocumentHealthCheck(&sv.HealthCheck, nodeDecoder); err != nil {
  10310 				return err
  10311 			}
  10312 
  10313 		default:
  10314 			// Do nothing and ignore the unexpected tag element
  10315 			err = decoder.Decoder.Skip()
  10316 			if err != nil {
  10317 				return err
  10318 			}
  10319 
  10320 		}
  10321 		decoder = originalDecoder
  10322 	}
  10323 	*v = sv
  10324 	return nil
  10325 }
  10326 
  10327 type awsRestxml_deserializeOpUpdateHostedZoneComment struct {
  10328 }
  10329 
  10330 func (*awsRestxml_deserializeOpUpdateHostedZoneComment) ID() string {
  10331 	return "OperationDeserializer"
  10332 }
  10333 
  10334 func (m *awsRestxml_deserializeOpUpdateHostedZoneComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10335 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10336 ) {
  10337 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10338 	if err != nil {
  10339 		return out, metadata, err
  10340 	}
  10341 
  10342 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10343 	if !ok {
  10344 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10345 	}
  10346 
  10347 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10348 		return out, metadata, awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response, &metadata)
  10349 	}
  10350 	output := &UpdateHostedZoneCommentOutput{}
  10351 	out.Result = output
  10352 
  10353 	var buff [1024]byte
  10354 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10355 	body := io.TeeReader(response.Body, ringBuffer)
  10356 	rootDecoder := xml.NewDecoder(body)
  10357 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10358 	if err == io.EOF {
  10359 		return out, metadata, nil
  10360 	}
  10361 	if err != nil {
  10362 		var snapshot bytes.Buffer
  10363 		io.Copy(&snapshot, ringBuffer)
  10364 		return out, metadata, &smithy.DeserializationError{
  10365 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10366 			Snapshot: snapshot.Bytes(),
  10367 		}
  10368 	}
  10369 
  10370 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10371 	err = awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(&output, decoder)
  10372 	if err != nil {
  10373 		var snapshot bytes.Buffer
  10374 		io.Copy(&snapshot, ringBuffer)
  10375 		return out, metadata, &smithy.DeserializationError{
  10376 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10377 			Snapshot: snapshot.Bytes(),
  10378 		}
  10379 	}
  10380 
  10381 	return out, metadata, err
  10382 }
  10383 
  10384 func awsRestxml_deserializeOpErrorUpdateHostedZoneComment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10385 	var errorBuffer bytes.Buffer
  10386 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10387 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10388 	}
  10389 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10390 
  10391 	errorCode := "UnknownError"
  10392 	errorMessage := errorCode
  10393 
  10394 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10395 	if err != nil {
  10396 		return err
  10397 	}
  10398 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10399 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10400 	}
  10401 	if len(errorComponents.Code) != 0 {
  10402 		errorCode = errorComponents.Code
  10403 	}
  10404 	if len(errorComponents.Message) != 0 {
  10405 		errorMessage = errorComponents.Message
  10406 	}
  10407 	errorBody.Seek(0, io.SeekStart)
  10408 	switch {
  10409 	case strings.EqualFold("InvalidInput", errorCode):
  10410 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10411 
  10412 	case strings.EqualFold("NoSuchHostedZone", errorCode):
  10413 		return awsRestxml_deserializeErrorNoSuchHostedZone(response, errorBody)
  10414 
  10415 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
  10416 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
  10417 
  10418 	default:
  10419 		genericError := &smithy.GenericAPIError{
  10420 			Code:    errorCode,
  10421 			Message: errorMessage,
  10422 		}
  10423 		return genericError
  10424 
  10425 	}
  10426 }
  10427 
  10428 func awsRestxml_deserializeOpDocumentUpdateHostedZoneCommentOutput(v **UpdateHostedZoneCommentOutput, decoder smithyxml.NodeDecoder) error {
  10429 	if v == nil {
  10430 		return fmt.Errorf("unexpected nil of type %T", v)
  10431 	}
  10432 	var sv *UpdateHostedZoneCommentOutput
  10433 	if *v == nil {
  10434 		sv = &UpdateHostedZoneCommentOutput{}
  10435 	} else {
  10436 		sv = *v
  10437 	}
  10438 
  10439 	for {
  10440 		t, done, err := decoder.Token()
  10441 		if err != nil {
  10442 			return err
  10443 		}
  10444 		if done {
  10445 			break
  10446 		}
  10447 		originalDecoder := decoder
  10448 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10449 		switch {
  10450 		case strings.EqualFold("HostedZone", t.Name.Local):
  10451 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10452 			if err := awsRestxml_deserializeDocumentHostedZone(&sv.HostedZone, nodeDecoder); err != nil {
  10453 				return err
  10454 			}
  10455 
  10456 		default:
  10457 			// Do nothing and ignore the unexpected tag element
  10458 			err = decoder.Decoder.Skip()
  10459 			if err != nil {
  10460 				return err
  10461 			}
  10462 
  10463 		}
  10464 		decoder = originalDecoder
  10465 	}
  10466 	*v = sv
  10467 	return nil
  10468 }
  10469 
  10470 type awsRestxml_deserializeOpUpdateTrafficPolicyComment struct {
  10471 }
  10472 
  10473 func (*awsRestxml_deserializeOpUpdateTrafficPolicyComment) ID() string {
  10474 	return "OperationDeserializer"
  10475 }
  10476 
  10477 func (m *awsRestxml_deserializeOpUpdateTrafficPolicyComment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10478 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10479 ) {
  10480 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10481 	if err != nil {
  10482 		return out, metadata, err
  10483 	}
  10484 
  10485 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10486 	if !ok {
  10487 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10488 	}
  10489 
  10490 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10491 		return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response, &metadata)
  10492 	}
  10493 	output := &UpdateTrafficPolicyCommentOutput{}
  10494 	out.Result = output
  10495 
  10496 	var buff [1024]byte
  10497 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10498 	body := io.TeeReader(response.Body, ringBuffer)
  10499 	rootDecoder := xml.NewDecoder(body)
  10500 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10501 	if err == io.EOF {
  10502 		return out, metadata, nil
  10503 	}
  10504 	if err != nil {
  10505 		var snapshot bytes.Buffer
  10506 		io.Copy(&snapshot, ringBuffer)
  10507 		return out, metadata, &smithy.DeserializationError{
  10508 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10509 			Snapshot: snapshot.Bytes(),
  10510 		}
  10511 	}
  10512 
  10513 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10514 	err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(&output, decoder)
  10515 	if err != nil {
  10516 		var snapshot bytes.Buffer
  10517 		io.Copy(&snapshot, ringBuffer)
  10518 		return out, metadata, &smithy.DeserializationError{
  10519 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10520 			Snapshot: snapshot.Bytes(),
  10521 		}
  10522 	}
  10523 
  10524 	return out, metadata, err
  10525 }
  10526 
  10527 func awsRestxml_deserializeOpErrorUpdateTrafficPolicyComment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10528 	var errorBuffer bytes.Buffer
  10529 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10530 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10531 	}
  10532 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10533 
  10534 	errorCode := "UnknownError"
  10535 	errorMessage := errorCode
  10536 
  10537 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10538 	if err != nil {
  10539 		return err
  10540 	}
  10541 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10542 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10543 	}
  10544 	if len(errorComponents.Code) != 0 {
  10545 		errorCode = errorComponents.Code
  10546 	}
  10547 	if len(errorComponents.Message) != 0 {
  10548 		errorMessage = errorComponents.Message
  10549 	}
  10550 	errorBody.Seek(0, io.SeekStart)
  10551 	switch {
  10552 	case strings.EqualFold("ConcurrentModification", errorCode):
  10553 		return awsRestxml_deserializeErrorConcurrentModification(response, errorBody)
  10554 
  10555 	case strings.EqualFold("InvalidInput", errorCode):
  10556 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10557 
  10558 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
  10559 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
  10560 
  10561 	default:
  10562 		genericError := &smithy.GenericAPIError{
  10563 			Code:    errorCode,
  10564 			Message: errorMessage,
  10565 		}
  10566 		return genericError
  10567 
  10568 	}
  10569 }
  10570 
  10571 func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyCommentOutput(v **UpdateTrafficPolicyCommentOutput, decoder smithyxml.NodeDecoder) error {
  10572 	if v == nil {
  10573 		return fmt.Errorf("unexpected nil of type %T", v)
  10574 	}
  10575 	var sv *UpdateTrafficPolicyCommentOutput
  10576 	if *v == nil {
  10577 		sv = &UpdateTrafficPolicyCommentOutput{}
  10578 	} else {
  10579 		sv = *v
  10580 	}
  10581 
  10582 	for {
  10583 		t, done, err := decoder.Token()
  10584 		if err != nil {
  10585 			return err
  10586 		}
  10587 		if done {
  10588 			break
  10589 		}
  10590 		originalDecoder := decoder
  10591 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10592 		switch {
  10593 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
  10594 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10595 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&sv.TrafficPolicy, nodeDecoder); err != nil {
  10596 				return err
  10597 			}
  10598 
  10599 		default:
  10600 			// Do nothing and ignore the unexpected tag element
  10601 			err = decoder.Decoder.Skip()
  10602 			if err != nil {
  10603 				return err
  10604 			}
  10605 
  10606 		}
  10607 		decoder = originalDecoder
  10608 	}
  10609 	*v = sv
  10610 	return nil
  10611 }
  10612 
  10613 type awsRestxml_deserializeOpUpdateTrafficPolicyInstance struct {
  10614 }
  10615 
  10616 func (*awsRestxml_deserializeOpUpdateTrafficPolicyInstance) ID() string {
  10617 	return "OperationDeserializer"
  10618 }
  10619 
  10620 func (m *awsRestxml_deserializeOpUpdateTrafficPolicyInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
  10621 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
  10622 ) {
  10623 	out, metadata, err = next.HandleDeserialize(ctx, in)
  10624 	if err != nil {
  10625 		return out, metadata, err
  10626 	}
  10627 
  10628 	response, ok := out.RawResponse.(*smithyhttp.Response)
  10629 	if !ok {
  10630 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
  10631 	}
  10632 
  10633 	if response.StatusCode < 200 || response.StatusCode >= 300 {
  10634 		return out, metadata, awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response, &metadata)
  10635 	}
  10636 	output := &UpdateTrafficPolicyInstanceOutput{}
  10637 	out.Result = output
  10638 
  10639 	var buff [1024]byte
  10640 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10641 	body := io.TeeReader(response.Body, ringBuffer)
  10642 	rootDecoder := xml.NewDecoder(body)
  10643 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10644 	if err == io.EOF {
  10645 		return out, metadata, nil
  10646 	}
  10647 	if err != nil {
  10648 		var snapshot bytes.Buffer
  10649 		io.Copy(&snapshot, ringBuffer)
  10650 		return out, metadata, &smithy.DeserializationError{
  10651 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10652 			Snapshot: snapshot.Bytes(),
  10653 		}
  10654 	}
  10655 
  10656 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10657 	err = awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(&output, decoder)
  10658 	if err != nil {
  10659 		var snapshot bytes.Buffer
  10660 		io.Copy(&snapshot, ringBuffer)
  10661 		return out, metadata, &smithy.DeserializationError{
  10662 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10663 			Snapshot: snapshot.Bytes(),
  10664 		}
  10665 	}
  10666 
  10667 	return out, metadata, err
  10668 }
  10669 
  10670 func awsRestxml_deserializeOpErrorUpdateTrafficPolicyInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
  10671 	var errorBuffer bytes.Buffer
  10672 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
  10673 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
  10674 	}
  10675 	errorBody := bytes.NewReader(errorBuffer.Bytes())
  10676 
  10677 	errorCode := "UnknownError"
  10678 	errorMessage := errorCode
  10679 
  10680 	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
  10681 	if err != nil {
  10682 		return err
  10683 	}
  10684 	if reqID := errorComponents.RequestID; len(reqID) != 0 {
  10685 		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
  10686 	}
  10687 	if len(errorComponents.Code) != 0 {
  10688 		errorCode = errorComponents.Code
  10689 	}
  10690 	if len(errorComponents.Message) != 0 {
  10691 		errorMessage = errorComponents.Message
  10692 	}
  10693 	errorBody.Seek(0, io.SeekStart)
  10694 	switch {
  10695 	case strings.EqualFold("ConflictingTypes", errorCode):
  10696 		return awsRestxml_deserializeErrorConflictingTypes(response, errorBody)
  10697 
  10698 	case strings.EqualFold("InvalidInput", errorCode):
  10699 		return awsRestxml_deserializeErrorInvalidInput(response, errorBody)
  10700 
  10701 	case strings.EqualFold("NoSuchTrafficPolicy", errorCode):
  10702 		return awsRestxml_deserializeErrorNoSuchTrafficPolicy(response, errorBody)
  10703 
  10704 	case strings.EqualFold("NoSuchTrafficPolicyInstance", errorCode):
  10705 		return awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response, errorBody)
  10706 
  10707 	case strings.EqualFold("PriorRequestNotComplete", errorCode):
  10708 		return awsRestxml_deserializeErrorPriorRequestNotComplete(response, errorBody)
  10709 
  10710 	default:
  10711 		genericError := &smithy.GenericAPIError{
  10712 			Code:    errorCode,
  10713 			Message: errorMessage,
  10714 		}
  10715 		return genericError
  10716 
  10717 	}
  10718 }
  10719 
  10720 func awsRestxml_deserializeOpDocumentUpdateTrafficPolicyInstanceOutput(v **UpdateTrafficPolicyInstanceOutput, decoder smithyxml.NodeDecoder) error {
  10721 	if v == nil {
  10722 		return fmt.Errorf("unexpected nil of type %T", v)
  10723 	}
  10724 	var sv *UpdateTrafficPolicyInstanceOutput
  10725 	if *v == nil {
  10726 		sv = &UpdateTrafficPolicyInstanceOutput{}
  10727 	} else {
  10728 		sv = *v
  10729 	}
  10730 
  10731 	for {
  10732 		t, done, err := decoder.Token()
  10733 		if err != nil {
  10734 			return err
  10735 		}
  10736 		if done {
  10737 			break
  10738 		}
  10739 		originalDecoder := decoder
  10740 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  10741 		switch {
  10742 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
  10743 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10744 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&sv.TrafficPolicyInstance, nodeDecoder); err != nil {
  10745 				return err
  10746 			}
  10747 
  10748 		default:
  10749 			// Do nothing and ignore the unexpected tag element
  10750 			err = decoder.Decoder.Skip()
  10751 			if err != nil {
  10752 				return err
  10753 			}
  10754 
  10755 		}
  10756 		decoder = originalDecoder
  10757 	}
  10758 	*v = sv
  10759 	return nil
  10760 }
  10761 
  10762 func awsRestxml_deserializeErrorCidrBlockInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  10763 	output := &types.CidrBlockInUseException{}
  10764 	var buff [1024]byte
  10765 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10766 	body := io.TeeReader(errorBody, ringBuffer)
  10767 	rootDecoder := xml.NewDecoder(body)
  10768 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10769 	if err == io.EOF {
  10770 		return output
  10771 	}
  10772 	if err != nil {
  10773 		var snapshot bytes.Buffer
  10774 		io.Copy(&snapshot, ringBuffer)
  10775 		return &smithy.DeserializationError{
  10776 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10777 			Snapshot: snapshot.Bytes(),
  10778 		}
  10779 	}
  10780 
  10781 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10782 	t, err = decoder.GetElement("Error")
  10783 	if err != nil {
  10784 		var snapshot bytes.Buffer
  10785 		io.Copy(&snapshot, ringBuffer)
  10786 		return &smithy.DeserializationError{
  10787 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10788 			Snapshot: snapshot.Bytes(),
  10789 		}
  10790 	}
  10791 
  10792 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10793 	err = awsRestxml_deserializeDocumentCidrBlockInUseException(&output, decoder)
  10794 	if err != nil {
  10795 		var snapshot bytes.Buffer
  10796 		io.Copy(&snapshot, ringBuffer)
  10797 		return &smithy.DeserializationError{
  10798 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10799 			Snapshot: snapshot.Bytes(),
  10800 		}
  10801 	}
  10802 
  10803 	return output
  10804 }
  10805 
  10806 func awsRestxml_deserializeErrorCidrCollectionAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  10807 	output := &types.CidrCollectionAlreadyExistsException{}
  10808 	var buff [1024]byte
  10809 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10810 	body := io.TeeReader(errorBody, ringBuffer)
  10811 	rootDecoder := xml.NewDecoder(body)
  10812 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10813 	if err == io.EOF {
  10814 		return output
  10815 	}
  10816 	if err != nil {
  10817 		var snapshot bytes.Buffer
  10818 		io.Copy(&snapshot, ringBuffer)
  10819 		return &smithy.DeserializationError{
  10820 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10821 			Snapshot: snapshot.Bytes(),
  10822 		}
  10823 	}
  10824 
  10825 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10826 	t, err = decoder.GetElement("Error")
  10827 	if err != nil {
  10828 		var snapshot bytes.Buffer
  10829 		io.Copy(&snapshot, ringBuffer)
  10830 		return &smithy.DeserializationError{
  10831 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10832 			Snapshot: snapshot.Bytes(),
  10833 		}
  10834 	}
  10835 
  10836 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10837 	err = awsRestxml_deserializeDocumentCidrCollectionAlreadyExistsException(&output, decoder)
  10838 	if err != nil {
  10839 		var snapshot bytes.Buffer
  10840 		io.Copy(&snapshot, ringBuffer)
  10841 		return &smithy.DeserializationError{
  10842 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10843 			Snapshot: snapshot.Bytes(),
  10844 		}
  10845 	}
  10846 
  10847 	return output
  10848 }
  10849 
  10850 func awsRestxml_deserializeErrorCidrCollectionInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  10851 	output := &types.CidrCollectionInUseException{}
  10852 	var buff [1024]byte
  10853 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10854 	body := io.TeeReader(errorBody, ringBuffer)
  10855 	rootDecoder := xml.NewDecoder(body)
  10856 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10857 	if err == io.EOF {
  10858 		return output
  10859 	}
  10860 	if err != nil {
  10861 		var snapshot bytes.Buffer
  10862 		io.Copy(&snapshot, ringBuffer)
  10863 		return &smithy.DeserializationError{
  10864 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10865 			Snapshot: snapshot.Bytes(),
  10866 		}
  10867 	}
  10868 
  10869 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10870 	t, err = decoder.GetElement("Error")
  10871 	if err != nil {
  10872 		var snapshot bytes.Buffer
  10873 		io.Copy(&snapshot, ringBuffer)
  10874 		return &smithy.DeserializationError{
  10875 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10876 			Snapshot: snapshot.Bytes(),
  10877 		}
  10878 	}
  10879 
  10880 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10881 	err = awsRestxml_deserializeDocumentCidrCollectionInUseException(&output, decoder)
  10882 	if err != nil {
  10883 		var snapshot bytes.Buffer
  10884 		io.Copy(&snapshot, ringBuffer)
  10885 		return &smithy.DeserializationError{
  10886 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10887 			Snapshot: snapshot.Bytes(),
  10888 		}
  10889 	}
  10890 
  10891 	return output
  10892 }
  10893 
  10894 func awsRestxml_deserializeErrorCidrCollectionVersionMismatchException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  10895 	output := &types.CidrCollectionVersionMismatchException{}
  10896 	var buff [1024]byte
  10897 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10898 	body := io.TeeReader(errorBody, ringBuffer)
  10899 	rootDecoder := xml.NewDecoder(body)
  10900 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10901 	if err == io.EOF {
  10902 		return output
  10903 	}
  10904 	if err != nil {
  10905 		var snapshot bytes.Buffer
  10906 		io.Copy(&snapshot, ringBuffer)
  10907 		return &smithy.DeserializationError{
  10908 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10909 			Snapshot: snapshot.Bytes(),
  10910 		}
  10911 	}
  10912 
  10913 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10914 	t, err = decoder.GetElement("Error")
  10915 	if err != nil {
  10916 		var snapshot bytes.Buffer
  10917 		io.Copy(&snapshot, ringBuffer)
  10918 		return &smithy.DeserializationError{
  10919 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10920 			Snapshot: snapshot.Bytes(),
  10921 		}
  10922 	}
  10923 
  10924 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10925 	err = awsRestxml_deserializeDocumentCidrCollectionVersionMismatchException(&output, decoder)
  10926 	if err != nil {
  10927 		var snapshot bytes.Buffer
  10928 		io.Copy(&snapshot, ringBuffer)
  10929 		return &smithy.DeserializationError{
  10930 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10931 			Snapshot: snapshot.Bytes(),
  10932 		}
  10933 	}
  10934 
  10935 	return output
  10936 }
  10937 
  10938 func awsRestxml_deserializeErrorConcurrentModification(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  10939 	output := &types.ConcurrentModification{}
  10940 	var buff [1024]byte
  10941 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10942 	body := io.TeeReader(errorBody, ringBuffer)
  10943 	rootDecoder := xml.NewDecoder(body)
  10944 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10945 	if err == io.EOF {
  10946 		return output
  10947 	}
  10948 	if err != nil {
  10949 		var snapshot bytes.Buffer
  10950 		io.Copy(&snapshot, ringBuffer)
  10951 		return &smithy.DeserializationError{
  10952 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10953 			Snapshot: snapshot.Bytes(),
  10954 		}
  10955 	}
  10956 
  10957 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  10958 	t, err = decoder.GetElement("Error")
  10959 	if err != nil {
  10960 		var snapshot bytes.Buffer
  10961 		io.Copy(&snapshot, ringBuffer)
  10962 		return &smithy.DeserializationError{
  10963 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10964 			Snapshot: snapshot.Bytes(),
  10965 		}
  10966 	}
  10967 
  10968 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  10969 	err = awsRestxml_deserializeDocumentConcurrentModification(&output, decoder)
  10970 	if err != nil {
  10971 		var snapshot bytes.Buffer
  10972 		io.Copy(&snapshot, ringBuffer)
  10973 		return &smithy.DeserializationError{
  10974 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10975 			Snapshot: snapshot.Bytes(),
  10976 		}
  10977 	}
  10978 
  10979 	return output
  10980 }
  10981 
  10982 func awsRestxml_deserializeErrorConflictingDomainExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  10983 	output := &types.ConflictingDomainExists{}
  10984 	var buff [1024]byte
  10985 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  10986 	body := io.TeeReader(errorBody, ringBuffer)
  10987 	rootDecoder := xml.NewDecoder(body)
  10988 	t, err := smithyxml.FetchRootElement(rootDecoder)
  10989 	if err == io.EOF {
  10990 		return output
  10991 	}
  10992 	if err != nil {
  10993 		var snapshot bytes.Buffer
  10994 		io.Copy(&snapshot, ringBuffer)
  10995 		return &smithy.DeserializationError{
  10996 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  10997 			Snapshot: snapshot.Bytes(),
  10998 		}
  10999 	}
  11000 
  11001 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11002 	t, err = decoder.GetElement("Error")
  11003 	if err != nil {
  11004 		var snapshot bytes.Buffer
  11005 		io.Copy(&snapshot, ringBuffer)
  11006 		return &smithy.DeserializationError{
  11007 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11008 			Snapshot: snapshot.Bytes(),
  11009 		}
  11010 	}
  11011 
  11012 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11013 	err = awsRestxml_deserializeDocumentConflictingDomainExists(&output, decoder)
  11014 	if err != nil {
  11015 		var snapshot bytes.Buffer
  11016 		io.Copy(&snapshot, ringBuffer)
  11017 		return &smithy.DeserializationError{
  11018 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11019 			Snapshot: snapshot.Bytes(),
  11020 		}
  11021 	}
  11022 
  11023 	return output
  11024 }
  11025 
  11026 func awsRestxml_deserializeErrorConflictingTypes(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11027 	output := &types.ConflictingTypes{}
  11028 	var buff [1024]byte
  11029 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11030 	body := io.TeeReader(errorBody, ringBuffer)
  11031 	rootDecoder := xml.NewDecoder(body)
  11032 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11033 	if err == io.EOF {
  11034 		return output
  11035 	}
  11036 	if err != nil {
  11037 		var snapshot bytes.Buffer
  11038 		io.Copy(&snapshot, ringBuffer)
  11039 		return &smithy.DeserializationError{
  11040 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11041 			Snapshot: snapshot.Bytes(),
  11042 		}
  11043 	}
  11044 
  11045 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11046 	t, err = decoder.GetElement("Error")
  11047 	if err != nil {
  11048 		var snapshot bytes.Buffer
  11049 		io.Copy(&snapshot, ringBuffer)
  11050 		return &smithy.DeserializationError{
  11051 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11052 			Snapshot: snapshot.Bytes(),
  11053 		}
  11054 	}
  11055 
  11056 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11057 	err = awsRestxml_deserializeDocumentConflictingTypes(&output, decoder)
  11058 	if err != nil {
  11059 		var snapshot bytes.Buffer
  11060 		io.Copy(&snapshot, ringBuffer)
  11061 		return &smithy.DeserializationError{
  11062 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11063 			Snapshot: snapshot.Bytes(),
  11064 		}
  11065 	}
  11066 
  11067 	return output
  11068 }
  11069 
  11070 func awsRestxml_deserializeErrorDelegationSetAlreadyCreated(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11071 	output := &types.DelegationSetAlreadyCreated{}
  11072 	var buff [1024]byte
  11073 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11074 	body := io.TeeReader(errorBody, ringBuffer)
  11075 	rootDecoder := xml.NewDecoder(body)
  11076 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11077 	if err == io.EOF {
  11078 		return output
  11079 	}
  11080 	if err != nil {
  11081 		var snapshot bytes.Buffer
  11082 		io.Copy(&snapshot, ringBuffer)
  11083 		return &smithy.DeserializationError{
  11084 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11085 			Snapshot: snapshot.Bytes(),
  11086 		}
  11087 	}
  11088 
  11089 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11090 	t, err = decoder.GetElement("Error")
  11091 	if err != nil {
  11092 		var snapshot bytes.Buffer
  11093 		io.Copy(&snapshot, ringBuffer)
  11094 		return &smithy.DeserializationError{
  11095 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11096 			Snapshot: snapshot.Bytes(),
  11097 		}
  11098 	}
  11099 
  11100 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11101 	err = awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(&output, decoder)
  11102 	if err != nil {
  11103 		var snapshot bytes.Buffer
  11104 		io.Copy(&snapshot, ringBuffer)
  11105 		return &smithy.DeserializationError{
  11106 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11107 			Snapshot: snapshot.Bytes(),
  11108 		}
  11109 	}
  11110 
  11111 	return output
  11112 }
  11113 
  11114 func awsRestxml_deserializeErrorDelegationSetAlreadyReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11115 	output := &types.DelegationSetAlreadyReusable{}
  11116 	var buff [1024]byte
  11117 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11118 	body := io.TeeReader(errorBody, ringBuffer)
  11119 	rootDecoder := xml.NewDecoder(body)
  11120 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11121 	if err == io.EOF {
  11122 		return output
  11123 	}
  11124 	if err != nil {
  11125 		var snapshot bytes.Buffer
  11126 		io.Copy(&snapshot, ringBuffer)
  11127 		return &smithy.DeserializationError{
  11128 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11129 			Snapshot: snapshot.Bytes(),
  11130 		}
  11131 	}
  11132 
  11133 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11134 	t, err = decoder.GetElement("Error")
  11135 	if err != nil {
  11136 		var snapshot bytes.Buffer
  11137 		io.Copy(&snapshot, ringBuffer)
  11138 		return &smithy.DeserializationError{
  11139 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11140 			Snapshot: snapshot.Bytes(),
  11141 		}
  11142 	}
  11143 
  11144 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11145 	err = awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(&output, decoder)
  11146 	if err != nil {
  11147 		var snapshot bytes.Buffer
  11148 		io.Copy(&snapshot, ringBuffer)
  11149 		return &smithy.DeserializationError{
  11150 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11151 			Snapshot: snapshot.Bytes(),
  11152 		}
  11153 	}
  11154 
  11155 	return output
  11156 }
  11157 
  11158 func awsRestxml_deserializeErrorDelegationSetInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11159 	output := &types.DelegationSetInUse{}
  11160 	var buff [1024]byte
  11161 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11162 	body := io.TeeReader(errorBody, ringBuffer)
  11163 	rootDecoder := xml.NewDecoder(body)
  11164 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11165 	if err == io.EOF {
  11166 		return output
  11167 	}
  11168 	if err != nil {
  11169 		var snapshot bytes.Buffer
  11170 		io.Copy(&snapshot, ringBuffer)
  11171 		return &smithy.DeserializationError{
  11172 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11173 			Snapshot: snapshot.Bytes(),
  11174 		}
  11175 	}
  11176 
  11177 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11178 	t, err = decoder.GetElement("Error")
  11179 	if err != nil {
  11180 		var snapshot bytes.Buffer
  11181 		io.Copy(&snapshot, ringBuffer)
  11182 		return &smithy.DeserializationError{
  11183 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11184 			Snapshot: snapshot.Bytes(),
  11185 		}
  11186 	}
  11187 
  11188 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11189 	err = awsRestxml_deserializeDocumentDelegationSetInUse(&output, decoder)
  11190 	if err != nil {
  11191 		var snapshot bytes.Buffer
  11192 		io.Copy(&snapshot, ringBuffer)
  11193 		return &smithy.DeserializationError{
  11194 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11195 			Snapshot: snapshot.Bytes(),
  11196 		}
  11197 	}
  11198 
  11199 	return output
  11200 }
  11201 
  11202 func awsRestxml_deserializeErrorDelegationSetNotAvailable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11203 	output := &types.DelegationSetNotAvailable{}
  11204 	var buff [1024]byte
  11205 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11206 	body := io.TeeReader(errorBody, ringBuffer)
  11207 	rootDecoder := xml.NewDecoder(body)
  11208 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11209 	if err == io.EOF {
  11210 		return output
  11211 	}
  11212 	if err != nil {
  11213 		var snapshot bytes.Buffer
  11214 		io.Copy(&snapshot, ringBuffer)
  11215 		return &smithy.DeserializationError{
  11216 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11217 			Snapshot: snapshot.Bytes(),
  11218 		}
  11219 	}
  11220 
  11221 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11222 	t, err = decoder.GetElement("Error")
  11223 	if err != nil {
  11224 		var snapshot bytes.Buffer
  11225 		io.Copy(&snapshot, ringBuffer)
  11226 		return &smithy.DeserializationError{
  11227 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11228 			Snapshot: snapshot.Bytes(),
  11229 		}
  11230 	}
  11231 
  11232 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11233 	err = awsRestxml_deserializeDocumentDelegationSetNotAvailable(&output, decoder)
  11234 	if err != nil {
  11235 		var snapshot bytes.Buffer
  11236 		io.Copy(&snapshot, ringBuffer)
  11237 		return &smithy.DeserializationError{
  11238 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11239 			Snapshot: snapshot.Bytes(),
  11240 		}
  11241 	}
  11242 
  11243 	return output
  11244 }
  11245 
  11246 func awsRestxml_deserializeErrorDelegationSetNotReusable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11247 	output := &types.DelegationSetNotReusable{}
  11248 	var buff [1024]byte
  11249 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11250 	body := io.TeeReader(errorBody, ringBuffer)
  11251 	rootDecoder := xml.NewDecoder(body)
  11252 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11253 	if err == io.EOF {
  11254 		return output
  11255 	}
  11256 	if err != nil {
  11257 		var snapshot bytes.Buffer
  11258 		io.Copy(&snapshot, ringBuffer)
  11259 		return &smithy.DeserializationError{
  11260 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11261 			Snapshot: snapshot.Bytes(),
  11262 		}
  11263 	}
  11264 
  11265 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11266 	t, err = decoder.GetElement("Error")
  11267 	if err != nil {
  11268 		var snapshot bytes.Buffer
  11269 		io.Copy(&snapshot, ringBuffer)
  11270 		return &smithy.DeserializationError{
  11271 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11272 			Snapshot: snapshot.Bytes(),
  11273 		}
  11274 	}
  11275 
  11276 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11277 	err = awsRestxml_deserializeDocumentDelegationSetNotReusable(&output, decoder)
  11278 	if err != nil {
  11279 		var snapshot bytes.Buffer
  11280 		io.Copy(&snapshot, ringBuffer)
  11281 		return &smithy.DeserializationError{
  11282 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11283 			Snapshot: snapshot.Bytes(),
  11284 		}
  11285 	}
  11286 
  11287 	return output
  11288 }
  11289 
  11290 func awsRestxml_deserializeErrorDNSSECNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11291 	output := &types.DNSSECNotFound{}
  11292 	var buff [1024]byte
  11293 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11294 	body := io.TeeReader(errorBody, ringBuffer)
  11295 	rootDecoder := xml.NewDecoder(body)
  11296 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11297 	if err == io.EOF {
  11298 		return output
  11299 	}
  11300 	if err != nil {
  11301 		var snapshot bytes.Buffer
  11302 		io.Copy(&snapshot, ringBuffer)
  11303 		return &smithy.DeserializationError{
  11304 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11305 			Snapshot: snapshot.Bytes(),
  11306 		}
  11307 	}
  11308 
  11309 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11310 	t, err = decoder.GetElement("Error")
  11311 	if err != nil {
  11312 		var snapshot bytes.Buffer
  11313 		io.Copy(&snapshot, ringBuffer)
  11314 		return &smithy.DeserializationError{
  11315 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11316 			Snapshot: snapshot.Bytes(),
  11317 		}
  11318 	}
  11319 
  11320 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11321 	err = awsRestxml_deserializeDocumentDNSSECNotFound(&output, decoder)
  11322 	if err != nil {
  11323 		var snapshot bytes.Buffer
  11324 		io.Copy(&snapshot, ringBuffer)
  11325 		return &smithy.DeserializationError{
  11326 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11327 			Snapshot: snapshot.Bytes(),
  11328 		}
  11329 	}
  11330 
  11331 	return output
  11332 }
  11333 
  11334 func awsRestxml_deserializeErrorHealthCheckAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11335 	output := &types.HealthCheckAlreadyExists{}
  11336 	var buff [1024]byte
  11337 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11338 	body := io.TeeReader(errorBody, ringBuffer)
  11339 	rootDecoder := xml.NewDecoder(body)
  11340 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11341 	if err == io.EOF {
  11342 		return output
  11343 	}
  11344 	if err != nil {
  11345 		var snapshot bytes.Buffer
  11346 		io.Copy(&snapshot, ringBuffer)
  11347 		return &smithy.DeserializationError{
  11348 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11349 			Snapshot: snapshot.Bytes(),
  11350 		}
  11351 	}
  11352 
  11353 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11354 	t, err = decoder.GetElement("Error")
  11355 	if err != nil {
  11356 		var snapshot bytes.Buffer
  11357 		io.Copy(&snapshot, ringBuffer)
  11358 		return &smithy.DeserializationError{
  11359 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11360 			Snapshot: snapshot.Bytes(),
  11361 		}
  11362 	}
  11363 
  11364 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11365 	err = awsRestxml_deserializeDocumentHealthCheckAlreadyExists(&output, decoder)
  11366 	if err != nil {
  11367 		var snapshot bytes.Buffer
  11368 		io.Copy(&snapshot, ringBuffer)
  11369 		return &smithy.DeserializationError{
  11370 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11371 			Snapshot: snapshot.Bytes(),
  11372 		}
  11373 	}
  11374 
  11375 	return output
  11376 }
  11377 
  11378 func awsRestxml_deserializeErrorHealthCheckInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11379 	output := &types.HealthCheckInUse{}
  11380 	var buff [1024]byte
  11381 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11382 	body := io.TeeReader(errorBody, ringBuffer)
  11383 	rootDecoder := xml.NewDecoder(body)
  11384 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11385 	if err == io.EOF {
  11386 		return output
  11387 	}
  11388 	if err != nil {
  11389 		var snapshot bytes.Buffer
  11390 		io.Copy(&snapshot, ringBuffer)
  11391 		return &smithy.DeserializationError{
  11392 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11393 			Snapshot: snapshot.Bytes(),
  11394 		}
  11395 	}
  11396 
  11397 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11398 	t, err = decoder.GetElement("Error")
  11399 	if err != nil {
  11400 		var snapshot bytes.Buffer
  11401 		io.Copy(&snapshot, ringBuffer)
  11402 		return &smithy.DeserializationError{
  11403 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11404 			Snapshot: snapshot.Bytes(),
  11405 		}
  11406 	}
  11407 
  11408 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11409 	err = awsRestxml_deserializeDocumentHealthCheckInUse(&output, decoder)
  11410 	if err != nil {
  11411 		var snapshot bytes.Buffer
  11412 		io.Copy(&snapshot, ringBuffer)
  11413 		return &smithy.DeserializationError{
  11414 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11415 			Snapshot: snapshot.Bytes(),
  11416 		}
  11417 	}
  11418 
  11419 	return output
  11420 }
  11421 
  11422 func awsRestxml_deserializeErrorHealthCheckVersionMismatch(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11423 	output := &types.HealthCheckVersionMismatch{}
  11424 	var buff [1024]byte
  11425 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11426 	body := io.TeeReader(errorBody, ringBuffer)
  11427 	rootDecoder := xml.NewDecoder(body)
  11428 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11429 	if err == io.EOF {
  11430 		return output
  11431 	}
  11432 	if err != nil {
  11433 		var snapshot bytes.Buffer
  11434 		io.Copy(&snapshot, ringBuffer)
  11435 		return &smithy.DeserializationError{
  11436 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11437 			Snapshot: snapshot.Bytes(),
  11438 		}
  11439 	}
  11440 
  11441 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11442 	t, err = decoder.GetElement("Error")
  11443 	if err != nil {
  11444 		var snapshot bytes.Buffer
  11445 		io.Copy(&snapshot, ringBuffer)
  11446 		return &smithy.DeserializationError{
  11447 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11448 			Snapshot: snapshot.Bytes(),
  11449 		}
  11450 	}
  11451 
  11452 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11453 	err = awsRestxml_deserializeDocumentHealthCheckVersionMismatch(&output, decoder)
  11454 	if err != nil {
  11455 		var snapshot bytes.Buffer
  11456 		io.Copy(&snapshot, ringBuffer)
  11457 		return &smithy.DeserializationError{
  11458 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11459 			Snapshot: snapshot.Bytes(),
  11460 		}
  11461 	}
  11462 
  11463 	return output
  11464 }
  11465 
  11466 func awsRestxml_deserializeErrorHostedZoneAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11467 	output := &types.HostedZoneAlreadyExists{}
  11468 	var buff [1024]byte
  11469 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11470 	body := io.TeeReader(errorBody, ringBuffer)
  11471 	rootDecoder := xml.NewDecoder(body)
  11472 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11473 	if err == io.EOF {
  11474 		return output
  11475 	}
  11476 	if err != nil {
  11477 		var snapshot bytes.Buffer
  11478 		io.Copy(&snapshot, ringBuffer)
  11479 		return &smithy.DeserializationError{
  11480 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11481 			Snapshot: snapshot.Bytes(),
  11482 		}
  11483 	}
  11484 
  11485 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11486 	t, err = decoder.GetElement("Error")
  11487 	if err != nil {
  11488 		var snapshot bytes.Buffer
  11489 		io.Copy(&snapshot, ringBuffer)
  11490 		return &smithy.DeserializationError{
  11491 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11492 			Snapshot: snapshot.Bytes(),
  11493 		}
  11494 	}
  11495 
  11496 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11497 	err = awsRestxml_deserializeDocumentHostedZoneAlreadyExists(&output, decoder)
  11498 	if err != nil {
  11499 		var snapshot bytes.Buffer
  11500 		io.Copy(&snapshot, ringBuffer)
  11501 		return &smithy.DeserializationError{
  11502 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11503 			Snapshot: snapshot.Bytes(),
  11504 		}
  11505 	}
  11506 
  11507 	return output
  11508 }
  11509 
  11510 func awsRestxml_deserializeErrorHostedZoneNotEmpty(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11511 	output := &types.HostedZoneNotEmpty{}
  11512 	var buff [1024]byte
  11513 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11514 	body := io.TeeReader(errorBody, ringBuffer)
  11515 	rootDecoder := xml.NewDecoder(body)
  11516 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11517 	if err == io.EOF {
  11518 		return output
  11519 	}
  11520 	if err != nil {
  11521 		var snapshot bytes.Buffer
  11522 		io.Copy(&snapshot, ringBuffer)
  11523 		return &smithy.DeserializationError{
  11524 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11525 			Snapshot: snapshot.Bytes(),
  11526 		}
  11527 	}
  11528 
  11529 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11530 	t, err = decoder.GetElement("Error")
  11531 	if err != nil {
  11532 		var snapshot bytes.Buffer
  11533 		io.Copy(&snapshot, ringBuffer)
  11534 		return &smithy.DeserializationError{
  11535 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11536 			Snapshot: snapshot.Bytes(),
  11537 		}
  11538 	}
  11539 
  11540 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11541 	err = awsRestxml_deserializeDocumentHostedZoneNotEmpty(&output, decoder)
  11542 	if err != nil {
  11543 		var snapshot bytes.Buffer
  11544 		io.Copy(&snapshot, ringBuffer)
  11545 		return &smithy.DeserializationError{
  11546 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11547 			Snapshot: snapshot.Bytes(),
  11548 		}
  11549 	}
  11550 
  11551 	return output
  11552 }
  11553 
  11554 func awsRestxml_deserializeErrorHostedZoneNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11555 	output := &types.HostedZoneNotFound{}
  11556 	var buff [1024]byte
  11557 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11558 	body := io.TeeReader(errorBody, ringBuffer)
  11559 	rootDecoder := xml.NewDecoder(body)
  11560 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11561 	if err == io.EOF {
  11562 		return output
  11563 	}
  11564 	if err != nil {
  11565 		var snapshot bytes.Buffer
  11566 		io.Copy(&snapshot, ringBuffer)
  11567 		return &smithy.DeserializationError{
  11568 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11569 			Snapshot: snapshot.Bytes(),
  11570 		}
  11571 	}
  11572 
  11573 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11574 	t, err = decoder.GetElement("Error")
  11575 	if err != nil {
  11576 		var snapshot bytes.Buffer
  11577 		io.Copy(&snapshot, ringBuffer)
  11578 		return &smithy.DeserializationError{
  11579 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11580 			Snapshot: snapshot.Bytes(),
  11581 		}
  11582 	}
  11583 
  11584 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11585 	err = awsRestxml_deserializeDocumentHostedZoneNotFound(&output, decoder)
  11586 	if err != nil {
  11587 		var snapshot bytes.Buffer
  11588 		io.Copy(&snapshot, ringBuffer)
  11589 		return &smithy.DeserializationError{
  11590 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11591 			Snapshot: snapshot.Bytes(),
  11592 		}
  11593 	}
  11594 
  11595 	return output
  11596 }
  11597 
  11598 func awsRestxml_deserializeErrorHostedZoneNotPrivate(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11599 	output := &types.HostedZoneNotPrivate{}
  11600 	var buff [1024]byte
  11601 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11602 	body := io.TeeReader(errorBody, ringBuffer)
  11603 	rootDecoder := xml.NewDecoder(body)
  11604 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11605 	if err == io.EOF {
  11606 		return output
  11607 	}
  11608 	if err != nil {
  11609 		var snapshot bytes.Buffer
  11610 		io.Copy(&snapshot, ringBuffer)
  11611 		return &smithy.DeserializationError{
  11612 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11613 			Snapshot: snapshot.Bytes(),
  11614 		}
  11615 	}
  11616 
  11617 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11618 	t, err = decoder.GetElement("Error")
  11619 	if err != nil {
  11620 		var snapshot bytes.Buffer
  11621 		io.Copy(&snapshot, ringBuffer)
  11622 		return &smithy.DeserializationError{
  11623 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11624 			Snapshot: snapshot.Bytes(),
  11625 		}
  11626 	}
  11627 
  11628 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11629 	err = awsRestxml_deserializeDocumentHostedZoneNotPrivate(&output, decoder)
  11630 	if err != nil {
  11631 		var snapshot bytes.Buffer
  11632 		io.Copy(&snapshot, ringBuffer)
  11633 		return &smithy.DeserializationError{
  11634 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11635 			Snapshot: snapshot.Bytes(),
  11636 		}
  11637 	}
  11638 
  11639 	return output
  11640 }
  11641 
  11642 func awsRestxml_deserializeErrorHostedZonePartiallyDelegated(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11643 	output := &types.HostedZonePartiallyDelegated{}
  11644 	var buff [1024]byte
  11645 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11646 	body := io.TeeReader(errorBody, ringBuffer)
  11647 	rootDecoder := xml.NewDecoder(body)
  11648 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11649 	if err == io.EOF {
  11650 		return output
  11651 	}
  11652 	if err != nil {
  11653 		var snapshot bytes.Buffer
  11654 		io.Copy(&snapshot, ringBuffer)
  11655 		return &smithy.DeserializationError{
  11656 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11657 			Snapshot: snapshot.Bytes(),
  11658 		}
  11659 	}
  11660 
  11661 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11662 	t, err = decoder.GetElement("Error")
  11663 	if err != nil {
  11664 		var snapshot bytes.Buffer
  11665 		io.Copy(&snapshot, ringBuffer)
  11666 		return &smithy.DeserializationError{
  11667 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11668 			Snapshot: snapshot.Bytes(),
  11669 		}
  11670 	}
  11671 
  11672 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11673 	err = awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(&output, decoder)
  11674 	if err != nil {
  11675 		var snapshot bytes.Buffer
  11676 		io.Copy(&snapshot, ringBuffer)
  11677 		return &smithy.DeserializationError{
  11678 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11679 			Snapshot: snapshot.Bytes(),
  11680 		}
  11681 	}
  11682 
  11683 	return output
  11684 }
  11685 
  11686 func awsRestxml_deserializeErrorIncompatibleVersion(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11687 	output := &types.IncompatibleVersion{}
  11688 	var buff [1024]byte
  11689 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11690 	body := io.TeeReader(errorBody, ringBuffer)
  11691 	rootDecoder := xml.NewDecoder(body)
  11692 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11693 	if err == io.EOF {
  11694 		return output
  11695 	}
  11696 	if err != nil {
  11697 		var snapshot bytes.Buffer
  11698 		io.Copy(&snapshot, ringBuffer)
  11699 		return &smithy.DeserializationError{
  11700 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11701 			Snapshot: snapshot.Bytes(),
  11702 		}
  11703 	}
  11704 
  11705 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11706 	t, err = decoder.GetElement("Error")
  11707 	if err != nil {
  11708 		var snapshot bytes.Buffer
  11709 		io.Copy(&snapshot, ringBuffer)
  11710 		return &smithy.DeserializationError{
  11711 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11712 			Snapshot: snapshot.Bytes(),
  11713 		}
  11714 	}
  11715 
  11716 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11717 	err = awsRestxml_deserializeDocumentIncompatibleVersion(&output, decoder)
  11718 	if err != nil {
  11719 		var snapshot bytes.Buffer
  11720 		io.Copy(&snapshot, ringBuffer)
  11721 		return &smithy.DeserializationError{
  11722 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11723 			Snapshot: snapshot.Bytes(),
  11724 		}
  11725 	}
  11726 
  11727 	return output
  11728 }
  11729 
  11730 func awsRestxml_deserializeErrorInsufficientCloudWatchLogsResourcePolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11731 	output := &types.InsufficientCloudWatchLogsResourcePolicy{}
  11732 	var buff [1024]byte
  11733 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11734 	body := io.TeeReader(errorBody, ringBuffer)
  11735 	rootDecoder := xml.NewDecoder(body)
  11736 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11737 	if err == io.EOF {
  11738 		return output
  11739 	}
  11740 	if err != nil {
  11741 		var snapshot bytes.Buffer
  11742 		io.Copy(&snapshot, ringBuffer)
  11743 		return &smithy.DeserializationError{
  11744 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11745 			Snapshot: snapshot.Bytes(),
  11746 		}
  11747 	}
  11748 
  11749 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11750 	t, err = decoder.GetElement("Error")
  11751 	if err != nil {
  11752 		var snapshot bytes.Buffer
  11753 		io.Copy(&snapshot, ringBuffer)
  11754 		return &smithy.DeserializationError{
  11755 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11756 			Snapshot: snapshot.Bytes(),
  11757 		}
  11758 	}
  11759 
  11760 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11761 	err = awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(&output, decoder)
  11762 	if err != nil {
  11763 		var snapshot bytes.Buffer
  11764 		io.Copy(&snapshot, ringBuffer)
  11765 		return &smithy.DeserializationError{
  11766 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11767 			Snapshot: snapshot.Bytes(),
  11768 		}
  11769 	}
  11770 
  11771 	return output
  11772 }
  11773 
  11774 func awsRestxml_deserializeErrorInvalidArgument(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11775 	output := &types.InvalidArgument{}
  11776 	var buff [1024]byte
  11777 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11778 	body := io.TeeReader(errorBody, ringBuffer)
  11779 	rootDecoder := xml.NewDecoder(body)
  11780 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11781 	if err == io.EOF {
  11782 		return output
  11783 	}
  11784 	if err != nil {
  11785 		var snapshot bytes.Buffer
  11786 		io.Copy(&snapshot, ringBuffer)
  11787 		return &smithy.DeserializationError{
  11788 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11789 			Snapshot: snapshot.Bytes(),
  11790 		}
  11791 	}
  11792 
  11793 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11794 	t, err = decoder.GetElement("Error")
  11795 	if err != nil {
  11796 		var snapshot bytes.Buffer
  11797 		io.Copy(&snapshot, ringBuffer)
  11798 		return &smithy.DeserializationError{
  11799 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11800 			Snapshot: snapshot.Bytes(),
  11801 		}
  11802 	}
  11803 
  11804 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11805 	err = awsRestxml_deserializeDocumentInvalidArgument(&output, decoder)
  11806 	if err != nil {
  11807 		var snapshot bytes.Buffer
  11808 		io.Copy(&snapshot, ringBuffer)
  11809 		return &smithy.DeserializationError{
  11810 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11811 			Snapshot: snapshot.Bytes(),
  11812 		}
  11813 	}
  11814 
  11815 	return output
  11816 }
  11817 
  11818 func awsRestxml_deserializeErrorInvalidChangeBatch(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11819 	output := &types.InvalidChangeBatch{}
  11820 	var buff [1024]byte
  11821 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11822 	body := io.TeeReader(errorBody, ringBuffer)
  11823 	rootDecoder := xml.NewDecoder(body)
  11824 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11825 	if err == io.EOF {
  11826 		return output
  11827 	}
  11828 	if err != nil {
  11829 		var snapshot bytes.Buffer
  11830 		io.Copy(&snapshot, ringBuffer)
  11831 		return &smithy.DeserializationError{
  11832 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11833 			Snapshot: snapshot.Bytes(),
  11834 		}
  11835 	}
  11836 
  11837 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11838 	t, err = decoder.GetElement("Error")
  11839 	if err != nil {
  11840 		var snapshot bytes.Buffer
  11841 		io.Copy(&snapshot, ringBuffer)
  11842 		return &smithy.DeserializationError{
  11843 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11844 			Snapshot: snapshot.Bytes(),
  11845 		}
  11846 	}
  11847 
  11848 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11849 	err = awsRestxml_deserializeDocumentInvalidChangeBatch(&output, decoder)
  11850 	if err != nil {
  11851 		var snapshot bytes.Buffer
  11852 		io.Copy(&snapshot, ringBuffer)
  11853 		return &smithy.DeserializationError{
  11854 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11855 			Snapshot: snapshot.Bytes(),
  11856 		}
  11857 	}
  11858 
  11859 	return output
  11860 }
  11861 
  11862 func awsRestxml_deserializeErrorInvalidDomainName(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11863 	output := &types.InvalidDomainName{}
  11864 	var buff [1024]byte
  11865 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11866 	body := io.TeeReader(errorBody, ringBuffer)
  11867 	rootDecoder := xml.NewDecoder(body)
  11868 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11869 	if err == io.EOF {
  11870 		return output
  11871 	}
  11872 	if err != nil {
  11873 		var snapshot bytes.Buffer
  11874 		io.Copy(&snapshot, ringBuffer)
  11875 		return &smithy.DeserializationError{
  11876 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11877 			Snapshot: snapshot.Bytes(),
  11878 		}
  11879 	}
  11880 
  11881 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11882 	t, err = decoder.GetElement("Error")
  11883 	if err != nil {
  11884 		var snapshot bytes.Buffer
  11885 		io.Copy(&snapshot, ringBuffer)
  11886 		return &smithy.DeserializationError{
  11887 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11888 			Snapshot: snapshot.Bytes(),
  11889 		}
  11890 	}
  11891 
  11892 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11893 	err = awsRestxml_deserializeDocumentInvalidDomainName(&output, decoder)
  11894 	if err != nil {
  11895 		var snapshot bytes.Buffer
  11896 		io.Copy(&snapshot, ringBuffer)
  11897 		return &smithy.DeserializationError{
  11898 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11899 			Snapshot: snapshot.Bytes(),
  11900 		}
  11901 	}
  11902 
  11903 	return output
  11904 }
  11905 
  11906 func awsRestxml_deserializeErrorInvalidInput(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11907 	output := &types.InvalidInput{}
  11908 	var buff [1024]byte
  11909 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11910 	body := io.TeeReader(errorBody, ringBuffer)
  11911 	rootDecoder := xml.NewDecoder(body)
  11912 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11913 	if err == io.EOF {
  11914 		return output
  11915 	}
  11916 	if err != nil {
  11917 		var snapshot bytes.Buffer
  11918 		io.Copy(&snapshot, ringBuffer)
  11919 		return &smithy.DeserializationError{
  11920 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11921 			Snapshot: snapshot.Bytes(),
  11922 		}
  11923 	}
  11924 
  11925 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11926 	t, err = decoder.GetElement("Error")
  11927 	if err != nil {
  11928 		var snapshot bytes.Buffer
  11929 		io.Copy(&snapshot, ringBuffer)
  11930 		return &smithy.DeserializationError{
  11931 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11932 			Snapshot: snapshot.Bytes(),
  11933 		}
  11934 	}
  11935 
  11936 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11937 	err = awsRestxml_deserializeDocumentInvalidInput(&output, decoder)
  11938 	if err != nil {
  11939 		var snapshot bytes.Buffer
  11940 		io.Copy(&snapshot, ringBuffer)
  11941 		return &smithy.DeserializationError{
  11942 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11943 			Snapshot: snapshot.Bytes(),
  11944 		}
  11945 	}
  11946 
  11947 	return output
  11948 }
  11949 
  11950 func awsRestxml_deserializeErrorInvalidKeySigningKeyName(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11951 	output := &types.InvalidKeySigningKeyName{}
  11952 	var buff [1024]byte
  11953 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11954 	body := io.TeeReader(errorBody, ringBuffer)
  11955 	rootDecoder := xml.NewDecoder(body)
  11956 	t, err := smithyxml.FetchRootElement(rootDecoder)
  11957 	if err == io.EOF {
  11958 		return output
  11959 	}
  11960 	if err != nil {
  11961 		var snapshot bytes.Buffer
  11962 		io.Copy(&snapshot, ringBuffer)
  11963 		return &smithy.DeserializationError{
  11964 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11965 			Snapshot: snapshot.Bytes(),
  11966 		}
  11967 	}
  11968 
  11969 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  11970 	t, err = decoder.GetElement("Error")
  11971 	if err != nil {
  11972 		var snapshot bytes.Buffer
  11973 		io.Copy(&snapshot, ringBuffer)
  11974 		return &smithy.DeserializationError{
  11975 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11976 			Snapshot: snapshot.Bytes(),
  11977 		}
  11978 	}
  11979 
  11980 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  11981 	err = awsRestxml_deserializeDocumentInvalidKeySigningKeyName(&output, decoder)
  11982 	if err != nil {
  11983 		var snapshot bytes.Buffer
  11984 		io.Copy(&snapshot, ringBuffer)
  11985 		return &smithy.DeserializationError{
  11986 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  11987 			Snapshot: snapshot.Bytes(),
  11988 		}
  11989 	}
  11990 
  11991 	return output
  11992 }
  11993 
  11994 func awsRestxml_deserializeErrorInvalidKeySigningKeyStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  11995 	output := &types.InvalidKeySigningKeyStatus{}
  11996 	var buff [1024]byte
  11997 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  11998 	body := io.TeeReader(errorBody, ringBuffer)
  11999 	rootDecoder := xml.NewDecoder(body)
  12000 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12001 	if err == io.EOF {
  12002 		return output
  12003 	}
  12004 	if err != nil {
  12005 		var snapshot bytes.Buffer
  12006 		io.Copy(&snapshot, ringBuffer)
  12007 		return &smithy.DeserializationError{
  12008 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12009 			Snapshot: snapshot.Bytes(),
  12010 		}
  12011 	}
  12012 
  12013 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12014 	t, err = decoder.GetElement("Error")
  12015 	if err != nil {
  12016 		var snapshot bytes.Buffer
  12017 		io.Copy(&snapshot, ringBuffer)
  12018 		return &smithy.DeserializationError{
  12019 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12020 			Snapshot: snapshot.Bytes(),
  12021 		}
  12022 	}
  12023 
  12024 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12025 	err = awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(&output, decoder)
  12026 	if err != nil {
  12027 		var snapshot bytes.Buffer
  12028 		io.Copy(&snapshot, ringBuffer)
  12029 		return &smithy.DeserializationError{
  12030 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12031 			Snapshot: snapshot.Bytes(),
  12032 		}
  12033 	}
  12034 
  12035 	return output
  12036 }
  12037 
  12038 func awsRestxml_deserializeErrorInvalidKMSArn(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12039 	output := &types.InvalidKMSArn{}
  12040 	var buff [1024]byte
  12041 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12042 	body := io.TeeReader(errorBody, ringBuffer)
  12043 	rootDecoder := xml.NewDecoder(body)
  12044 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12045 	if err == io.EOF {
  12046 		return output
  12047 	}
  12048 	if err != nil {
  12049 		var snapshot bytes.Buffer
  12050 		io.Copy(&snapshot, ringBuffer)
  12051 		return &smithy.DeserializationError{
  12052 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12053 			Snapshot: snapshot.Bytes(),
  12054 		}
  12055 	}
  12056 
  12057 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12058 	t, err = decoder.GetElement("Error")
  12059 	if err != nil {
  12060 		var snapshot bytes.Buffer
  12061 		io.Copy(&snapshot, ringBuffer)
  12062 		return &smithy.DeserializationError{
  12063 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12064 			Snapshot: snapshot.Bytes(),
  12065 		}
  12066 	}
  12067 
  12068 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12069 	err = awsRestxml_deserializeDocumentInvalidKMSArn(&output, decoder)
  12070 	if err != nil {
  12071 		var snapshot bytes.Buffer
  12072 		io.Copy(&snapshot, ringBuffer)
  12073 		return &smithy.DeserializationError{
  12074 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12075 			Snapshot: snapshot.Bytes(),
  12076 		}
  12077 	}
  12078 
  12079 	return output
  12080 }
  12081 
  12082 func awsRestxml_deserializeErrorInvalidPaginationToken(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12083 	output := &types.InvalidPaginationToken{}
  12084 	var buff [1024]byte
  12085 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12086 	body := io.TeeReader(errorBody, ringBuffer)
  12087 	rootDecoder := xml.NewDecoder(body)
  12088 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12089 	if err == io.EOF {
  12090 		return output
  12091 	}
  12092 	if err != nil {
  12093 		var snapshot bytes.Buffer
  12094 		io.Copy(&snapshot, ringBuffer)
  12095 		return &smithy.DeserializationError{
  12096 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12097 			Snapshot: snapshot.Bytes(),
  12098 		}
  12099 	}
  12100 
  12101 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12102 	t, err = decoder.GetElement("Error")
  12103 	if err != nil {
  12104 		var snapshot bytes.Buffer
  12105 		io.Copy(&snapshot, ringBuffer)
  12106 		return &smithy.DeserializationError{
  12107 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12108 			Snapshot: snapshot.Bytes(),
  12109 		}
  12110 	}
  12111 
  12112 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12113 	err = awsRestxml_deserializeDocumentInvalidPaginationToken(&output, decoder)
  12114 	if err != nil {
  12115 		var snapshot bytes.Buffer
  12116 		io.Copy(&snapshot, ringBuffer)
  12117 		return &smithy.DeserializationError{
  12118 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12119 			Snapshot: snapshot.Bytes(),
  12120 		}
  12121 	}
  12122 
  12123 	return output
  12124 }
  12125 
  12126 func awsRestxml_deserializeErrorInvalidSigningStatus(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12127 	output := &types.InvalidSigningStatus{}
  12128 	var buff [1024]byte
  12129 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12130 	body := io.TeeReader(errorBody, ringBuffer)
  12131 	rootDecoder := xml.NewDecoder(body)
  12132 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12133 	if err == io.EOF {
  12134 		return output
  12135 	}
  12136 	if err != nil {
  12137 		var snapshot bytes.Buffer
  12138 		io.Copy(&snapshot, ringBuffer)
  12139 		return &smithy.DeserializationError{
  12140 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12141 			Snapshot: snapshot.Bytes(),
  12142 		}
  12143 	}
  12144 
  12145 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12146 	t, err = decoder.GetElement("Error")
  12147 	if err != nil {
  12148 		var snapshot bytes.Buffer
  12149 		io.Copy(&snapshot, ringBuffer)
  12150 		return &smithy.DeserializationError{
  12151 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12152 			Snapshot: snapshot.Bytes(),
  12153 		}
  12154 	}
  12155 
  12156 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12157 	err = awsRestxml_deserializeDocumentInvalidSigningStatus(&output, decoder)
  12158 	if err != nil {
  12159 		var snapshot bytes.Buffer
  12160 		io.Copy(&snapshot, ringBuffer)
  12161 		return &smithy.DeserializationError{
  12162 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12163 			Snapshot: snapshot.Bytes(),
  12164 		}
  12165 	}
  12166 
  12167 	return output
  12168 }
  12169 
  12170 func awsRestxml_deserializeErrorInvalidTrafficPolicyDocument(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12171 	output := &types.InvalidTrafficPolicyDocument{}
  12172 	var buff [1024]byte
  12173 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12174 	body := io.TeeReader(errorBody, ringBuffer)
  12175 	rootDecoder := xml.NewDecoder(body)
  12176 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12177 	if err == io.EOF {
  12178 		return output
  12179 	}
  12180 	if err != nil {
  12181 		var snapshot bytes.Buffer
  12182 		io.Copy(&snapshot, ringBuffer)
  12183 		return &smithy.DeserializationError{
  12184 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12185 			Snapshot: snapshot.Bytes(),
  12186 		}
  12187 	}
  12188 
  12189 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12190 	t, err = decoder.GetElement("Error")
  12191 	if err != nil {
  12192 		var snapshot bytes.Buffer
  12193 		io.Copy(&snapshot, ringBuffer)
  12194 		return &smithy.DeserializationError{
  12195 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12196 			Snapshot: snapshot.Bytes(),
  12197 		}
  12198 	}
  12199 
  12200 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12201 	err = awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(&output, decoder)
  12202 	if err != nil {
  12203 		var snapshot bytes.Buffer
  12204 		io.Copy(&snapshot, ringBuffer)
  12205 		return &smithy.DeserializationError{
  12206 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12207 			Snapshot: snapshot.Bytes(),
  12208 		}
  12209 	}
  12210 
  12211 	return output
  12212 }
  12213 
  12214 func awsRestxml_deserializeErrorInvalidVPCId(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12215 	output := &types.InvalidVPCId{}
  12216 	var buff [1024]byte
  12217 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12218 	body := io.TeeReader(errorBody, ringBuffer)
  12219 	rootDecoder := xml.NewDecoder(body)
  12220 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12221 	if err == io.EOF {
  12222 		return output
  12223 	}
  12224 	if err != nil {
  12225 		var snapshot bytes.Buffer
  12226 		io.Copy(&snapshot, ringBuffer)
  12227 		return &smithy.DeserializationError{
  12228 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12229 			Snapshot: snapshot.Bytes(),
  12230 		}
  12231 	}
  12232 
  12233 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12234 	t, err = decoder.GetElement("Error")
  12235 	if err != nil {
  12236 		var snapshot bytes.Buffer
  12237 		io.Copy(&snapshot, ringBuffer)
  12238 		return &smithy.DeserializationError{
  12239 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12240 			Snapshot: snapshot.Bytes(),
  12241 		}
  12242 	}
  12243 
  12244 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12245 	err = awsRestxml_deserializeDocumentInvalidVPCId(&output, decoder)
  12246 	if err != nil {
  12247 		var snapshot bytes.Buffer
  12248 		io.Copy(&snapshot, ringBuffer)
  12249 		return &smithy.DeserializationError{
  12250 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12251 			Snapshot: snapshot.Bytes(),
  12252 		}
  12253 	}
  12254 
  12255 	return output
  12256 }
  12257 
  12258 func awsRestxml_deserializeErrorKeySigningKeyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12259 	output := &types.KeySigningKeyAlreadyExists{}
  12260 	var buff [1024]byte
  12261 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12262 	body := io.TeeReader(errorBody, ringBuffer)
  12263 	rootDecoder := xml.NewDecoder(body)
  12264 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12265 	if err == io.EOF {
  12266 		return output
  12267 	}
  12268 	if err != nil {
  12269 		var snapshot bytes.Buffer
  12270 		io.Copy(&snapshot, ringBuffer)
  12271 		return &smithy.DeserializationError{
  12272 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12273 			Snapshot: snapshot.Bytes(),
  12274 		}
  12275 	}
  12276 
  12277 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12278 	t, err = decoder.GetElement("Error")
  12279 	if err != nil {
  12280 		var snapshot bytes.Buffer
  12281 		io.Copy(&snapshot, ringBuffer)
  12282 		return &smithy.DeserializationError{
  12283 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12284 			Snapshot: snapshot.Bytes(),
  12285 		}
  12286 	}
  12287 
  12288 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12289 	err = awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(&output, decoder)
  12290 	if err != nil {
  12291 		var snapshot bytes.Buffer
  12292 		io.Copy(&snapshot, ringBuffer)
  12293 		return &smithy.DeserializationError{
  12294 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12295 			Snapshot: snapshot.Bytes(),
  12296 		}
  12297 	}
  12298 
  12299 	return output
  12300 }
  12301 
  12302 func awsRestxml_deserializeErrorKeySigningKeyInParentDSRecord(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12303 	output := &types.KeySigningKeyInParentDSRecord{}
  12304 	var buff [1024]byte
  12305 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12306 	body := io.TeeReader(errorBody, ringBuffer)
  12307 	rootDecoder := xml.NewDecoder(body)
  12308 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12309 	if err == io.EOF {
  12310 		return output
  12311 	}
  12312 	if err != nil {
  12313 		var snapshot bytes.Buffer
  12314 		io.Copy(&snapshot, ringBuffer)
  12315 		return &smithy.DeserializationError{
  12316 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12317 			Snapshot: snapshot.Bytes(),
  12318 		}
  12319 	}
  12320 
  12321 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12322 	t, err = decoder.GetElement("Error")
  12323 	if err != nil {
  12324 		var snapshot bytes.Buffer
  12325 		io.Copy(&snapshot, ringBuffer)
  12326 		return &smithy.DeserializationError{
  12327 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12328 			Snapshot: snapshot.Bytes(),
  12329 		}
  12330 	}
  12331 
  12332 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12333 	err = awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(&output, decoder)
  12334 	if err != nil {
  12335 		var snapshot bytes.Buffer
  12336 		io.Copy(&snapshot, ringBuffer)
  12337 		return &smithy.DeserializationError{
  12338 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12339 			Snapshot: snapshot.Bytes(),
  12340 		}
  12341 	}
  12342 
  12343 	return output
  12344 }
  12345 
  12346 func awsRestxml_deserializeErrorKeySigningKeyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12347 	output := &types.KeySigningKeyInUse{}
  12348 	var buff [1024]byte
  12349 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12350 	body := io.TeeReader(errorBody, ringBuffer)
  12351 	rootDecoder := xml.NewDecoder(body)
  12352 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12353 	if err == io.EOF {
  12354 		return output
  12355 	}
  12356 	if err != nil {
  12357 		var snapshot bytes.Buffer
  12358 		io.Copy(&snapshot, ringBuffer)
  12359 		return &smithy.DeserializationError{
  12360 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12361 			Snapshot: snapshot.Bytes(),
  12362 		}
  12363 	}
  12364 
  12365 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12366 	t, err = decoder.GetElement("Error")
  12367 	if err != nil {
  12368 		var snapshot bytes.Buffer
  12369 		io.Copy(&snapshot, ringBuffer)
  12370 		return &smithy.DeserializationError{
  12371 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12372 			Snapshot: snapshot.Bytes(),
  12373 		}
  12374 	}
  12375 
  12376 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12377 	err = awsRestxml_deserializeDocumentKeySigningKeyInUse(&output, decoder)
  12378 	if err != nil {
  12379 		var snapshot bytes.Buffer
  12380 		io.Copy(&snapshot, ringBuffer)
  12381 		return &smithy.DeserializationError{
  12382 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12383 			Snapshot: snapshot.Bytes(),
  12384 		}
  12385 	}
  12386 
  12387 	return output
  12388 }
  12389 
  12390 func awsRestxml_deserializeErrorKeySigningKeyWithActiveStatusNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12391 	output := &types.KeySigningKeyWithActiveStatusNotFound{}
  12392 	var buff [1024]byte
  12393 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12394 	body := io.TeeReader(errorBody, ringBuffer)
  12395 	rootDecoder := xml.NewDecoder(body)
  12396 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12397 	if err == io.EOF {
  12398 		return output
  12399 	}
  12400 	if err != nil {
  12401 		var snapshot bytes.Buffer
  12402 		io.Copy(&snapshot, ringBuffer)
  12403 		return &smithy.DeserializationError{
  12404 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12405 			Snapshot: snapshot.Bytes(),
  12406 		}
  12407 	}
  12408 
  12409 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12410 	t, err = decoder.GetElement("Error")
  12411 	if err != nil {
  12412 		var snapshot bytes.Buffer
  12413 		io.Copy(&snapshot, ringBuffer)
  12414 		return &smithy.DeserializationError{
  12415 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12416 			Snapshot: snapshot.Bytes(),
  12417 		}
  12418 	}
  12419 
  12420 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12421 	err = awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(&output, decoder)
  12422 	if err != nil {
  12423 		var snapshot bytes.Buffer
  12424 		io.Copy(&snapshot, ringBuffer)
  12425 		return &smithy.DeserializationError{
  12426 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12427 			Snapshot: snapshot.Bytes(),
  12428 		}
  12429 	}
  12430 
  12431 	return output
  12432 }
  12433 
  12434 func awsRestxml_deserializeErrorLastVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12435 	output := &types.LastVPCAssociation{}
  12436 	var buff [1024]byte
  12437 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12438 	body := io.TeeReader(errorBody, ringBuffer)
  12439 	rootDecoder := xml.NewDecoder(body)
  12440 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12441 	if err == io.EOF {
  12442 		return output
  12443 	}
  12444 	if err != nil {
  12445 		var snapshot bytes.Buffer
  12446 		io.Copy(&snapshot, ringBuffer)
  12447 		return &smithy.DeserializationError{
  12448 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12449 			Snapshot: snapshot.Bytes(),
  12450 		}
  12451 	}
  12452 
  12453 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12454 	t, err = decoder.GetElement("Error")
  12455 	if err != nil {
  12456 		var snapshot bytes.Buffer
  12457 		io.Copy(&snapshot, ringBuffer)
  12458 		return &smithy.DeserializationError{
  12459 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12460 			Snapshot: snapshot.Bytes(),
  12461 		}
  12462 	}
  12463 
  12464 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12465 	err = awsRestxml_deserializeDocumentLastVPCAssociation(&output, decoder)
  12466 	if err != nil {
  12467 		var snapshot bytes.Buffer
  12468 		io.Copy(&snapshot, ringBuffer)
  12469 		return &smithy.DeserializationError{
  12470 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12471 			Snapshot: snapshot.Bytes(),
  12472 		}
  12473 	}
  12474 
  12475 	return output
  12476 }
  12477 
  12478 func awsRestxml_deserializeErrorLimitsExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12479 	output := &types.LimitsExceeded{}
  12480 	var buff [1024]byte
  12481 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12482 	body := io.TeeReader(errorBody, ringBuffer)
  12483 	rootDecoder := xml.NewDecoder(body)
  12484 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12485 	if err == io.EOF {
  12486 		return output
  12487 	}
  12488 	if err != nil {
  12489 		var snapshot bytes.Buffer
  12490 		io.Copy(&snapshot, ringBuffer)
  12491 		return &smithy.DeserializationError{
  12492 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12493 			Snapshot: snapshot.Bytes(),
  12494 		}
  12495 	}
  12496 
  12497 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12498 	t, err = decoder.GetElement("Error")
  12499 	if err != nil {
  12500 		var snapshot bytes.Buffer
  12501 		io.Copy(&snapshot, ringBuffer)
  12502 		return &smithy.DeserializationError{
  12503 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12504 			Snapshot: snapshot.Bytes(),
  12505 		}
  12506 	}
  12507 
  12508 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12509 	err = awsRestxml_deserializeDocumentLimitsExceeded(&output, decoder)
  12510 	if err != nil {
  12511 		var snapshot bytes.Buffer
  12512 		io.Copy(&snapshot, ringBuffer)
  12513 		return &smithy.DeserializationError{
  12514 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12515 			Snapshot: snapshot.Bytes(),
  12516 		}
  12517 	}
  12518 
  12519 	return output
  12520 }
  12521 
  12522 func awsRestxml_deserializeErrorNoSuchChange(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12523 	output := &types.NoSuchChange{}
  12524 	var buff [1024]byte
  12525 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12526 	body := io.TeeReader(errorBody, ringBuffer)
  12527 	rootDecoder := xml.NewDecoder(body)
  12528 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12529 	if err == io.EOF {
  12530 		return output
  12531 	}
  12532 	if err != nil {
  12533 		var snapshot bytes.Buffer
  12534 		io.Copy(&snapshot, ringBuffer)
  12535 		return &smithy.DeserializationError{
  12536 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12537 			Snapshot: snapshot.Bytes(),
  12538 		}
  12539 	}
  12540 
  12541 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12542 	t, err = decoder.GetElement("Error")
  12543 	if err != nil {
  12544 		var snapshot bytes.Buffer
  12545 		io.Copy(&snapshot, ringBuffer)
  12546 		return &smithy.DeserializationError{
  12547 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12548 			Snapshot: snapshot.Bytes(),
  12549 		}
  12550 	}
  12551 
  12552 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12553 	err = awsRestxml_deserializeDocumentNoSuchChange(&output, decoder)
  12554 	if err != nil {
  12555 		var snapshot bytes.Buffer
  12556 		io.Copy(&snapshot, ringBuffer)
  12557 		return &smithy.DeserializationError{
  12558 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12559 			Snapshot: snapshot.Bytes(),
  12560 		}
  12561 	}
  12562 
  12563 	return output
  12564 }
  12565 
  12566 func awsRestxml_deserializeErrorNoSuchCidrCollectionException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12567 	output := &types.NoSuchCidrCollectionException{}
  12568 	var buff [1024]byte
  12569 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12570 	body := io.TeeReader(errorBody, ringBuffer)
  12571 	rootDecoder := xml.NewDecoder(body)
  12572 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12573 	if err == io.EOF {
  12574 		return output
  12575 	}
  12576 	if err != nil {
  12577 		var snapshot bytes.Buffer
  12578 		io.Copy(&snapshot, ringBuffer)
  12579 		return &smithy.DeserializationError{
  12580 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12581 			Snapshot: snapshot.Bytes(),
  12582 		}
  12583 	}
  12584 
  12585 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12586 	t, err = decoder.GetElement("Error")
  12587 	if err != nil {
  12588 		var snapshot bytes.Buffer
  12589 		io.Copy(&snapshot, ringBuffer)
  12590 		return &smithy.DeserializationError{
  12591 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12592 			Snapshot: snapshot.Bytes(),
  12593 		}
  12594 	}
  12595 
  12596 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12597 	err = awsRestxml_deserializeDocumentNoSuchCidrCollectionException(&output, decoder)
  12598 	if err != nil {
  12599 		var snapshot bytes.Buffer
  12600 		io.Copy(&snapshot, ringBuffer)
  12601 		return &smithy.DeserializationError{
  12602 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12603 			Snapshot: snapshot.Bytes(),
  12604 		}
  12605 	}
  12606 
  12607 	return output
  12608 }
  12609 
  12610 func awsRestxml_deserializeErrorNoSuchCidrLocationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12611 	output := &types.NoSuchCidrLocationException{}
  12612 	var buff [1024]byte
  12613 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12614 	body := io.TeeReader(errorBody, ringBuffer)
  12615 	rootDecoder := xml.NewDecoder(body)
  12616 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12617 	if err == io.EOF {
  12618 		return output
  12619 	}
  12620 	if err != nil {
  12621 		var snapshot bytes.Buffer
  12622 		io.Copy(&snapshot, ringBuffer)
  12623 		return &smithy.DeserializationError{
  12624 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12625 			Snapshot: snapshot.Bytes(),
  12626 		}
  12627 	}
  12628 
  12629 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12630 	t, err = decoder.GetElement("Error")
  12631 	if err != nil {
  12632 		var snapshot bytes.Buffer
  12633 		io.Copy(&snapshot, ringBuffer)
  12634 		return &smithy.DeserializationError{
  12635 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12636 			Snapshot: snapshot.Bytes(),
  12637 		}
  12638 	}
  12639 
  12640 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12641 	err = awsRestxml_deserializeDocumentNoSuchCidrLocationException(&output, decoder)
  12642 	if err != nil {
  12643 		var snapshot bytes.Buffer
  12644 		io.Copy(&snapshot, ringBuffer)
  12645 		return &smithy.DeserializationError{
  12646 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12647 			Snapshot: snapshot.Bytes(),
  12648 		}
  12649 	}
  12650 
  12651 	return output
  12652 }
  12653 
  12654 func awsRestxml_deserializeErrorNoSuchCloudWatchLogsLogGroup(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12655 	output := &types.NoSuchCloudWatchLogsLogGroup{}
  12656 	var buff [1024]byte
  12657 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12658 	body := io.TeeReader(errorBody, ringBuffer)
  12659 	rootDecoder := xml.NewDecoder(body)
  12660 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12661 	if err == io.EOF {
  12662 		return output
  12663 	}
  12664 	if err != nil {
  12665 		var snapshot bytes.Buffer
  12666 		io.Copy(&snapshot, ringBuffer)
  12667 		return &smithy.DeserializationError{
  12668 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12669 			Snapshot: snapshot.Bytes(),
  12670 		}
  12671 	}
  12672 
  12673 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12674 	t, err = decoder.GetElement("Error")
  12675 	if err != nil {
  12676 		var snapshot bytes.Buffer
  12677 		io.Copy(&snapshot, ringBuffer)
  12678 		return &smithy.DeserializationError{
  12679 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12680 			Snapshot: snapshot.Bytes(),
  12681 		}
  12682 	}
  12683 
  12684 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12685 	err = awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(&output, decoder)
  12686 	if err != nil {
  12687 		var snapshot bytes.Buffer
  12688 		io.Copy(&snapshot, ringBuffer)
  12689 		return &smithy.DeserializationError{
  12690 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12691 			Snapshot: snapshot.Bytes(),
  12692 		}
  12693 	}
  12694 
  12695 	return output
  12696 }
  12697 
  12698 func awsRestxml_deserializeErrorNoSuchDelegationSet(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12699 	output := &types.NoSuchDelegationSet{}
  12700 	var buff [1024]byte
  12701 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12702 	body := io.TeeReader(errorBody, ringBuffer)
  12703 	rootDecoder := xml.NewDecoder(body)
  12704 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12705 	if err == io.EOF {
  12706 		return output
  12707 	}
  12708 	if err != nil {
  12709 		var snapshot bytes.Buffer
  12710 		io.Copy(&snapshot, ringBuffer)
  12711 		return &smithy.DeserializationError{
  12712 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12713 			Snapshot: snapshot.Bytes(),
  12714 		}
  12715 	}
  12716 
  12717 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12718 	t, err = decoder.GetElement("Error")
  12719 	if err != nil {
  12720 		var snapshot bytes.Buffer
  12721 		io.Copy(&snapshot, ringBuffer)
  12722 		return &smithy.DeserializationError{
  12723 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12724 			Snapshot: snapshot.Bytes(),
  12725 		}
  12726 	}
  12727 
  12728 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12729 	err = awsRestxml_deserializeDocumentNoSuchDelegationSet(&output, decoder)
  12730 	if err != nil {
  12731 		var snapshot bytes.Buffer
  12732 		io.Copy(&snapshot, ringBuffer)
  12733 		return &smithy.DeserializationError{
  12734 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12735 			Snapshot: snapshot.Bytes(),
  12736 		}
  12737 	}
  12738 
  12739 	return output
  12740 }
  12741 
  12742 func awsRestxml_deserializeErrorNoSuchGeoLocation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12743 	output := &types.NoSuchGeoLocation{}
  12744 	var buff [1024]byte
  12745 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12746 	body := io.TeeReader(errorBody, ringBuffer)
  12747 	rootDecoder := xml.NewDecoder(body)
  12748 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12749 	if err == io.EOF {
  12750 		return output
  12751 	}
  12752 	if err != nil {
  12753 		var snapshot bytes.Buffer
  12754 		io.Copy(&snapshot, ringBuffer)
  12755 		return &smithy.DeserializationError{
  12756 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12757 			Snapshot: snapshot.Bytes(),
  12758 		}
  12759 	}
  12760 
  12761 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12762 	t, err = decoder.GetElement("Error")
  12763 	if err != nil {
  12764 		var snapshot bytes.Buffer
  12765 		io.Copy(&snapshot, ringBuffer)
  12766 		return &smithy.DeserializationError{
  12767 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12768 			Snapshot: snapshot.Bytes(),
  12769 		}
  12770 	}
  12771 
  12772 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12773 	err = awsRestxml_deserializeDocumentNoSuchGeoLocation(&output, decoder)
  12774 	if err != nil {
  12775 		var snapshot bytes.Buffer
  12776 		io.Copy(&snapshot, ringBuffer)
  12777 		return &smithy.DeserializationError{
  12778 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12779 			Snapshot: snapshot.Bytes(),
  12780 		}
  12781 	}
  12782 
  12783 	return output
  12784 }
  12785 
  12786 func awsRestxml_deserializeErrorNoSuchHealthCheck(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12787 	output := &types.NoSuchHealthCheck{}
  12788 	var buff [1024]byte
  12789 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12790 	body := io.TeeReader(errorBody, ringBuffer)
  12791 	rootDecoder := xml.NewDecoder(body)
  12792 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12793 	if err == io.EOF {
  12794 		return output
  12795 	}
  12796 	if err != nil {
  12797 		var snapshot bytes.Buffer
  12798 		io.Copy(&snapshot, ringBuffer)
  12799 		return &smithy.DeserializationError{
  12800 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12801 			Snapshot: snapshot.Bytes(),
  12802 		}
  12803 	}
  12804 
  12805 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12806 	t, err = decoder.GetElement("Error")
  12807 	if err != nil {
  12808 		var snapshot bytes.Buffer
  12809 		io.Copy(&snapshot, ringBuffer)
  12810 		return &smithy.DeserializationError{
  12811 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12812 			Snapshot: snapshot.Bytes(),
  12813 		}
  12814 	}
  12815 
  12816 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12817 	err = awsRestxml_deserializeDocumentNoSuchHealthCheck(&output, decoder)
  12818 	if err != nil {
  12819 		var snapshot bytes.Buffer
  12820 		io.Copy(&snapshot, ringBuffer)
  12821 		return &smithy.DeserializationError{
  12822 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12823 			Snapshot: snapshot.Bytes(),
  12824 		}
  12825 	}
  12826 
  12827 	return output
  12828 }
  12829 
  12830 func awsRestxml_deserializeErrorNoSuchHostedZone(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12831 	output := &types.NoSuchHostedZone{}
  12832 	var buff [1024]byte
  12833 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12834 	body := io.TeeReader(errorBody, ringBuffer)
  12835 	rootDecoder := xml.NewDecoder(body)
  12836 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12837 	if err == io.EOF {
  12838 		return output
  12839 	}
  12840 	if err != nil {
  12841 		var snapshot bytes.Buffer
  12842 		io.Copy(&snapshot, ringBuffer)
  12843 		return &smithy.DeserializationError{
  12844 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12845 			Snapshot: snapshot.Bytes(),
  12846 		}
  12847 	}
  12848 
  12849 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12850 	t, err = decoder.GetElement("Error")
  12851 	if err != nil {
  12852 		var snapshot bytes.Buffer
  12853 		io.Copy(&snapshot, ringBuffer)
  12854 		return &smithy.DeserializationError{
  12855 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12856 			Snapshot: snapshot.Bytes(),
  12857 		}
  12858 	}
  12859 
  12860 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12861 	err = awsRestxml_deserializeDocumentNoSuchHostedZone(&output, decoder)
  12862 	if err != nil {
  12863 		var snapshot bytes.Buffer
  12864 		io.Copy(&snapshot, ringBuffer)
  12865 		return &smithy.DeserializationError{
  12866 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12867 			Snapshot: snapshot.Bytes(),
  12868 		}
  12869 	}
  12870 
  12871 	return output
  12872 }
  12873 
  12874 func awsRestxml_deserializeErrorNoSuchKeySigningKey(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12875 	output := &types.NoSuchKeySigningKey{}
  12876 	var buff [1024]byte
  12877 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12878 	body := io.TeeReader(errorBody, ringBuffer)
  12879 	rootDecoder := xml.NewDecoder(body)
  12880 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12881 	if err == io.EOF {
  12882 		return output
  12883 	}
  12884 	if err != nil {
  12885 		var snapshot bytes.Buffer
  12886 		io.Copy(&snapshot, ringBuffer)
  12887 		return &smithy.DeserializationError{
  12888 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12889 			Snapshot: snapshot.Bytes(),
  12890 		}
  12891 	}
  12892 
  12893 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12894 	t, err = decoder.GetElement("Error")
  12895 	if err != nil {
  12896 		var snapshot bytes.Buffer
  12897 		io.Copy(&snapshot, ringBuffer)
  12898 		return &smithy.DeserializationError{
  12899 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12900 			Snapshot: snapshot.Bytes(),
  12901 		}
  12902 	}
  12903 
  12904 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12905 	err = awsRestxml_deserializeDocumentNoSuchKeySigningKey(&output, decoder)
  12906 	if err != nil {
  12907 		var snapshot bytes.Buffer
  12908 		io.Copy(&snapshot, ringBuffer)
  12909 		return &smithy.DeserializationError{
  12910 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12911 			Snapshot: snapshot.Bytes(),
  12912 		}
  12913 	}
  12914 
  12915 	return output
  12916 }
  12917 
  12918 func awsRestxml_deserializeErrorNoSuchQueryLoggingConfig(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12919 	output := &types.NoSuchQueryLoggingConfig{}
  12920 	var buff [1024]byte
  12921 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12922 	body := io.TeeReader(errorBody, ringBuffer)
  12923 	rootDecoder := xml.NewDecoder(body)
  12924 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12925 	if err == io.EOF {
  12926 		return output
  12927 	}
  12928 	if err != nil {
  12929 		var snapshot bytes.Buffer
  12930 		io.Copy(&snapshot, ringBuffer)
  12931 		return &smithy.DeserializationError{
  12932 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12933 			Snapshot: snapshot.Bytes(),
  12934 		}
  12935 	}
  12936 
  12937 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12938 	t, err = decoder.GetElement("Error")
  12939 	if err != nil {
  12940 		var snapshot bytes.Buffer
  12941 		io.Copy(&snapshot, ringBuffer)
  12942 		return &smithy.DeserializationError{
  12943 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12944 			Snapshot: snapshot.Bytes(),
  12945 		}
  12946 	}
  12947 
  12948 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12949 	err = awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(&output, decoder)
  12950 	if err != nil {
  12951 		var snapshot bytes.Buffer
  12952 		io.Copy(&snapshot, ringBuffer)
  12953 		return &smithy.DeserializationError{
  12954 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12955 			Snapshot: snapshot.Bytes(),
  12956 		}
  12957 	}
  12958 
  12959 	return output
  12960 }
  12961 
  12962 func awsRestxml_deserializeErrorNoSuchTrafficPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  12963 	output := &types.NoSuchTrafficPolicy{}
  12964 	var buff [1024]byte
  12965 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  12966 	body := io.TeeReader(errorBody, ringBuffer)
  12967 	rootDecoder := xml.NewDecoder(body)
  12968 	t, err := smithyxml.FetchRootElement(rootDecoder)
  12969 	if err == io.EOF {
  12970 		return output
  12971 	}
  12972 	if err != nil {
  12973 		var snapshot bytes.Buffer
  12974 		io.Copy(&snapshot, ringBuffer)
  12975 		return &smithy.DeserializationError{
  12976 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12977 			Snapshot: snapshot.Bytes(),
  12978 		}
  12979 	}
  12980 
  12981 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  12982 	t, err = decoder.GetElement("Error")
  12983 	if err != nil {
  12984 		var snapshot bytes.Buffer
  12985 		io.Copy(&snapshot, ringBuffer)
  12986 		return &smithy.DeserializationError{
  12987 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12988 			Snapshot: snapshot.Bytes(),
  12989 		}
  12990 	}
  12991 
  12992 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  12993 	err = awsRestxml_deserializeDocumentNoSuchTrafficPolicy(&output, decoder)
  12994 	if err != nil {
  12995 		var snapshot bytes.Buffer
  12996 		io.Copy(&snapshot, ringBuffer)
  12997 		return &smithy.DeserializationError{
  12998 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  12999 			Snapshot: snapshot.Bytes(),
  13000 		}
  13001 	}
  13002 
  13003 	return output
  13004 }
  13005 
  13006 func awsRestxml_deserializeErrorNoSuchTrafficPolicyInstance(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13007 	output := &types.NoSuchTrafficPolicyInstance{}
  13008 	var buff [1024]byte
  13009 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13010 	body := io.TeeReader(errorBody, ringBuffer)
  13011 	rootDecoder := xml.NewDecoder(body)
  13012 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13013 	if err == io.EOF {
  13014 		return output
  13015 	}
  13016 	if err != nil {
  13017 		var snapshot bytes.Buffer
  13018 		io.Copy(&snapshot, ringBuffer)
  13019 		return &smithy.DeserializationError{
  13020 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13021 			Snapshot: snapshot.Bytes(),
  13022 		}
  13023 	}
  13024 
  13025 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13026 	t, err = decoder.GetElement("Error")
  13027 	if err != nil {
  13028 		var snapshot bytes.Buffer
  13029 		io.Copy(&snapshot, ringBuffer)
  13030 		return &smithy.DeserializationError{
  13031 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13032 			Snapshot: snapshot.Bytes(),
  13033 		}
  13034 	}
  13035 
  13036 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13037 	err = awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(&output, decoder)
  13038 	if err != nil {
  13039 		var snapshot bytes.Buffer
  13040 		io.Copy(&snapshot, ringBuffer)
  13041 		return &smithy.DeserializationError{
  13042 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13043 			Snapshot: snapshot.Bytes(),
  13044 		}
  13045 	}
  13046 
  13047 	return output
  13048 }
  13049 
  13050 func awsRestxml_deserializeErrorNotAuthorizedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13051 	output := &types.NotAuthorizedException{}
  13052 	var buff [1024]byte
  13053 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13054 	body := io.TeeReader(errorBody, ringBuffer)
  13055 	rootDecoder := xml.NewDecoder(body)
  13056 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13057 	if err == io.EOF {
  13058 		return output
  13059 	}
  13060 	if err != nil {
  13061 		var snapshot bytes.Buffer
  13062 		io.Copy(&snapshot, ringBuffer)
  13063 		return &smithy.DeserializationError{
  13064 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13065 			Snapshot: snapshot.Bytes(),
  13066 		}
  13067 	}
  13068 
  13069 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13070 	t, err = decoder.GetElement("Error")
  13071 	if err != nil {
  13072 		var snapshot bytes.Buffer
  13073 		io.Copy(&snapshot, ringBuffer)
  13074 		return &smithy.DeserializationError{
  13075 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13076 			Snapshot: snapshot.Bytes(),
  13077 		}
  13078 	}
  13079 
  13080 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13081 	err = awsRestxml_deserializeDocumentNotAuthorizedException(&output, decoder)
  13082 	if err != nil {
  13083 		var snapshot bytes.Buffer
  13084 		io.Copy(&snapshot, ringBuffer)
  13085 		return &smithy.DeserializationError{
  13086 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13087 			Snapshot: snapshot.Bytes(),
  13088 		}
  13089 	}
  13090 
  13091 	return output
  13092 }
  13093 
  13094 func awsRestxml_deserializeErrorPriorRequestNotComplete(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13095 	output := &types.PriorRequestNotComplete{}
  13096 	var buff [1024]byte
  13097 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13098 	body := io.TeeReader(errorBody, ringBuffer)
  13099 	rootDecoder := xml.NewDecoder(body)
  13100 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13101 	if err == io.EOF {
  13102 		return output
  13103 	}
  13104 	if err != nil {
  13105 		var snapshot bytes.Buffer
  13106 		io.Copy(&snapshot, ringBuffer)
  13107 		return &smithy.DeserializationError{
  13108 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13109 			Snapshot: snapshot.Bytes(),
  13110 		}
  13111 	}
  13112 
  13113 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13114 	t, err = decoder.GetElement("Error")
  13115 	if err != nil {
  13116 		var snapshot bytes.Buffer
  13117 		io.Copy(&snapshot, ringBuffer)
  13118 		return &smithy.DeserializationError{
  13119 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13120 			Snapshot: snapshot.Bytes(),
  13121 		}
  13122 	}
  13123 
  13124 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13125 	err = awsRestxml_deserializeDocumentPriorRequestNotComplete(&output, decoder)
  13126 	if err != nil {
  13127 		var snapshot bytes.Buffer
  13128 		io.Copy(&snapshot, ringBuffer)
  13129 		return &smithy.DeserializationError{
  13130 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13131 			Snapshot: snapshot.Bytes(),
  13132 		}
  13133 	}
  13134 
  13135 	return output
  13136 }
  13137 
  13138 func awsRestxml_deserializeErrorPublicZoneVPCAssociation(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13139 	output := &types.PublicZoneVPCAssociation{}
  13140 	var buff [1024]byte
  13141 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13142 	body := io.TeeReader(errorBody, ringBuffer)
  13143 	rootDecoder := xml.NewDecoder(body)
  13144 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13145 	if err == io.EOF {
  13146 		return output
  13147 	}
  13148 	if err != nil {
  13149 		var snapshot bytes.Buffer
  13150 		io.Copy(&snapshot, ringBuffer)
  13151 		return &smithy.DeserializationError{
  13152 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13153 			Snapshot: snapshot.Bytes(),
  13154 		}
  13155 	}
  13156 
  13157 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13158 	t, err = decoder.GetElement("Error")
  13159 	if err != nil {
  13160 		var snapshot bytes.Buffer
  13161 		io.Copy(&snapshot, ringBuffer)
  13162 		return &smithy.DeserializationError{
  13163 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13164 			Snapshot: snapshot.Bytes(),
  13165 		}
  13166 	}
  13167 
  13168 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13169 	err = awsRestxml_deserializeDocumentPublicZoneVPCAssociation(&output, decoder)
  13170 	if err != nil {
  13171 		var snapshot bytes.Buffer
  13172 		io.Copy(&snapshot, ringBuffer)
  13173 		return &smithy.DeserializationError{
  13174 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13175 			Snapshot: snapshot.Bytes(),
  13176 		}
  13177 	}
  13178 
  13179 	return output
  13180 }
  13181 
  13182 func awsRestxml_deserializeErrorQueryLoggingConfigAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13183 	output := &types.QueryLoggingConfigAlreadyExists{}
  13184 	var buff [1024]byte
  13185 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13186 	body := io.TeeReader(errorBody, ringBuffer)
  13187 	rootDecoder := xml.NewDecoder(body)
  13188 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13189 	if err == io.EOF {
  13190 		return output
  13191 	}
  13192 	if err != nil {
  13193 		var snapshot bytes.Buffer
  13194 		io.Copy(&snapshot, ringBuffer)
  13195 		return &smithy.DeserializationError{
  13196 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13197 			Snapshot: snapshot.Bytes(),
  13198 		}
  13199 	}
  13200 
  13201 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13202 	t, err = decoder.GetElement("Error")
  13203 	if err != nil {
  13204 		var snapshot bytes.Buffer
  13205 		io.Copy(&snapshot, ringBuffer)
  13206 		return &smithy.DeserializationError{
  13207 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13208 			Snapshot: snapshot.Bytes(),
  13209 		}
  13210 	}
  13211 
  13212 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13213 	err = awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(&output, decoder)
  13214 	if err != nil {
  13215 		var snapshot bytes.Buffer
  13216 		io.Copy(&snapshot, ringBuffer)
  13217 		return &smithy.DeserializationError{
  13218 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13219 			Snapshot: snapshot.Bytes(),
  13220 		}
  13221 	}
  13222 
  13223 	return output
  13224 }
  13225 
  13226 func awsRestxml_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13227 	output := &types.ThrottlingException{}
  13228 	var buff [1024]byte
  13229 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13230 	body := io.TeeReader(errorBody, ringBuffer)
  13231 	rootDecoder := xml.NewDecoder(body)
  13232 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13233 	if err == io.EOF {
  13234 		return output
  13235 	}
  13236 	if err != nil {
  13237 		var snapshot bytes.Buffer
  13238 		io.Copy(&snapshot, ringBuffer)
  13239 		return &smithy.DeserializationError{
  13240 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13241 			Snapshot: snapshot.Bytes(),
  13242 		}
  13243 	}
  13244 
  13245 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13246 	t, err = decoder.GetElement("Error")
  13247 	if err != nil {
  13248 		var snapshot bytes.Buffer
  13249 		io.Copy(&snapshot, ringBuffer)
  13250 		return &smithy.DeserializationError{
  13251 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13252 			Snapshot: snapshot.Bytes(),
  13253 		}
  13254 	}
  13255 
  13256 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13257 	err = awsRestxml_deserializeDocumentThrottlingException(&output, decoder)
  13258 	if err != nil {
  13259 		var snapshot bytes.Buffer
  13260 		io.Copy(&snapshot, ringBuffer)
  13261 		return &smithy.DeserializationError{
  13262 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13263 			Snapshot: snapshot.Bytes(),
  13264 		}
  13265 	}
  13266 
  13267 	return output
  13268 }
  13269 
  13270 func awsRestxml_deserializeErrorTooManyHealthChecks(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13271 	output := &types.TooManyHealthChecks{}
  13272 	var buff [1024]byte
  13273 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13274 	body := io.TeeReader(errorBody, ringBuffer)
  13275 	rootDecoder := xml.NewDecoder(body)
  13276 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13277 	if err == io.EOF {
  13278 		return output
  13279 	}
  13280 	if err != nil {
  13281 		var snapshot bytes.Buffer
  13282 		io.Copy(&snapshot, ringBuffer)
  13283 		return &smithy.DeserializationError{
  13284 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13285 			Snapshot: snapshot.Bytes(),
  13286 		}
  13287 	}
  13288 
  13289 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13290 	t, err = decoder.GetElement("Error")
  13291 	if err != nil {
  13292 		var snapshot bytes.Buffer
  13293 		io.Copy(&snapshot, ringBuffer)
  13294 		return &smithy.DeserializationError{
  13295 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13296 			Snapshot: snapshot.Bytes(),
  13297 		}
  13298 	}
  13299 
  13300 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13301 	err = awsRestxml_deserializeDocumentTooManyHealthChecks(&output, decoder)
  13302 	if err != nil {
  13303 		var snapshot bytes.Buffer
  13304 		io.Copy(&snapshot, ringBuffer)
  13305 		return &smithy.DeserializationError{
  13306 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13307 			Snapshot: snapshot.Bytes(),
  13308 		}
  13309 	}
  13310 
  13311 	return output
  13312 }
  13313 
  13314 func awsRestxml_deserializeErrorTooManyHostedZones(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13315 	output := &types.TooManyHostedZones{}
  13316 	var buff [1024]byte
  13317 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13318 	body := io.TeeReader(errorBody, ringBuffer)
  13319 	rootDecoder := xml.NewDecoder(body)
  13320 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13321 	if err == io.EOF {
  13322 		return output
  13323 	}
  13324 	if err != nil {
  13325 		var snapshot bytes.Buffer
  13326 		io.Copy(&snapshot, ringBuffer)
  13327 		return &smithy.DeserializationError{
  13328 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13329 			Snapshot: snapshot.Bytes(),
  13330 		}
  13331 	}
  13332 
  13333 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13334 	t, err = decoder.GetElement("Error")
  13335 	if err != nil {
  13336 		var snapshot bytes.Buffer
  13337 		io.Copy(&snapshot, ringBuffer)
  13338 		return &smithy.DeserializationError{
  13339 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13340 			Snapshot: snapshot.Bytes(),
  13341 		}
  13342 	}
  13343 
  13344 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13345 	err = awsRestxml_deserializeDocumentTooManyHostedZones(&output, decoder)
  13346 	if err != nil {
  13347 		var snapshot bytes.Buffer
  13348 		io.Copy(&snapshot, ringBuffer)
  13349 		return &smithy.DeserializationError{
  13350 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13351 			Snapshot: snapshot.Bytes(),
  13352 		}
  13353 	}
  13354 
  13355 	return output
  13356 }
  13357 
  13358 func awsRestxml_deserializeErrorTooManyKeySigningKeys(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13359 	output := &types.TooManyKeySigningKeys{}
  13360 	var buff [1024]byte
  13361 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13362 	body := io.TeeReader(errorBody, ringBuffer)
  13363 	rootDecoder := xml.NewDecoder(body)
  13364 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13365 	if err == io.EOF {
  13366 		return output
  13367 	}
  13368 	if err != nil {
  13369 		var snapshot bytes.Buffer
  13370 		io.Copy(&snapshot, ringBuffer)
  13371 		return &smithy.DeserializationError{
  13372 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13373 			Snapshot: snapshot.Bytes(),
  13374 		}
  13375 	}
  13376 
  13377 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13378 	t, err = decoder.GetElement("Error")
  13379 	if err != nil {
  13380 		var snapshot bytes.Buffer
  13381 		io.Copy(&snapshot, ringBuffer)
  13382 		return &smithy.DeserializationError{
  13383 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13384 			Snapshot: snapshot.Bytes(),
  13385 		}
  13386 	}
  13387 
  13388 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13389 	err = awsRestxml_deserializeDocumentTooManyKeySigningKeys(&output, decoder)
  13390 	if err != nil {
  13391 		var snapshot bytes.Buffer
  13392 		io.Copy(&snapshot, ringBuffer)
  13393 		return &smithy.DeserializationError{
  13394 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13395 			Snapshot: snapshot.Bytes(),
  13396 		}
  13397 	}
  13398 
  13399 	return output
  13400 }
  13401 
  13402 func awsRestxml_deserializeErrorTooManyTrafficPolicies(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13403 	output := &types.TooManyTrafficPolicies{}
  13404 	var buff [1024]byte
  13405 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13406 	body := io.TeeReader(errorBody, ringBuffer)
  13407 	rootDecoder := xml.NewDecoder(body)
  13408 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13409 	if err == io.EOF {
  13410 		return output
  13411 	}
  13412 	if err != nil {
  13413 		var snapshot bytes.Buffer
  13414 		io.Copy(&snapshot, ringBuffer)
  13415 		return &smithy.DeserializationError{
  13416 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13417 			Snapshot: snapshot.Bytes(),
  13418 		}
  13419 	}
  13420 
  13421 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13422 	t, err = decoder.GetElement("Error")
  13423 	if err != nil {
  13424 		var snapshot bytes.Buffer
  13425 		io.Copy(&snapshot, ringBuffer)
  13426 		return &smithy.DeserializationError{
  13427 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13428 			Snapshot: snapshot.Bytes(),
  13429 		}
  13430 	}
  13431 
  13432 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13433 	err = awsRestxml_deserializeDocumentTooManyTrafficPolicies(&output, decoder)
  13434 	if err != nil {
  13435 		var snapshot bytes.Buffer
  13436 		io.Copy(&snapshot, ringBuffer)
  13437 		return &smithy.DeserializationError{
  13438 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13439 			Snapshot: snapshot.Bytes(),
  13440 		}
  13441 	}
  13442 
  13443 	return output
  13444 }
  13445 
  13446 func awsRestxml_deserializeErrorTooManyTrafficPolicyInstances(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13447 	output := &types.TooManyTrafficPolicyInstances{}
  13448 	var buff [1024]byte
  13449 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13450 	body := io.TeeReader(errorBody, ringBuffer)
  13451 	rootDecoder := xml.NewDecoder(body)
  13452 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13453 	if err == io.EOF {
  13454 		return output
  13455 	}
  13456 	if err != nil {
  13457 		var snapshot bytes.Buffer
  13458 		io.Copy(&snapshot, ringBuffer)
  13459 		return &smithy.DeserializationError{
  13460 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13461 			Snapshot: snapshot.Bytes(),
  13462 		}
  13463 	}
  13464 
  13465 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13466 	t, err = decoder.GetElement("Error")
  13467 	if err != nil {
  13468 		var snapshot bytes.Buffer
  13469 		io.Copy(&snapshot, ringBuffer)
  13470 		return &smithy.DeserializationError{
  13471 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13472 			Snapshot: snapshot.Bytes(),
  13473 		}
  13474 	}
  13475 
  13476 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13477 	err = awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(&output, decoder)
  13478 	if err != nil {
  13479 		var snapshot bytes.Buffer
  13480 		io.Copy(&snapshot, ringBuffer)
  13481 		return &smithy.DeserializationError{
  13482 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13483 			Snapshot: snapshot.Bytes(),
  13484 		}
  13485 	}
  13486 
  13487 	return output
  13488 }
  13489 
  13490 func awsRestxml_deserializeErrorTooManyTrafficPolicyVersionsForCurrentPolicy(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13491 	output := &types.TooManyTrafficPolicyVersionsForCurrentPolicy{}
  13492 	var buff [1024]byte
  13493 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13494 	body := io.TeeReader(errorBody, ringBuffer)
  13495 	rootDecoder := xml.NewDecoder(body)
  13496 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13497 	if err == io.EOF {
  13498 		return output
  13499 	}
  13500 	if err != nil {
  13501 		var snapshot bytes.Buffer
  13502 		io.Copy(&snapshot, ringBuffer)
  13503 		return &smithy.DeserializationError{
  13504 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13505 			Snapshot: snapshot.Bytes(),
  13506 		}
  13507 	}
  13508 
  13509 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13510 	t, err = decoder.GetElement("Error")
  13511 	if err != nil {
  13512 		var snapshot bytes.Buffer
  13513 		io.Copy(&snapshot, ringBuffer)
  13514 		return &smithy.DeserializationError{
  13515 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13516 			Snapshot: snapshot.Bytes(),
  13517 		}
  13518 	}
  13519 
  13520 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13521 	err = awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(&output, decoder)
  13522 	if err != nil {
  13523 		var snapshot bytes.Buffer
  13524 		io.Copy(&snapshot, ringBuffer)
  13525 		return &smithy.DeserializationError{
  13526 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13527 			Snapshot: snapshot.Bytes(),
  13528 		}
  13529 	}
  13530 
  13531 	return output
  13532 }
  13533 
  13534 func awsRestxml_deserializeErrorTooManyVPCAssociationAuthorizations(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13535 	output := &types.TooManyVPCAssociationAuthorizations{}
  13536 	var buff [1024]byte
  13537 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13538 	body := io.TeeReader(errorBody, ringBuffer)
  13539 	rootDecoder := xml.NewDecoder(body)
  13540 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13541 	if err == io.EOF {
  13542 		return output
  13543 	}
  13544 	if err != nil {
  13545 		var snapshot bytes.Buffer
  13546 		io.Copy(&snapshot, ringBuffer)
  13547 		return &smithy.DeserializationError{
  13548 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13549 			Snapshot: snapshot.Bytes(),
  13550 		}
  13551 	}
  13552 
  13553 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13554 	t, err = decoder.GetElement("Error")
  13555 	if err != nil {
  13556 		var snapshot bytes.Buffer
  13557 		io.Copy(&snapshot, ringBuffer)
  13558 		return &smithy.DeserializationError{
  13559 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13560 			Snapshot: snapshot.Bytes(),
  13561 		}
  13562 	}
  13563 
  13564 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13565 	err = awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(&output, decoder)
  13566 	if err != nil {
  13567 		var snapshot bytes.Buffer
  13568 		io.Copy(&snapshot, ringBuffer)
  13569 		return &smithy.DeserializationError{
  13570 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13571 			Snapshot: snapshot.Bytes(),
  13572 		}
  13573 	}
  13574 
  13575 	return output
  13576 }
  13577 
  13578 func awsRestxml_deserializeErrorTrafficPolicyAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13579 	output := &types.TrafficPolicyAlreadyExists{}
  13580 	var buff [1024]byte
  13581 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13582 	body := io.TeeReader(errorBody, ringBuffer)
  13583 	rootDecoder := xml.NewDecoder(body)
  13584 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13585 	if err == io.EOF {
  13586 		return output
  13587 	}
  13588 	if err != nil {
  13589 		var snapshot bytes.Buffer
  13590 		io.Copy(&snapshot, ringBuffer)
  13591 		return &smithy.DeserializationError{
  13592 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13593 			Snapshot: snapshot.Bytes(),
  13594 		}
  13595 	}
  13596 
  13597 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13598 	t, err = decoder.GetElement("Error")
  13599 	if err != nil {
  13600 		var snapshot bytes.Buffer
  13601 		io.Copy(&snapshot, ringBuffer)
  13602 		return &smithy.DeserializationError{
  13603 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13604 			Snapshot: snapshot.Bytes(),
  13605 		}
  13606 	}
  13607 
  13608 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13609 	err = awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(&output, decoder)
  13610 	if err != nil {
  13611 		var snapshot bytes.Buffer
  13612 		io.Copy(&snapshot, ringBuffer)
  13613 		return &smithy.DeserializationError{
  13614 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13615 			Snapshot: snapshot.Bytes(),
  13616 		}
  13617 	}
  13618 
  13619 	return output
  13620 }
  13621 
  13622 func awsRestxml_deserializeErrorTrafficPolicyInstanceAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13623 	output := &types.TrafficPolicyInstanceAlreadyExists{}
  13624 	var buff [1024]byte
  13625 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13626 	body := io.TeeReader(errorBody, ringBuffer)
  13627 	rootDecoder := xml.NewDecoder(body)
  13628 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13629 	if err == io.EOF {
  13630 		return output
  13631 	}
  13632 	if err != nil {
  13633 		var snapshot bytes.Buffer
  13634 		io.Copy(&snapshot, ringBuffer)
  13635 		return &smithy.DeserializationError{
  13636 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13637 			Snapshot: snapshot.Bytes(),
  13638 		}
  13639 	}
  13640 
  13641 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13642 	t, err = decoder.GetElement("Error")
  13643 	if err != nil {
  13644 		var snapshot bytes.Buffer
  13645 		io.Copy(&snapshot, ringBuffer)
  13646 		return &smithy.DeserializationError{
  13647 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13648 			Snapshot: snapshot.Bytes(),
  13649 		}
  13650 	}
  13651 
  13652 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13653 	err = awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(&output, decoder)
  13654 	if err != nil {
  13655 		var snapshot bytes.Buffer
  13656 		io.Copy(&snapshot, ringBuffer)
  13657 		return &smithy.DeserializationError{
  13658 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13659 			Snapshot: snapshot.Bytes(),
  13660 		}
  13661 	}
  13662 
  13663 	return output
  13664 }
  13665 
  13666 func awsRestxml_deserializeErrorTrafficPolicyInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13667 	output := &types.TrafficPolicyInUse{}
  13668 	var buff [1024]byte
  13669 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13670 	body := io.TeeReader(errorBody, ringBuffer)
  13671 	rootDecoder := xml.NewDecoder(body)
  13672 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13673 	if err == io.EOF {
  13674 		return output
  13675 	}
  13676 	if err != nil {
  13677 		var snapshot bytes.Buffer
  13678 		io.Copy(&snapshot, ringBuffer)
  13679 		return &smithy.DeserializationError{
  13680 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13681 			Snapshot: snapshot.Bytes(),
  13682 		}
  13683 	}
  13684 
  13685 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13686 	t, err = decoder.GetElement("Error")
  13687 	if err != nil {
  13688 		var snapshot bytes.Buffer
  13689 		io.Copy(&snapshot, ringBuffer)
  13690 		return &smithy.DeserializationError{
  13691 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13692 			Snapshot: snapshot.Bytes(),
  13693 		}
  13694 	}
  13695 
  13696 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13697 	err = awsRestxml_deserializeDocumentTrafficPolicyInUse(&output, decoder)
  13698 	if err != nil {
  13699 		var snapshot bytes.Buffer
  13700 		io.Copy(&snapshot, ringBuffer)
  13701 		return &smithy.DeserializationError{
  13702 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13703 			Snapshot: snapshot.Bytes(),
  13704 		}
  13705 	}
  13706 
  13707 	return output
  13708 }
  13709 
  13710 func awsRestxml_deserializeErrorVPCAssociationAuthorizationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13711 	output := &types.VPCAssociationAuthorizationNotFound{}
  13712 	var buff [1024]byte
  13713 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13714 	body := io.TeeReader(errorBody, ringBuffer)
  13715 	rootDecoder := xml.NewDecoder(body)
  13716 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13717 	if err == io.EOF {
  13718 		return output
  13719 	}
  13720 	if err != nil {
  13721 		var snapshot bytes.Buffer
  13722 		io.Copy(&snapshot, ringBuffer)
  13723 		return &smithy.DeserializationError{
  13724 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13725 			Snapshot: snapshot.Bytes(),
  13726 		}
  13727 	}
  13728 
  13729 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13730 	t, err = decoder.GetElement("Error")
  13731 	if err != nil {
  13732 		var snapshot bytes.Buffer
  13733 		io.Copy(&snapshot, ringBuffer)
  13734 		return &smithy.DeserializationError{
  13735 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13736 			Snapshot: snapshot.Bytes(),
  13737 		}
  13738 	}
  13739 
  13740 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13741 	err = awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(&output, decoder)
  13742 	if err != nil {
  13743 		var snapshot bytes.Buffer
  13744 		io.Copy(&snapshot, ringBuffer)
  13745 		return &smithy.DeserializationError{
  13746 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13747 			Snapshot: snapshot.Bytes(),
  13748 		}
  13749 	}
  13750 
  13751 	return output
  13752 }
  13753 
  13754 func awsRestxml_deserializeErrorVPCAssociationNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
  13755 	output := &types.VPCAssociationNotFound{}
  13756 	var buff [1024]byte
  13757 	ringBuffer := smithyio.NewRingBuffer(buff[:])
  13758 	body := io.TeeReader(errorBody, ringBuffer)
  13759 	rootDecoder := xml.NewDecoder(body)
  13760 	t, err := smithyxml.FetchRootElement(rootDecoder)
  13761 	if err == io.EOF {
  13762 		return output
  13763 	}
  13764 	if err != nil {
  13765 		var snapshot bytes.Buffer
  13766 		io.Copy(&snapshot, ringBuffer)
  13767 		return &smithy.DeserializationError{
  13768 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13769 			Snapshot: snapshot.Bytes(),
  13770 		}
  13771 	}
  13772 
  13773 	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
  13774 	t, err = decoder.GetElement("Error")
  13775 	if err != nil {
  13776 		var snapshot bytes.Buffer
  13777 		io.Copy(&snapshot, ringBuffer)
  13778 		return &smithy.DeserializationError{
  13779 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13780 			Snapshot: snapshot.Bytes(),
  13781 		}
  13782 	}
  13783 
  13784 	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  13785 	err = awsRestxml_deserializeDocumentVPCAssociationNotFound(&output, decoder)
  13786 	if err != nil {
  13787 		var snapshot bytes.Buffer
  13788 		io.Copy(&snapshot, ringBuffer)
  13789 		return &smithy.DeserializationError{
  13790 			Err:      fmt.Errorf("failed to decode response body, %w", err),
  13791 			Snapshot: snapshot.Bytes(),
  13792 		}
  13793 	}
  13794 
  13795 	return output
  13796 }
  13797 
  13798 func awsRestxml_deserializeDocumentAccountLimit(v **types.AccountLimit, decoder smithyxml.NodeDecoder) error {
  13799 	if v == nil {
  13800 		return fmt.Errorf("unexpected nil of type %T", v)
  13801 	}
  13802 	var sv *types.AccountLimit
  13803 	if *v == nil {
  13804 		sv = &types.AccountLimit{}
  13805 	} else {
  13806 		sv = *v
  13807 	}
  13808 
  13809 	for {
  13810 		t, done, err := decoder.Token()
  13811 		if err != nil {
  13812 			return err
  13813 		}
  13814 		if done {
  13815 			break
  13816 		}
  13817 		originalDecoder := decoder
  13818 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  13819 		switch {
  13820 		case strings.EqualFold("Type", t.Name.Local):
  13821 			val, err := decoder.Value()
  13822 			if err != nil {
  13823 				return err
  13824 			}
  13825 			if val == nil {
  13826 				break
  13827 			}
  13828 			{
  13829 				xtv := string(val)
  13830 				sv.Type = types.AccountLimitType(xtv)
  13831 			}
  13832 
  13833 		case strings.EqualFold("Value", t.Name.Local):
  13834 			val, err := decoder.Value()
  13835 			if err != nil {
  13836 				return err
  13837 			}
  13838 			if val == nil {
  13839 				break
  13840 			}
  13841 			{
  13842 				xtv := string(val)
  13843 				i64, err := strconv.ParseInt(xtv, 10, 64)
  13844 				if err != nil {
  13845 					return err
  13846 				}
  13847 				sv.Value = i64
  13848 			}
  13849 
  13850 		default:
  13851 			// Do nothing and ignore the unexpected tag element
  13852 			err = decoder.Decoder.Skip()
  13853 			if err != nil {
  13854 				return err
  13855 			}
  13856 
  13857 		}
  13858 		decoder = originalDecoder
  13859 	}
  13860 	*v = sv
  13861 	return nil
  13862 }
  13863 
  13864 func awsRestxml_deserializeDocumentAlarmIdentifier(v **types.AlarmIdentifier, decoder smithyxml.NodeDecoder) error {
  13865 	if v == nil {
  13866 		return fmt.Errorf("unexpected nil of type %T", v)
  13867 	}
  13868 	var sv *types.AlarmIdentifier
  13869 	if *v == nil {
  13870 		sv = &types.AlarmIdentifier{}
  13871 	} else {
  13872 		sv = *v
  13873 	}
  13874 
  13875 	for {
  13876 		t, done, err := decoder.Token()
  13877 		if err != nil {
  13878 			return err
  13879 		}
  13880 		if done {
  13881 			break
  13882 		}
  13883 		originalDecoder := decoder
  13884 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  13885 		switch {
  13886 		case strings.EqualFold("Name", t.Name.Local):
  13887 			val, err := decoder.Value()
  13888 			if err != nil {
  13889 				return err
  13890 			}
  13891 			if val == nil {
  13892 				break
  13893 			}
  13894 			{
  13895 				xtv := string(val)
  13896 				sv.Name = ptr.String(xtv)
  13897 			}
  13898 
  13899 		case strings.EqualFold("Region", t.Name.Local):
  13900 			val, err := decoder.Value()
  13901 			if err != nil {
  13902 				return err
  13903 			}
  13904 			if val == nil {
  13905 				break
  13906 			}
  13907 			{
  13908 				xtv := string(val)
  13909 				sv.Region = types.CloudWatchRegion(xtv)
  13910 			}
  13911 
  13912 		default:
  13913 			// Do nothing and ignore the unexpected tag element
  13914 			err = decoder.Decoder.Skip()
  13915 			if err != nil {
  13916 				return err
  13917 			}
  13918 
  13919 		}
  13920 		decoder = originalDecoder
  13921 	}
  13922 	*v = sv
  13923 	return nil
  13924 }
  13925 
  13926 func awsRestxml_deserializeDocumentAliasTarget(v **types.AliasTarget, decoder smithyxml.NodeDecoder) error {
  13927 	if v == nil {
  13928 		return fmt.Errorf("unexpected nil of type %T", v)
  13929 	}
  13930 	var sv *types.AliasTarget
  13931 	if *v == nil {
  13932 		sv = &types.AliasTarget{}
  13933 	} else {
  13934 		sv = *v
  13935 	}
  13936 
  13937 	for {
  13938 		t, done, err := decoder.Token()
  13939 		if err != nil {
  13940 			return err
  13941 		}
  13942 		if done {
  13943 			break
  13944 		}
  13945 		originalDecoder := decoder
  13946 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  13947 		switch {
  13948 		case strings.EqualFold("DNSName", t.Name.Local):
  13949 			val, err := decoder.Value()
  13950 			if err != nil {
  13951 				return err
  13952 			}
  13953 			if val == nil {
  13954 				break
  13955 			}
  13956 			{
  13957 				xtv := string(val)
  13958 				sv.DNSName = ptr.String(xtv)
  13959 			}
  13960 
  13961 		case strings.EqualFold("EvaluateTargetHealth", t.Name.Local):
  13962 			val, err := decoder.Value()
  13963 			if err != nil {
  13964 				return err
  13965 			}
  13966 			if val == nil {
  13967 				break
  13968 			}
  13969 			{
  13970 				xtv, err := strconv.ParseBool(string(val))
  13971 				if err != nil {
  13972 					return fmt.Errorf("expected AliasHealthEnabled to be of type *bool, got %T instead", val)
  13973 				}
  13974 				sv.EvaluateTargetHealth = xtv
  13975 			}
  13976 
  13977 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  13978 			val, err := decoder.Value()
  13979 			if err != nil {
  13980 				return err
  13981 			}
  13982 			if val == nil {
  13983 				break
  13984 			}
  13985 			{
  13986 				xtv := string(val)
  13987 				sv.HostedZoneId = ptr.String(xtv)
  13988 			}
  13989 
  13990 		default:
  13991 			// Do nothing and ignore the unexpected tag element
  13992 			err = decoder.Decoder.Skip()
  13993 			if err != nil {
  13994 				return err
  13995 			}
  13996 
  13997 		}
  13998 		decoder = originalDecoder
  13999 	}
  14000 	*v = sv
  14001 	return nil
  14002 }
  14003 
  14004 func awsRestxml_deserializeDocumentChangeInfo(v **types.ChangeInfo, decoder smithyxml.NodeDecoder) error {
  14005 	if v == nil {
  14006 		return fmt.Errorf("unexpected nil of type %T", v)
  14007 	}
  14008 	var sv *types.ChangeInfo
  14009 	if *v == nil {
  14010 		sv = &types.ChangeInfo{}
  14011 	} else {
  14012 		sv = *v
  14013 	}
  14014 
  14015 	for {
  14016 		t, done, err := decoder.Token()
  14017 		if err != nil {
  14018 			return err
  14019 		}
  14020 		if done {
  14021 			break
  14022 		}
  14023 		originalDecoder := decoder
  14024 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14025 		switch {
  14026 		case strings.EqualFold("Comment", t.Name.Local):
  14027 			val, err := decoder.Value()
  14028 			if err != nil {
  14029 				return err
  14030 			}
  14031 			if val == nil {
  14032 				break
  14033 			}
  14034 			{
  14035 				xtv := string(val)
  14036 				sv.Comment = ptr.String(xtv)
  14037 			}
  14038 
  14039 		case strings.EqualFold("Id", t.Name.Local):
  14040 			val, err := decoder.Value()
  14041 			if err != nil {
  14042 				return err
  14043 			}
  14044 			if val == nil {
  14045 				break
  14046 			}
  14047 			{
  14048 				xtv := string(val)
  14049 				sv.Id = ptr.String(xtv)
  14050 			}
  14051 
  14052 		case strings.EqualFold("Status", t.Name.Local):
  14053 			val, err := decoder.Value()
  14054 			if err != nil {
  14055 				return err
  14056 			}
  14057 			if val == nil {
  14058 				break
  14059 			}
  14060 			{
  14061 				xtv := string(val)
  14062 				sv.Status = types.ChangeStatus(xtv)
  14063 			}
  14064 
  14065 		case strings.EqualFold("SubmittedAt", t.Name.Local):
  14066 			val, err := decoder.Value()
  14067 			if err != nil {
  14068 				return err
  14069 			}
  14070 			if val == nil {
  14071 				break
  14072 			}
  14073 			{
  14074 				xtv := string(val)
  14075 				t, err := smithytime.ParseDateTime(xtv)
  14076 				if err != nil {
  14077 					return err
  14078 				}
  14079 				sv.SubmittedAt = ptr.Time(t)
  14080 			}
  14081 
  14082 		default:
  14083 			// Do nothing and ignore the unexpected tag element
  14084 			err = decoder.Decoder.Skip()
  14085 			if err != nil {
  14086 				return err
  14087 			}
  14088 
  14089 		}
  14090 		decoder = originalDecoder
  14091 	}
  14092 	*v = sv
  14093 	return nil
  14094 }
  14095 
  14096 func awsRestxml_deserializeDocumentCheckerIpRanges(v *[]string, decoder smithyxml.NodeDecoder) error {
  14097 	if v == nil {
  14098 		return fmt.Errorf("unexpected nil of type %T", v)
  14099 	}
  14100 	var sv []string
  14101 	if *v == nil {
  14102 		sv = make([]string, 0)
  14103 	} else {
  14104 		sv = *v
  14105 	}
  14106 
  14107 	originalDecoder := decoder
  14108 	for {
  14109 		t, done, err := decoder.Token()
  14110 		if err != nil {
  14111 			return err
  14112 		}
  14113 		if done {
  14114 			break
  14115 		}
  14116 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14117 		decoder = memberDecoder
  14118 		switch {
  14119 		case strings.EqualFold("member", t.Name.Local):
  14120 			var col string
  14121 			val, err := decoder.Value()
  14122 			if err != nil {
  14123 				return err
  14124 			}
  14125 			if val == nil {
  14126 				break
  14127 			}
  14128 			{
  14129 				xtv := string(val)
  14130 				col = xtv
  14131 			}
  14132 			sv = append(sv, col)
  14133 
  14134 		default:
  14135 			err = decoder.Decoder.Skip()
  14136 			if err != nil {
  14137 				return err
  14138 			}
  14139 
  14140 		}
  14141 		decoder = originalDecoder
  14142 	}
  14143 	*v = sv
  14144 	return nil
  14145 }
  14146 
  14147 func awsRestxml_deserializeDocumentCheckerIpRangesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  14148 	var sv []string
  14149 	if *v == nil {
  14150 		sv = make([]string, 0)
  14151 	} else {
  14152 		sv = *v
  14153 	}
  14154 
  14155 	switch {
  14156 	default:
  14157 		var mv string
  14158 		t := decoder.StartEl
  14159 		_ = t
  14160 		val, err := decoder.Value()
  14161 		if err != nil {
  14162 			return err
  14163 		}
  14164 		if val == nil {
  14165 			break
  14166 		}
  14167 		{
  14168 			xtv := string(val)
  14169 			mv = xtv
  14170 		}
  14171 		sv = append(sv, mv)
  14172 	}
  14173 	*v = sv
  14174 	return nil
  14175 }
  14176 func awsRestxml_deserializeDocumentChildHealthCheckList(v *[]string, decoder smithyxml.NodeDecoder) error {
  14177 	if v == nil {
  14178 		return fmt.Errorf("unexpected nil of type %T", v)
  14179 	}
  14180 	var sv []string
  14181 	if *v == nil {
  14182 		sv = make([]string, 0)
  14183 	} else {
  14184 		sv = *v
  14185 	}
  14186 
  14187 	originalDecoder := decoder
  14188 	for {
  14189 		t, done, err := decoder.Token()
  14190 		if err != nil {
  14191 			return err
  14192 		}
  14193 		if done {
  14194 			break
  14195 		}
  14196 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14197 		decoder = memberDecoder
  14198 		switch {
  14199 		case strings.EqualFold("ChildHealthCheck", t.Name.Local):
  14200 			var col string
  14201 			val, err := decoder.Value()
  14202 			if err != nil {
  14203 				return err
  14204 			}
  14205 			if val == nil {
  14206 				break
  14207 			}
  14208 			{
  14209 				xtv := string(val)
  14210 				col = xtv
  14211 			}
  14212 			sv = append(sv, col)
  14213 
  14214 		default:
  14215 			err = decoder.Decoder.Skip()
  14216 			if err != nil {
  14217 				return err
  14218 			}
  14219 
  14220 		}
  14221 		decoder = originalDecoder
  14222 	}
  14223 	*v = sv
  14224 	return nil
  14225 }
  14226 
  14227 func awsRestxml_deserializeDocumentChildHealthCheckListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  14228 	var sv []string
  14229 	if *v == nil {
  14230 		sv = make([]string, 0)
  14231 	} else {
  14232 		sv = *v
  14233 	}
  14234 
  14235 	switch {
  14236 	default:
  14237 		var mv string
  14238 		t := decoder.StartEl
  14239 		_ = t
  14240 		val, err := decoder.Value()
  14241 		if err != nil {
  14242 			return err
  14243 		}
  14244 		if val == nil {
  14245 			break
  14246 		}
  14247 		{
  14248 			xtv := string(val)
  14249 			mv = xtv
  14250 		}
  14251 		sv = append(sv, mv)
  14252 	}
  14253 	*v = sv
  14254 	return nil
  14255 }
  14256 func awsRestxml_deserializeDocumentCidrBlockInUseException(v **types.CidrBlockInUseException, decoder smithyxml.NodeDecoder) error {
  14257 	if v == nil {
  14258 		return fmt.Errorf("unexpected nil of type %T", v)
  14259 	}
  14260 	var sv *types.CidrBlockInUseException
  14261 	if *v == nil {
  14262 		sv = &types.CidrBlockInUseException{}
  14263 	} else {
  14264 		sv = *v
  14265 	}
  14266 
  14267 	for {
  14268 		t, done, err := decoder.Token()
  14269 		if err != nil {
  14270 			return err
  14271 		}
  14272 		if done {
  14273 			break
  14274 		}
  14275 		originalDecoder := decoder
  14276 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14277 		switch {
  14278 		case strings.EqualFold("Message", t.Name.Local):
  14279 			val, err := decoder.Value()
  14280 			if err != nil {
  14281 				return err
  14282 			}
  14283 			if val == nil {
  14284 				break
  14285 			}
  14286 			{
  14287 				xtv := string(val)
  14288 				sv.Message = ptr.String(xtv)
  14289 			}
  14290 
  14291 		default:
  14292 			// Do nothing and ignore the unexpected tag element
  14293 			err = decoder.Decoder.Skip()
  14294 			if err != nil {
  14295 				return err
  14296 			}
  14297 
  14298 		}
  14299 		decoder = originalDecoder
  14300 	}
  14301 	*v = sv
  14302 	return nil
  14303 }
  14304 
  14305 func awsRestxml_deserializeDocumentCidrBlockSummaries(v *[]types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
  14306 	if v == nil {
  14307 		return fmt.Errorf("unexpected nil of type %T", v)
  14308 	}
  14309 	var sv []types.CidrBlockSummary
  14310 	if *v == nil {
  14311 		sv = make([]types.CidrBlockSummary, 0)
  14312 	} else {
  14313 		sv = *v
  14314 	}
  14315 
  14316 	originalDecoder := decoder
  14317 	for {
  14318 		t, done, err := decoder.Token()
  14319 		if err != nil {
  14320 			return err
  14321 		}
  14322 		if done {
  14323 			break
  14324 		}
  14325 		switch {
  14326 		case strings.EqualFold("member", t.Name.Local):
  14327 			var col types.CidrBlockSummary
  14328 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14329 			destAddr := &col
  14330 			if err := awsRestxml_deserializeDocumentCidrBlockSummary(&destAddr, nodeDecoder); err != nil {
  14331 				return err
  14332 			}
  14333 			col = *destAddr
  14334 			sv = append(sv, col)
  14335 
  14336 		default:
  14337 			err = decoder.Decoder.Skip()
  14338 			if err != nil {
  14339 				return err
  14340 			}
  14341 
  14342 		}
  14343 		decoder = originalDecoder
  14344 	}
  14345 	*v = sv
  14346 	return nil
  14347 }
  14348 
  14349 func awsRestxml_deserializeDocumentCidrBlockSummariesUnwrapped(v *[]types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
  14350 	var sv []types.CidrBlockSummary
  14351 	if *v == nil {
  14352 		sv = make([]types.CidrBlockSummary, 0)
  14353 	} else {
  14354 		sv = *v
  14355 	}
  14356 
  14357 	switch {
  14358 	default:
  14359 		var mv types.CidrBlockSummary
  14360 		t := decoder.StartEl
  14361 		_ = t
  14362 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14363 		destAddr := &mv
  14364 		if err := awsRestxml_deserializeDocumentCidrBlockSummary(&destAddr, nodeDecoder); err != nil {
  14365 			return err
  14366 		}
  14367 		mv = *destAddr
  14368 		sv = append(sv, mv)
  14369 	}
  14370 	*v = sv
  14371 	return nil
  14372 }
  14373 func awsRestxml_deserializeDocumentCidrBlockSummary(v **types.CidrBlockSummary, decoder smithyxml.NodeDecoder) error {
  14374 	if v == nil {
  14375 		return fmt.Errorf("unexpected nil of type %T", v)
  14376 	}
  14377 	var sv *types.CidrBlockSummary
  14378 	if *v == nil {
  14379 		sv = &types.CidrBlockSummary{}
  14380 	} else {
  14381 		sv = *v
  14382 	}
  14383 
  14384 	for {
  14385 		t, done, err := decoder.Token()
  14386 		if err != nil {
  14387 			return err
  14388 		}
  14389 		if done {
  14390 			break
  14391 		}
  14392 		originalDecoder := decoder
  14393 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14394 		switch {
  14395 		case strings.EqualFold("CidrBlock", t.Name.Local):
  14396 			val, err := decoder.Value()
  14397 			if err != nil {
  14398 				return err
  14399 			}
  14400 			if val == nil {
  14401 				break
  14402 			}
  14403 			{
  14404 				xtv := string(val)
  14405 				sv.CidrBlock = ptr.String(xtv)
  14406 			}
  14407 
  14408 		case strings.EqualFold("LocationName", t.Name.Local):
  14409 			val, err := decoder.Value()
  14410 			if err != nil {
  14411 				return err
  14412 			}
  14413 			if val == nil {
  14414 				break
  14415 			}
  14416 			{
  14417 				xtv := string(val)
  14418 				sv.LocationName = ptr.String(xtv)
  14419 			}
  14420 
  14421 		default:
  14422 			// Do nothing and ignore the unexpected tag element
  14423 			err = decoder.Decoder.Skip()
  14424 			if err != nil {
  14425 				return err
  14426 			}
  14427 
  14428 		}
  14429 		decoder = originalDecoder
  14430 	}
  14431 	*v = sv
  14432 	return nil
  14433 }
  14434 
  14435 func awsRestxml_deserializeDocumentCidrCollection(v **types.CidrCollection, decoder smithyxml.NodeDecoder) error {
  14436 	if v == nil {
  14437 		return fmt.Errorf("unexpected nil of type %T", v)
  14438 	}
  14439 	var sv *types.CidrCollection
  14440 	if *v == nil {
  14441 		sv = &types.CidrCollection{}
  14442 	} else {
  14443 		sv = *v
  14444 	}
  14445 
  14446 	for {
  14447 		t, done, err := decoder.Token()
  14448 		if err != nil {
  14449 			return err
  14450 		}
  14451 		if done {
  14452 			break
  14453 		}
  14454 		originalDecoder := decoder
  14455 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14456 		switch {
  14457 		case strings.EqualFold("Arn", t.Name.Local):
  14458 			val, err := decoder.Value()
  14459 			if err != nil {
  14460 				return err
  14461 			}
  14462 			if val == nil {
  14463 				break
  14464 			}
  14465 			{
  14466 				xtv := string(val)
  14467 				sv.Arn = ptr.String(xtv)
  14468 			}
  14469 
  14470 		case strings.EqualFold("Id", t.Name.Local):
  14471 			val, err := decoder.Value()
  14472 			if err != nil {
  14473 				return err
  14474 			}
  14475 			if val == nil {
  14476 				break
  14477 			}
  14478 			{
  14479 				xtv := string(val)
  14480 				sv.Id = ptr.String(xtv)
  14481 			}
  14482 
  14483 		case strings.EqualFold("Name", t.Name.Local):
  14484 			val, err := decoder.Value()
  14485 			if err != nil {
  14486 				return err
  14487 			}
  14488 			if val == nil {
  14489 				break
  14490 			}
  14491 			{
  14492 				xtv := string(val)
  14493 				sv.Name = ptr.String(xtv)
  14494 			}
  14495 
  14496 		case strings.EqualFold("Version", t.Name.Local):
  14497 			val, err := decoder.Value()
  14498 			if err != nil {
  14499 				return err
  14500 			}
  14501 			if val == nil {
  14502 				break
  14503 			}
  14504 			{
  14505 				xtv := string(val)
  14506 				i64, err := strconv.ParseInt(xtv, 10, 64)
  14507 				if err != nil {
  14508 					return err
  14509 				}
  14510 				sv.Version = ptr.Int64(i64)
  14511 			}
  14512 
  14513 		default:
  14514 			// Do nothing and ignore the unexpected tag element
  14515 			err = decoder.Decoder.Skip()
  14516 			if err != nil {
  14517 				return err
  14518 			}
  14519 
  14520 		}
  14521 		decoder = originalDecoder
  14522 	}
  14523 	*v = sv
  14524 	return nil
  14525 }
  14526 
  14527 func awsRestxml_deserializeDocumentCidrCollectionAlreadyExistsException(v **types.CidrCollectionAlreadyExistsException, decoder smithyxml.NodeDecoder) error {
  14528 	if v == nil {
  14529 		return fmt.Errorf("unexpected nil of type %T", v)
  14530 	}
  14531 	var sv *types.CidrCollectionAlreadyExistsException
  14532 	if *v == nil {
  14533 		sv = &types.CidrCollectionAlreadyExistsException{}
  14534 	} else {
  14535 		sv = *v
  14536 	}
  14537 
  14538 	for {
  14539 		t, done, err := decoder.Token()
  14540 		if err != nil {
  14541 			return err
  14542 		}
  14543 		if done {
  14544 			break
  14545 		}
  14546 		originalDecoder := decoder
  14547 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14548 		switch {
  14549 		case strings.EqualFold("Message", t.Name.Local):
  14550 			val, err := decoder.Value()
  14551 			if err != nil {
  14552 				return err
  14553 			}
  14554 			if val == nil {
  14555 				break
  14556 			}
  14557 			{
  14558 				xtv := string(val)
  14559 				sv.Message = ptr.String(xtv)
  14560 			}
  14561 
  14562 		default:
  14563 			// Do nothing and ignore the unexpected tag element
  14564 			err = decoder.Decoder.Skip()
  14565 			if err != nil {
  14566 				return err
  14567 			}
  14568 
  14569 		}
  14570 		decoder = originalDecoder
  14571 	}
  14572 	*v = sv
  14573 	return nil
  14574 }
  14575 
  14576 func awsRestxml_deserializeDocumentCidrCollectionInUseException(v **types.CidrCollectionInUseException, decoder smithyxml.NodeDecoder) error {
  14577 	if v == nil {
  14578 		return fmt.Errorf("unexpected nil of type %T", v)
  14579 	}
  14580 	var sv *types.CidrCollectionInUseException
  14581 	if *v == nil {
  14582 		sv = &types.CidrCollectionInUseException{}
  14583 	} else {
  14584 		sv = *v
  14585 	}
  14586 
  14587 	for {
  14588 		t, done, err := decoder.Token()
  14589 		if err != nil {
  14590 			return err
  14591 		}
  14592 		if done {
  14593 			break
  14594 		}
  14595 		originalDecoder := decoder
  14596 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14597 		switch {
  14598 		case strings.EqualFold("Message", t.Name.Local):
  14599 			val, err := decoder.Value()
  14600 			if err != nil {
  14601 				return err
  14602 			}
  14603 			if val == nil {
  14604 				break
  14605 			}
  14606 			{
  14607 				xtv := string(val)
  14608 				sv.Message = ptr.String(xtv)
  14609 			}
  14610 
  14611 		default:
  14612 			// Do nothing and ignore the unexpected tag element
  14613 			err = decoder.Decoder.Skip()
  14614 			if err != nil {
  14615 				return err
  14616 			}
  14617 
  14618 		}
  14619 		decoder = originalDecoder
  14620 	}
  14621 	*v = sv
  14622 	return nil
  14623 }
  14624 
  14625 func awsRestxml_deserializeDocumentCidrCollectionVersionMismatchException(v **types.CidrCollectionVersionMismatchException, decoder smithyxml.NodeDecoder) error {
  14626 	if v == nil {
  14627 		return fmt.Errorf("unexpected nil of type %T", v)
  14628 	}
  14629 	var sv *types.CidrCollectionVersionMismatchException
  14630 	if *v == nil {
  14631 		sv = &types.CidrCollectionVersionMismatchException{}
  14632 	} else {
  14633 		sv = *v
  14634 	}
  14635 
  14636 	for {
  14637 		t, done, err := decoder.Token()
  14638 		if err != nil {
  14639 			return err
  14640 		}
  14641 		if done {
  14642 			break
  14643 		}
  14644 		originalDecoder := decoder
  14645 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14646 		switch {
  14647 		case strings.EqualFold("Message", t.Name.Local):
  14648 			val, err := decoder.Value()
  14649 			if err != nil {
  14650 				return err
  14651 			}
  14652 			if val == nil {
  14653 				break
  14654 			}
  14655 			{
  14656 				xtv := string(val)
  14657 				sv.Message = ptr.String(xtv)
  14658 			}
  14659 
  14660 		default:
  14661 			// Do nothing and ignore the unexpected tag element
  14662 			err = decoder.Decoder.Skip()
  14663 			if err != nil {
  14664 				return err
  14665 			}
  14666 
  14667 		}
  14668 		decoder = originalDecoder
  14669 	}
  14670 	*v = sv
  14671 	return nil
  14672 }
  14673 
  14674 func awsRestxml_deserializeDocumentCidrRoutingConfig(v **types.CidrRoutingConfig, decoder smithyxml.NodeDecoder) error {
  14675 	if v == nil {
  14676 		return fmt.Errorf("unexpected nil of type %T", v)
  14677 	}
  14678 	var sv *types.CidrRoutingConfig
  14679 	if *v == nil {
  14680 		sv = &types.CidrRoutingConfig{}
  14681 	} else {
  14682 		sv = *v
  14683 	}
  14684 
  14685 	for {
  14686 		t, done, err := decoder.Token()
  14687 		if err != nil {
  14688 			return err
  14689 		}
  14690 		if done {
  14691 			break
  14692 		}
  14693 		originalDecoder := decoder
  14694 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14695 		switch {
  14696 		case strings.EqualFold("CollectionId", t.Name.Local):
  14697 			val, err := decoder.Value()
  14698 			if err != nil {
  14699 				return err
  14700 			}
  14701 			if val == nil {
  14702 				break
  14703 			}
  14704 			{
  14705 				xtv := string(val)
  14706 				sv.CollectionId = ptr.String(xtv)
  14707 			}
  14708 
  14709 		case strings.EqualFold("LocationName", t.Name.Local):
  14710 			val, err := decoder.Value()
  14711 			if err != nil {
  14712 				return err
  14713 			}
  14714 			if val == nil {
  14715 				break
  14716 			}
  14717 			{
  14718 				xtv := string(val)
  14719 				sv.LocationName = ptr.String(xtv)
  14720 			}
  14721 
  14722 		default:
  14723 			// Do nothing and ignore the unexpected tag element
  14724 			err = decoder.Decoder.Skip()
  14725 			if err != nil {
  14726 				return err
  14727 			}
  14728 
  14729 		}
  14730 		decoder = originalDecoder
  14731 	}
  14732 	*v = sv
  14733 	return nil
  14734 }
  14735 
  14736 func awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(v **types.CloudWatchAlarmConfiguration, decoder smithyxml.NodeDecoder) error {
  14737 	if v == nil {
  14738 		return fmt.Errorf("unexpected nil of type %T", v)
  14739 	}
  14740 	var sv *types.CloudWatchAlarmConfiguration
  14741 	if *v == nil {
  14742 		sv = &types.CloudWatchAlarmConfiguration{}
  14743 	} else {
  14744 		sv = *v
  14745 	}
  14746 
  14747 	for {
  14748 		t, done, err := decoder.Token()
  14749 		if err != nil {
  14750 			return err
  14751 		}
  14752 		if done {
  14753 			break
  14754 		}
  14755 		originalDecoder := decoder
  14756 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14757 		switch {
  14758 		case strings.EqualFold("ComparisonOperator", t.Name.Local):
  14759 			val, err := decoder.Value()
  14760 			if err != nil {
  14761 				return err
  14762 			}
  14763 			if val == nil {
  14764 				break
  14765 			}
  14766 			{
  14767 				xtv := string(val)
  14768 				sv.ComparisonOperator = types.ComparisonOperator(xtv)
  14769 			}
  14770 
  14771 		case strings.EqualFold("Dimensions", t.Name.Local):
  14772 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14773 			if err := awsRestxml_deserializeDocumentDimensionList(&sv.Dimensions, nodeDecoder); err != nil {
  14774 				return err
  14775 			}
  14776 
  14777 		case strings.EqualFold("EvaluationPeriods", t.Name.Local):
  14778 			val, err := decoder.Value()
  14779 			if err != nil {
  14780 				return err
  14781 			}
  14782 			if val == nil {
  14783 				break
  14784 			}
  14785 			{
  14786 				xtv := string(val)
  14787 				i64, err := strconv.ParseInt(xtv, 10, 64)
  14788 				if err != nil {
  14789 					return err
  14790 				}
  14791 				sv.EvaluationPeriods = ptr.Int32(int32(i64))
  14792 			}
  14793 
  14794 		case strings.EqualFold("MetricName", t.Name.Local):
  14795 			val, err := decoder.Value()
  14796 			if err != nil {
  14797 				return err
  14798 			}
  14799 			if val == nil {
  14800 				break
  14801 			}
  14802 			{
  14803 				xtv := string(val)
  14804 				sv.MetricName = ptr.String(xtv)
  14805 			}
  14806 
  14807 		case strings.EqualFold("Namespace", t.Name.Local):
  14808 			val, err := decoder.Value()
  14809 			if err != nil {
  14810 				return err
  14811 			}
  14812 			if val == nil {
  14813 				break
  14814 			}
  14815 			{
  14816 				xtv := string(val)
  14817 				sv.Namespace = ptr.String(xtv)
  14818 			}
  14819 
  14820 		case strings.EqualFold("Period", t.Name.Local):
  14821 			val, err := decoder.Value()
  14822 			if err != nil {
  14823 				return err
  14824 			}
  14825 			if val == nil {
  14826 				break
  14827 			}
  14828 			{
  14829 				xtv := string(val)
  14830 				i64, err := strconv.ParseInt(xtv, 10, 64)
  14831 				if err != nil {
  14832 					return err
  14833 				}
  14834 				sv.Period = ptr.Int32(int32(i64))
  14835 			}
  14836 
  14837 		case strings.EqualFold("Statistic", t.Name.Local):
  14838 			val, err := decoder.Value()
  14839 			if err != nil {
  14840 				return err
  14841 			}
  14842 			if val == nil {
  14843 				break
  14844 			}
  14845 			{
  14846 				xtv := string(val)
  14847 				sv.Statistic = types.Statistic(xtv)
  14848 			}
  14849 
  14850 		case strings.EqualFold("Threshold", t.Name.Local):
  14851 			val, err := decoder.Value()
  14852 			if err != nil {
  14853 				return err
  14854 			}
  14855 			if val == nil {
  14856 				break
  14857 			}
  14858 			{
  14859 				xtv := string(val)
  14860 				f64, err := strconv.ParseFloat(xtv, 64)
  14861 				if err != nil {
  14862 					return err
  14863 				}
  14864 				sv.Threshold = ptr.Float64(f64)
  14865 			}
  14866 
  14867 		default:
  14868 			// Do nothing and ignore the unexpected tag element
  14869 			err = decoder.Decoder.Skip()
  14870 			if err != nil {
  14871 				return err
  14872 			}
  14873 
  14874 		}
  14875 		decoder = originalDecoder
  14876 	}
  14877 	*v = sv
  14878 	return nil
  14879 }
  14880 
  14881 func awsRestxml_deserializeDocumentCollectionSummaries(v *[]types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
  14882 	if v == nil {
  14883 		return fmt.Errorf("unexpected nil of type %T", v)
  14884 	}
  14885 	var sv []types.CollectionSummary
  14886 	if *v == nil {
  14887 		sv = make([]types.CollectionSummary, 0)
  14888 	} else {
  14889 		sv = *v
  14890 	}
  14891 
  14892 	originalDecoder := decoder
  14893 	for {
  14894 		t, done, err := decoder.Token()
  14895 		if err != nil {
  14896 			return err
  14897 		}
  14898 		if done {
  14899 			break
  14900 		}
  14901 		switch {
  14902 		case strings.EqualFold("member", t.Name.Local):
  14903 			var col types.CollectionSummary
  14904 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14905 			destAddr := &col
  14906 			if err := awsRestxml_deserializeDocumentCollectionSummary(&destAddr, nodeDecoder); err != nil {
  14907 				return err
  14908 			}
  14909 			col = *destAddr
  14910 			sv = append(sv, col)
  14911 
  14912 		default:
  14913 			err = decoder.Decoder.Skip()
  14914 			if err != nil {
  14915 				return err
  14916 			}
  14917 
  14918 		}
  14919 		decoder = originalDecoder
  14920 	}
  14921 	*v = sv
  14922 	return nil
  14923 }
  14924 
  14925 func awsRestxml_deserializeDocumentCollectionSummariesUnwrapped(v *[]types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
  14926 	var sv []types.CollectionSummary
  14927 	if *v == nil {
  14928 		sv = make([]types.CollectionSummary, 0)
  14929 	} else {
  14930 		sv = *v
  14931 	}
  14932 
  14933 	switch {
  14934 	default:
  14935 		var mv types.CollectionSummary
  14936 		t := decoder.StartEl
  14937 		_ = t
  14938 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  14939 		destAddr := &mv
  14940 		if err := awsRestxml_deserializeDocumentCollectionSummary(&destAddr, nodeDecoder); err != nil {
  14941 			return err
  14942 		}
  14943 		mv = *destAddr
  14944 		sv = append(sv, mv)
  14945 	}
  14946 	*v = sv
  14947 	return nil
  14948 }
  14949 func awsRestxml_deserializeDocumentCollectionSummary(v **types.CollectionSummary, decoder smithyxml.NodeDecoder) error {
  14950 	if v == nil {
  14951 		return fmt.Errorf("unexpected nil of type %T", v)
  14952 	}
  14953 	var sv *types.CollectionSummary
  14954 	if *v == nil {
  14955 		sv = &types.CollectionSummary{}
  14956 	} else {
  14957 		sv = *v
  14958 	}
  14959 
  14960 	for {
  14961 		t, done, err := decoder.Token()
  14962 		if err != nil {
  14963 			return err
  14964 		}
  14965 		if done {
  14966 			break
  14967 		}
  14968 		originalDecoder := decoder
  14969 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  14970 		switch {
  14971 		case strings.EqualFold("Arn", t.Name.Local):
  14972 			val, err := decoder.Value()
  14973 			if err != nil {
  14974 				return err
  14975 			}
  14976 			if val == nil {
  14977 				break
  14978 			}
  14979 			{
  14980 				xtv := string(val)
  14981 				sv.Arn = ptr.String(xtv)
  14982 			}
  14983 
  14984 		case strings.EqualFold("Id", t.Name.Local):
  14985 			val, err := decoder.Value()
  14986 			if err != nil {
  14987 				return err
  14988 			}
  14989 			if val == nil {
  14990 				break
  14991 			}
  14992 			{
  14993 				xtv := string(val)
  14994 				sv.Id = ptr.String(xtv)
  14995 			}
  14996 
  14997 		case strings.EqualFold("Name", t.Name.Local):
  14998 			val, err := decoder.Value()
  14999 			if err != nil {
  15000 				return err
  15001 			}
  15002 			if val == nil {
  15003 				break
  15004 			}
  15005 			{
  15006 				xtv := string(val)
  15007 				sv.Name = ptr.String(xtv)
  15008 			}
  15009 
  15010 		case strings.EqualFold("Version", t.Name.Local):
  15011 			val, err := decoder.Value()
  15012 			if err != nil {
  15013 				return err
  15014 			}
  15015 			if val == nil {
  15016 				break
  15017 			}
  15018 			{
  15019 				xtv := string(val)
  15020 				i64, err := strconv.ParseInt(xtv, 10, 64)
  15021 				if err != nil {
  15022 					return err
  15023 				}
  15024 				sv.Version = ptr.Int64(i64)
  15025 			}
  15026 
  15027 		default:
  15028 			// Do nothing and ignore the unexpected tag element
  15029 			err = decoder.Decoder.Skip()
  15030 			if err != nil {
  15031 				return err
  15032 			}
  15033 
  15034 		}
  15035 		decoder = originalDecoder
  15036 	}
  15037 	*v = sv
  15038 	return nil
  15039 }
  15040 
  15041 func awsRestxml_deserializeDocumentConcurrentModification(v **types.ConcurrentModification, decoder smithyxml.NodeDecoder) error {
  15042 	if v == nil {
  15043 		return fmt.Errorf("unexpected nil of type %T", v)
  15044 	}
  15045 	var sv *types.ConcurrentModification
  15046 	if *v == nil {
  15047 		sv = &types.ConcurrentModification{}
  15048 	} else {
  15049 		sv = *v
  15050 	}
  15051 
  15052 	for {
  15053 		t, done, err := decoder.Token()
  15054 		if err != nil {
  15055 			return err
  15056 		}
  15057 		if done {
  15058 			break
  15059 		}
  15060 		originalDecoder := decoder
  15061 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15062 		switch {
  15063 		case strings.EqualFold("message", t.Name.Local):
  15064 			val, err := decoder.Value()
  15065 			if err != nil {
  15066 				return err
  15067 			}
  15068 			if val == nil {
  15069 				break
  15070 			}
  15071 			{
  15072 				xtv := string(val)
  15073 				sv.Message = ptr.String(xtv)
  15074 			}
  15075 
  15076 		default:
  15077 			// Do nothing and ignore the unexpected tag element
  15078 			err = decoder.Decoder.Skip()
  15079 			if err != nil {
  15080 				return err
  15081 			}
  15082 
  15083 		}
  15084 		decoder = originalDecoder
  15085 	}
  15086 	*v = sv
  15087 	return nil
  15088 }
  15089 
  15090 func awsRestxml_deserializeDocumentConflictingDomainExists(v **types.ConflictingDomainExists, decoder smithyxml.NodeDecoder) error {
  15091 	if v == nil {
  15092 		return fmt.Errorf("unexpected nil of type %T", v)
  15093 	}
  15094 	var sv *types.ConflictingDomainExists
  15095 	if *v == nil {
  15096 		sv = &types.ConflictingDomainExists{}
  15097 	} else {
  15098 		sv = *v
  15099 	}
  15100 
  15101 	for {
  15102 		t, done, err := decoder.Token()
  15103 		if err != nil {
  15104 			return err
  15105 		}
  15106 		if done {
  15107 			break
  15108 		}
  15109 		originalDecoder := decoder
  15110 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15111 		switch {
  15112 		case strings.EqualFold("message", t.Name.Local):
  15113 			val, err := decoder.Value()
  15114 			if err != nil {
  15115 				return err
  15116 			}
  15117 			if val == nil {
  15118 				break
  15119 			}
  15120 			{
  15121 				xtv := string(val)
  15122 				sv.Message = ptr.String(xtv)
  15123 			}
  15124 
  15125 		default:
  15126 			// Do nothing and ignore the unexpected tag element
  15127 			err = decoder.Decoder.Skip()
  15128 			if err != nil {
  15129 				return err
  15130 			}
  15131 
  15132 		}
  15133 		decoder = originalDecoder
  15134 	}
  15135 	*v = sv
  15136 	return nil
  15137 }
  15138 
  15139 func awsRestxml_deserializeDocumentConflictingTypes(v **types.ConflictingTypes, decoder smithyxml.NodeDecoder) error {
  15140 	if v == nil {
  15141 		return fmt.Errorf("unexpected nil of type %T", v)
  15142 	}
  15143 	var sv *types.ConflictingTypes
  15144 	if *v == nil {
  15145 		sv = &types.ConflictingTypes{}
  15146 	} else {
  15147 		sv = *v
  15148 	}
  15149 
  15150 	for {
  15151 		t, done, err := decoder.Token()
  15152 		if err != nil {
  15153 			return err
  15154 		}
  15155 		if done {
  15156 			break
  15157 		}
  15158 		originalDecoder := decoder
  15159 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15160 		switch {
  15161 		case strings.EqualFold("message", t.Name.Local):
  15162 			val, err := decoder.Value()
  15163 			if err != nil {
  15164 				return err
  15165 			}
  15166 			if val == nil {
  15167 				break
  15168 			}
  15169 			{
  15170 				xtv := string(val)
  15171 				sv.Message = ptr.String(xtv)
  15172 			}
  15173 
  15174 		default:
  15175 			// Do nothing and ignore the unexpected tag element
  15176 			err = decoder.Decoder.Skip()
  15177 			if err != nil {
  15178 				return err
  15179 			}
  15180 
  15181 		}
  15182 		decoder = originalDecoder
  15183 	}
  15184 	*v = sv
  15185 	return nil
  15186 }
  15187 
  15188 func awsRestxml_deserializeDocumentDelegationSet(v **types.DelegationSet, decoder smithyxml.NodeDecoder) error {
  15189 	if v == nil {
  15190 		return fmt.Errorf("unexpected nil of type %T", v)
  15191 	}
  15192 	var sv *types.DelegationSet
  15193 	if *v == nil {
  15194 		sv = &types.DelegationSet{}
  15195 	} else {
  15196 		sv = *v
  15197 	}
  15198 
  15199 	for {
  15200 		t, done, err := decoder.Token()
  15201 		if err != nil {
  15202 			return err
  15203 		}
  15204 		if done {
  15205 			break
  15206 		}
  15207 		originalDecoder := decoder
  15208 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15209 		switch {
  15210 		case strings.EqualFold("CallerReference", t.Name.Local):
  15211 			val, err := decoder.Value()
  15212 			if err != nil {
  15213 				return err
  15214 			}
  15215 			if val == nil {
  15216 				break
  15217 			}
  15218 			{
  15219 				xtv := string(val)
  15220 				sv.CallerReference = ptr.String(xtv)
  15221 			}
  15222 
  15223 		case strings.EqualFold("Id", t.Name.Local):
  15224 			val, err := decoder.Value()
  15225 			if err != nil {
  15226 				return err
  15227 			}
  15228 			if val == nil {
  15229 				break
  15230 			}
  15231 			{
  15232 				xtv := string(val)
  15233 				sv.Id = ptr.String(xtv)
  15234 			}
  15235 
  15236 		case strings.EqualFold("NameServers", t.Name.Local):
  15237 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15238 			if err := awsRestxml_deserializeDocumentDelegationSetNameServers(&sv.NameServers, nodeDecoder); err != nil {
  15239 				return err
  15240 			}
  15241 
  15242 		default:
  15243 			// Do nothing and ignore the unexpected tag element
  15244 			err = decoder.Decoder.Skip()
  15245 			if err != nil {
  15246 				return err
  15247 			}
  15248 
  15249 		}
  15250 		decoder = originalDecoder
  15251 	}
  15252 	*v = sv
  15253 	return nil
  15254 }
  15255 
  15256 func awsRestxml_deserializeDocumentDelegationSetAlreadyCreated(v **types.DelegationSetAlreadyCreated, decoder smithyxml.NodeDecoder) error {
  15257 	if v == nil {
  15258 		return fmt.Errorf("unexpected nil of type %T", v)
  15259 	}
  15260 	var sv *types.DelegationSetAlreadyCreated
  15261 	if *v == nil {
  15262 		sv = &types.DelegationSetAlreadyCreated{}
  15263 	} else {
  15264 		sv = *v
  15265 	}
  15266 
  15267 	for {
  15268 		t, done, err := decoder.Token()
  15269 		if err != nil {
  15270 			return err
  15271 		}
  15272 		if done {
  15273 			break
  15274 		}
  15275 		originalDecoder := decoder
  15276 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15277 		switch {
  15278 		case strings.EqualFold("message", t.Name.Local):
  15279 			val, err := decoder.Value()
  15280 			if err != nil {
  15281 				return err
  15282 			}
  15283 			if val == nil {
  15284 				break
  15285 			}
  15286 			{
  15287 				xtv := string(val)
  15288 				sv.Message = ptr.String(xtv)
  15289 			}
  15290 
  15291 		default:
  15292 			// Do nothing and ignore the unexpected tag element
  15293 			err = decoder.Decoder.Skip()
  15294 			if err != nil {
  15295 				return err
  15296 			}
  15297 
  15298 		}
  15299 		decoder = originalDecoder
  15300 	}
  15301 	*v = sv
  15302 	return nil
  15303 }
  15304 
  15305 func awsRestxml_deserializeDocumentDelegationSetAlreadyReusable(v **types.DelegationSetAlreadyReusable, decoder smithyxml.NodeDecoder) error {
  15306 	if v == nil {
  15307 		return fmt.Errorf("unexpected nil of type %T", v)
  15308 	}
  15309 	var sv *types.DelegationSetAlreadyReusable
  15310 	if *v == nil {
  15311 		sv = &types.DelegationSetAlreadyReusable{}
  15312 	} else {
  15313 		sv = *v
  15314 	}
  15315 
  15316 	for {
  15317 		t, done, err := decoder.Token()
  15318 		if err != nil {
  15319 			return err
  15320 		}
  15321 		if done {
  15322 			break
  15323 		}
  15324 		originalDecoder := decoder
  15325 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15326 		switch {
  15327 		case strings.EqualFold("message", t.Name.Local):
  15328 			val, err := decoder.Value()
  15329 			if err != nil {
  15330 				return err
  15331 			}
  15332 			if val == nil {
  15333 				break
  15334 			}
  15335 			{
  15336 				xtv := string(val)
  15337 				sv.Message = ptr.String(xtv)
  15338 			}
  15339 
  15340 		default:
  15341 			// Do nothing and ignore the unexpected tag element
  15342 			err = decoder.Decoder.Skip()
  15343 			if err != nil {
  15344 				return err
  15345 			}
  15346 
  15347 		}
  15348 		decoder = originalDecoder
  15349 	}
  15350 	*v = sv
  15351 	return nil
  15352 }
  15353 
  15354 func awsRestxml_deserializeDocumentDelegationSetInUse(v **types.DelegationSetInUse, decoder smithyxml.NodeDecoder) error {
  15355 	if v == nil {
  15356 		return fmt.Errorf("unexpected nil of type %T", v)
  15357 	}
  15358 	var sv *types.DelegationSetInUse
  15359 	if *v == nil {
  15360 		sv = &types.DelegationSetInUse{}
  15361 	} else {
  15362 		sv = *v
  15363 	}
  15364 
  15365 	for {
  15366 		t, done, err := decoder.Token()
  15367 		if err != nil {
  15368 			return err
  15369 		}
  15370 		if done {
  15371 			break
  15372 		}
  15373 		originalDecoder := decoder
  15374 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15375 		switch {
  15376 		case strings.EqualFold("message", t.Name.Local):
  15377 			val, err := decoder.Value()
  15378 			if err != nil {
  15379 				return err
  15380 			}
  15381 			if val == nil {
  15382 				break
  15383 			}
  15384 			{
  15385 				xtv := string(val)
  15386 				sv.Message = ptr.String(xtv)
  15387 			}
  15388 
  15389 		default:
  15390 			// Do nothing and ignore the unexpected tag element
  15391 			err = decoder.Decoder.Skip()
  15392 			if err != nil {
  15393 				return err
  15394 			}
  15395 
  15396 		}
  15397 		decoder = originalDecoder
  15398 	}
  15399 	*v = sv
  15400 	return nil
  15401 }
  15402 
  15403 func awsRestxml_deserializeDocumentDelegationSetNameServers(v *[]string, decoder smithyxml.NodeDecoder) error {
  15404 	if v == nil {
  15405 		return fmt.Errorf("unexpected nil of type %T", v)
  15406 	}
  15407 	var sv []string
  15408 	if *v == nil {
  15409 		sv = make([]string, 0)
  15410 	} else {
  15411 		sv = *v
  15412 	}
  15413 
  15414 	originalDecoder := decoder
  15415 	for {
  15416 		t, done, err := decoder.Token()
  15417 		if err != nil {
  15418 			return err
  15419 		}
  15420 		if done {
  15421 			break
  15422 		}
  15423 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15424 		decoder = memberDecoder
  15425 		switch {
  15426 		case strings.EqualFold("NameServer", t.Name.Local):
  15427 			var col string
  15428 			val, err := decoder.Value()
  15429 			if err != nil {
  15430 				return err
  15431 			}
  15432 			if val == nil {
  15433 				break
  15434 			}
  15435 			{
  15436 				xtv := string(val)
  15437 				col = xtv
  15438 			}
  15439 			sv = append(sv, col)
  15440 
  15441 		default:
  15442 			err = decoder.Decoder.Skip()
  15443 			if err != nil {
  15444 				return err
  15445 			}
  15446 
  15447 		}
  15448 		decoder = originalDecoder
  15449 	}
  15450 	*v = sv
  15451 	return nil
  15452 }
  15453 
  15454 func awsRestxml_deserializeDocumentDelegationSetNameServersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  15455 	var sv []string
  15456 	if *v == nil {
  15457 		sv = make([]string, 0)
  15458 	} else {
  15459 		sv = *v
  15460 	}
  15461 
  15462 	switch {
  15463 	default:
  15464 		var mv string
  15465 		t := decoder.StartEl
  15466 		_ = t
  15467 		val, err := decoder.Value()
  15468 		if err != nil {
  15469 			return err
  15470 		}
  15471 		if val == nil {
  15472 			break
  15473 		}
  15474 		{
  15475 			xtv := string(val)
  15476 			mv = xtv
  15477 		}
  15478 		sv = append(sv, mv)
  15479 	}
  15480 	*v = sv
  15481 	return nil
  15482 }
  15483 func awsRestxml_deserializeDocumentDelegationSetNotAvailable(v **types.DelegationSetNotAvailable, decoder smithyxml.NodeDecoder) error {
  15484 	if v == nil {
  15485 		return fmt.Errorf("unexpected nil of type %T", v)
  15486 	}
  15487 	var sv *types.DelegationSetNotAvailable
  15488 	if *v == nil {
  15489 		sv = &types.DelegationSetNotAvailable{}
  15490 	} else {
  15491 		sv = *v
  15492 	}
  15493 
  15494 	for {
  15495 		t, done, err := decoder.Token()
  15496 		if err != nil {
  15497 			return err
  15498 		}
  15499 		if done {
  15500 			break
  15501 		}
  15502 		originalDecoder := decoder
  15503 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15504 		switch {
  15505 		case strings.EqualFold("message", t.Name.Local):
  15506 			val, err := decoder.Value()
  15507 			if err != nil {
  15508 				return err
  15509 			}
  15510 			if val == nil {
  15511 				break
  15512 			}
  15513 			{
  15514 				xtv := string(val)
  15515 				sv.Message = ptr.String(xtv)
  15516 			}
  15517 
  15518 		default:
  15519 			// Do nothing and ignore the unexpected tag element
  15520 			err = decoder.Decoder.Skip()
  15521 			if err != nil {
  15522 				return err
  15523 			}
  15524 
  15525 		}
  15526 		decoder = originalDecoder
  15527 	}
  15528 	*v = sv
  15529 	return nil
  15530 }
  15531 
  15532 func awsRestxml_deserializeDocumentDelegationSetNotReusable(v **types.DelegationSetNotReusable, decoder smithyxml.NodeDecoder) error {
  15533 	if v == nil {
  15534 		return fmt.Errorf("unexpected nil of type %T", v)
  15535 	}
  15536 	var sv *types.DelegationSetNotReusable
  15537 	if *v == nil {
  15538 		sv = &types.DelegationSetNotReusable{}
  15539 	} else {
  15540 		sv = *v
  15541 	}
  15542 
  15543 	for {
  15544 		t, done, err := decoder.Token()
  15545 		if err != nil {
  15546 			return err
  15547 		}
  15548 		if done {
  15549 			break
  15550 		}
  15551 		originalDecoder := decoder
  15552 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15553 		switch {
  15554 		case strings.EqualFold("message", t.Name.Local):
  15555 			val, err := decoder.Value()
  15556 			if err != nil {
  15557 				return err
  15558 			}
  15559 			if val == nil {
  15560 				break
  15561 			}
  15562 			{
  15563 				xtv := string(val)
  15564 				sv.Message = ptr.String(xtv)
  15565 			}
  15566 
  15567 		default:
  15568 			// Do nothing and ignore the unexpected tag element
  15569 			err = decoder.Decoder.Skip()
  15570 			if err != nil {
  15571 				return err
  15572 			}
  15573 
  15574 		}
  15575 		decoder = originalDecoder
  15576 	}
  15577 	*v = sv
  15578 	return nil
  15579 }
  15580 
  15581 func awsRestxml_deserializeDocumentDelegationSets(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error {
  15582 	if v == nil {
  15583 		return fmt.Errorf("unexpected nil of type %T", v)
  15584 	}
  15585 	var sv []types.DelegationSet
  15586 	if *v == nil {
  15587 		sv = make([]types.DelegationSet, 0)
  15588 	} else {
  15589 		sv = *v
  15590 	}
  15591 
  15592 	originalDecoder := decoder
  15593 	for {
  15594 		t, done, err := decoder.Token()
  15595 		if err != nil {
  15596 			return err
  15597 		}
  15598 		if done {
  15599 			break
  15600 		}
  15601 		switch {
  15602 		case strings.EqualFold("DelegationSet", t.Name.Local):
  15603 			var col types.DelegationSet
  15604 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15605 			destAddr := &col
  15606 			if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil {
  15607 				return err
  15608 			}
  15609 			col = *destAddr
  15610 			sv = append(sv, col)
  15611 
  15612 		default:
  15613 			err = decoder.Decoder.Skip()
  15614 			if err != nil {
  15615 				return err
  15616 			}
  15617 
  15618 		}
  15619 		decoder = originalDecoder
  15620 	}
  15621 	*v = sv
  15622 	return nil
  15623 }
  15624 
  15625 func awsRestxml_deserializeDocumentDelegationSetsUnwrapped(v *[]types.DelegationSet, decoder smithyxml.NodeDecoder) error {
  15626 	var sv []types.DelegationSet
  15627 	if *v == nil {
  15628 		sv = make([]types.DelegationSet, 0)
  15629 	} else {
  15630 		sv = *v
  15631 	}
  15632 
  15633 	switch {
  15634 	default:
  15635 		var mv types.DelegationSet
  15636 		t := decoder.StartEl
  15637 		_ = t
  15638 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15639 		destAddr := &mv
  15640 		if err := awsRestxml_deserializeDocumentDelegationSet(&destAddr, nodeDecoder); err != nil {
  15641 			return err
  15642 		}
  15643 		mv = *destAddr
  15644 		sv = append(sv, mv)
  15645 	}
  15646 	*v = sv
  15647 	return nil
  15648 }
  15649 func awsRestxml_deserializeDocumentDimension(v **types.Dimension, decoder smithyxml.NodeDecoder) error {
  15650 	if v == nil {
  15651 		return fmt.Errorf("unexpected nil of type %T", v)
  15652 	}
  15653 	var sv *types.Dimension
  15654 	if *v == nil {
  15655 		sv = &types.Dimension{}
  15656 	} else {
  15657 		sv = *v
  15658 	}
  15659 
  15660 	for {
  15661 		t, done, err := decoder.Token()
  15662 		if err != nil {
  15663 			return err
  15664 		}
  15665 		if done {
  15666 			break
  15667 		}
  15668 		originalDecoder := decoder
  15669 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15670 		switch {
  15671 		case strings.EqualFold("Name", t.Name.Local):
  15672 			val, err := decoder.Value()
  15673 			if err != nil {
  15674 				return err
  15675 			}
  15676 			if val == nil {
  15677 				break
  15678 			}
  15679 			{
  15680 				xtv := string(val)
  15681 				sv.Name = ptr.String(xtv)
  15682 			}
  15683 
  15684 		case strings.EqualFold("Value", t.Name.Local):
  15685 			val, err := decoder.Value()
  15686 			if err != nil {
  15687 				return err
  15688 			}
  15689 			if val == nil {
  15690 				break
  15691 			}
  15692 			{
  15693 				xtv := string(val)
  15694 				sv.Value = ptr.String(xtv)
  15695 			}
  15696 
  15697 		default:
  15698 			// Do nothing and ignore the unexpected tag element
  15699 			err = decoder.Decoder.Skip()
  15700 			if err != nil {
  15701 				return err
  15702 			}
  15703 
  15704 		}
  15705 		decoder = originalDecoder
  15706 	}
  15707 	*v = sv
  15708 	return nil
  15709 }
  15710 
  15711 func awsRestxml_deserializeDocumentDimensionList(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error {
  15712 	if v == nil {
  15713 		return fmt.Errorf("unexpected nil of type %T", v)
  15714 	}
  15715 	var sv []types.Dimension
  15716 	if *v == nil {
  15717 		sv = make([]types.Dimension, 0)
  15718 	} else {
  15719 		sv = *v
  15720 	}
  15721 
  15722 	originalDecoder := decoder
  15723 	for {
  15724 		t, done, err := decoder.Token()
  15725 		if err != nil {
  15726 			return err
  15727 		}
  15728 		if done {
  15729 			break
  15730 		}
  15731 		switch {
  15732 		case strings.EqualFold("Dimension", t.Name.Local):
  15733 			var col types.Dimension
  15734 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15735 			destAddr := &col
  15736 			if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil {
  15737 				return err
  15738 			}
  15739 			col = *destAddr
  15740 			sv = append(sv, col)
  15741 
  15742 		default:
  15743 			err = decoder.Decoder.Skip()
  15744 			if err != nil {
  15745 				return err
  15746 			}
  15747 
  15748 		}
  15749 		decoder = originalDecoder
  15750 	}
  15751 	*v = sv
  15752 	return nil
  15753 }
  15754 
  15755 func awsRestxml_deserializeDocumentDimensionListUnwrapped(v *[]types.Dimension, decoder smithyxml.NodeDecoder) error {
  15756 	var sv []types.Dimension
  15757 	if *v == nil {
  15758 		sv = make([]types.Dimension, 0)
  15759 	} else {
  15760 		sv = *v
  15761 	}
  15762 
  15763 	switch {
  15764 	default:
  15765 		var mv types.Dimension
  15766 		t := decoder.StartEl
  15767 		_ = t
  15768 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15769 		destAddr := &mv
  15770 		if err := awsRestxml_deserializeDocumentDimension(&destAddr, nodeDecoder); err != nil {
  15771 			return err
  15772 		}
  15773 		mv = *destAddr
  15774 		sv = append(sv, mv)
  15775 	}
  15776 	*v = sv
  15777 	return nil
  15778 }
  15779 func awsRestxml_deserializeDocumentDNSSECNotFound(v **types.DNSSECNotFound, decoder smithyxml.NodeDecoder) error {
  15780 	if v == nil {
  15781 		return fmt.Errorf("unexpected nil of type %T", v)
  15782 	}
  15783 	var sv *types.DNSSECNotFound
  15784 	if *v == nil {
  15785 		sv = &types.DNSSECNotFound{}
  15786 	} else {
  15787 		sv = *v
  15788 	}
  15789 
  15790 	for {
  15791 		t, done, err := decoder.Token()
  15792 		if err != nil {
  15793 			return err
  15794 		}
  15795 		if done {
  15796 			break
  15797 		}
  15798 		originalDecoder := decoder
  15799 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15800 		switch {
  15801 		case strings.EqualFold("message", t.Name.Local):
  15802 			val, err := decoder.Value()
  15803 			if err != nil {
  15804 				return err
  15805 			}
  15806 			if val == nil {
  15807 				break
  15808 			}
  15809 			{
  15810 				xtv := string(val)
  15811 				sv.Message = ptr.String(xtv)
  15812 			}
  15813 
  15814 		default:
  15815 			// Do nothing and ignore the unexpected tag element
  15816 			err = decoder.Decoder.Skip()
  15817 			if err != nil {
  15818 				return err
  15819 			}
  15820 
  15821 		}
  15822 		decoder = originalDecoder
  15823 	}
  15824 	*v = sv
  15825 	return nil
  15826 }
  15827 
  15828 func awsRestxml_deserializeDocumentDNSSECStatus(v **types.DNSSECStatus, decoder smithyxml.NodeDecoder) error {
  15829 	if v == nil {
  15830 		return fmt.Errorf("unexpected nil of type %T", v)
  15831 	}
  15832 	var sv *types.DNSSECStatus
  15833 	if *v == nil {
  15834 		sv = &types.DNSSECStatus{}
  15835 	} else {
  15836 		sv = *v
  15837 	}
  15838 
  15839 	for {
  15840 		t, done, err := decoder.Token()
  15841 		if err != nil {
  15842 			return err
  15843 		}
  15844 		if done {
  15845 			break
  15846 		}
  15847 		originalDecoder := decoder
  15848 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15849 		switch {
  15850 		case strings.EqualFold("ServeSignature", t.Name.Local):
  15851 			val, err := decoder.Value()
  15852 			if err != nil {
  15853 				return err
  15854 			}
  15855 			if val == nil {
  15856 				break
  15857 			}
  15858 			{
  15859 				xtv := string(val)
  15860 				sv.ServeSignature = ptr.String(xtv)
  15861 			}
  15862 
  15863 		case strings.EqualFold("StatusMessage", t.Name.Local):
  15864 			val, err := decoder.Value()
  15865 			if err != nil {
  15866 				return err
  15867 			}
  15868 			if val == nil {
  15869 				break
  15870 			}
  15871 			{
  15872 				xtv := string(val)
  15873 				sv.StatusMessage = ptr.String(xtv)
  15874 			}
  15875 
  15876 		default:
  15877 			// Do nothing and ignore the unexpected tag element
  15878 			err = decoder.Decoder.Skip()
  15879 			if err != nil {
  15880 				return err
  15881 			}
  15882 
  15883 		}
  15884 		decoder = originalDecoder
  15885 	}
  15886 	*v = sv
  15887 	return nil
  15888 }
  15889 
  15890 func awsRestxml_deserializeDocumentErrorMessages(v *[]string, decoder smithyxml.NodeDecoder) error {
  15891 	if v == nil {
  15892 		return fmt.Errorf("unexpected nil of type %T", v)
  15893 	}
  15894 	var sv []string
  15895 	if *v == nil {
  15896 		sv = make([]string, 0)
  15897 	} else {
  15898 		sv = *v
  15899 	}
  15900 
  15901 	originalDecoder := decoder
  15902 	for {
  15903 		t, done, err := decoder.Token()
  15904 		if err != nil {
  15905 			return err
  15906 		}
  15907 		if done {
  15908 			break
  15909 		}
  15910 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  15911 		decoder = memberDecoder
  15912 		switch {
  15913 		case strings.EqualFold("Message", t.Name.Local):
  15914 			var col string
  15915 			val, err := decoder.Value()
  15916 			if err != nil {
  15917 				return err
  15918 			}
  15919 			if val == nil {
  15920 				break
  15921 			}
  15922 			{
  15923 				xtv := string(val)
  15924 				col = xtv
  15925 			}
  15926 			sv = append(sv, col)
  15927 
  15928 		default:
  15929 			err = decoder.Decoder.Skip()
  15930 			if err != nil {
  15931 				return err
  15932 			}
  15933 
  15934 		}
  15935 		decoder = originalDecoder
  15936 	}
  15937 	*v = sv
  15938 	return nil
  15939 }
  15940 
  15941 func awsRestxml_deserializeDocumentErrorMessagesUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  15942 	var sv []string
  15943 	if *v == nil {
  15944 		sv = make([]string, 0)
  15945 	} else {
  15946 		sv = *v
  15947 	}
  15948 
  15949 	switch {
  15950 	default:
  15951 		var mv string
  15952 		t := decoder.StartEl
  15953 		_ = t
  15954 		val, err := decoder.Value()
  15955 		if err != nil {
  15956 			return err
  15957 		}
  15958 		if val == nil {
  15959 			break
  15960 		}
  15961 		{
  15962 			xtv := string(val)
  15963 			mv = xtv
  15964 		}
  15965 		sv = append(sv, mv)
  15966 	}
  15967 	*v = sv
  15968 	return nil
  15969 }
  15970 func awsRestxml_deserializeDocumentGeoLocation(v **types.GeoLocation, decoder smithyxml.NodeDecoder) error {
  15971 	if v == nil {
  15972 		return fmt.Errorf("unexpected nil of type %T", v)
  15973 	}
  15974 	var sv *types.GeoLocation
  15975 	if *v == nil {
  15976 		sv = &types.GeoLocation{}
  15977 	} else {
  15978 		sv = *v
  15979 	}
  15980 
  15981 	for {
  15982 		t, done, err := decoder.Token()
  15983 		if err != nil {
  15984 			return err
  15985 		}
  15986 		if done {
  15987 			break
  15988 		}
  15989 		originalDecoder := decoder
  15990 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  15991 		switch {
  15992 		case strings.EqualFold("ContinentCode", t.Name.Local):
  15993 			val, err := decoder.Value()
  15994 			if err != nil {
  15995 				return err
  15996 			}
  15997 			if val == nil {
  15998 				break
  15999 			}
  16000 			{
  16001 				xtv := string(val)
  16002 				sv.ContinentCode = ptr.String(xtv)
  16003 			}
  16004 
  16005 		case strings.EqualFold("CountryCode", t.Name.Local):
  16006 			val, err := decoder.Value()
  16007 			if err != nil {
  16008 				return err
  16009 			}
  16010 			if val == nil {
  16011 				break
  16012 			}
  16013 			{
  16014 				xtv := string(val)
  16015 				sv.CountryCode = ptr.String(xtv)
  16016 			}
  16017 
  16018 		case strings.EqualFold("SubdivisionCode", t.Name.Local):
  16019 			val, err := decoder.Value()
  16020 			if err != nil {
  16021 				return err
  16022 			}
  16023 			if val == nil {
  16024 				break
  16025 			}
  16026 			{
  16027 				xtv := string(val)
  16028 				sv.SubdivisionCode = ptr.String(xtv)
  16029 			}
  16030 
  16031 		default:
  16032 			// Do nothing and ignore the unexpected tag element
  16033 			err = decoder.Decoder.Skip()
  16034 			if err != nil {
  16035 				return err
  16036 			}
  16037 
  16038 		}
  16039 		decoder = originalDecoder
  16040 	}
  16041 	*v = sv
  16042 	return nil
  16043 }
  16044 
  16045 func awsRestxml_deserializeDocumentGeoLocationDetails(v **types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
  16046 	if v == nil {
  16047 		return fmt.Errorf("unexpected nil of type %T", v)
  16048 	}
  16049 	var sv *types.GeoLocationDetails
  16050 	if *v == nil {
  16051 		sv = &types.GeoLocationDetails{}
  16052 	} else {
  16053 		sv = *v
  16054 	}
  16055 
  16056 	for {
  16057 		t, done, err := decoder.Token()
  16058 		if err != nil {
  16059 			return err
  16060 		}
  16061 		if done {
  16062 			break
  16063 		}
  16064 		originalDecoder := decoder
  16065 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16066 		switch {
  16067 		case strings.EqualFold("ContinentCode", t.Name.Local):
  16068 			val, err := decoder.Value()
  16069 			if err != nil {
  16070 				return err
  16071 			}
  16072 			if val == nil {
  16073 				break
  16074 			}
  16075 			{
  16076 				xtv := string(val)
  16077 				sv.ContinentCode = ptr.String(xtv)
  16078 			}
  16079 
  16080 		case strings.EqualFold("ContinentName", t.Name.Local):
  16081 			val, err := decoder.Value()
  16082 			if err != nil {
  16083 				return err
  16084 			}
  16085 			if val == nil {
  16086 				break
  16087 			}
  16088 			{
  16089 				xtv := string(val)
  16090 				sv.ContinentName = ptr.String(xtv)
  16091 			}
  16092 
  16093 		case strings.EqualFold("CountryCode", t.Name.Local):
  16094 			val, err := decoder.Value()
  16095 			if err != nil {
  16096 				return err
  16097 			}
  16098 			if val == nil {
  16099 				break
  16100 			}
  16101 			{
  16102 				xtv := string(val)
  16103 				sv.CountryCode = ptr.String(xtv)
  16104 			}
  16105 
  16106 		case strings.EqualFold("CountryName", t.Name.Local):
  16107 			val, err := decoder.Value()
  16108 			if err != nil {
  16109 				return err
  16110 			}
  16111 			if val == nil {
  16112 				break
  16113 			}
  16114 			{
  16115 				xtv := string(val)
  16116 				sv.CountryName = ptr.String(xtv)
  16117 			}
  16118 
  16119 		case strings.EqualFold("SubdivisionCode", t.Name.Local):
  16120 			val, err := decoder.Value()
  16121 			if err != nil {
  16122 				return err
  16123 			}
  16124 			if val == nil {
  16125 				break
  16126 			}
  16127 			{
  16128 				xtv := string(val)
  16129 				sv.SubdivisionCode = ptr.String(xtv)
  16130 			}
  16131 
  16132 		case strings.EqualFold("SubdivisionName", t.Name.Local):
  16133 			val, err := decoder.Value()
  16134 			if err != nil {
  16135 				return err
  16136 			}
  16137 			if val == nil {
  16138 				break
  16139 			}
  16140 			{
  16141 				xtv := string(val)
  16142 				sv.SubdivisionName = ptr.String(xtv)
  16143 			}
  16144 
  16145 		default:
  16146 			// Do nothing and ignore the unexpected tag element
  16147 			err = decoder.Decoder.Skip()
  16148 			if err != nil {
  16149 				return err
  16150 			}
  16151 
  16152 		}
  16153 		decoder = originalDecoder
  16154 	}
  16155 	*v = sv
  16156 	return nil
  16157 }
  16158 
  16159 func awsRestxml_deserializeDocumentGeoLocationDetailsList(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
  16160 	if v == nil {
  16161 		return fmt.Errorf("unexpected nil of type %T", v)
  16162 	}
  16163 	var sv []types.GeoLocationDetails
  16164 	if *v == nil {
  16165 		sv = make([]types.GeoLocationDetails, 0)
  16166 	} else {
  16167 		sv = *v
  16168 	}
  16169 
  16170 	originalDecoder := decoder
  16171 	for {
  16172 		t, done, err := decoder.Token()
  16173 		if err != nil {
  16174 			return err
  16175 		}
  16176 		if done {
  16177 			break
  16178 		}
  16179 		switch {
  16180 		case strings.EqualFold("GeoLocationDetails", t.Name.Local):
  16181 			var col types.GeoLocationDetails
  16182 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16183 			destAddr := &col
  16184 			if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil {
  16185 				return err
  16186 			}
  16187 			col = *destAddr
  16188 			sv = append(sv, col)
  16189 
  16190 		default:
  16191 			err = decoder.Decoder.Skip()
  16192 			if err != nil {
  16193 				return err
  16194 			}
  16195 
  16196 		}
  16197 		decoder = originalDecoder
  16198 	}
  16199 	*v = sv
  16200 	return nil
  16201 }
  16202 
  16203 func awsRestxml_deserializeDocumentGeoLocationDetailsListUnwrapped(v *[]types.GeoLocationDetails, decoder smithyxml.NodeDecoder) error {
  16204 	var sv []types.GeoLocationDetails
  16205 	if *v == nil {
  16206 		sv = make([]types.GeoLocationDetails, 0)
  16207 	} else {
  16208 		sv = *v
  16209 	}
  16210 
  16211 	switch {
  16212 	default:
  16213 		var mv types.GeoLocationDetails
  16214 		t := decoder.StartEl
  16215 		_ = t
  16216 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16217 		destAddr := &mv
  16218 		if err := awsRestxml_deserializeDocumentGeoLocationDetails(&destAddr, nodeDecoder); err != nil {
  16219 			return err
  16220 		}
  16221 		mv = *destAddr
  16222 		sv = append(sv, mv)
  16223 	}
  16224 	*v = sv
  16225 	return nil
  16226 }
  16227 func awsRestxml_deserializeDocumentHealthCheck(v **types.HealthCheck, decoder smithyxml.NodeDecoder) error {
  16228 	if v == nil {
  16229 		return fmt.Errorf("unexpected nil of type %T", v)
  16230 	}
  16231 	var sv *types.HealthCheck
  16232 	if *v == nil {
  16233 		sv = &types.HealthCheck{}
  16234 	} else {
  16235 		sv = *v
  16236 	}
  16237 
  16238 	for {
  16239 		t, done, err := decoder.Token()
  16240 		if err != nil {
  16241 			return err
  16242 		}
  16243 		if done {
  16244 			break
  16245 		}
  16246 		originalDecoder := decoder
  16247 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16248 		switch {
  16249 		case strings.EqualFold("CallerReference", t.Name.Local):
  16250 			val, err := decoder.Value()
  16251 			if err != nil {
  16252 				return err
  16253 			}
  16254 			if val == nil {
  16255 				break
  16256 			}
  16257 			{
  16258 				xtv := string(val)
  16259 				sv.CallerReference = ptr.String(xtv)
  16260 			}
  16261 
  16262 		case strings.EqualFold("CloudWatchAlarmConfiguration", t.Name.Local):
  16263 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16264 			if err := awsRestxml_deserializeDocumentCloudWatchAlarmConfiguration(&sv.CloudWatchAlarmConfiguration, nodeDecoder); err != nil {
  16265 				return err
  16266 			}
  16267 
  16268 		case strings.EqualFold("HealthCheckConfig", t.Name.Local):
  16269 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16270 			if err := awsRestxml_deserializeDocumentHealthCheckConfig(&sv.HealthCheckConfig, nodeDecoder); err != nil {
  16271 				return err
  16272 			}
  16273 
  16274 		case strings.EqualFold("HealthCheckVersion", t.Name.Local):
  16275 			val, err := decoder.Value()
  16276 			if err != nil {
  16277 				return err
  16278 			}
  16279 			if val == nil {
  16280 				break
  16281 			}
  16282 			{
  16283 				xtv := string(val)
  16284 				i64, err := strconv.ParseInt(xtv, 10, 64)
  16285 				if err != nil {
  16286 					return err
  16287 				}
  16288 				sv.HealthCheckVersion = ptr.Int64(i64)
  16289 			}
  16290 
  16291 		case strings.EqualFold("Id", t.Name.Local):
  16292 			val, err := decoder.Value()
  16293 			if err != nil {
  16294 				return err
  16295 			}
  16296 			if val == nil {
  16297 				break
  16298 			}
  16299 			{
  16300 				xtv := string(val)
  16301 				sv.Id = ptr.String(xtv)
  16302 			}
  16303 
  16304 		case strings.EqualFold("LinkedService", t.Name.Local):
  16305 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16306 			if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil {
  16307 				return err
  16308 			}
  16309 
  16310 		default:
  16311 			// Do nothing and ignore the unexpected tag element
  16312 			err = decoder.Decoder.Skip()
  16313 			if err != nil {
  16314 				return err
  16315 			}
  16316 
  16317 		}
  16318 		decoder = originalDecoder
  16319 	}
  16320 	*v = sv
  16321 	return nil
  16322 }
  16323 
  16324 func awsRestxml_deserializeDocumentHealthCheckAlreadyExists(v **types.HealthCheckAlreadyExists, decoder smithyxml.NodeDecoder) error {
  16325 	if v == nil {
  16326 		return fmt.Errorf("unexpected nil of type %T", v)
  16327 	}
  16328 	var sv *types.HealthCheckAlreadyExists
  16329 	if *v == nil {
  16330 		sv = &types.HealthCheckAlreadyExists{}
  16331 	} else {
  16332 		sv = *v
  16333 	}
  16334 
  16335 	for {
  16336 		t, done, err := decoder.Token()
  16337 		if err != nil {
  16338 			return err
  16339 		}
  16340 		if done {
  16341 			break
  16342 		}
  16343 		originalDecoder := decoder
  16344 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16345 		switch {
  16346 		case strings.EqualFold("message", t.Name.Local):
  16347 			val, err := decoder.Value()
  16348 			if err != nil {
  16349 				return err
  16350 			}
  16351 			if val == nil {
  16352 				break
  16353 			}
  16354 			{
  16355 				xtv := string(val)
  16356 				sv.Message = ptr.String(xtv)
  16357 			}
  16358 
  16359 		default:
  16360 			// Do nothing and ignore the unexpected tag element
  16361 			err = decoder.Decoder.Skip()
  16362 			if err != nil {
  16363 				return err
  16364 			}
  16365 
  16366 		}
  16367 		decoder = originalDecoder
  16368 	}
  16369 	*v = sv
  16370 	return nil
  16371 }
  16372 
  16373 func awsRestxml_deserializeDocumentHealthCheckConfig(v **types.HealthCheckConfig, decoder smithyxml.NodeDecoder) error {
  16374 	if v == nil {
  16375 		return fmt.Errorf("unexpected nil of type %T", v)
  16376 	}
  16377 	var sv *types.HealthCheckConfig
  16378 	if *v == nil {
  16379 		sv = &types.HealthCheckConfig{}
  16380 	} else {
  16381 		sv = *v
  16382 	}
  16383 
  16384 	for {
  16385 		t, done, err := decoder.Token()
  16386 		if err != nil {
  16387 			return err
  16388 		}
  16389 		if done {
  16390 			break
  16391 		}
  16392 		originalDecoder := decoder
  16393 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16394 		switch {
  16395 		case strings.EqualFold("AlarmIdentifier", t.Name.Local):
  16396 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16397 			if err := awsRestxml_deserializeDocumentAlarmIdentifier(&sv.AlarmIdentifier, nodeDecoder); err != nil {
  16398 				return err
  16399 			}
  16400 
  16401 		case strings.EqualFold("ChildHealthChecks", t.Name.Local):
  16402 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16403 			if err := awsRestxml_deserializeDocumentChildHealthCheckList(&sv.ChildHealthChecks, nodeDecoder); err != nil {
  16404 				return err
  16405 			}
  16406 
  16407 		case strings.EqualFold("Disabled", t.Name.Local):
  16408 			val, err := decoder.Value()
  16409 			if err != nil {
  16410 				return err
  16411 			}
  16412 			if val == nil {
  16413 				break
  16414 			}
  16415 			{
  16416 				xtv, err := strconv.ParseBool(string(val))
  16417 				if err != nil {
  16418 					return fmt.Errorf("expected Disabled to be of type *bool, got %T instead", val)
  16419 				}
  16420 				sv.Disabled = ptr.Bool(xtv)
  16421 			}
  16422 
  16423 		case strings.EqualFold("EnableSNI", t.Name.Local):
  16424 			val, err := decoder.Value()
  16425 			if err != nil {
  16426 				return err
  16427 			}
  16428 			if val == nil {
  16429 				break
  16430 			}
  16431 			{
  16432 				xtv, err := strconv.ParseBool(string(val))
  16433 				if err != nil {
  16434 					return fmt.Errorf("expected EnableSNI to be of type *bool, got %T instead", val)
  16435 				}
  16436 				sv.EnableSNI = ptr.Bool(xtv)
  16437 			}
  16438 
  16439 		case strings.EqualFold("FailureThreshold", t.Name.Local):
  16440 			val, err := decoder.Value()
  16441 			if err != nil {
  16442 				return err
  16443 			}
  16444 			if val == nil {
  16445 				break
  16446 			}
  16447 			{
  16448 				xtv := string(val)
  16449 				i64, err := strconv.ParseInt(xtv, 10, 64)
  16450 				if err != nil {
  16451 					return err
  16452 				}
  16453 				sv.FailureThreshold = ptr.Int32(int32(i64))
  16454 			}
  16455 
  16456 		case strings.EqualFold("FullyQualifiedDomainName", t.Name.Local):
  16457 			val, err := decoder.Value()
  16458 			if err != nil {
  16459 				return err
  16460 			}
  16461 			if val == nil {
  16462 				break
  16463 			}
  16464 			{
  16465 				xtv := string(val)
  16466 				sv.FullyQualifiedDomainName = ptr.String(xtv)
  16467 			}
  16468 
  16469 		case strings.EqualFold("HealthThreshold", t.Name.Local):
  16470 			val, err := decoder.Value()
  16471 			if err != nil {
  16472 				return err
  16473 			}
  16474 			if val == nil {
  16475 				break
  16476 			}
  16477 			{
  16478 				xtv := string(val)
  16479 				i64, err := strconv.ParseInt(xtv, 10, 64)
  16480 				if err != nil {
  16481 					return err
  16482 				}
  16483 				sv.HealthThreshold = ptr.Int32(int32(i64))
  16484 			}
  16485 
  16486 		case strings.EqualFold("InsufficientDataHealthStatus", t.Name.Local):
  16487 			val, err := decoder.Value()
  16488 			if err != nil {
  16489 				return err
  16490 			}
  16491 			if val == nil {
  16492 				break
  16493 			}
  16494 			{
  16495 				xtv := string(val)
  16496 				sv.InsufficientDataHealthStatus = types.InsufficientDataHealthStatus(xtv)
  16497 			}
  16498 
  16499 		case strings.EqualFold("Inverted", t.Name.Local):
  16500 			val, err := decoder.Value()
  16501 			if err != nil {
  16502 				return err
  16503 			}
  16504 			if val == nil {
  16505 				break
  16506 			}
  16507 			{
  16508 				xtv, err := strconv.ParseBool(string(val))
  16509 				if err != nil {
  16510 					return fmt.Errorf("expected Inverted to be of type *bool, got %T instead", val)
  16511 				}
  16512 				sv.Inverted = ptr.Bool(xtv)
  16513 			}
  16514 
  16515 		case strings.EqualFold("IPAddress", t.Name.Local):
  16516 			val, err := decoder.Value()
  16517 			if err != nil {
  16518 				return err
  16519 			}
  16520 			if val == nil {
  16521 				break
  16522 			}
  16523 			{
  16524 				xtv := string(val)
  16525 				sv.IPAddress = ptr.String(xtv)
  16526 			}
  16527 
  16528 		case strings.EqualFold("MeasureLatency", t.Name.Local):
  16529 			val, err := decoder.Value()
  16530 			if err != nil {
  16531 				return err
  16532 			}
  16533 			if val == nil {
  16534 				break
  16535 			}
  16536 			{
  16537 				xtv, err := strconv.ParseBool(string(val))
  16538 				if err != nil {
  16539 					return fmt.Errorf("expected MeasureLatency to be of type *bool, got %T instead", val)
  16540 				}
  16541 				sv.MeasureLatency = ptr.Bool(xtv)
  16542 			}
  16543 
  16544 		case strings.EqualFold("Port", t.Name.Local):
  16545 			val, err := decoder.Value()
  16546 			if err != nil {
  16547 				return err
  16548 			}
  16549 			if val == nil {
  16550 				break
  16551 			}
  16552 			{
  16553 				xtv := string(val)
  16554 				i64, err := strconv.ParseInt(xtv, 10, 64)
  16555 				if err != nil {
  16556 					return err
  16557 				}
  16558 				sv.Port = ptr.Int32(int32(i64))
  16559 			}
  16560 
  16561 		case strings.EqualFold("Regions", t.Name.Local):
  16562 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16563 			if err := awsRestxml_deserializeDocumentHealthCheckRegionList(&sv.Regions, nodeDecoder); err != nil {
  16564 				return err
  16565 			}
  16566 
  16567 		case strings.EqualFold("RequestInterval", t.Name.Local):
  16568 			val, err := decoder.Value()
  16569 			if err != nil {
  16570 				return err
  16571 			}
  16572 			if val == nil {
  16573 				break
  16574 			}
  16575 			{
  16576 				xtv := string(val)
  16577 				i64, err := strconv.ParseInt(xtv, 10, 64)
  16578 				if err != nil {
  16579 					return err
  16580 				}
  16581 				sv.RequestInterval = ptr.Int32(int32(i64))
  16582 			}
  16583 
  16584 		case strings.EqualFold("ResourcePath", t.Name.Local):
  16585 			val, err := decoder.Value()
  16586 			if err != nil {
  16587 				return err
  16588 			}
  16589 			if val == nil {
  16590 				break
  16591 			}
  16592 			{
  16593 				xtv := string(val)
  16594 				sv.ResourcePath = ptr.String(xtv)
  16595 			}
  16596 
  16597 		case strings.EqualFold("RoutingControlArn", t.Name.Local):
  16598 			val, err := decoder.Value()
  16599 			if err != nil {
  16600 				return err
  16601 			}
  16602 			if val == nil {
  16603 				break
  16604 			}
  16605 			{
  16606 				xtv := string(val)
  16607 				sv.RoutingControlArn = ptr.String(xtv)
  16608 			}
  16609 
  16610 		case strings.EqualFold("SearchString", t.Name.Local):
  16611 			val, err := decoder.Value()
  16612 			if err != nil {
  16613 				return err
  16614 			}
  16615 			if val == nil {
  16616 				break
  16617 			}
  16618 			{
  16619 				xtv := string(val)
  16620 				sv.SearchString = ptr.String(xtv)
  16621 			}
  16622 
  16623 		case strings.EqualFold("Type", t.Name.Local):
  16624 			val, err := decoder.Value()
  16625 			if err != nil {
  16626 				return err
  16627 			}
  16628 			if val == nil {
  16629 				break
  16630 			}
  16631 			{
  16632 				xtv := string(val)
  16633 				sv.Type = types.HealthCheckType(xtv)
  16634 			}
  16635 
  16636 		default:
  16637 			// Do nothing and ignore the unexpected tag element
  16638 			err = decoder.Decoder.Skip()
  16639 			if err != nil {
  16640 				return err
  16641 			}
  16642 
  16643 		}
  16644 		decoder = originalDecoder
  16645 	}
  16646 	*v = sv
  16647 	return nil
  16648 }
  16649 
  16650 func awsRestxml_deserializeDocumentHealthCheckInUse(v **types.HealthCheckInUse, decoder smithyxml.NodeDecoder) error {
  16651 	if v == nil {
  16652 		return fmt.Errorf("unexpected nil of type %T", v)
  16653 	}
  16654 	var sv *types.HealthCheckInUse
  16655 	if *v == nil {
  16656 		sv = &types.HealthCheckInUse{}
  16657 	} else {
  16658 		sv = *v
  16659 	}
  16660 
  16661 	for {
  16662 		t, done, err := decoder.Token()
  16663 		if err != nil {
  16664 			return err
  16665 		}
  16666 		if done {
  16667 			break
  16668 		}
  16669 		originalDecoder := decoder
  16670 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16671 		switch {
  16672 		case strings.EqualFold("message", t.Name.Local):
  16673 			val, err := decoder.Value()
  16674 			if err != nil {
  16675 				return err
  16676 			}
  16677 			if val == nil {
  16678 				break
  16679 			}
  16680 			{
  16681 				xtv := string(val)
  16682 				sv.Message = ptr.String(xtv)
  16683 			}
  16684 
  16685 		default:
  16686 			// Do nothing and ignore the unexpected tag element
  16687 			err = decoder.Decoder.Skip()
  16688 			if err != nil {
  16689 				return err
  16690 			}
  16691 
  16692 		}
  16693 		decoder = originalDecoder
  16694 	}
  16695 	*v = sv
  16696 	return nil
  16697 }
  16698 
  16699 func awsRestxml_deserializeDocumentHealthCheckObservation(v **types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
  16700 	if v == nil {
  16701 		return fmt.Errorf("unexpected nil of type %T", v)
  16702 	}
  16703 	var sv *types.HealthCheckObservation
  16704 	if *v == nil {
  16705 		sv = &types.HealthCheckObservation{}
  16706 	} else {
  16707 		sv = *v
  16708 	}
  16709 
  16710 	for {
  16711 		t, done, err := decoder.Token()
  16712 		if err != nil {
  16713 			return err
  16714 		}
  16715 		if done {
  16716 			break
  16717 		}
  16718 		originalDecoder := decoder
  16719 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  16720 		switch {
  16721 		case strings.EqualFold("IPAddress", t.Name.Local):
  16722 			val, err := decoder.Value()
  16723 			if err != nil {
  16724 				return err
  16725 			}
  16726 			if val == nil {
  16727 				break
  16728 			}
  16729 			{
  16730 				xtv := string(val)
  16731 				sv.IPAddress = ptr.String(xtv)
  16732 			}
  16733 
  16734 		case strings.EqualFold("Region", t.Name.Local):
  16735 			val, err := decoder.Value()
  16736 			if err != nil {
  16737 				return err
  16738 			}
  16739 			if val == nil {
  16740 				break
  16741 			}
  16742 			{
  16743 				xtv := string(val)
  16744 				sv.Region = types.HealthCheckRegion(xtv)
  16745 			}
  16746 
  16747 		case strings.EqualFold("StatusReport", t.Name.Local):
  16748 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16749 			if err := awsRestxml_deserializeDocumentStatusReport(&sv.StatusReport, nodeDecoder); err != nil {
  16750 				return err
  16751 			}
  16752 
  16753 		default:
  16754 			// Do nothing and ignore the unexpected tag element
  16755 			err = decoder.Decoder.Skip()
  16756 			if err != nil {
  16757 				return err
  16758 			}
  16759 
  16760 		}
  16761 		decoder = originalDecoder
  16762 	}
  16763 	*v = sv
  16764 	return nil
  16765 }
  16766 
  16767 func awsRestxml_deserializeDocumentHealthCheckObservations(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
  16768 	if v == nil {
  16769 		return fmt.Errorf("unexpected nil of type %T", v)
  16770 	}
  16771 	var sv []types.HealthCheckObservation
  16772 	if *v == nil {
  16773 		sv = make([]types.HealthCheckObservation, 0)
  16774 	} else {
  16775 		sv = *v
  16776 	}
  16777 
  16778 	originalDecoder := decoder
  16779 	for {
  16780 		t, done, err := decoder.Token()
  16781 		if err != nil {
  16782 			return err
  16783 		}
  16784 		if done {
  16785 			break
  16786 		}
  16787 		switch {
  16788 		case strings.EqualFold("HealthCheckObservation", t.Name.Local):
  16789 			var col types.HealthCheckObservation
  16790 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16791 			destAddr := &col
  16792 			if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil {
  16793 				return err
  16794 			}
  16795 			col = *destAddr
  16796 			sv = append(sv, col)
  16797 
  16798 		default:
  16799 			err = decoder.Decoder.Skip()
  16800 			if err != nil {
  16801 				return err
  16802 			}
  16803 
  16804 		}
  16805 		decoder = originalDecoder
  16806 	}
  16807 	*v = sv
  16808 	return nil
  16809 }
  16810 
  16811 func awsRestxml_deserializeDocumentHealthCheckObservationsUnwrapped(v *[]types.HealthCheckObservation, decoder smithyxml.NodeDecoder) error {
  16812 	var sv []types.HealthCheckObservation
  16813 	if *v == nil {
  16814 		sv = make([]types.HealthCheckObservation, 0)
  16815 	} else {
  16816 		sv = *v
  16817 	}
  16818 
  16819 	switch {
  16820 	default:
  16821 		var mv types.HealthCheckObservation
  16822 		t := decoder.StartEl
  16823 		_ = t
  16824 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16825 		destAddr := &mv
  16826 		if err := awsRestxml_deserializeDocumentHealthCheckObservation(&destAddr, nodeDecoder); err != nil {
  16827 			return err
  16828 		}
  16829 		mv = *destAddr
  16830 		sv = append(sv, mv)
  16831 	}
  16832 	*v = sv
  16833 	return nil
  16834 }
  16835 func awsRestxml_deserializeDocumentHealthCheckRegionList(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error {
  16836 	if v == nil {
  16837 		return fmt.Errorf("unexpected nil of type %T", v)
  16838 	}
  16839 	var sv []types.HealthCheckRegion
  16840 	if *v == nil {
  16841 		sv = make([]types.HealthCheckRegion, 0)
  16842 	} else {
  16843 		sv = *v
  16844 	}
  16845 
  16846 	originalDecoder := decoder
  16847 	for {
  16848 		t, done, err := decoder.Token()
  16849 		if err != nil {
  16850 			return err
  16851 		}
  16852 		if done {
  16853 			break
  16854 		}
  16855 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16856 		decoder = memberDecoder
  16857 		switch {
  16858 		case strings.EqualFold("Region", t.Name.Local):
  16859 			var col types.HealthCheckRegion
  16860 			val, err := decoder.Value()
  16861 			if err != nil {
  16862 				return err
  16863 			}
  16864 			if val == nil {
  16865 				break
  16866 			}
  16867 			{
  16868 				xtv := string(val)
  16869 				col = types.HealthCheckRegion(xtv)
  16870 			}
  16871 			sv = append(sv, col)
  16872 
  16873 		default:
  16874 			err = decoder.Decoder.Skip()
  16875 			if err != nil {
  16876 				return err
  16877 			}
  16878 
  16879 		}
  16880 		decoder = originalDecoder
  16881 	}
  16882 	*v = sv
  16883 	return nil
  16884 }
  16885 
  16886 func awsRestxml_deserializeDocumentHealthCheckRegionListUnwrapped(v *[]types.HealthCheckRegion, decoder smithyxml.NodeDecoder) error {
  16887 	var sv []types.HealthCheckRegion
  16888 	if *v == nil {
  16889 		sv = make([]types.HealthCheckRegion, 0)
  16890 	} else {
  16891 		sv = *v
  16892 	}
  16893 
  16894 	switch {
  16895 	default:
  16896 		var mv types.HealthCheckRegion
  16897 		t := decoder.StartEl
  16898 		_ = t
  16899 		val, err := decoder.Value()
  16900 		if err != nil {
  16901 			return err
  16902 		}
  16903 		if val == nil {
  16904 			break
  16905 		}
  16906 		{
  16907 			xtv := string(val)
  16908 			mv = types.HealthCheckRegion(xtv)
  16909 		}
  16910 		sv = append(sv, mv)
  16911 	}
  16912 	*v = sv
  16913 	return nil
  16914 }
  16915 func awsRestxml_deserializeDocumentHealthChecks(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error {
  16916 	if v == nil {
  16917 		return fmt.Errorf("unexpected nil of type %T", v)
  16918 	}
  16919 	var sv []types.HealthCheck
  16920 	if *v == nil {
  16921 		sv = make([]types.HealthCheck, 0)
  16922 	} else {
  16923 		sv = *v
  16924 	}
  16925 
  16926 	originalDecoder := decoder
  16927 	for {
  16928 		t, done, err := decoder.Token()
  16929 		if err != nil {
  16930 			return err
  16931 		}
  16932 		if done {
  16933 			break
  16934 		}
  16935 		switch {
  16936 		case strings.EqualFold("HealthCheck", t.Name.Local):
  16937 			var col types.HealthCheck
  16938 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16939 			destAddr := &col
  16940 			if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil {
  16941 				return err
  16942 			}
  16943 			col = *destAddr
  16944 			sv = append(sv, col)
  16945 
  16946 		default:
  16947 			err = decoder.Decoder.Skip()
  16948 			if err != nil {
  16949 				return err
  16950 			}
  16951 
  16952 		}
  16953 		decoder = originalDecoder
  16954 	}
  16955 	*v = sv
  16956 	return nil
  16957 }
  16958 
  16959 func awsRestxml_deserializeDocumentHealthChecksUnwrapped(v *[]types.HealthCheck, decoder smithyxml.NodeDecoder) error {
  16960 	var sv []types.HealthCheck
  16961 	if *v == nil {
  16962 		sv = make([]types.HealthCheck, 0)
  16963 	} else {
  16964 		sv = *v
  16965 	}
  16966 
  16967 	switch {
  16968 	default:
  16969 		var mv types.HealthCheck
  16970 		t := decoder.StartEl
  16971 		_ = t
  16972 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  16973 		destAddr := &mv
  16974 		if err := awsRestxml_deserializeDocumentHealthCheck(&destAddr, nodeDecoder); err != nil {
  16975 			return err
  16976 		}
  16977 		mv = *destAddr
  16978 		sv = append(sv, mv)
  16979 	}
  16980 	*v = sv
  16981 	return nil
  16982 }
  16983 func awsRestxml_deserializeDocumentHealthCheckVersionMismatch(v **types.HealthCheckVersionMismatch, decoder smithyxml.NodeDecoder) error {
  16984 	if v == nil {
  16985 		return fmt.Errorf("unexpected nil of type %T", v)
  16986 	}
  16987 	var sv *types.HealthCheckVersionMismatch
  16988 	if *v == nil {
  16989 		sv = &types.HealthCheckVersionMismatch{}
  16990 	} else {
  16991 		sv = *v
  16992 	}
  16993 
  16994 	for {
  16995 		t, done, err := decoder.Token()
  16996 		if err != nil {
  16997 			return err
  16998 		}
  16999 		if done {
  17000 			break
  17001 		}
  17002 		originalDecoder := decoder
  17003 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17004 		switch {
  17005 		case strings.EqualFold("message", t.Name.Local):
  17006 			val, err := decoder.Value()
  17007 			if err != nil {
  17008 				return err
  17009 			}
  17010 			if val == nil {
  17011 				break
  17012 			}
  17013 			{
  17014 				xtv := string(val)
  17015 				sv.Message = ptr.String(xtv)
  17016 			}
  17017 
  17018 		default:
  17019 			// Do nothing and ignore the unexpected tag element
  17020 			err = decoder.Decoder.Skip()
  17021 			if err != nil {
  17022 				return err
  17023 			}
  17024 
  17025 		}
  17026 		decoder = originalDecoder
  17027 	}
  17028 	*v = sv
  17029 	return nil
  17030 }
  17031 
  17032 func awsRestxml_deserializeDocumentHostedZone(v **types.HostedZone, decoder smithyxml.NodeDecoder) error {
  17033 	if v == nil {
  17034 		return fmt.Errorf("unexpected nil of type %T", v)
  17035 	}
  17036 	var sv *types.HostedZone
  17037 	if *v == nil {
  17038 		sv = &types.HostedZone{}
  17039 	} else {
  17040 		sv = *v
  17041 	}
  17042 
  17043 	for {
  17044 		t, done, err := decoder.Token()
  17045 		if err != nil {
  17046 			return err
  17047 		}
  17048 		if done {
  17049 			break
  17050 		}
  17051 		originalDecoder := decoder
  17052 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17053 		switch {
  17054 		case strings.EqualFold("CallerReference", t.Name.Local):
  17055 			val, err := decoder.Value()
  17056 			if err != nil {
  17057 				return err
  17058 			}
  17059 			if val == nil {
  17060 				break
  17061 			}
  17062 			{
  17063 				xtv := string(val)
  17064 				sv.CallerReference = ptr.String(xtv)
  17065 			}
  17066 
  17067 		case strings.EqualFold("Config", t.Name.Local):
  17068 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17069 			if err := awsRestxml_deserializeDocumentHostedZoneConfig(&sv.Config, nodeDecoder); err != nil {
  17070 				return err
  17071 			}
  17072 
  17073 		case strings.EqualFold("Id", t.Name.Local):
  17074 			val, err := decoder.Value()
  17075 			if err != nil {
  17076 				return err
  17077 			}
  17078 			if val == nil {
  17079 				break
  17080 			}
  17081 			{
  17082 				xtv := string(val)
  17083 				sv.Id = ptr.String(xtv)
  17084 			}
  17085 
  17086 		case strings.EqualFold("LinkedService", t.Name.Local):
  17087 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17088 			if err := awsRestxml_deserializeDocumentLinkedService(&sv.LinkedService, nodeDecoder); err != nil {
  17089 				return err
  17090 			}
  17091 
  17092 		case strings.EqualFold("Name", t.Name.Local):
  17093 			val, err := decoder.Value()
  17094 			if err != nil {
  17095 				return err
  17096 			}
  17097 			if val == nil {
  17098 				break
  17099 			}
  17100 			{
  17101 				xtv := string(val)
  17102 				sv.Name = ptr.String(xtv)
  17103 			}
  17104 
  17105 		case strings.EqualFold("ResourceRecordSetCount", t.Name.Local):
  17106 			val, err := decoder.Value()
  17107 			if err != nil {
  17108 				return err
  17109 			}
  17110 			if val == nil {
  17111 				break
  17112 			}
  17113 			{
  17114 				xtv := string(val)
  17115 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17116 				if err != nil {
  17117 					return err
  17118 				}
  17119 				sv.ResourceRecordSetCount = ptr.Int64(i64)
  17120 			}
  17121 
  17122 		default:
  17123 			// Do nothing and ignore the unexpected tag element
  17124 			err = decoder.Decoder.Skip()
  17125 			if err != nil {
  17126 				return err
  17127 			}
  17128 
  17129 		}
  17130 		decoder = originalDecoder
  17131 	}
  17132 	*v = sv
  17133 	return nil
  17134 }
  17135 
  17136 func awsRestxml_deserializeDocumentHostedZoneAlreadyExists(v **types.HostedZoneAlreadyExists, decoder smithyxml.NodeDecoder) error {
  17137 	if v == nil {
  17138 		return fmt.Errorf("unexpected nil of type %T", v)
  17139 	}
  17140 	var sv *types.HostedZoneAlreadyExists
  17141 	if *v == nil {
  17142 		sv = &types.HostedZoneAlreadyExists{}
  17143 	} else {
  17144 		sv = *v
  17145 	}
  17146 
  17147 	for {
  17148 		t, done, err := decoder.Token()
  17149 		if err != nil {
  17150 			return err
  17151 		}
  17152 		if done {
  17153 			break
  17154 		}
  17155 		originalDecoder := decoder
  17156 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17157 		switch {
  17158 		case strings.EqualFold("message", t.Name.Local):
  17159 			val, err := decoder.Value()
  17160 			if err != nil {
  17161 				return err
  17162 			}
  17163 			if val == nil {
  17164 				break
  17165 			}
  17166 			{
  17167 				xtv := string(val)
  17168 				sv.Message = ptr.String(xtv)
  17169 			}
  17170 
  17171 		default:
  17172 			// Do nothing and ignore the unexpected tag element
  17173 			err = decoder.Decoder.Skip()
  17174 			if err != nil {
  17175 				return err
  17176 			}
  17177 
  17178 		}
  17179 		decoder = originalDecoder
  17180 	}
  17181 	*v = sv
  17182 	return nil
  17183 }
  17184 
  17185 func awsRestxml_deserializeDocumentHostedZoneConfig(v **types.HostedZoneConfig, decoder smithyxml.NodeDecoder) error {
  17186 	if v == nil {
  17187 		return fmt.Errorf("unexpected nil of type %T", v)
  17188 	}
  17189 	var sv *types.HostedZoneConfig
  17190 	if *v == nil {
  17191 		sv = &types.HostedZoneConfig{}
  17192 	} else {
  17193 		sv = *v
  17194 	}
  17195 
  17196 	for {
  17197 		t, done, err := decoder.Token()
  17198 		if err != nil {
  17199 			return err
  17200 		}
  17201 		if done {
  17202 			break
  17203 		}
  17204 		originalDecoder := decoder
  17205 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17206 		switch {
  17207 		case strings.EqualFold("Comment", t.Name.Local):
  17208 			val, err := decoder.Value()
  17209 			if err != nil {
  17210 				return err
  17211 			}
  17212 			if val == nil {
  17213 				break
  17214 			}
  17215 			{
  17216 				xtv := string(val)
  17217 				sv.Comment = ptr.String(xtv)
  17218 			}
  17219 
  17220 		case strings.EqualFold("PrivateZone", t.Name.Local):
  17221 			val, err := decoder.Value()
  17222 			if err != nil {
  17223 				return err
  17224 			}
  17225 			if val == nil {
  17226 				break
  17227 			}
  17228 			{
  17229 				xtv, err := strconv.ParseBool(string(val))
  17230 				if err != nil {
  17231 					return fmt.Errorf("expected IsPrivateZone to be of type *bool, got %T instead", val)
  17232 				}
  17233 				sv.PrivateZone = xtv
  17234 			}
  17235 
  17236 		default:
  17237 			// Do nothing and ignore the unexpected tag element
  17238 			err = decoder.Decoder.Skip()
  17239 			if err != nil {
  17240 				return err
  17241 			}
  17242 
  17243 		}
  17244 		decoder = originalDecoder
  17245 	}
  17246 	*v = sv
  17247 	return nil
  17248 }
  17249 
  17250 func awsRestxml_deserializeDocumentHostedZoneLimit(v **types.HostedZoneLimit, decoder smithyxml.NodeDecoder) error {
  17251 	if v == nil {
  17252 		return fmt.Errorf("unexpected nil of type %T", v)
  17253 	}
  17254 	var sv *types.HostedZoneLimit
  17255 	if *v == nil {
  17256 		sv = &types.HostedZoneLimit{}
  17257 	} else {
  17258 		sv = *v
  17259 	}
  17260 
  17261 	for {
  17262 		t, done, err := decoder.Token()
  17263 		if err != nil {
  17264 			return err
  17265 		}
  17266 		if done {
  17267 			break
  17268 		}
  17269 		originalDecoder := decoder
  17270 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17271 		switch {
  17272 		case strings.EqualFold("Type", t.Name.Local):
  17273 			val, err := decoder.Value()
  17274 			if err != nil {
  17275 				return err
  17276 			}
  17277 			if val == nil {
  17278 				break
  17279 			}
  17280 			{
  17281 				xtv := string(val)
  17282 				sv.Type = types.HostedZoneLimitType(xtv)
  17283 			}
  17284 
  17285 		case strings.EqualFold("Value", t.Name.Local):
  17286 			val, err := decoder.Value()
  17287 			if err != nil {
  17288 				return err
  17289 			}
  17290 			if val == nil {
  17291 				break
  17292 			}
  17293 			{
  17294 				xtv := string(val)
  17295 				i64, err := strconv.ParseInt(xtv, 10, 64)
  17296 				if err != nil {
  17297 					return err
  17298 				}
  17299 				sv.Value = i64
  17300 			}
  17301 
  17302 		default:
  17303 			// Do nothing and ignore the unexpected tag element
  17304 			err = decoder.Decoder.Skip()
  17305 			if err != nil {
  17306 				return err
  17307 			}
  17308 
  17309 		}
  17310 		decoder = originalDecoder
  17311 	}
  17312 	*v = sv
  17313 	return nil
  17314 }
  17315 
  17316 func awsRestxml_deserializeDocumentHostedZoneNotEmpty(v **types.HostedZoneNotEmpty, decoder smithyxml.NodeDecoder) error {
  17317 	if v == nil {
  17318 		return fmt.Errorf("unexpected nil of type %T", v)
  17319 	}
  17320 	var sv *types.HostedZoneNotEmpty
  17321 	if *v == nil {
  17322 		sv = &types.HostedZoneNotEmpty{}
  17323 	} else {
  17324 		sv = *v
  17325 	}
  17326 
  17327 	for {
  17328 		t, done, err := decoder.Token()
  17329 		if err != nil {
  17330 			return err
  17331 		}
  17332 		if done {
  17333 			break
  17334 		}
  17335 		originalDecoder := decoder
  17336 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17337 		switch {
  17338 		case strings.EqualFold("message", t.Name.Local):
  17339 			val, err := decoder.Value()
  17340 			if err != nil {
  17341 				return err
  17342 			}
  17343 			if val == nil {
  17344 				break
  17345 			}
  17346 			{
  17347 				xtv := string(val)
  17348 				sv.Message = ptr.String(xtv)
  17349 			}
  17350 
  17351 		default:
  17352 			// Do nothing and ignore the unexpected tag element
  17353 			err = decoder.Decoder.Skip()
  17354 			if err != nil {
  17355 				return err
  17356 			}
  17357 
  17358 		}
  17359 		decoder = originalDecoder
  17360 	}
  17361 	*v = sv
  17362 	return nil
  17363 }
  17364 
  17365 func awsRestxml_deserializeDocumentHostedZoneNotFound(v **types.HostedZoneNotFound, decoder smithyxml.NodeDecoder) error {
  17366 	if v == nil {
  17367 		return fmt.Errorf("unexpected nil of type %T", v)
  17368 	}
  17369 	var sv *types.HostedZoneNotFound
  17370 	if *v == nil {
  17371 		sv = &types.HostedZoneNotFound{}
  17372 	} else {
  17373 		sv = *v
  17374 	}
  17375 
  17376 	for {
  17377 		t, done, err := decoder.Token()
  17378 		if err != nil {
  17379 			return err
  17380 		}
  17381 		if done {
  17382 			break
  17383 		}
  17384 		originalDecoder := decoder
  17385 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17386 		switch {
  17387 		case strings.EqualFold("message", t.Name.Local):
  17388 			val, err := decoder.Value()
  17389 			if err != nil {
  17390 				return err
  17391 			}
  17392 			if val == nil {
  17393 				break
  17394 			}
  17395 			{
  17396 				xtv := string(val)
  17397 				sv.Message = ptr.String(xtv)
  17398 			}
  17399 
  17400 		default:
  17401 			// Do nothing and ignore the unexpected tag element
  17402 			err = decoder.Decoder.Skip()
  17403 			if err != nil {
  17404 				return err
  17405 			}
  17406 
  17407 		}
  17408 		decoder = originalDecoder
  17409 	}
  17410 	*v = sv
  17411 	return nil
  17412 }
  17413 
  17414 func awsRestxml_deserializeDocumentHostedZoneNotPrivate(v **types.HostedZoneNotPrivate, decoder smithyxml.NodeDecoder) error {
  17415 	if v == nil {
  17416 		return fmt.Errorf("unexpected nil of type %T", v)
  17417 	}
  17418 	var sv *types.HostedZoneNotPrivate
  17419 	if *v == nil {
  17420 		sv = &types.HostedZoneNotPrivate{}
  17421 	} else {
  17422 		sv = *v
  17423 	}
  17424 
  17425 	for {
  17426 		t, done, err := decoder.Token()
  17427 		if err != nil {
  17428 			return err
  17429 		}
  17430 		if done {
  17431 			break
  17432 		}
  17433 		originalDecoder := decoder
  17434 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17435 		switch {
  17436 		case strings.EqualFold("message", t.Name.Local):
  17437 			val, err := decoder.Value()
  17438 			if err != nil {
  17439 				return err
  17440 			}
  17441 			if val == nil {
  17442 				break
  17443 			}
  17444 			{
  17445 				xtv := string(val)
  17446 				sv.Message = ptr.String(xtv)
  17447 			}
  17448 
  17449 		default:
  17450 			// Do nothing and ignore the unexpected tag element
  17451 			err = decoder.Decoder.Skip()
  17452 			if err != nil {
  17453 				return err
  17454 			}
  17455 
  17456 		}
  17457 		decoder = originalDecoder
  17458 	}
  17459 	*v = sv
  17460 	return nil
  17461 }
  17462 
  17463 func awsRestxml_deserializeDocumentHostedZoneOwner(v **types.HostedZoneOwner, decoder smithyxml.NodeDecoder) error {
  17464 	if v == nil {
  17465 		return fmt.Errorf("unexpected nil of type %T", v)
  17466 	}
  17467 	var sv *types.HostedZoneOwner
  17468 	if *v == nil {
  17469 		sv = &types.HostedZoneOwner{}
  17470 	} else {
  17471 		sv = *v
  17472 	}
  17473 
  17474 	for {
  17475 		t, done, err := decoder.Token()
  17476 		if err != nil {
  17477 			return err
  17478 		}
  17479 		if done {
  17480 			break
  17481 		}
  17482 		originalDecoder := decoder
  17483 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17484 		switch {
  17485 		case strings.EqualFold("OwningAccount", t.Name.Local):
  17486 			val, err := decoder.Value()
  17487 			if err != nil {
  17488 				return err
  17489 			}
  17490 			if val == nil {
  17491 				break
  17492 			}
  17493 			{
  17494 				xtv := string(val)
  17495 				sv.OwningAccount = ptr.String(xtv)
  17496 			}
  17497 
  17498 		case strings.EqualFold("OwningService", t.Name.Local):
  17499 			val, err := decoder.Value()
  17500 			if err != nil {
  17501 				return err
  17502 			}
  17503 			if val == nil {
  17504 				break
  17505 			}
  17506 			{
  17507 				xtv := string(val)
  17508 				sv.OwningService = ptr.String(xtv)
  17509 			}
  17510 
  17511 		default:
  17512 			// Do nothing and ignore the unexpected tag element
  17513 			err = decoder.Decoder.Skip()
  17514 			if err != nil {
  17515 				return err
  17516 			}
  17517 
  17518 		}
  17519 		decoder = originalDecoder
  17520 	}
  17521 	*v = sv
  17522 	return nil
  17523 }
  17524 
  17525 func awsRestxml_deserializeDocumentHostedZonePartiallyDelegated(v **types.HostedZonePartiallyDelegated, decoder smithyxml.NodeDecoder) error {
  17526 	if v == nil {
  17527 		return fmt.Errorf("unexpected nil of type %T", v)
  17528 	}
  17529 	var sv *types.HostedZonePartiallyDelegated
  17530 	if *v == nil {
  17531 		sv = &types.HostedZonePartiallyDelegated{}
  17532 	} else {
  17533 		sv = *v
  17534 	}
  17535 
  17536 	for {
  17537 		t, done, err := decoder.Token()
  17538 		if err != nil {
  17539 			return err
  17540 		}
  17541 		if done {
  17542 			break
  17543 		}
  17544 		originalDecoder := decoder
  17545 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17546 		switch {
  17547 		case strings.EqualFold("message", t.Name.Local):
  17548 			val, err := decoder.Value()
  17549 			if err != nil {
  17550 				return err
  17551 			}
  17552 			if val == nil {
  17553 				break
  17554 			}
  17555 			{
  17556 				xtv := string(val)
  17557 				sv.Message = ptr.String(xtv)
  17558 			}
  17559 
  17560 		default:
  17561 			// Do nothing and ignore the unexpected tag element
  17562 			err = decoder.Decoder.Skip()
  17563 			if err != nil {
  17564 				return err
  17565 			}
  17566 
  17567 		}
  17568 		decoder = originalDecoder
  17569 	}
  17570 	*v = sv
  17571 	return nil
  17572 }
  17573 
  17574 func awsRestxml_deserializeDocumentHostedZones(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error {
  17575 	if v == nil {
  17576 		return fmt.Errorf("unexpected nil of type %T", v)
  17577 	}
  17578 	var sv []types.HostedZone
  17579 	if *v == nil {
  17580 		sv = make([]types.HostedZone, 0)
  17581 	} else {
  17582 		sv = *v
  17583 	}
  17584 
  17585 	originalDecoder := decoder
  17586 	for {
  17587 		t, done, err := decoder.Token()
  17588 		if err != nil {
  17589 			return err
  17590 		}
  17591 		if done {
  17592 			break
  17593 		}
  17594 		switch {
  17595 		case strings.EqualFold("HostedZone", t.Name.Local):
  17596 			var col types.HostedZone
  17597 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17598 			destAddr := &col
  17599 			if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil {
  17600 				return err
  17601 			}
  17602 			col = *destAddr
  17603 			sv = append(sv, col)
  17604 
  17605 		default:
  17606 			err = decoder.Decoder.Skip()
  17607 			if err != nil {
  17608 				return err
  17609 			}
  17610 
  17611 		}
  17612 		decoder = originalDecoder
  17613 	}
  17614 	*v = sv
  17615 	return nil
  17616 }
  17617 
  17618 func awsRestxml_deserializeDocumentHostedZonesUnwrapped(v *[]types.HostedZone, decoder smithyxml.NodeDecoder) error {
  17619 	var sv []types.HostedZone
  17620 	if *v == nil {
  17621 		sv = make([]types.HostedZone, 0)
  17622 	} else {
  17623 		sv = *v
  17624 	}
  17625 
  17626 	switch {
  17627 	default:
  17628 		var mv types.HostedZone
  17629 		t := decoder.StartEl
  17630 		_ = t
  17631 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17632 		destAddr := &mv
  17633 		if err := awsRestxml_deserializeDocumentHostedZone(&destAddr, nodeDecoder); err != nil {
  17634 			return err
  17635 		}
  17636 		mv = *destAddr
  17637 		sv = append(sv, mv)
  17638 	}
  17639 	*v = sv
  17640 	return nil
  17641 }
  17642 func awsRestxml_deserializeDocumentHostedZoneSummaries(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
  17643 	if v == nil {
  17644 		return fmt.Errorf("unexpected nil of type %T", v)
  17645 	}
  17646 	var sv []types.HostedZoneSummary
  17647 	if *v == nil {
  17648 		sv = make([]types.HostedZoneSummary, 0)
  17649 	} else {
  17650 		sv = *v
  17651 	}
  17652 
  17653 	originalDecoder := decoder
  17654 	for {
  17655 		t, done, err := decoder.Token()
  17656 		if err != nil {
  17657 			return err
  17658 		}
  17659 		if done {
  17660 			break
  17661 		}
  17662 		switch {
  17663 		case strings.EqualFold("HostedZoneSummary", t.Name.Local):
  17664 			var col types.HostedZoneSummary
  17665 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17666 			destAddr := &col
  17667 			if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil {
  17668 				return err
  17669 			}
  17670 			col = *destAddr
  17671 			sv = append(sv, col)
  17672 
  17673 		default:
  17674 			err = decoder.Decoder.Skip()
  17675 			if err != nil {
  17676 				return err
  17677 			}
  17678 
  17679 		}
  17680 		decoder = originalDecoder
  17681 	}
  17682 	*v = sv
  17683 	return nil
  17684 }
  17685 
  17686 func awsRestxml_deserializeDocumentHostedZoneSummariesUnwrapped(v *[]types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
  17687 	var sv []types.HostedZoneSummary
  17688 	if *v == nil {
  17689 		sv = make([]types.HostedZoneSummary, 0)
  17690 	} else {
  17691 		sv = *v
  17692 	}
  17693 
  17694 	switch {
  17695 	default:
  17696 		var mv types.HostedZoneSummary
  17697 		t := decoder.StartEl
  17698 		_ = t
  17699 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17700 		destAddr := &mv
  17701 		if err := awsRestxml_deserializeDocumentHostedZoneSummary(&destAddr, nodeDecoder); err != nil {
  17702 			return err
  17703 		}
  17704 		mv = *destAddr
  17705 		sv = append(sv, mv)
  17706 	}
  17707 	*v = sv
  17708 	return nil
  17709 }
  17710 func awsRestxml_deserializeDocumentHostedZoneSummary(v **types.HostedZoneSummary, decoder smithyxml.NodeDecoder) error {
  17711 	if v == nil {
  17712 		return fmt.Errorf("unexpected nil of type %T", v)
  17713 	}
  17714 	var sv *types.HostedZoneSummary
  17715 	if *v == nil {
  17716 		sv = &types.HostedZoneSummary{}
  17717 	} else {
  17718 		sv = *v
  17719 	}
  17720 
  17721 	for {
  17722 		t, done, err := decoder.Token()
  17723 		if err != nil {
  17724 			return err
  17725 		}
  17726 		if done {
  17727 			break
  17728 		}
  17729 		originalDecoder := decoder
  17730 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17731 		switch {
  17732 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  17733 			val, err := decoder.Value()
  17734 			if err != nil {
  17735 				return err
  17736 			}
  17737 			if val == nil {
  17738 				break
  17739 			}
  17740 			{
  17741 				xtv := string(val)
  17742 				sv.HostedZoneId = ptr.String(xtv)
  17743 			}
  17744 
  17745 		case strings.EqualFold("Name", t.Name.Local):
  17746 			val, err := decoder.Value()
  17747 			if err != nil {
  17748 				return err
  17749 			}
  17750 			if val == nil {
  17751 				break
  17752 			}
  17753 			{
  17754 				xtv := string(val)
  17755 				sv.Name = ptr.String(xtv)
  17756 			}
  17757 
  17758 		case strings.EqualFold("Owner", t.Name.Local):
  17759 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17760 			if err := awsRestxml_deserializeDocumentHostedZoneOwner(&sv.Owner, nodeDecoder); err != nil {
  17761 				return err
  17762 			}
  17763 
  17764 		default:
  17765 			// Do nothing and ignore the unexpected tag element
  17766 			err = decoder.Decoder.Skip()
  17767 			if err != nil {
  17768 				return err
  17769 			}
  17770 
  17771 		}
  17772 		decoder = originalDecoder
  17773 	}
  17774 	*v = sv
  17775 	return nil
  17776 }
  17777 
  17778 func awsRestxml_deserializeDocumentIncompatibleVersion(v **types.IncompatibleVersion, decoder smithyxml.NodeDecoder) error {
  17779 	if v == nil {
  17780 		return fmt.Errorf("unexpected nil of type %T", v)
  17781 	}
  17782 	var sv *types.IncompatibleVersion
  17783 	if *v == nil {
  17784 		sv = &types.IncompatibleVersion{}
  17785 	} else {
  17786 		sv = *v
  17787 	}
  17788 
  17789 	for {
  17790 		t, done, err := decoder.Token()
  17791 		if err != nil {
  17792 			return err
  17793 		}
  17794 		if done {
  17795 			break
  17796 		}
  17797 		originalDecoder := decoder
  17798 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17799 		switch {
  17800 		case strings.EqualFold("message", t.Name.Local):
  17801 			val, err := decoder.Value()
  17802 			if err != nil {
  17803 				return err
  17804 			}
  17805 			if val == nil {
  17806 				break
  17807 			}
  17808 			{
  17809 				xtv := string(val)
  17810 				sv.Message = ptr.String(xtv)
  17811 			}
  17812 
  17813 		default:
  17814 			// Do nothing and ignore the unexpected tag element
  17815 			err = decoder.Decoder.Skip()
  17816 			if err != nil {
  17817 				return err
  17818 			}
  17819 
  17820 		}
  17821 		decoder = originalDecoder
  17822 	}
  17823 	*v = sv
  17824 	return nil
  17825 }
  17826 
  17827 func awsRestxml_deserializeDocumentInsufficientCloudWatchLogsResourcePolicy(v **types.InsufficientCloudWatchLogsResourcePolicy, decoder smithyxml.NodeDecoder) error {
  17828 	if v == nil {
  17829 		return fmt.Errorf("unexpected nil of type %T", v)
  17830 	}
  17831 	var sv *types.InsufficientCloudWatchLogsResourcePolicy
  17832 	if *v == nil {
  17833 		sv = &types.InsufficientCloudWatchLogsResourcePolicy{}
  17834 	} else {
  17835 		sv = *v
  17836 	}
  17837 
  17838 	for {
  17839 		t, done, err := decoder.Token()
  17840 		if err != nil {
  17841 			return err
  17842 		}
  17843 		if done {
  17844 			break
  17845 		}
  17846 		originalDecoder := decoder
  17847 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17848 		switch {
  17849 		case strings.EqualFold("message", t.Name.Local):
  17850 			val, err := decoder.Value()
  17851 			if err != nil {
  17852 				return err
  17853 			}
  17854 			if val == nil {
  17855 				break
  17856 			}
  17857 			{
  17858 				xtv := string(val)
  17859 				sv.Message = ptr.String(xtv)
  17860 			}
  17861 
  17862 		default:
  17863 			// Do nothing and ignore the unexpected tag element
  17864 			err = decoder.Decoder.Skip()
  17865 			if err != nil {
  17866 				return err
  17867 			}
  17868 
  17869 		}
  17870 		decoder = originalDecoder
  17871 	}
  17872 	*v = sv
  17873 	return nil
  17874 }
  17875 
  17876 func awsRestxml_deserializeDocumentInvalidArgument(v **types.InvalidArgument, decoder smithyxml.NodeDecoder) error {
  17877 	if v == nil {
  17878 		return fmt.Errorf("unexpected nil of type %T", v)
  17879 	}
  17880 	var sv *types.InvalidArgument
  17881 	if *v == nil {
  17882 		sv = &types.InvalidArgument{}
  17883 	} else {
  17884 		sv = *v
  17885 	}
  17886 
  17887 	for {
  17888 		t, done, err := decoder.Token()
  17889 		if err != nil {
  17890 			return err
  17891 		}
  17892 		if done {
  17893 			break
  17894 		}
  17895 		originalDecoder := decoder
  17896 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17897 		switch {
  17898 		case strings.EqualFold("message", t.Name.Local):
  17899 			val, err := decoder.Value()
  17900 			if err != nil {
  17901 				return err
  17902 			}
  17903 			if val == nil {
  17904 				break
  17905 			}
  17906 			{
  17907 				xtv := string(val)
  17908 				sv.Message = ptr.String(xtv)
  17909 			}
  17910 
  17911 		default:
  17912 			// Do nothing and ignore the unexpected tag element
  17913 			err = decoder.Decoder.Skip()
  17914 			if err != nil {
  17915 				return err
  17916 			}
  17917 
  17918 		}
  17919 		decoder = originalDecoder
  17920 	}
  17921 	*v = sv
  17922 	return nil
  17923 }
  17924 
  17925 func awsRestxml_deserializeDocumentInvalidChangeBatch(v **types.InvalidChangeBatch, decoder smithyxml.NodeDecoder) error {
  17926 	if v == nil {
  17927 		return fmt.Errorf("unexpected nil of type %T", v)
  17928 	}
  17929 	var sv *types.InvalidChangeBatch
  17930 	if *v == nil {
  17931 		sv = &types.InvalidChangeBatch{}
  17932 	} else {
  17933 		sv = *v
  17934 	}
  17935 
  17936 	for {
  17937 		t, done, err := decoder.Token()
  17938 		if err != nil {
  17939 			return err
  17940 		}
  17941 		if done {
  17942 			break
  17943 		}
  17944 		originalDecoder := decoder
  17945 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  17946 		switch {
  17947 		case strings.EqualFold("message", t.Name.Local):
  17948 			val, err := decoder.Value()
  17949 			if err != nil {
  17950 				return err
  17951 			}
  17952 			if val == nil {
  17953 				break
  17954 			}
  17955 			{
  17956 				xtv := string(val)
  17957 				sv.Message = ptr.String(xtv)
  17958 			}
  17959 
  17960 		case strings.EqualFold("messages", t.Name.Local):
  17961 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  17962 			if err := awsRestxml_deserializeDocumentErrorMessages(&sv.Messages, nodeDecoder); err != nil {
  17963 				return err
  17964 			}
  17965 
  17966 		default:
  17967 			// Do nothing and ignore the unexpected tag element
  17968 			err = decoder.Decoder.Skip()
  17969 			if err != nil {
  17970 				return err
  17971 			}
  17972 
  17973 		}
  17974 		decoder = originalDecoder
  17975 	}
  17976 	*v = sv
  17977 	return nil
  17978 }
  17979 
  17980 func awsRestxml_deserializeDocumentInvalidDomainName(v **types.InvalidDomainName, decoder smithyxml.NodeDecoder) error {
  17981 	if v == nil {
  17982 		return fmt.Errorf("unexpected nil of type %T", v)
  17983 	}
  17984 	var sv *types.InvalidDomainName
  17985 	if *v == nil {
  17986 		sv = &types.InvalidDomainName{}
  17987 	} else {
  17988 		sv = *v
  17989 	}
  17990 
  17991 	for {
  17992 		t, done, err := decoder.Token()
  17993 		if err != nil {
  17994 			return err
  17995 		}
  17996 		if done {
  17997 			break
  17998 		}
  17999 		originalDecoder := decoder
  18000 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18001 		switch {
  18002 		case strings.EqualFold("message", t.Name.Local):
  18003 			val, err := decoder.Value()
  18004 			if err != nil {
  18005 				return err
  18006 			}
  18007 			if val == nil {
  18008 				break
  18009 			}
  18010 			{
  18011 				xtv := string(val)
  18012 				sv.Message = ptr.String(xtv)
  18013 			}
  18014 
  18015 		default:
  18016 			// Do nothing and ignore the unexpected tag element
  18017 			err = decoder.Decoder.Skip()
  18018 			if err != nil {
  18019 				return err
  18020 			}
  18021 
  18022 		}
  18023 		decoder = originalDecoder
  18024 	}
  18025 	*v = sv
  18026 	return nil
  18027 }
  18028 
  18029 func awsRestxml_deserializeDocumentInvalidInput(v **types.InvalidInput, decoder smithyxml.NodeDecoder) error {
  18030 	if v == nil {
  18031 		return fmt.Errorf("unexpected nil of type %T", v)
  18032 	}
  18033 	var sv *types.InvalidInput
  18034 	if *v == nil {
  18035 		sv = &types.InvalidInput{}
  18036 	} else {
  18037 		sv = *v
  18038 	}
  18039 
  18040 	for {
  18041 		t, done, err := decoder.Token()
  18042 		if err != nil {
  18043 			return err
  18044 		}
  18045 		if done {
  18046 			break
  18047 		}
  18048 		originalDecoder := decoder
  18049 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18050 		switch {
  18051 		case strings.EqualFold("message", t.Name.Local):
  18052 			val, err := decoder.Value()
  18053 			if err != nil {
  18054 				return err
  18055 			}
  18056 			if val == nil {
  18057 				break
  18058 			}
  18059 			{
  18060 				xtv := string(val)
  18061 				sv.Message = ptr.String(xtv)
  18062 			}
  18063 
  18064 		default:
  18065 			// Do nothing and ignore the unexpected tag element
  18066 			err = decoder.Decoder.Skip()
  18067 			if err != nil {
  18068 				return err
  18069 			}
  18070 
  18071 		}
  18072 		decoder = originalDecoder
  18073 	}
  18074 	*v = sv
  18075 	return nil
  18076 }
  18077 
  18078 func awsRestxml_deserializeDocumentInvalidKeySigningKeyName(v **types.InvalidKeySigningKeyName, decoder smithyxml.NodeDecoder) error {
  18079 	if v == nil {
  18080 		return fmt.Errorf("unexpected nil of type %T", v)
  18081 	}
  18082 	var sv *types.InvalidKeySigningKeyName
  18083 	if *v == nil {
  18084 		sv = &types.InvalidKeySigningKeyName{}
  18085 	} else {
  18086 		sv = *v
  18087 	}
  18088 
  18089 	for {
  18090 		t, done, err := decoder.Token()
  18091 		if err != nil {
  18092 			return err
  18093 		}
  18094 		if done {
  18095 			break
  18096 		}
  18097 		originalDecoder := decoder
  18098 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18099 		switch {
  18100 		case strings.EqualFold("message", t.Name.Local):
  18101 			val, err := decoder.Value()
  18102 			if err != nil {
  18103 				return err
  18104 			}
  18105 			if val == nil {
  18106 				break
  18107 			}
  18108 			{
  18109 				xtv := string(val)
  18110 				sv.Message = ptr.String(xtv)
  18111 			}
  18112 
  18113 		default:
  18114 			// Do nothing and ignore the unexpected tag element
  18115 			err = decoder.Decoder.Skip()
  18116 			if err != nil {
  18117 				return err
  18118 			}
  18119 
  18120 		}
  18121 		decoder = originalDecoder
  18122 	}
  18123 	*v = sv
  18124 	return nil
  18125 }
  18126 
  18127 func awsRestxml_deserializeDocumentInvalidKeySigningKeyStatus(v **types.InvalidKeySigningKeyStatus, decoder smithyxml.NodeDecoder) error {
  18128 	if v == nil {
  18129 		return fmt.Errorf("unexpected nil of type %T", v)
  18130 	}
  18131 	var sv *types.InvalidKeySigningKeyStatus
  18132 	if *v == nil {
  18133 		sv = &types.InvalidKeySigningKeyStatus{}
  18134 	} else {
  18135 		sv = *v
  18136 	}
  18137 
  18138 	for {
  18139 		t, done, err := decoder.Token()
  18140 		if err != nil {
  18141 			return err
  18142 		}
  18143 		if done {
  18144 			break
  18145 		}
  18146 		originalDecoder := decoder
  18147 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18148 		switch {
  18149 		case strings.EqualFold("message", t.Name.Local):
  18150 			val, err := decoder.Value()
  18151 			if err != nil {
  18152 				return err
  18153 			}
  18154 			if val == nil {
  18155 				break
  18156 			}
  18157 			{
  18158 				xtv := string(val)
  18159 				sv.Message = ptr.String(xtv)
  18160 			}
  18161 
  18162 		default:
  18163 			// Do nothing and ignore the unexpected tag element
  18164 			err = decoder.Decoder.Skip()
  18165 			if err != nil {
  18166 				return err
  18167 			}
  18168 
  18169 		}
  18170 		decoder = originalDecoder
  18171 	}
  18172 	*v = sv
  18173 	return nil
  18174 }
  18175 
  18176 func awsRestxml_deserializeDocumentInvalidKMSArn(v **types.InvalidKMSArn, decoder smithyxml.NodeDecoder) error {
  18177 	if v == nil {
  18178 		return fmt.Errorf("unexpected nil of type %T", v)
  18179 	}
  18180 	var sv *types.InvalidKMSArn
  18181 	if *v == nil {
  18182 		sv = &types.InvalidKMSArn{}
  18183 	} else {
  18184 		sv = *v
  18185 	}
  18186 
  18187 	for {
  18188 		t, done, err := decoder.Token()
  18189 		if err != nil {
  18190 			return err
  18191 		}
  18192 		if done {
  18193 			break
  18194 		}
  18195 		originalDecoder := decoder
  18196 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18197 		switch {
  18198 		case strings.EqualFold("message", t.Name.Local):
  18199 			val, err := decoder.Value()
  18200 			if err != nil {
  18201 				return err
  18202 			}
  18203 			if val == nil {
  18204 				break
  18205 			}
  18206 			{
  18207 				xtv := string(val)
  18208 				sv.Message = ptr.String(xtv)
  18209 			}
  18210 
  18211 		default:
  18212 			// Do nothing and ignore the unexpected tag element
  18213 			err = decoder.Decoder.Skip()
  18214 			if err != nil {
  18215 				return err
  18216 			}
  18217 
  18218 		}
  18219 		decoder = originalDecoder
  18220 	}
  18221 	*v = sv
  18222 	return nil
  18223 }
  18224 
  18225 func awsRestxml_deserializeDocumentInvalidPaginationToken(v **types.InvalidPaginationToken, decoder smithyxml.NodeDecoder) error {
  18226 	if v == nil {
  18227 		return fmt.Errorf("unexpected nil of type %T", v)
  18228 	}
  18229 	var sv *types.InvalidPaginationToken
  18230 	if *v == nil {
  18231 		sv = &types.InvalidPaginationToken{}
  18232 	} else {
  18233 		sv = *v
  18234 	}
  18235 
  18236 	for {
  18237 		t, done, err := decoder.Token()
  18238 		if err != nil {
  18239 			return err
  18240 		}
  18241 		if done {
  18242 			break
  18243 		}
  18244 		originalDecoder := decoder
  18245 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18246 		switch {
  18247 		case strings.EqualFold("message", t.Name.Local):
  18248 			val, err := decoder.Value()
  18249 			if err != nil {
  18250 				return err
  18251 			}
  18252 			if val == nil {
  18253 				break
  18254 			}
  18255 			{
  18256 				xtv := string(val)
  18257 				sv.Message = ptr.String(xtv)
  18258 			}
  18259 
  18260 		default:
  18261 			// Do nothing and ignore the unexpected tag element
  18262 			err = decoder.Decoder.Skip()
  18263 			if err != nil {
  18264 				return err
  18265 			}
  18266 
  18267 		}
  18268 		decoder = originalDecoder
  18269 	}
  18270 	*v = sv
  18271 	return nil
  18272 }
  18273 
  18274 func awsRestxml_deserializeDocumentInvalidSigningStatus(v **types.InvalidSigningStatus, decoder smithyxml.NodeDecoder) error {
  18275 	if v == nil {
  18276 		return fmt.Errorf("unexpected nil of type %T", v)
  18277 	}
  18278 	var sv *types.InvalidSigningStatus
  18279 	if *v == nil {
  18280 		sv = &types.InvalidSigningStatus{}
  18281 	} else {
  18282 		sv = *v
  18283 	}
  18284 
  18285 	for {
  18286 		t, done, err := decoder.Token()
  18287 		if err != nil {
  18288 			return err
  18289 		}
  18290 		if done {
  18291 			break
  18292 		}
  18293 		originalDecoder := decoder
  18294 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18295 		switch {
  18296 		case strings.EqualFold("message", t.Name.Local):
  18297 			val, err := decoder.Value()
  18298 			if err != nil {
  18299 				return err
  18300 			}
  18301 			if val == nil {
  18302 				break
  18303 			}
  18304 			{
  18305 				xtv := string(val)
  18306 				sv.Message = ptr.String(xtv)
  18307 			}
  18308 
  18309 		default:
  18310 			// Do nothing and ignore the unexpected tag element
  18311 			err = decoder.Decoder.Skip()
  18312 			if err != nil {
  18313 				return err
  18314 			}
  18315 
  18316 		}
  18317 		decoder = originalDecoder
  18318 	}
  18319 	*v = sv
  18320 	return nil
  18321 }
  18322 
  18323 func awsRestxml_deserializeDocumentInvalidTrafficPolicyDocument(v **types.InvalidTrafficPolicyDocument, decoder smithyxml.NodeDecoder) error {
  18324 	if v == nil {
  18325 		return fmt.Errorf("unexpected nil of type %T", v)
  18326 	}
  18327 	var sv *types.InvalidTrafficPolicyDocument
  18328 	if *v == nil {
  18329 		sv = &types.InvalidTrafficPolicyDocument{}
  18330 	} else {
  18331 		sv = *v
  18332 	}
  18333 
  18334 	for {
  18335 		t, done, err := decoder.Token()
  18336 		if err != nil {
  18337 			return err
  18338 		}
  18339 		if done {
  18340 			break
  18341 		}
  18342 		originalDecoder := decoder
  18343 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18344 		switch {
  18345 		case strings.EqualFold("message", t.Name.Local):
  18346 			val, err := decoder.Value()
  18347 			if err != nil {
  18348 				return err
  18349 			}
  18350 			if val == nil {
  18351 				break
  18352 			}
  18353 			{
  18354 				xtv := string(val)
  18355 				sv.Message = ptr.String(xtv)
  18356 			}
  18357 
  18358 		default:
  18359 			// Do nothing and ignore the unexpected tag element
  18360 			err = decoder.Decoder.Skip()
  18361 			if err != nil {
  18362 				return err
  18363 			}
  18364 
  18365 		}
  18366 		decoder = originalDecoder
  18367 	}
  18368 	*v = sv
  18369 	return nil
  18370 }
  18371 
  18372 func awsRestxml_deserializeDocumentInvalidVPCId(v **types.InvalidVPCId, decoder smithyxml.NodeDecoder) error {
  18373 	if v == nil {
  18374 		return fmt.Errorf("unexpected nil of type %T", v)
  18375 	}
  18376 	var sv *types.InvalidVPCId
  18377 	if *v == nil {
  18378 		sv = &types.InvalidVPCId{}
  18379 	} else {
  18380 		sv = *v
  18381 	}
  18382 
  18383 	for {
  18384 		t, done, err := decoder.Token()
  18385 		if err != nil {
  18386 			return err
  18387 		}
  18388 		if done {
  18389 			break
  18390 		}
  18391 		originalDecoder := decoder
  18392 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18393 		switch {
  18394 		case strings.EqualFold("message", t.Name.Local):
  18395 			val, err := decoder.Value()
  18396 			if err != nil {
  18397 				return err
  18398 			}
  18399 			if val == nil {
  18400 				break
  18401 			}
  18402 			{
  18403 				xtv := string(val)
  18404 				sv.Message = ptr.String(xtv)
  18405 			}
  18406 
  18407 		default:
  18408 			// Do nothing and ignore the unexpected tag element
  18409 			err = decoder.Decoder.Skip()
  18410 			if err != nil {
  18411 				return err
  18412 			}
  18413 
  18414 		}
  18415 		decoder = originalDecoder
  18416 	}
  18417 	*v = sv
  18418 	return nil
  18419 }
  18420 
  18421 func awsRestxml_deserializeDocumentKeySigningKey(v **types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
  18422 	if v == nil {
  18423 		return fmt.Errorf("unexpected nil of type %T", v)
  18424 	}
  18425 	var sv *types.KeySigningKey
  18426 	if *v == nil {
  18427 		sv = &types.KeySigningKey{}
  18428 	} else {
  18429 		sv = *v
  18430 	}
  18431 
  18432 	for {
  18433 		t, done, err := decoder.Token()
  18434 		if err != nil {
  18435 			return err
  18436 		}
  18437 		if done {
  18438 			break
  18439 		}
  18440 		originalDecoder := decoder
  18441 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18442 		switch {
  18443 		case strings.EqualFold("CreatedDate", t.Name.Local):
  18444 			val, err := decoder.Value()
  18445 			if err != nil {
  18446 				return err
  18447 			}
  18448 			if val == nil {
  18449 				break
  18450 			}
  18451 			{
  18452 				xtv := string(val)
  18453 				t, err := smithytime.ParseDateTime(xtv)
  18454 				if err != nil {
  18455 					return err
  18456 				}
  18457 				sv.CreatedDate = ptr.Time(t)
  18458 			}
  18459 
  18460 		case strings.EqualFold("DigestAlgorithmMnemonic", t.Name.Local):
  18461 			val, err := decoder.Value()
  18462 			if err != nil {
  18463 				return err
  18464 			}
  18465 			if val == nil {
  18466 				break
  18467 			}
  18468 			{
  18469 				xtv := string(val)
  18470 				sv.DigestAlgorithmMnemonic = ptr.String(xtv)
  18471 			}
  18472 
  18473 		case strings.EqualFold("DigestAlgorithmType", t.Name.Local):
  18474 			val, err := decoder.Value()
  18475 			if err != nil {
  18476 				return err
  18477 			}
  18478 			if val == nil {
  18479 				break
  18480 			}
  18481 			{
  18482 				xtv := string(val)
  18483 				i64, err := strconv.ParseInt(xtv, 10, 64)
  18484 				if err != nil {
  18485 					return err
  18486 				}
  18487 				sv.DigestAlgorithmType = int32(i64)
  18488 			}
  18489 
  18490 		case strings.EqualFold("DigestValue", t.Name.Local):
  18491 			val, err := decoder.Value()
  18492 			if err != nil {
  18493 				return err
  18494 			}
  18495 			if val == nil {
  18496 				break
  18497 			}
  18498 			{
  18499 				xtv := string(val)
  18500 				sv.DigestValue = ptr.String(xtv)
  18501 			}
  18502 
  18503 		case strings.EqualFold("DNSKEYRecord", t.Name.Local):
  18504 			val, err := decoder.Value()
  18505 			if err != nil {
  18506 				return err
  18507 			}
  18508 			if val == nil {
  18509 				break
  18510 			}
  18511 			{
  18512 				xtv := string(val)
  18513 				sv.DNSKEYRecord = ptr.String(xtv)
  18514 			}
  18515 
  18516 		case strings.EqualFold("DSRecord", t.Name.Local):
  18517 			val, err := decoder.Value()
  18518 			if err != nil {
  18519 				return err
  18520 			}
  18521 			if val == nil {
  18522 				break
  18523 			}
  18524 			{
  18525 				xtv := string(val)
  18526 				sv.DSRecord = ptr.String(xtv)
  18527 			}
  18528 
  18529 		case strings.EqualFold("Flag", t.Name.Local):
  18530 			val, err := decoder.Value()
  18531 			if err != nil {
  18532 				return err
  18533 			}
  18534 			if val == nil {
  18535 				break
  18536 			}
  18537 			{
  18538 				xtv := string(val)
  18539 				i64, err := strconv.ParseInt(xtv, 10, 64)
  18540 				if err != nil {
  18541 					return err
  18542 				}
  18543 				sv.Flag = int32(i64)
  18544 			}
  18545 
  18546 		case strings.EqualFold("KeyTag", t.Name.Local):
  18547 			val, err := decoder.Value()
  18548 			if err != nil {
  18549 				return err
  18550 			}
  18551 			if val == nil {
  18552 				break
  18553 			}
  18554 			{
  18555 				xtv := string(val)
  18556 				i64, err := strconv.ParseInt(xtv, 10, 64)
  18557 				if err != nil {
  18558 					return err
  18559 				}
  18560 				sv.KeyTag = int32(i64)
  18561 			}
  18562 
  18563 		case strings.EqualFold("KmsArn", t.Name.Local):
  18564 			val, err := decoder.Value()
  18565 			if err != nil {
  18566 				return err
  18567 			}
  18568 			if val == nil {
  18569 				break
  18570 			}
  18571 			{
  18572 				xtv := string(val)
  18573 				sv.KmsArn = ptr.String(xtv)
  18574 			}
  18575 
  18576 		case strings.EqualFold("LastModifiedDate", t.Name.Local):
  18577 			val, err := decoder.Value()
  18578 			if err != nil {
  18579 				return err
  18580 			}
  18581 			if val == nil {
  18582 				break
  18583 			}
  18584 			{
  18585 				xtv := string(val)
  18586 				t, err := smithytime.ParseDateTime(xtv)
  18587 				if err != nil {
  18588 					return err
  18589 				}
  18590 				sv.LastModifiedDate = ptr.Time(t)
  18591 			}
  18592 
  18593 		case strings.EqualFold("Name", t.Name.Local):
  18594 			val, err := decoder.Value()
  18595 			if err != nil {
  18596 				return err
  18597 			}
  18598 			if val == nil {
  18599 				break
  18600 			}
  18601 			{
  18602 				xtv := string(val)
  18603 				sv.Name = ptr.String(xtv)
  18604 			}
  18605 
  18606 		case strings.EqualFold("PublicKey", t.Name.Local):
  18607 			val, err := decoder.Value()
  18608 			if err != nil {
  18609 				return err
  18610 			}
  18611 			if val == nil {
  18612 				break
  18613 			}
  18614 			{
  18615 				xtv := string(val)
  18616 				sv.PublicKey = ptr.String(xtv)
  18617 			}
  18618 
  18619 		case strings.EqualFold("SigningAlgorithmMnemonic", t.Name.Local):
  18620 			val, err := decoder.Value()
  18621 			if err != nil {
  18622 				return err
  18623 			}
  18624 			if val == nil {
  18625 				break
  18626 			}
  18627 			{
  18628 				xtv := string(val)
  18629 				sv.SigningAlgorithmMnemonic = ptr.String(xtv)
  18630 			}
  18631 
  18632 		case strings.EqualFold("SigningAlgorithmType", t.Name.Local):
  18633 			val, err := decoder.Value()
  18634 			if err != nil {
  18635 				return err
  18636 			}
  18637 			if val == nil {
  18638 				break
  18639 			}
  18640 			{
  18641 				xtv := string(val)
  18642 				i64, err := strconv.ParseInt(xtv, 10, 64)
  18643 				if err != nil {
  18644 					return err
  18645 				}
  18646 				sv.SigningAlgorithmType = int32(i64)
  18647 			}
  18648 
  18649 		case strings.EqualFold("Status", t.Name.Local):
  18650 			val, err := decoder.Value()
  18651 			if err != nil {
  18652 				return err
  18653 			}
  18654 			if val == nil {
  18655 				break
  18656 			}
  18657 			{
  18658 				xtv := string(val)
  18659 				sv.Status = ptr.String(xtv)
  18660 			}
  18661 
  18662 		case strings.EqualFold("StatusMessage", t.Name.Local):
  18663 			val, err := decoder.Value()
  18664 			if err != nil {
  18665 				return err
  18666 			}
  18667 			if val == nil {
  18668 				break
  18669 			}
  18670 			{
  18671 				xtv := string(val)
  18672 				sv.StatusMessage = ptr.String(xtv)
  18673 			}
  18674 
  18675 		default:
  18676 			// Do nothing and ignore the unexpected tag element
  18677 			err = decoder.Decoder.Skip()
  18678 			if err != nil {
  18679 				return err
  18680 			}
  18681 
  18682 		}
  18683 		decoder = originalDecoder
  18684 	}
  18685 	*v = sv
  18686 	return nil
  18687 }
  18688 
  18689 func awsRestxml_deserializeDocumentKeySigningKeyAlreadyExists(v **types.KeySigningKeyAlreadyExists, decoder smithyxml.NodeDecoder) error {
  18690 	if v == nil {
  18691 		return fmt.Errorf("unexpected nil of type %T", v)
  18692 	}
  18693 	var sv *types.KeySigningKeyAlreadyExists
  18694 	if *v == nil {
  18695 		sv = &types.KeySigningKeyAlreadyExists{}
  18696 	} else {
  18697 		sv = *v
  18698 	}
  18699 
  18700 	for {
  18701 		t, done, err := decoder.Token()
  18702 		if err != nil {
  18703 			return err
  18704 		}
  18705 		if done {
  18706 			break
  18707 		}
  18708 		originalDecoder := decoder
  18709 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18710 		switch {
  18711 		case strings.EqualFold("message", t.Name.Local):
  18712 			val, err := decoder.Value()
  18713 			if err != nil {
  18714 				return err
  18715 			}
  18716 			if val == nil {
  18717 				break
  18718 			}
  18719 			{
  18720 				xtv := string(val)
  18721 				sv.Message = ptr.String(xtv)
  18722 			}
  18723 
  18724 		default:
  18725 			// Do nothing and ignore the unexpected tag element
  18726 			err = decoder.Decoder.Skip()
  18727 			if err != nil {
  18728 				return err
  18729 			}
  18730 
  18731 		}
  18732 		decoder = originalDecoder
  18733 	}
  18734 	*v = sv
  18735 	return nil
  18736 }
  18737 
  18738 func awsRestxml_deserializeDocumentKeySigningKeyInParentDSRecord(v **types.KeySigningKeyInParentDSRecord, decoder smithyxml.NodeDecoder) error {
  18739 	if v == nil {
  18740 		return fmt.Errorf("unexpected nil of type %T", v)
  18741 	}
  18742 	var sv *types.KeySigningKeyInParentDSRecord
  18743 	if *v == nil {
  18744 		sv = &types.KeySigningKeyInParentDSRecord{}
  18745 	} else {
  18746 		sv = *v
  18747 	}
  18748 
  18749 	for {
  18750 		t, done, err := decoder.Token()
  18751 		if err != nil {
  18752 			return err
  18753 		}
  18754 		if done {
  18755 			break
  18756 		}
  18757 		originalDecoder := decoder
  18758 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18759 		switch {
  18760 		case strings.EqualFold("message", t.Name.Local):
  18761 			val, err := decoder.Value()
  18762 			if err != nil {
  18763 				return err
  18764 			}
  18765 			if val == nil {
  18766 				break
  18767 			}
  18768 			{
  18769 				xtv := string(val)
  18770 				sv.Message = ptr.String(xtv)
  18771 			}
  18772 
  18773 		default:
  18774 			// Do nothing and ignore the unexpected tag element
  18775 			err = decoder.Decoder.Skip()
  18776 			if err != nil {
  18777 				return err
  18778 			}
  18779 
  18780 		}
  18781 		decoder = originalDecoder
  18782 	}
  18783 	*v = sv
  18784 	return nil
  18785 }
  18786 
  18787 func awsRestxml_deserializeDocumentKeySigningKeyInUse(v **types.KeySigningKeyInUse, decoder smithyxml.NodeDecoder) error {
  18788 	if v == nil {
  18789 		return fmt.Errorf("unexpected nil of type %T", v)
  18790 	}
  18791 	var sv *types.KeySigningKeyInUse
  18792 	if *v == nil {
  18793 		sv = &types.KeySigningKeyInUse{}
  18794 	} else {
  18795 		sv = *v
  18796 	}
  18797 
  18798 	for {
  18799 		t, done, err := decoder.Token()
  18800 		if err != nil {
  18801 			return err
  18802 		}
  18803 		if done {
  18804 			break
  18805 		}
  18806 		originalDecoder := decoder
  18807 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18808 		switch {
  18809 		case strings.EqualFold("message", t.Name.Local):
  18810 			val, err := decoder.Value()
  18811 			if err != nil {
  18812 				return err
  18813 			}
  18814 			if val == nil {
  18815 				break
  18816 			}
  18817 			{
  18818 				xtv := string(val)
  18819 				sv.Message = ptr.String(xtv)
  18820 			}
  18821 
  18822 		default:
  18823 			// Do nothing and ignore the unexpected tag element
  18824 			err = decoder.Decoder.Skip()
  18825 			if err != nil {
  18826 				return err
  18827 			}
  18828 
  18829 		}
  18830 		decoder = originalDecoder
  18831 	}
  18832 	*v = sv
  18833 	return nil
  18834 }
  18835 
  18836 func awsRestxml_deserializeDocumentKeySigningKeys(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
  18837 	if v == nil {
  18838 		return fmt.Errorf("unexpected nil of type %T", v)
  18839 	}
  18840 	var sv []types.KeySigningKey
  18841 	if *v == nil {
  18842 		sv = make([]types.KeySigningKey, 0)
  18843 	} else {
  18844 		sv = *v
  18845 	}
  18846 
  18847 	originalDecoder := decoder
  18848 	for {
  18849 		t, done, err := decoder.Token()
  18850 		if err != nil {
  18851 			return err
  18852 		}
  18853 		if done {
  18854 			break
  18855 		}
  18856 		switch {
  18857 		case strings.EqualFold("member", t.Name.Local):
  18858 			var col types.KeySigningKey
  18859 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18860 			destAddr := &col
  18861 			if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil {
  18862 				return err
  18863 			}
  18864 			col = *destAddr
  18865 			sv = append(sv, col)
  18866 
  18867 		default:
  18868 			err = decoder.Decoder.Skip()
  18869 			if err != nil {
  18870 				return err
  18871 			}
  18872 
  18873 		}
  18874 		decoder = originalDecoder
  18875 	}
  18876 	*v = sv
  18877 	return nil
  18878 }
  18879 
  18880 func awsRestxml_deserializeDocumentKeySigningKeysUnwrapped(v *[]types.KeySigningKey, decoder smithyxml.NodeDecoder) error {
  18881 	var sv []types.KeySigningKey
  18882 	if *v == nil {
  18883 		sv = make([]types.KeySigningKey, 0)
  18884 	} else {
  18885 		sv = *v
  18886 	}
  18887 
  18888 	switch {
  18889 	default:
  18890 		var mv types.KeySigningKey
  18891 		t := decoder.StartEl
  18892 		_ = t
  18893 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  18894 		destAddr := &mv
  18895 		if err := awsRestxml_deserializeDocumentKeySigningKey(&destAddr, nodeDecoder); err != nil {
  18896 			return err
  18897 		}
  18898 		mv = *destAddr
  18899 		sv = append(sv, mv)
  18900 	}
  18901 	*v = sv
  18902 	return nil
  18903 }
  18904 func awsRestxml_deserializeDocumentKeySigningKeyWithActiveStatusNotFound(v **types.KeySigningKeyWithActiveStatusNotFound, decoder smithyxml.NodeDecoder) error {
  18905 	if v == nil {
  18906 		return fmt.Errorf("unexpected nil of type %T", v)
  18907 	}
  18908 	var sv *types.KeySigningKeyWithActiveStatusNotFound
  18909 	if *v == nil {
  18910 		sv = &types.KeySigningKeyWithActiveStatusNotFound{}
  18911 	} else {
  18912 		sv = *v
  18913 	}
  18914 
  18915 	for {
  18916 		t, done, err := decoder.Token()
  18917 		if err != nil {
  18918 			return err
  18919 		}
  18920 		if done {
  18921 			break
  18922 		}
  18923 		originalDecoder := decoder
  18924 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18925 		switch {
  18926 		case strings.EqualFold("message", t.Name.Local):
  18927 			val, err := decoder.Value()
  18928 			if err != nil {
  18929 				return err
  18930 			}
  18931 			if val == nil {
  18932 				break
  18933 			}
  18934 			{
  18935 				xtv := string(val)
  18936 				sv.Message = ptr.String(xtv)
  18937 			}
  18938 
  18939 		default:
  18940 			// Do nothing and ignore the unexpected tag element
  18941 			err = decoder.Decoder.Skip()
  18942 			if err != nil {
  18943 				return err
  18944 			}
  18945 
  18946 		}
  18947 		decoder = originalDecoder
  18948 	}
  18949 	*v = sv
  18950 	return nil
  18951 }
  18952 
  18953 func awsRestxml_deserializeDocumentLastVPCAssociation(v **types.LastVPCAssociation, decoder smithyxml.NodeDecoder) error {
  18954 	if v == nil {
  18955 		return fmt.Errorf("unexpected nil of type %T", v)
  18956 	}
  18957 	var sv *types.LastVPCAssociation
  18958 	if *v == nil {
  18959 		sv = &types.LastVPCAssociation{}
  18960 	} else {
  18961 		sv = *v
  18962 	}
  18963 
  18964 	for {
  18965 		t, done, err := decoder.Token()
  18966 		if err != nil {
  18967 			return err
  18968 		}
  18969 		if done {
  18970 			break
  18971 		}
  18972 		originalDecoder := decoder
  18973 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  18974 		switch {
  18975 		case strings.EqualFold("message", t.Name.Local):
  18976 			val, err := decoder.Value()
  18977 			if err != nil {
  18978 				return err
  18979 			}
  18980 			if val == nil {
  18981 				break
  18982 			}
  18983 			{
  18984 				xtv := string(val)
  18985 				sv.Message = ptr.String(xtv)
  18986 			}
  18987 
  18988 		default:
  18989 			// Do nothing and ignore the unexpected tag element
  18990 			err = decoder.Decoder.Skip()
  18991 			if err != nil {
  18992 				return err
  18993 			}
  18994 
  18995 		}
  18996 		decoder = originalDecoder
  18997 	}
  18998 	*v = sv
  18999 	return nil
  19000 }
  19001 
  19002 func awsRestxml_deserializeDocumentLimitsExceeded(v **types.LimitsExceeded, decoder smithyxml.NodeDecoder) error {
  19003 	if v == nil {
  19004 		return fmt.Errorf("unexpected nil of type %T", v)
  19005 	}
  19006 	var sv *types.LimitsExceeded
  19007 	if *v == nil {
  19008 		sv = &types.LimitsExceeded{}
  19009 	} else {
  19010 		sv = *v
  19011 	}
  19012 
  19013 	for {
  19014 		t, done, err := decoder.Token()
  19015 		if err != nil {
  19016 			return err
  19017 		}
  19018 		if done {
  19019 			break
  19020 		}
  19021 		originalDecoder := decoder
  19022 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19023 		switch {
  19024 		case strings.EqualFold("message", t.Name.Local):
  19025 			val, err := decoder.Value()
  19026 			if err != nil {
  19027 				return err
  19028 			}
  19029 			if val == nil {
  19030 				break
  19031 			}
  19032 			{
  19033 				xtv := string(val)
  19034 				sv.Message = ptr.String(xtv)
  19035 			}
  19036 
  19037 		default:
  19038 			// Do nothing and ignore the unexpected tag element
  19039 			err = decoder.Decoder.Skip()
  19040 			if err != nil {
  19041 				return err
  19042 			}
  19043 
  19044 		}
  19045 		decoder = originalDecoder
  19046 	}
  19047 	*v = sv
  19048 	return nil
  19049 }
  19050 
  19051 func awsRestxml_deserializeDocumentLinkedService(v **types.LinkedService, decoder smithyxml.NodeDecoder) error {
  19052 	if v == nil {
  19053 		return fmt.Errorf("unexpected nil of type %T", v)
  19054 	}
  19055 	var sv *types.LinkedService
  19056 	if *v == nil {
  19057 		sv = &types.LinkedService{}
  19058 	} else {
  19059 		sv = *v
  19060 	}
  19061 
  19062 	for {
  19063 		t, done, err := decoder.Token()
  19064 		if err != nil {
  19065 			return err
  19066 		}
  19067 		if done {
  19068 			break
  19069 		}
  19070 		originalDecoder := decoder
  19071 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19072 		switch {
  19073 		case strings.EqualFold("Description", t.Name.Local):
  19074 			val, err := decoder.Value()
  19075 			if err != nil {
  19076 				return err
  19077 			}
  19078 			if val == nil {
  19079 				break
  19080 			}
  19081 			{
  19082 				xtv := string(val)
  19083 				sv.Description = ptr.String(xtv)
  19084 			}
  19085 
  19086 		case strings.EqualFold("ServicePrincipal", t.Name.Local):
  19087 			val, err := decoder.Value()
  19088 			if err != nil {
  19089 				return err
  19090 			}
  19091 			if val == nil {
  19092 				break
  19093 			}
  19094 			{
  19095 				xtv := string(val)
  19096 				sv.ServicePrincipal = ptr.String(xtv)
  19097 			}
  19098 
  19099 		default:
  19100 			// Do nothing and ignore the unexpected tag element
  19101 			err = decoder.Decoder.Skip()
  19102 			if err != nil {
  19103 				return err
  19104 			}
  19105 
  19106 		}
  19107 		decoder = originalDecoder
  19108 	}
  19109 	*v = sv
  19110 	return nil
  19111 }
  19112 
  19113 func awsRestxml_deserializeDocumentLocationSummaries(v *[]types.LocationSummary, decoder smithyxml.NodeDecoder) error {
  19114 	if v == nil {
  19115 		return fmt.Errorf("unexpected nil of type %T", v)
  19116 	}
  19117 	var sv []types.LocationSummary
  19118 	if *v == nil {
  19119 		sv = make([]types.LocationSummary, 0)
  19120 	} else {
  19121 		sv = *v
  19122 	}
  19123 
  19124 	originalDecoder := decoder
  19125 	for {
  19126 		t, done, err := decoder.Token()
  19127 		if err != nil {
  19128 			return err
  19129 		}
  19130 		if done {
  19131 			break
  19132 		}
  19133 		switch {
  19134 		case strings.EqualFold("member", t.Name.Local):
  19135 			var col types.LocationSummary
  19136 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  19137 			destAddr := &col
  19138 			if err := awsRestxml_deserializeDocumentLocationSummary(&destAddr, nodeDecoder); err != nil {
  19139 				return err
  19140 			}
  19141 			col = *destAddr
  19142 			sv = append(sv, col)
  19143 
  19144 		default:
  19145 			err = decoder.Decoder.Skip()
  19146 			if err != nil {
  19147 				return err
  19148 			}
  19149 
  19150 		}
  19151 		decoder = originalDecoder
  19152 	}
  19153 	*v = sv
  19154 	return nil
  19155 }
  19156 
  19157 func awsRestxml_deserializeDocumentLocationSummariesUnwrapped(v *[]types.LocationSummary, decoder smithyxml.NodeDecoder) error {
  19158 	var sv []types.LocationSummary
  19159 	if *v == nil {
  19160 		sv = make([]types.LocationSummary, 0)
  19161 	} else {
  19162 		sv = *v
  19163 	}
  19164 
  19165 	switch {
  19166 	default:
  19167 		var mv types.LocationSummary
  19168 		t := decoder.StartEl
  19169 		_ = t
  19170 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  19171 		destAddr := &mv
  19172 		if err := awsRestxml_deserializeDocumentLocationSummary(&destAddr, nodeDecoder); err != nil {
  19173 			return err
  19174 		}
  19175 		mv = *destAddr
  19176 		sv = append(sv, mv)
  19177 	}
  19178 	*v = sv
  19179 	return nil
  19180 }
  19181 func awsRestxml_deserializeDocumentLocationSummary(v **types.LocationSummary, decoder smithyxml.NodeDecoder) error {
  19182 	if v == nil {
  19183 		return fmt.Errorf("unexpected nil of type %T", v)
  19184 	}
  19185 	var sv *types.LocationSummary
  19186 	if *v == nil {
  19187 		sv = &types.LocationSummary{}
  19188 	} else {
  19189 		sv = *v
  19190 	}
  19191 
  19192 	for {
  19193 		t, done, err := decoder.Token()
  19194 		if err != nil {
  19195 			return err
  19196 		}
  19197 		if done {
  19198 			break
  19199 		}
  19200 		originalDecoder := decoder
  19201 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19202 		switch {
  19203 		case strings.EqualFold("LocationName", t.Name.Local):
  19204 			val, err := decoder.Value()
  19205 			if err != nil {
  19206 				return err
  19207 			}
  19208 			if val == nil {
  19209 				break
  19210 			}
  19211 			{
  19212 				xtv := string(val)
  19213 				sv.LocationName = ptr.String(xtv)
  19214 			}
  19215 
  19216 		default:
  19217 			// Do nothing and ignore the unexpected tag element
  19218 			err = decoder.Decoder.Skip()
  19219 			if err != nil {
  19220 				return err
  19221 			}
  19222 
  19223 		}
  19224 		decoder = originalDecoder
  19225 	}
  19226 	*v = sv
  19227 	return nil
  19228 }
  19229 
  19230 func awsRestxml_deserializeDocumentNoSuchChange(v **types.NoSuchChange, decoder smithyxml.NodeDecoder) error {
  19231 	if v == nil {
  19232 		return fmt.Errorf("unexpected nil of type %T", v)
  19233 	}
  19234 	var sv *types.NoSuchChange
  19235 	if *v == nil {
  19236 		sv = &types.NoSuchChange{}
  19237 	} else {
  19238 		sv = *v
  19239 	}
  19240 
  19241 	for {
  19242 		t, done, err := decoder.Token()
  19243 		if err != nil {
  19244 			return err
  19245 		}
  19246 		if done {
  19247 			break
  19248 		}
  19249 		originalDecoder := decoder
  19250 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19251 		switch {
  19252 		case strings.EqualFold("message", t.Name.Local):
  19253 			val, err := decoder.Value()
  19254 			if err != nil {
  19255 				return err
  19256 			}
  19257 			if val == nil {
  19258 				break
  19259 			}
  19260 			{
  19261 				xtv := string(val)
  19262 				sv.Message = ptr.String(xtv)
  19263 			}
  19264 
  19265 		default:
  19266 			// Do nothing and ignore the unexpected tag element
  19267 			err = decoder.Decoder.Skip()
  19268 			if err != nil {
  19269 				return err
  19270 			}
  19271 
  19272 		}
  19273 		decoder = originalDecoder
  19274 	}
  19275 	*v = sv
  19276 	return nil
  19277 }
  19278 
  19279 func awsRestxml_deserializeDocumentNoSuchCidrCollectionException(v **types.NoSuchCidrCollectionException, decoder smithyxml.NodeDecoder) error {
  19280 	if v == nil {
  19281 		return fmt.Errorf("unexpected nil of type %T", v)
  19282 	}
  19283 	var sv *types.NoSuchCidrCollectionException
  19284 	if *v == nil {
  19285 		sv = &types.NoSuchCidrCollectionException{}
  19286 	} else {
  19287 		sv = *v
  19288 	}
  19289 
  19290 	for {
  19291 		t, done, err := decoder.Token()
  19292 		if err != nil {
  19293 			return err
  19294 		}
  19295 		if done {
  19296 			break
  19297 		}
  19298 		originalDecoder := decoder
  19299 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19300 		switch {
  19301 		case strings.EqualFold("Message", t.Name.Local):
  19302 			val, err := decoder.Value()
  19303 			if err != nil {
  19304 				return err
  19305 			}
  19306 			if val == nil {
  19307 				break
  19308 			}
  19309 			{
  19310 				xtv := string(val)
  19311 				sv.Message = ptr.String(xtv)
  19312 			}
  19313 
  19314 		default:
  19315 			// Do nothing and ignore the unexpected tag element
  19316 			err = decoder.Decoder.Skip()
  19317 			if err != nil {
  19318 				return err
  19319 			}
  19320 
  19321 		}
  19322 		decoder = originalDecoder
  19323 	}
  19324 	*v = sv
  19325 	return nil
  19326 }
  19327 
  19328 func awsRestxml_deserializeDocumentNoSuchCidrLocationException(v **types.NoSuchCidrLocationException, decoder smithyxml.NodeDecoder) error {
  19329 	if v == nil {
  19330 		return fmt.Errorf("unexpected nil of type %T", v)
  19331 	}
  19332 	var sv *types.NoSuchCidrLocationException
  19333 	if *v == nil {
  19334 		sv = &types.NoSuchCidrLocationException{}
  19335 	} else {
  19336 		sv = *v
  19337 	}
  19338 
  19339 	for {
  19340 		t, done, err := decoder.Token()
  19341 		if err != nil {
  19342 			return err
  19343 		}
  19344 		if done {
  19345 			break
  19346 		}
  19347 		originalDecoder := decoder
  19348 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19349 		switch {
  19350 		case strings.EqualFold("Message", t.Name.Local):
  19351 			val, err := decoder.Value()
  19352 			if err != nil {
  19353 				return err
  19354 			}
  19355 			if val == nil {
  19356 				break
  19357 			}
  19358 			{
  19359 				xtv := string(val)
  19360 				sv.Message = ptr.String(xtv)
  19361 			}
  19362 
  19363 		default:
  19364 			// Do nothing and ignore the unexpected tag element
  19365 			err = decoder.Decoder.Skip()
  19366 			if err != nil {
  19367 				return err
  19368 			}
  19369 
  19370 		}
  19371 		decoder = originalDecoder
  19372 	}
  19373 	*v = sv
  19374 	return nil
  19375 }
  19376 
  19377 func awsRestxml_deserializeDocumentNoSuchCloudWatchLogsLogGroup(v **types.NoSuchCloudWatchLogsLogGroup, decoder smithyxml.NodeDecoder) error {
  19378 	if v == nil {
  19379 		return fmt.Errorf("unexpected nil of type %T", v)
  19380 	}
  19381 	var sv *types.NoSuchCloudWatchLogsLogGroup
  19382 	if *v == nil {
  19383 		sv = &types.NoSuchCloudWatchLogsLogGroup{}
  19384 	} else {
  19385 		sv = *v
  19386 	}
  19387 
  19388 	for {
  19389 		t, done, err := decoder.Token()
  19390 		if err != nil {
  19391 			return err
  19392 		}
  19393 		if done {
  19394 			break
  19395 		}
  19396 		originalDecoder := decoder
  19397 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19398 		switch {
  19399 		case strings.EqualFold("message", t.Name.Local):
  19400 			val, err := decoder.Value()
  19401 			if err != nil {
  19402 				return err
  19403 			}
  19404 			if val == nil {
  19405 				break
  19406 			}
  19407 			{
  19408 				xtv := string(val)
  19409 				sv.Message = ptr.String(xtv)
  19410 			}
  19411 
  19412 		default:
  19413 			// Do nothing and ignore the unexpected tag element
  19414 			err = decoder.Decoder.Skip()
  19415 			if err != nil {
  19416 				return err
  19417 			}
  19418 
  19419 		}
  19420 		decoder = originalDecoder
  19421 	}
  19422 	*v = sv
  19423 	return nil
  19424 }
  19425 
  19426 func awsRestxml_deserializeDocumentNoSuchDelegationSet(v **types.NoSuchDelegationSet, decoder smithyxml.NodeDecoder) error {
  19427 	if v == nil {
  19428 		return fmt.Errorf("unexpected nil of type %T", v)
  19429 	}
  19430 	var sv *types.NoSuchDelegationSet
  19431 	if *v == nil {
  19432 		sv = &types.NoSuchDelegationSet{}
  19433 	} else {
  19434 		sv = *v
  19435 	}
  19436 
  19437 	for {
  19438 		t, done, err := decoder.Token()
  19439 		if err != nil {
  19440 			return err
  19441 		}
  19442 		if done {
  19443 			break
  19444 		}
  19445 		originalDecoder := decoder
  19446 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19447 		switch {
  19448 		case strings.EqualFold("message", t.Name.Local):
  19449 			val, err := decoder.Value()
  19450 			if err != nil {
  19451 				return err
  19452 			}
  19453 			if val == nil {
  19454 				break
  19455 			}
  19456 			{
  19457 				xtv := string(val)
  19458 				sv.Message = ptr.String(xtv)
  19459 			}
  19460 
  19461 		default:
  19462 			// Do nothing and ignore the unexpected tag element
  19463 			err = decoder.Decoder.Skip()
  19464 			if err != nil {
  19465 				return err
  19466 			}
  19467 
  19468 		}
  19469 		decoder = originalDecoder
  19470 	}
  19471 	*v = sv
  19472 	return nil
  19473 }
  19474 
  19475 func awsRestxml_deserializeDocumentNoSuchGeoLocation(v **types.NoSuchGeoLocation, decoder smithyxml.NodeDecoder) error {
  19476 	if v == nil {
  19477 		return fmt.Errorf("unexpected nil of type %T", v)
  19478 	}
  19479 	var sv *types.NoSuchGeoLocation
  19480 	if *v == nil {
  19481 		sv = &types.NoSuchGeoLocation{}
  19482 	} else {
  19483 		sv = *v
  19484 	}
  19485 
  19486 	for {
  19487 		t, done, err := decoder.Token()
  19488 		if err != nil {
  19489 			return err
  19490 		}
  19491 		if done {
  19492 			break
  19493 		}
  19494 		originalDecoder := decoder
  19495 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19496 		switch {
  19497 		case strings.EqualFold("message", t.Name.Local):
  19498 			val, err := decoder.Value()
  19499 			if err != nil {
  19500 				return err
  19501 			}
  19502 			if val == nil {
  19503 				break
  19504 			}
  19505 			{
  19506 				xtv := string(val)
  19507 				sv.Message = ptr.String(xtv)
  19508 			}
  19509 
  19510 		default:
  19511 			// Do nothing and ignore the unexpected tag element
  19512 			err = decoder.Decoder.Skip()
  19513 			if err != nil {
  19514 				return err
  19515 			}
  19516 
  19517 		}
  19518 		decoder = originalDecoder
  19519 	}
  19520 	*v = sv
  19521 	return nil
  19522 }
  19523 
  19524 func awsRestxml_deserializeDocumentNoSuchHealthCheck(v **types.NoSuchHealthCheck, decoder smithyxml.NodeDecoder) error {
  19525 	if v == nil {
  19526 		return fmt.Errorf("unexpected nil of type %T", v)
  19527 	}
  19528 	var sv *types.NoSuchHealthCheck
  19529 	if *v == nil {
  19530 		sv = &types.NoSuchHealthCheck{}
  19531 	} else {
  19532 		sv = *v
  19533 	}
  19534 
  19535 	for {
  19536 		t, done, err := decoder.Token()
  19537 		if err != nil {
  19538 			return err
  19539 		}
  19540 		if done {
  19541 			break
  19542 		}
  19543 		originalDecoder := decoder
  19544 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19545 		switch {
  19546 		case strings.EqualFold("message", t.Name.Local):
  19547 			val, err := decoder.Value()
  19548 			if err != nil {
  19549 				return err
  19550 			}
  19551 			if val == nil {
  19552 				break
  19553 			}
  19554 			{
  19555 				xtv := string(val)
  19556 				sv.Message = ptr.String(xtv)
  19557 			}
  19558 
  19559 		default:
  19560 			// Do nothing and ignore the unexpected tag element
  19561 			err = decoder.Decoder.Skip()
  19562 			if err != nil {
  19563 				return err
  19564 			}
  19565 
  19566 		}
  19567 		decoder = originalDecoder
  19568 	}
  19569 	*v = sv
  19570 	return nil
  19571 }
  19572 
  19573 func awsRestxml_deserializeDocumentNoSuchHostedZone(v **types.NoSuchHostedZone, decoder smithyxml.NodeDecoder) error {
  19574 	if v == nil {
  19575 		return fmt.Errorf("unexpected nil of type %T", v)
  19576 	}
  19577 	var sv *types.NoSuchHostedZone
  19578 	if *v == nil {
  19579 		sv = &types.NoSuchHostedZone{}
  19580 	} else {
  19581 		sv = *v
  19582 	}
  19583 
  19584 	for {
  19585 		t, done, err := decoder.Token()
  19586 		if err != nil {
  19587 			return err
  19588 		}
  19589 		if done {
  19590 			break
  19591 		}
  19592 		originalDecoder := decoder
  19593 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19594 		switch {
  19595 		case strings.EqualFold("message", t.Name.Local):
  19596 			val, err := decoder.Value()
  19597 			if err != nil {
  19598 				return err
  19599 			}
  19600 			if val == nil {
  19601 				break
  19602 			}
  19603 			{
  19604 				xtv := string(val)
  19605 				sv.Message = ptr.String(xtv)
  19606 			}
  19607 
  19608 		default:
  19609 			// Do nothing and ignore the unexpected tag element
  19610 			err = decoder.Decoder.Skip()
  19611 			if err != nil {
  19612 				return err
  19613 			}
  19614 
  19615 		}
  19616 		decoder = originalDecoder
  19617 	}
  19618 	*v = sv
  19619 	return nil
  19620 }
  19621 
  19622 func awsRestxml_deserializeDocumentNoSuchKeySigningKey(v **types.NoSuchKeySigningKey, decoder smithyxml.NodeDecoder) error {
  19623 	if v == nil {
  19624 		return fmt.Errorf("unexpected nil of type %T", v)
  19625 	}
  19626 	var sv *types.NoSuchKeySigningKey
  19627 	if *v == nil {
  19628 		sv = &types.NoSuchKeySigningKey{}
  19629 	} else {
  19630 		sv = *v
  19631 	}
  19632 
  19633 	for {
  19634 		t, done, err := decoder.Token()
  19635 		if err != nil {
  19636 			return err
  19637 		}
  19638 		if done {
  19639 			break
  19640 		}
  19641 		originalDecoder := decoder
  19642 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19643 		switch {
  19644 		case strings.EqualFold("message", t.Name.Local):
  19645 			val, err := decoder.Value()
  19646 			if err != nil {
  19647 				return err
  19648 			}
  19649 			if val == nil {
  19650 				break
  19651 			}
  19652 			{
  19653 				xtv := string(val)
  19654 				sv.Message = ptr.String(xtv)
  19655 			}
  19656 
  19657 		default:
  19658 			// Do nothing and ignore the unexpected tag element
  19659 			err = decoder.Decoder.Skip()
  19660 			if err != nil {
  19661 				return err
  19662 			}
  19663 
  19664 		}
  19665 		decoder = originalDecoder
  19666 	}
  19667 	*v = sv
  19668 	return nil
  19669 }
  19670 
  19671 func awsRestxml_deserializeDocumentNoSuchQueryLoggingConfig(v **types.NoSuchQueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  19672 	if v == nil {
  19673 		return fmt.Errorf("unexpected nil of type %T", v)
  19674 	}
  19675 	var sv *types.NoSuchQueryLoggingConfig
  19676 	if *v == nil {
  19677 		sv = &types.NoSuchQueryLoggingConfig{}
  19678 	} else {
  19679 		sv = *v
  19680 	}
  19681 
  19682 	for {
  19683 		t, done, err := decoder.Token()
  19684 		if err != nil {
  19685 			return err
  19686 		}
  19687 		if done {
  19688 			break
  19689 		}
  19690 		originalDecoder := decoder
  19691 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19692 		switch {
  19693 		case strings.EqualFold("message", t.Name.Local):
  19694 			val, err := decoder.Value()
  19695 			if err != nil {
  19696 				return err
  19697 			}
  19698 			if val == nil {
  19699 				break
  19700 			}
  19701 			{
  19702 				xtv := string(val)
  19703 				sv.Message = ptr.String(xtv)
  19704 			}
  19705 
  19706 		default:
  19707 			// Do nothing and ignore the unexpected tag element
  19708 			err = decoder.Decoder.Skip()
  19709 			if err != nil {
  19710 				return err
  19711 			}
  19712 
  19713 		}
  19714 		decoder = originalDecoder
  19715 	}
  19716 	*v = sv
  19717 	return nil
  19718 }
  19719 
  19720 func awsRestxml_deserializeDocumentNoSuchTrafficPolicy(v **types.NoSuchTrafficPolicy, decoder smithyxml.NodeDecoder) error {
  19721 	if v == nil {
  19722 		return fmt.Errorf("unexpected nil of type %T", v)
  19723 	}
  19724 	var sv *types.NoSuchTrafficPolicy
  19725 	if *v == nil {
  19726 		sv = &types.NoSuchTrafficPolicy{}
  19727 	} else {
  19728 		sv = *v
  19729 	}
  19730 
  19731 	for {
  19732 		t, done, err := decoder.Token()
  19733 		if err != nil {
  19734 			return err
  19735 		}
  19736 		if done {
  19737 			break
  19738 		}
  19739 		originalDecoder := decoder
  19740 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19741 		switch {
  19742 		case strings.EqualFold("message", t.Name.Local):
  19743 			val, err := decoder.Value()
  19744 			if err != nil {
  19745 				return err
  19746 			}
  19747 			if val == nil {
  19748 				break
  19749 			}
  19750 			{
  19751 				xtv := string(val)
  19752 				sv.Message = ptr.String(xtv)
  19753 			}
  19754 
  19755 		default:
  19756 			// Do nothing and ignore the unexpected tag element
  19757 			err = decoder.Decoder.Skip()
  19758 			if err != nil {
  19759 				return err
  19760 			}
  19761 
  19762 		}
  19763 		decoder = originalDecoder
  19764 	}
  19765 	*v = sv
  19766 	return nil
  19767 }
  19768 
  19769 func awsRestxml_deserializeDocumentNoSuchTrafficPolicyInstance(v **types.NoSuchTrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  19770 	if v == nil {
  19771 		return fmt.Errorf("unexpected nil of type %T", v)
  19772 	}
  19773 	var sv *types.NoSuchTrafficPolicyInstance
  19774 	if *v == nil {
  19775 		sv = &types.NoSuchTrafficPolicyInstance{}
  19776 	} else {
  19777 		sv = *v
  19778 	}
  19779 
  19780 	for {
  19781 		t, done, err := decoder.Token()
  19782 		if err != nil {
  19783 			return err
  19784 		}
  19785 		if done {
  19786 			break
  19787 		}
  19788 		originalDecoder := decoder
  19789 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19790 		switch {
  19791 		case strings.EqualFold("message", t.Name.Local):
  19792 			val, err := decoder.Value()
  19793 			if err != nil {
  19794 				return err
  19795 			}
  19796 			if val == nil {
  19797 				break
  19798 			}
  19799 			{
  19800 				xtv := string(val)
  19801 				sv.Message = ptr.String(xtv)
  19802 			}
  19803 
  19804 		default:
  19805 			// Do nothing and ignore the unexpected tag element
  19806 			err = decoder.Decoder.Skip()
  19807 			if err != nil {
  19808 				return err
  19809 			}
  19810 
  19811 		}
  19812 		decoder = originalDecoder
  19813 	}
  19814 	*v = sv
  19815 	return nil
  19816 }
  19817 
  19818 func awsRestxml_deserializeDocumentNotAuthorizedException(v **types.NotAuthorizedException, decoder smithyxml.NodeDecoder) error {
  19819 	if v == nil {
  19820 		return fmt.Errorf("unexpected nil of type %T", v)
  19821 	}
  19822 	var sv *types.NotAuthorizedException
  19823 	if *v == nil {
  19824 		sv = &types.NotAuthorizedException{}
  19825 	} else {
  19826 		sv = *v
  19827 	}
  19828 
  19829 	for {
  19830 		t, done, err := decoder.Token()
  19831 		if err != nil {
  19832 			return err
  19833 		}
  19834 		if done {
  19835 			break
  19836 		}
  19837 		originalDecoder := decoder
  19838 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19839 		switch {
  19840 		case strings.EqualFold("message", t.Name.Local):
  19841 			val, err := decoder.Value()
  19842 			if err != nil {
  19843 				return err
  19844 			}
  19845 			if val == nil {
  19846 				break
  19847 			}
  19848 			{
  19849 				xtv := string(val)
  19850 				sv.Message = ptr.String(xtv)
  19851 			}
  19852 
  19853 		default:
  19854 			// Do nothing and ignore the unexpected tag element
  19855 			err = decoder.Decoder.Skip()
  19856 			if err != nil {
  19857 				return err
  19858 			}
  19859 
  19860 		}
  19861 		decoder = originalDecoder
  19862 	}
  19863 	*v = sv
  19864 	return nil
  19865 }
  19866 
  19867 func awsRestxml_deserializeDocumentPriorRequestNotComplete(v **types.PriorRequestNotComplete, decoder smithyxml.NodeDecoder) error {
  19868 	if v == nil {
  19869 		return fmt.Errorf("unexpected nil of type %T", v)
  19870 	}
  19871 	var sv *types.PriorRequestNotComplete
  19872 	if *v == nil {
  19873 		sv = &types.PriorRequestNotComplete{}
  19874 	} else {
  19875 		sv = *v
  19876 	}
  19877 
  19878 	for {
  19879 		t, done, err := decoder.Token()
  19880 		if err != nil {
  19881 			return err
  19882 		}
  19883 		if done {
  19884 			break
  19885 		}
  19886 		originalDecoder := decoder
  19887 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19888 		switch {
  19889 		case strings.EqualFold("message", t.Name.Local):
  19890 			val, err := decoder.Value()
  19891 			if err != nil {
  19892 				return err
  19893 			}
  19894 			if val == nil {
  19895 				break
  19896 			}
  19897 			{
  19898 				xtv := string(val)
  19899 				sv.Message = ptr.String(xtv)
  19900 			}
  19901 
  19902 		default:
  19903 			// Do nothing and ignore the unexpected tag element
  19904 			err = decoder.Decoder.Skip()
  19905 			if err != nil {
  19906 				return err
  19907 			}
  19908 
  19909 		}
  19910 		decoder = originalDecoder
  19911 	}
  19912 	*v = sv
  19913 	return nil
  19914 }
  19915 
  19916 func awsRestxml_deserializeDocumentPublicZoneVPCAssociation(v **types.PublicZoneVPCAssociation, decoder smithyxml.NodeDecoder) error {
  19917 	if v == nil {
  19918 		return fmt.Errorf("unexpected nil of type %T", v)
  19919 	}
  19920 	var sv *types.PublicZoneVPCAssociation
  19921 	if *v == nil {
  19922 		sv = &types.PublicZoneVPCAssociation{}
  19923 	} else {
  19924 		sv = *v
  19925 	}
  19926 
  19927 	for {
  19928 		t, done, err := decoder.Token()
  19929 		if err != nil {
  19930 			return err
  19931 		}
  19932 		if done {
  19933 			break
  19934 		}
  19935 		originalDecoder := decoder
  19936 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19937 		switch {
  19938 		case strings.EqualFold("message", t.Name.Local):
  19939 			val, err := decoder.Value()
  19940 			if err != nil {
  19941 				return err
  19942 			}
  19943 			if val == nil {
  19944 				break
  19945 			}
  19946 			{
  19947 				xtv := string(val)
  19948 				sv.Message = ptr.String(xtv)
  19949 			}
  19950 
  19951 		default:
  19952 			// Do nothing and ignore the unexpected tag element
  19953 			err = decoder.Decoder.Skip()
  19954 			if err != nil {
  19955 				return err
  19956 			}
  19957 
  19958 		}
  19959 		decoder = originalDecoder
  19960 	}
  19961 	*v = sv
  19962 	return nil
  19963 }
  19964 
  19965 func awsRestxml_deserializeDocumentQueryLoggingConfig(v **types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  19966 	if v == nil {
  19967 		return fmt.Errorf("unexpected nil of type %T", v)
  19968 	}
  19969 	var sv *types.QueryLoggingConfig
  19970 	if *v == nil {
  19971 		sv = &types.QueryLoggingConfig{}
  19972 	} else {
  19973 		sv = *v
  19974 	}
  19975 
  19976 	for {
  19977 		t, done, err := decoder.Token()
  19978 		if err != nil {
  19979 			return err
  19980 		}
  19981 		if done {
  19982 			break
  19983 		}
  19984 		originalDecoder := decoder
  19985 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  19986 		switch {
  19987 		case strings.EqualFold("CloudWatchLogsLogGroupArn", t.Name.Local):
  19988 			val, err := decoder.Value()
  19989 			if err != nil {
  19990 				return err
  19991 			}
  19992 			if val == nil {
  19993 				break
  19994 			}
  19995 			{
  19996 				xtv := string(val)
  19997 				sv.CloudWatchLogsLogGroupArn = ptr.String(xtv)
  19998 			}
  19999 
  20000 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  20001 			val, err := decoder.Value()
  20002 			if err != nil {
  20003 				return err
  20004 			}
  20005 			if val == nil {
  20006 				break
  20007 			}
  20008 			{
  20009 				xtv := string(val)
  20010 				sv.HostedZoneId = ptr.String(xtv)
  20011 			}
  20012 
  20013 		case strings.EqualFold("Id", t.Name.Local):
  20014 			val, err := decoder.Value()
  20015 			if err != nil {
  20016 				return err
  20017 			}
  20018 			if val == nil {
  20019 				break
  20020 			}
  20021 			{
  20022 				xtv := string(val)
  20023 				sv.Id = ptr.String(xtv)
  20024 			}
  20025 
  20026 		default:
  20027 			// Do nothing and ignore the unexpected tag element
  20028 			err = decoder.Decoder.Skip()
  20029 			if err != nil {
  20030 				return err
  20031 			}
  20032 
  20033 		}
  20034 		decoder = originalDecoder
  20035 	}
  20036 	*v = sv
  20037 	return nil
  20038 }
  20039 
  20040 func awsRestxml_deserializeDocumentQueryLoggingConfigAlreadyExists(v **types.QueryLoggingConfigAlreadyExists, decoder smithyxml.NodeDecoder) error {
  20041 	if v == nil {
  20042 		return fmt.Errorf("unexpected nil of type %T", v)
  20043 	}
  20044 	var sv *types.QueryLoggingConfigAlreadyExists
  20045 	if *v == nil {
  20046 		sv = &types.QueryLoggingConfigAlreadyExists{}
  20047 	} else {
  20048 		sv = *v
  20049 	}
  20050 
  20051 	for {
  20052 		t, done, err := decoder.Token()
  20053 		if err != nil {
  20054 			return err
  20055 		}
  20056 		if done {
  20057 			break
  20058 		}
  20059 		originalDecoder := decoder
  20060 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20061 		switch {
  20062 		case strings.EqualFold("message", t.Name.Local):
  20063 			val, err := decoder.Value()
  20064 			if err != nil {
  20065 				return err
  20066 			}
  20067 			if val == nil {
  20068 				break
  20069 			}
  20070 			{
  20071 				xtv := string(val)
  20072 				sv.Message = ptr.String(xtv)
  20073 			}
  20074 
  20075 		default:
  20076 			// Do nothing and ignore the unexpected tag element
  20077 			err = decoder.Decoder.Skip()
  20078 			if err != nil {
  20079 				return err
  20080 			}
  20081 
  20082 		}
  20083 		decoder = originalDecoder
  20084 	}
  20085 	*v = sv
  20086 	return nil
  20087 }
  20088 
  20089 func awsRestxml_deserializeDocumentQueryLoggingConfigs(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  20090 	if v == nil {
  20091 		return fmt.Errorf("unexpected nil of type %T", v)
  20092 	}
  20093 	var sv []types.QueryLoggingConfig
  20094 	if *v == nil {
  20095 		sv = make([]types.QueryLoggingConfig, 0)
  20096 	} else {
  20097 		sv = *v
  20098 	}
  20099 
  20100 	originalDecoder := decoder
  20101 	for {
  20102 		t, done, err := decoder.Token()
  20103 		if err != nil {
  20104 			return err
  20105 		}
  20106 		if done {
  20107 			break
  20108 		}
  20109 		switch {
  20110 		case strings.EqualFold("QueryLoggingConfig", t.Name.Local):
  20111 			var col types.QueryLoggingConfig
  20112 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20113 			destAddr := &col
  20114 			if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil {
  20115 				return err
  20116 			}
  20117 			col = *destAddr
  20118 			sv = append(sv, col)
  20119 
  20120 		default:
  20121 			err = decoder.Decoder.Skip()
  20122 			if err != nil {
  20123 				return err
  20124 			}
  20125 
  20126 		}
  20127 		decoder = originalDecoder
  20128 	}
  20129 	*v = sv
  20130 	return nil
  20131 }
  20132 
  20133 func awsRestxml_deserializeDocumentQueryLoggingConfigsUnwrapped(v *[]types.QueryLoggingConfig, decoder smithyxml.NodeDecoder) error {
  20134 	var sv []types.QueryLoggingConfig
  20135 	if *v == nil {
  20136 		sv = make([]types.QueryLoggingConfig, 0)
  20137 	} else {
  20138 		sv = *v
  20139 	}
  20140 
  20141 	switch {
  20142 	default:
  20143 		var mv types.QueryLoggingConfig
  20144 		t := decoder.StartEl
  20145 		_ = t
  20146 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20147 		destAddr := &mv
  20148 		if err := awsRestxml_deserializeDocumentQueryLoggingConfig(&destAddr, nodeDecoder); err != nil {
  20149 			return err
  20150 		}
  20151 		mv = *destAddr
  20152 		sv = append(sv, mv)
  20153 	}
  20154 	*v = sv
  20155 	return nil
  20156 }
  20157 func awsRestxml_deserializeDocumentRecordData(v *[]string, decoder smithyxml.NodeDecoder) error {
  20158 	if v == nil {
  20159 		return fmt.Errorf("unexpected nil of type %T", v)
  20160 	}
  20161 	var sv []string
  20162 	if *v == nil {
  20163 		sv = make([]string, 0)
  20164 	} else {
  20165 		sv = *v
  20166 	}
  20167 
  20168 	originalDecoder := decoder
  20169 	for {
  20170 		t, done, err := decoder.Token()
  20171 		if err != nil {
  20172 			return err
  20173 		}
  20174 		if done {
  20175 			break
  20176 		}
  20177 		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20178 		decoder = memberDecoder
  20179 		switch {
  20180 		case strings.EqualFold("RecordDataEntry", t.Name.Local):
  20181 			var col string
  20182 			val, err := decoder.Value()
  20183 			if err != nil {
  20184 				return err
  20185 			}
  20186 			if val == nil {
  20187 				break
  20188 			}
  20189 			{
  20190 				xtv := string(val)
  20191 				col = xtv
  20192 			}
  20193 			sv = append(sv, col)
  20194 
  20195 		default:
  20196 			err = decoder.Decoder.Skip()
  20197 			if err != nil {
  20198 				return err
  20199 			}
  20200 
  20201 		}
  20202 		decoder = originalDecoder
  20203 	}
  20204 	*v = sv
  20205 	return nil
  20206 }
  20207 
  20208 func awsRestxml_deserializeDocumentRecordDataUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
  20209 	var sv []string
  20210 	if *v == nil {
  20211 		sv = make([]string, 0)
  20212 	} else {
  20213 		sv = *v
  20214 	}
  20215 
  20216 	switch {
  20217 	default:
  20218 		var mv string
  20219 		t := decoder.StartEl
  20220 		_ = t
  20221 		val, err := decoder.Value()
  20222 		if err != nil {
  20223 			return err
  20224 		}
  20225 		if val == nil {
  20226 			break
  20227 		}
  20228 		{
  20229 			xtv := string(val)
  20230 			mv = xtv
  20231 		}
  20232 		sv = append(sv, mv)
  20233 	}
  20234 	*v = sv
  20235 	return nil
  20236 }
  20237 func awsRestxml_deserializeDocumentResourceRecord(v **types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
  20238 	if v == nil {
  20239 		return fmt.Errorf("unexpected nil of type %T", v)
  20240 	}
  20241 	var sv *types.ResourceRecord
  20242 	if *v == nil {
  20243 		sv = &types.ResourceRecord{}
  20244 	} else {
  20245 		sv = *v
  20246 	}
  20247 
  20248 	for {
  20249 		t, done, err := decoder.Token()
  20250 		if err != nil {
  20251 			return err
  20252 		}
  20253 		if done {
  20254 			break
  20255 		}
  20256 		originalDecoder := decoder
  20257 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20258 		switch {
  20259 		case strings.EqualFold("Value", t.Name.Local):
  20260 			val, err := decoder.Value()
  20261 			if err != nil {
  20262 				return err
  20263 			}
  20264 			if val == nil {
  20265 				break
  20266 			}
  20267 			{
  20268 				xtv := string(val)
  20269 				sv.Value = ptr.String(xtv)
  20270 			}
  20271 
  20272 		default:
  20273 			// Do nothing and ignore the unexpected tag element
  20274 			err = decoder.Decoder.Skip()
  20275 			if err != nil {
  20276 				return err
  20277 			}
  20278 
  20279 		}
  20280 		decoder = originalDecoder
  20281 	}
  20282 	*v = sv
  20283 	return nil
  20284 }
  20285 
  20286 func awsRestxml_deserializeDocumentResourceRecords(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
  20287 	if v == nil {
  20288 		return fmt.Errorf("unexpected nil of type %T", v)
  20289 	}
  20290 	var sv []types.ResourceRecord
  20291 	if *v == nil {
  20292 		sv = make([]types.ResourceRecord, 0)
  20293 	} else {
  20294 		sv = *v
  20295 	}
  20296 
  20297 	originalDecoder := decoder
  20298 	for {
  20299 		t, done, err := decoder.Token()
  20300 		if err != nil {
  20301 			return err
  20302 		}
  20303 		if done {
  20304 			break
  20305 		}
  20306 		switch {
  20307 		case strings.EqualFold("ResourceRecord", t.Name.Local):
  20308 			var col types.ResourceRecord
  20309 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20310 			destAddr := &col
  20311 			if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil {
  20312 				return err
  20313 			}
  20314 			col = *destAddr
  20315 			sv = append(sv, col)
  20316 
  20317 		default:
  20318 			err = decoder.Decoder.Skip()
  20319 			if err != nil {
  20320 				return err
  20321 			}
  20322 
  20323 		}
  20324 		decoder = originalDecoder
  20325 	}
  20326 	*v = sv
  20327 	return nil
  20328 }
  20329 
  20330 func awsRestxml_deserializeDocumentResourceRecordsUnwrapped(v *[]types.ResourceRecord, decoder smithyxml.NodeDecoder) error {
  20331 	var sv []types.ResourceRecord
  20332 	if *v == nil {
  20333 		sv = make([]types.ResourceRecord, 0)
  20334 	} else {
  20335 		sv = *v
  20336 	}
  20337 
  20338 	switch {
  20339 	default:
  20340 		var mv types.ResourceRecord
  20341 		t := decoder.StartEl
  20342 		_ = t
  20343 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20344 		destAddr := &mv
  20345 		if err := awsRestxml_deserializeDocumentResourceRecord(&destAddr, nodeDecoder); err != nil {
  20346 			return err
  20347 		}
  20348 		mv = *destAddr
  20349 		sv = append(sv, mv)
  20350 	}
  20351 	*v = sv
  20352 	return nil
  20353 }
  20354 func awsRestxml_deserializeDocumentResourceRecordSet(v **types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
  20355 	if v == nil {
  20356 		return fmt.Errorf("unexpected nil of type %T", v)
  20357 	}
  20358 	var sv *types.ResourceRecordSet
  20359 	if *v == nil {
  20360 		sv = &types.ResourceRecordSet{}
  20361 	} else {
  20362 		sv = *v
  20363 	}
  20364 
  20365 	for {
  20366 		t, done, err := decoder.Token()
  20367 		if err != nil {
  20368 			return err
  20369 		}
  20370 		if done {
  20371 			break
  20372 		}
  20373 		originalDecoder := decoder
  20374 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20375 		switch {
  20376 		case strings.EqualFold("AliasTarget", t.Name.Local):
  20377 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20378 			if err := awsRestxml_deserializeDocumentAliasTarget(&sv.AliasTarget, nodeDecoder); err != nil {
  20379 				return err
  20380 			}
  20381 
  20382 		case strings.EqualFold("CidrRoutingConfig", t.Name.Local):
  20383 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20384 			if err := awsRestxml_deserializeDocumentCidrRoutingConfig(&sv.CidrRoutingConfig, nodeDecoder); err != nil {
  20385 				return err
  20386 			}
  20387 
  20388 		case strings.EqualFold("Failover", t.Name.Local):
  20389 			val, err := decoder.Value()
  20390 			if err != nil {
  20391 				return err
  20392 			}
  20393 			if val == nil {
  20394 				break
  20395 			}
  20396 			{
  20397 				xtv := string(val)
  20398 				sv.Failover = types.ResourceRecordSetFailover(xtv)
  20399 			}
  20400 
  20401 		case strings.EqualFold("GeoLocation", t.Name.Local):
  20402 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20403 			if err := awsRestxml_deserializeDocumentGeoLocation(&sv.GeoLocation, nodeDecoder); err != nil {
  20404 				return err
  20405 			}
  20406 
  20407 		case strings.EqualFold("HealthCheckId", t.Name.Local):
  20408 			val, err := decoder.Value()
  20409 			if err != nil {
  20410 				return err
  20411 			}
  20412 			if val == nil {
  20413 				break
  20414 			}
  20415 			{
  20416 				xtv := string(val)
  20417 				sv.HealthCheckId = ptr.String(xtv)
  20418 			}
  20419 
  20420 		case strings.EqualFold("MultiValueAnswer", t.Name.Local):
  20421 			val, err := decoder.Value()
  20422 			if err != nil {
  20423 				return err
  20424 			}
  20425 			if val == nil {
  20426 				break
  20427 			}
  20428 			{
  20429 				xtv, err := strconv.ParseBool(string(val))
  20430 				if err != nil {
  20431 					return fmt.Errorf("expected ResourceRecordSetMultiValueAnswer to be of type *bool, got %T instead", val)
  20432 				}
  20433 				sv.MultiValueAnswer = ptr.Bool(xtv)
  20434 			}
  20435 
  20436 		case strings.EqualFold("Name", 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.Name = ptr.String(xtv)
  20447 			}
  20448 
  20449 		case strings.EqualFold("Region", t.Name.Local):
  20450 			val, err := decoder.Value()
  20451 			if err != nil {
  20452 				return err
  20453 			}
  20454 			if val == nil {
  20455 				break
  20456 			}
  20457 			{
  20458 				xtv := string(val)
  20459 				sv.Region = types.ResourceRecordSetRegion(xtv)
  20460 			}
  20461 
  20462 		case strings.EqualFold("ResourceRecords", t.Name.Local):
  20463 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20464 			if err := awsRestxml_deserializeDocumentResourceRecords(&sv.ResourceRecords, nodeDecoder); err != nil {
  20465 				return err
  20466 			}
  20467 
  20468 		case strings.EqualFold("SetIdentifier", t.Name.Local):
  20469 			val, err := decoder.Value()
  20470 			if err != nil {
  20471 				return err
  20472 			}
  20473 			if val == nil {
  20474 				break
  20475 			}
  20476 			{
  20477 				xtv := string(val)
  20478 				sv.SetIdentifier = ptr.String(xtv)
  20479 			}
  20480 
  20481 		case strings.EqualFold("TrafficPolicyInstanceId", t.Name.Local):
  20482 			val, err := decoder.Value()
  20483 			if err != nil {
  20484 				return err
  20485 			}
  20486 			if val == nil {
  20487 				break
  20488 			}
  20489 			{
  20490 				xtv := string(val)
  20491 				sv.TrafficPolicyInstanceId = ptr.String(xtv)
  20492 			}
  20493 
  20494 		case strings.EqualFold("TTL", t.Name.Local):
  20495 			val, err := decoder.Value()
  20496 			if err != nil {
  20497 				return err
  20498 			}
  20499 			if val == nil {
  20500 				break
  20501 			}
  20502 			{
  20503 				xtv := string(val)
  20504 				i64, err := strconv.ParseInt(xtv, 10, 64)
  20505 				if err != nil {
  20506 					return err
  20507 				}
  20508 				sv.TTL = ptr.Int64(i64)
  20509 			}
  20510 
  20511 		case strings.EqualFold("Type", 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.Type = types.RRType(xtv)
  20522 			}
  20523 
  20524 		case strings.EqualFold("Weight", t.Name.Local):
  20525 			val, err := decoder.Value()
  20526 			if err != nil {
  20527 				return err
  20528 			}
  20529 			if val == nil {
  20530 				break
  20531 			}
  20532 			{
  20533 				xtv := string(val)
  20534 				i64, err := strconv.ParseInt(xtv, 10, 64)
  20535 				if err != nil {
  20536 					return err
  20537 				}
  20538 				sv.Weight = ptr.Int64(i64)
  20539 			}
  20540 
  20541 		default:
  20542 			// Do nothing and ignore the unexpected tag element
  20543 			err = decoder.Decoder.Skip()
  20544 			if err != nil {
  20545 				return err
  20546 			}
  20547 
  20548 		}
  20549 		decoder = originalDecoder
  20550 	}
  20551 	*v = sv
  20552 	return nil
  20553 }
  20554 
  20555 func awsRestxml_deserializeDocumentResourceRecordSets(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
  20556 	if v == nil {
  20557 		return fmt.Errorf("unexpected nil of type %T", v)
  20558 	}
  20559 	var sv []types.ResourceRecordSet
  20560 	if *v == nil {
  20561 		sv = make([]types.ResourceRecordSet, 0)
  20562 	} else {
  20563 		sv = *v
  20564 	}
  20565 
  20566 	originalDecoder := decoder
  20567 	for {
  20568 		t, done, err := decoder.Token()
  20569 		if err != nil {
  20570 			return err
  20571 		}
  20572 		if done {
  20573 			break
  20574 		}
  20575 		switch {
  20576 		case strings.EqualFold("ResourceRecordSet", t.Name.Local):
  20577 			var col types.ResourceRecordSet
  20578 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20579 			destAddr := &col
  20580 			if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil {
  20581 				return err
  20582 			}
  20583 			col = *destAddr
  20584 			sv = append(sv, col)
  20585 
  20586 		default:
  20587 			err = decoder.Decoder.Skip()
  20588 			if err != nil {
  20589 				return err
  20590 			}
  20591 
  20592 		}
  20593 		decoder = originalDecoder
  20594 	}
  20595 	*v = sv
  20596 	return nil
  20597 }
  20598 
  20599 func awsRestxml_deserializeDocumentResourceRecordSetsUnwrapped(v *[]types.ResourceRecordSet, decoder smithyxml.NodeDecoder) error {
  20600 	var sv []types.ResourceRecordSet
  20601 	if *v == nil {
  20602 		sv = make([]types.ResourceRecordSet, 0)
  20603 	} else {
  20604 		sv = *v
  20605 	}
  20606 
  20607 	switch {
  20608 	default:
  20609 		var mv types.ResourceRecordSet
  20610 		t := decoder.StartEl
  20611 		_ = t
  20612 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20613 		destAddr := &mv
  20614 		if err := awsRestxml_deserializeDocumentResourceRecordSet(&destAddr, nodeDecoder); err != nil {
  20615 			return err
  20616 		}
  20617 		mv = *destAddr
  20618 		sv = append(sv, mv)
  20619 	}
  20620 	*v = sv
  20621 	return nil
  20622 }
  20623 func awsRestxml_deserializeDocumentResourceTagSet(v **types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
  20624 	if v == nil {
  20625 		return fmt.Errorf("unexpected nil of type %T", v)
  20626 	}
  20627 	var sv *types.ResourceTagSet
  20628 	if *v == nil {
  20629 		sv = &types.ResourceTagSet{}
  20630 	} else {
  20631 		sv = *v
  20632 	}
  20633 
  20634 	for {
  20635 		t, done, err := decoder.Token()
  20636 		if err != nil {
  20637 			return err
  20638 		}
  20639 		if done {
  20640 			break
  20641 		}
  20642 		originalDecoder := decoder
  20643 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20644 		switch {
  20645 		case strings.EqualFold("ResourceId", t.Name.Local):
  20646 			val, err := decoder.Value()
  20647 			if err != nil {
  20648 				return err
  20649 			}
  20650 			if val == nil {
  20651 				break
  20652 			}
  20653 			{
  20654 				xtv := string(val)
  20655 				sv.ResourceId = ptr.String(xtv)
  20656 			}
  20657 
  20658 		case strings.EqualFold("ResourceType", t.Name.Local):
  20659 			val, err := decoder.Value()
  20660 			if err != nil {
  20661 				return err
  20662 			}
  20663 			if val == nil {
  20664 				break
  20665 			}
  20666 			{
  20667 				xtv := string(val)
  20668 				sv.ResourceType = types.TagResourceType(xtv)
  20669 			}
  20670 
  20671 		case strings.EqualFold("Tags", t.Name.Local):
  20672 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20673 			if err := awsRestxml_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil {
  20674 				return err
  20675 			}
  20676 
  20677 		default:
  20678 			// Do nothing and ignore the unexpected tag element
  20679 			err = decoder.Decoder.Skip()
  20680 			if err != nil {
  20681 				return err
  20682 			}
  20683 
  20684 		}
  20685 		decoder = originalDecoder
  20686 	}
  20687 	*v = sv
  20688 	return nil
  20689 }
  20690 
  20691 func awsRestxml_deserializeDocumentResourceTagSetList(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
  20692 	if v == nil {
  20693 		return fmt.Errorf("unexpected nil of type %T", v)
  20694 	}
  20695 	var sv []types.ResourceTagSet
  20696 	if *v == nil {
  20697 		sv = make([]types.ResourceTagSet, 0)
  20698 	} else {
  20699 		sv = *v
  20700 	}
  20701 
  20702 	originalDecoder := decoder
  20703 	for {
  20704 		t, done, err := decoder.Token()
  20705 		if err != nil {
  20706 			return err
  20707 		}
  20708 		if done {
  20709 			break
  20710 		}
  20711 		switch {
  20712 		case strings.EqualFold("ResourceTagSet", t.Name.Local):
  20713 			var col types.ResourceTagSet
  20714 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20715 			destAddr := &col
  20716 			if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil {
  20717 				return err
  20718 			}
  20719 			col = *destAddr
  20720 			sv = append(sv, col)
  20721 
  20722 		default:
  20723 			err = decoder.Decoder.Skip()
  20724 			if err != nil {
  20725 				return err
  20726 			}
  20727 
  20728 		}
  20729 		decoder = originalDecoder
  20730 	}
  20731 	*v = sv
  20732 	return nil
  20733 }
  20734 
  20735 func awsRestxml_deserializeDocumentResourceTagSetListUnwrapped(v *[]types.ResourceTagSet, decoder smithyxml.NodeDecoder) error {
  20736 	var sv []types.ResourceTagSet
  20737 	if *v == nil {
  20738 		sv = make([]types.ResourceTagSet, 0)
  20739 	} else {
  20740 		sv = *v
  20741 	}
  20742 
  20743 	switch {
  20744 	default:
  20745 		var mv types.ResourceTagSet
  20746 		t := decoder.StartEl
  20747 		_ = t
  20748 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20749 		destAddr := &mv
  20750 		if err := awsRestxml_deserializeDocumentResourceTagSet(&destAddr, nodeDecoder); err != nil {
  20751 			return err
  20752 		}
  20753 		mv = *destAddr
  20754 		sv = append(sv, mv)
  20755 	}
  20756 	*v = sv
  20757 	return nil
  20758 }
  20759 func awsRestxml_deserializeDocumentReusableDelegationSetLimit(v **types.ReusableDelegationSetLimit, decoder smithyxml.NodeDecoder) error {
  20760 	if v == nil {
  20761 		return fmt.Errorf("unexpected nil of type %T", v)
  20762 	}
  20763 	var sv *types.ReusableDelegationSetLimit
  20764 	if *v == nil {
  20765 		sv = &types.ReusableDelegationSetLimit{}
  20766 	} else {
  20767 		sv = *v
  20768 	}
  20769 
  20770 	for {
  20771 		t, done, err := decoder.Token()
  20772 		if err != nil {
  20773 			return err
  20774 		}
  20775 		if done {
  20776 			break
  20777 		}
  20778 		originalDecoder := decoder
  20779 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20780 		switch {
  20781 		case strings.EqualFold("Type", t.Name.Local):
  20782 			val, err := decoder.Value()
  20783 			if err != nil {
  20784 				return err
  20785 			}
  20786 			if val == nil {
  20787 				break
  20788 			}
  20789 			{
  20790 				xtv := string(val)
  20791 				sv.Type = types.ReusableDelegationSetLimitType(xtv)
  20792 			}
  20793 
  20794 		case strings.EqualFold("Value", t.Name.Local):
  20795 			val, err := decoder.Value()
  20796 			if err != nil {
  20797 				return err
  20798 			}
  20799 			if val == nil {
  20800 				break
  20801 			}
  20802 			{
  20803 				xtv := string(val)
  20804 				i64, err := strconv.ParseInt(xtv, 10, 64)
  20805 				if err != nil {
  20806 					return err
  20807 				}
  20808 				sv.Value = i64
  20809 			}
  20810 
  20811 		default:
  20812 			// Do nothing and ignore the unexpected tag element
  20813 			err = decoder.Decoder.Skip()
  20814 			if err != nil {
  20815 				return err
  20816 			}
  20817 
  20818 		}
  20819 		decoder = originalDecoder
  20820 	}
  20821 	*v = sv
  20822 	return nil
  20823 }
  20824 
  20825 func awsRestxml_deserializeDocumentStatusReport(v **types.StatusReport, decoder smithyxml.NodeDecoder) error {
  20826 	if v == nil {
  20827 		return fmt.Errorf("unexpected nil of type %T", v)
  20828 	}
  20829 	var sv *types.StatusReport
  20830 	if *v == nil {
  20831 		sv = &types.StatusReport{}
  20832 	} else {
  20833 		sv = *v
  20834 	}
  20835 
  20836 	for {
  20837 		t, done, err := decoder.Token()
  20838 		if err != nil {
  20839 			return err
  20840 		}
  20841 		if done {
  20842 			break
  20843 		}
  20844 		originalDecoder := decoder
  20845 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20846 		switch {
  20847 		case strings.EqualFold("CheckedTime", t.Name.Local):
  20848 			val, err := decoder.Value()
  20849 			if err != nil {
  20850 				return err
  20851 			}
  20852 			if val == nil {
  20853 				break
  20854 			}
  20855 			{
  20856 				xtv := string(val)
  20857 				t, err := smithytime.ParseDateTime(xtv)
  20858 				if err != nil {
  20859 					return err
  20860 				}
  20861 				sv.CheckedTime = ptr.Time(t)
  20862 			}
  20863 
  20864 		case strings.EqualFold("Status", t.Name.Local):
  20865 			val, err := decoder.Value()
  20866 			if err != nil {
  20867 				return err
  20868 			}
  20869 			if val == nil {
  20870 				break
  20871 			}
  20872 			{
  20873 				xtv := string(val)
  20874 				sv.Status = ptr.String(xtv)
  20875 			}
  20876 
  20877 		default:
  20878 			// Do nothing and ignore the unexpected tag element
  20879 			err = decoder.Decoder.Skip()
  20880 			if err != nil {
  20881 				return err
  20882 			}
  20883 
  20884 		}
  20885 		decoder = originalDecoder
  20886 	}
  20887 	*v = sv
  20888 	return nil
  20889 }
  20890 
  20891 func awsRestxml_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error {
  20892 	if v == nil {
  20893 		return fmt.Errorf("unexpected nil of type %T", v)
  20894 	}
  20895 	var sv *types.Tag
  20896 	if *v == nil {
  20897 		sv = &types.Tag{}
  20898 	} else {
  20899 		sv = *v
  20900 	}
  20901 
  20902 	for {
  20903 		t, done, err := decoder.Token()
  20904 		if err != nil {
  20905 			return err
  20906 		}
  20907 		if done {
  20908 			break
  20909 		}
  20910 		originalDecoder := decoder
  20911 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  20912 		switch {
  20913 		case strings.EqualFold("Key", t.Name.Local):
  20914 			val, err := decoder.Value()
  20915 			if err != nil {
  20916 				return err
  20917 			}
  20918 			if val == nil {
  20919 				break
  20920 			}
  20921 			{
  20922 				xtv := string(val)
  20923 				sv.Key = ptr.String(xtv)
  20924 			}
  20925 
  20926 		case strings.EqualFold("Value", t.Name.Local):
  20927 			val, err := decoder.Value()
  20928 			if err != nil {
  20929 				return err
  20930 			}
  20931 			if val == nil {
  20932 				break
  20933 			}
  20934 			{
  20935 				xtv := string(val)
  20936 				sv.Value = ptr.String(xtv)
  20937 			}
  20938 
  20939 		default:
  20940 			// Do nothing and ignore the unexpected tag element
  20941 			err = decoder.Decoder.Skip()
  20942 			if err != nil {
  20943 				return err
  20944 			}
  20945 
  20946 		}
  20947 		decoder = originalDecoder
  20948 	}
  20949 	*v = sv
  20950 	return nil
  20951 }
  20952 
  20953 func awsRestxml_deserializeDocumentTagList(v *[]types.Tag, decoder smithyxml.NodeDecoder) error {
  20954 	if v == nil {
  20955 		return fmt.Errorf("unexpected nil of type %T", v)
  20956 	}
  20957 	var sv []types.Tag
  20958 	if *v == nil {
  20959 		sv = make([]types.Tag, 0)
  20960 	} else {
  20961 		sv = *v
  20962 	}
  20963 
  20964 	originalDecoder := decoder
  20965 	for {
  20966 		t, done, err := decoder.Token()
  20967 		if err != nil {
  20968 			return err
  20969 		}
  20970 		if done {
  20971 			break
  20972 		}
  20973 		switch {
  20974 		case strings.EqualFold("Tag", t.Name.Local):
  20975 			var col types.Tag
  20976 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  20977 			destAddr := &col
  20978 			if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil {
  20979 				return err
  20980 			}
  20981 			col = *destAddr
  20982 			sv = append(sv, col)
  20983 
  20984 		default:
  20985 			err = decoder.Decoder.Skip()
  20986 			if err != nil {
  20987 				return err
  20988 			}
  20989 
  20990 		}
  20991 		decoder = originalDecoder
  20992 	}
  20993 	*v = sv
  20994 	return nil
  20995 }
  20996 
  20997 func awsRestxml_deserializeDocumentTagListUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error {
  20998 	var sv []types.Tag
  20999 	if *v == nil {
  21000 		sv = make([]types.Tag, 0)
  21001 	} else {
  21002 		sv = *v
  21003 	}
  21004 
  21005 	switch {
  21006 	default:
  21007 		var mv types.Tag
  21008 		t := decoder.StartEl
  21009 		_ = t
  21010 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21011 		destAddr := &mv
  21012 		if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil {
  21013 			return err
  21014 		}
  21015 		mv = *destAddr
  21016 		sv = append(sv, mv)
  21017 	}
  21018 	*v = sv
  21019 	return nil
  21020 }
  21021 func awsRestxml_deserializeDocumentThrottlingException(v **types.ThrottlingException, decoder smithyxml.NodeDecoder) error {
  21022 	if v == nil {
  21023 		return fmt.Errorf("unexpected nil of type %T", v)
  21024 	}
  21025 	var sv *types.ThrottlingException
  21026 	if *v == nil {
  21027 		sv = &types.ThrottlingException{}
  21028 	} else {
  21029 		sv = *v
  21030 	}
  21031 
  21032 	for {
  21033 		t, done, err := decoder.Token()
  21034 		if err != nil {
  21035 			return err
  21036 		}
  21037 		if done {
  21038 			break
  21039 		}
  21040 		originalDecoder := decoder
  21041 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21042 		switch {
  21043 		case strings.EqualFold("message", t.Name.Local):
  21044 			val, err := decoder.Value()
  21045 			if err != nil {
  21046 				return err
  21047 			}
  21048 			if val == nil {
  21049 				break
  21050 			}
  21051 			{
  21052 				xtv := string(val)
  21053 				sv.Message = ptr.String(xtv)
  21054 			}
  21055 
  21056 		default:
  21057 			// Do nothing and ignore the unexpected tag element
  21058 			err = decoder.Decoder.Skip()
  21059 			if err != nil {
  21060 				return err
  21061 			}
  21062 
  21063 		}
  21064 		decoder = originalDecoder
  21065 	}
  21066 	*v = sv
  21067 	return nil
  21068 }
  21069 
  21070 func awsRestxml_deserializeDocumentTooManyHealthChecks(v **types.TooManyHealthChecks, decoder smithyxml.NodeDecoder) error {
  21071 	if v == nil {
  21072 		return fmt.Errorf("unexpected nil of type %T", v)
  21073 	}
  21074 	var sv *types.TooManyHealthChecks
  21075 	if *v == nil {
  21076 		sv = &types.TooManyHealthChecks{}
  21077 	} else {
  21078 		sv = *v
  21079 	}
  21080 
  21081 	for {
  21082 		t, done, err := decoder.Token()
  21083 		if err != nil {
  21084 			return err
  21085 		}
  21086 		if done {
  21087 			break
  21088 		}
  21089 		originalDecoder := decoder
  21090 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21091 		switch {
  21092 		case strings.EqualFold("message", t.Name.Local):
  21093 			val, err := decoder.Value()
  21094 			if err != nil {
  21095 				return err
  21096 			}
  21097 			if val == nil {
  21098 				break
  21099 			}
  21100 			{
  21101 				xtv := string(val)
  21102 				sv.Message = ptr.String(xtv)
  21103 			}
  21104 
  21105 		default:
  21106 			// Do nothing and ignore the unexpected tag element
  21107 			err = decoder.Decoder.Skip()
  21108 			if err != nil {
  21109 				return err
  21110 			}
  21111 
  21112 		}
  21113 		decoder = originalDecoder
  21114 	}
  21115 	*v = sv
  21116 	return nil
  21117 }
  21118 
  21119 func awsRestxml_deserializeDocumentTooManyHostedZones(v **types.TooManyHostedZones, decoder smithyxml.NodeDecoder) error {
  21120 	if v == nil {
  21121 		return fmt.Errorf("unexpected nil of type %T", v)
  21122 	}
  21123 	var sv *types.TooManyHostedZones
  21124 	if *v == nil {
  21125 		sv = &types.TooManyHostedZones{}
  21126 	} else {
  21127 		sv = *v
  21128 	}
  21129 
  21130 	for {
  21131 		t, done, err := decoder.Token()
  21132 		if err != nil {
  21133 			return err
  21134 		}
  21135 		if done {
  21136 			break
  21137 		}
  21138 		originalDecoder := decoder
  21139 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21140 		switch {
  21141 		case strings.EqualFold("message", t.Name.Local):
  21142 			val, err := decoder.Value()
  21143 			if err != nil {
  21144 				return err
  21145 			}
  21146 			if val == nil {
  21147 				break
  21148 			}
  21149 			{
  21150 				xtv := string(val)
  21151 				sv.Message = ptr.String(xtv)
  21152 			}
  21153 
  21154 		default:
  21155 			// Do nothing and ignore the unexpected tag element
  21156 			err = decoder.Decoder.Skip()
  21157 			if err != nil {
  21158 				return err
  21159 			}
  21160 
  21161 		}
  21162 		decoder = originalDecoder
  21163 	}
  21164 	*v = sv
  21165 	return nil
  21166 }
  21167 
  21168 func awsRestxml_deserializeDocumentTooManyKeySigningKeys(v **types.TooManyKeySigningKeys, decoder smithyxml.NodeDecoder) error {
  21169 	if v == nil {
  21170 		return fmt.Errorf("unexpected nil of type %T", v)
  21171 	}
  21172 	var sv *types.TooManyKeySigningKeys
  21173 	if *v == nil {
  21174 		sv = &types.TooManyKeySigningKeys{}
  21175 	} else {
  21176 		sv = *v
  21177 	}
  21178 
  21179 	for {
  21180 		t, done, err := decoder.Token()
  21181 		if err != nil {
  21182 			return err
  21183 		}
  21184 		if done {
  21185 			break
  21186 		}
  21187 		originalDecoder := decoder
  21188 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21189 		switch {
  21190 		case strings.EqualFold("message", t.Name.Local):
  21191 			val, err := decoder.Value()
  21192 			if err != nil {
  21193 				return err
  21194 			}
  21195 			if val == nil {
  21196 				break
  21197 			}
  21198 			{
  21199 				xtv := string(val)
  21200 				sv.Message = ptr.String(xtv)
  21201 			}
  21202 
  21203 		default:
  21204 			// Do nothing and ignore the unexpected tag element
  21205 			err = decoder.Decoder.Skip()
  21206 			if err != nil {
  21207 				return err
  21208 			}
  21209 
  21210 		}
  21211 		decoder = originalDecoder
  21212 	}
  21213 	*v = sv
  21214 	return nil
  21215 }
  21216 
  21217 func awsRestxml_deserializeDocumentTooManyTrafficPolicies(v **types.TooManyTrafficPolicies, decoder smithyxml.NodeDecoder) error {
  21218 	if v == nil {
  21219 		return fmt.Errorf("unexpected nil of type %T", v)
  21220 	}
  21221 	var sv *types.TooManyTrafficPolicies
  21222 	if *v == nil {
  21223 		sv = &types.TooManyTrafficPolicies{}
  21224 	} else {
  21225 		sv = *v
  21226 	}
  21227 
  21228 	for {
  21229 		t, done, err := decoder.Token()
  21230 		if err != nil {
  21231 			return err
  21232 		}
  21233 		if done {
  21234 			break
  21235 		}
  21236 		originalDecoder := decoder
  21237 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21238 		switch {
  21239 		case strings.EqualFold("message", t.Name.Local):
  21240 			val, err := decoder.Value()
  21241 			if err != nil {
  21242 				return err
  21243 			}
  21244 			if val == nil {
  21245 				break
  21246 			}
  21247 			{
  21248 				xtv := string(val)
  21249 				sv.Message = ptr.String(xtv)
  21250 			}
  21251 
  21252 		default:
  21253 			// Do nothing and ignore the unexpected tag element
  21254 			err = decoder.Decoder.Skip()
  21255 			if err != nil {
  21256 				return err
  21257 			}
  21258 
  21259 		}
  21260 		decoder = originalDecoder
  21261 	}
  21262 	*v = sv
  21263 	return nil
  21264 }
  21265 
  21266 func awsRestxml_deserializeDocumentTooManyTrafficPolicyInstances(v **types.TooManyTrafficPolicyInstances, decoder smithyxml.NodeDecoder) error {
  21267 	if v == nil {
  21268 		return fmt.Errorf("unexpected nil of type %T", v)
  21269 	}
  21270 	var sv *types.TooManyTrafficPolicyInstances
  21271 	if *v == nil {
  21272 		sv = &types.TooManyTrafficPolicyInstances{}
  21273 	} else {
  21274 		sv = *v
  21275 	}
  21276 
  21277 	for {
  21278 		t, done, err := decoder.Token()
  21279 		if err != nil {
  21280 			return err
  21281 		}
  21282 		if done {
  21283 			break
  21284 		}
  21285 		originalDecoder := decoder
  21286 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21287 		switch {
  21288 		case strings.EqualFold("message", t.Name.Local):
  21289 			val, err := decoder.Value()
  21290 			if err != nil {
  21291 				return err
  21292 			}
  21293 			if val == nil {
  21294 				break
  21295 			}
  21296 			{
  21297 				xtv := string(val)
  21298 				sv.Message = ptr.String(xtv)
  21299 			}
  21300 
  21301 		default:
  21302 			// Do nothing and ignore the unexpected tag element
  21303 			err = decoder.Decoder.Skip()
  21304 			if err != nil {
  21305 				return err
  21306 			}
  21307 
  21308 		}
  21309 		decoder = originalDecoder
  21310 	}
  21311 	*v = sv
  21312 	return nil
  21313 }
  21314 
  21315 func awsRestxml_deserializeDocumentTooManyTrafficPolicyVersionsForCurrentPolicy(v **types.TooManyTrafficPolicyVersionsForCurrentPolicy, decoder smithyxml.NodeDecoder) error {
  21316 	if v == nil {
  21317 		return fmt.Errorf("unexpected nil of type %T", v)
  21318 	}
  21319 	var sv *types.TooManyTrafficPolicyVersionsForCurrentPolicy
  21320 	if *v == nil {
  21321 		sv = &types.TooManyTrafficPolicyVersionsForCurrentPolicy{}
  21322 	} else {
  21323 		sv = *v
  21324 	}
  21325 
  21326 	for {
  21327 		t, done, err := decoder.Token()
  21328 		if err != nil {
  21329 			return err
  21330 		}
  21331 		if done {
  21332 			break
  21333 		}
  21334 		originalDecoder := decoder
  21335 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21336 		switch {
  21337 		case strings.EqualFold("message", t.Name.Local):
  21338 			val, err := decoder.Value()
  21339 			if err != nil {
  21340 				return err
  21341 			}
  21342 			if val == nil {
  21343 				break
  21344 			}
  21345 			{
  21346 				xtv := string(val)
  21347 				sv.Message = ptr.String(xtv)
  21348 			}
  21349 
  21350 		default:
  21351 			// Do nothing and ignore the unexpected tag element
  21352 			err = decoder.Decoder.Skip()
  21353 			if err != nil {
  21354 				return err
  21355 			}
  21356 
  21357 		}
  21358 		decoder = originalDecoder
  21359 	}
  21360 	*v = sv
  21361 	return nil
  21362 }
  21363 
  21364 func awsRestxml_deserializeDocumentTooManyVPCAssociationAuthorizations(v **types.TooManyVPCAssociationAuthorizations, decoder smithyxml.NodeDecoder) error {
  21365 	if v == nil {
  21366 		return fmt.Errorf("unexpected nil of type %T", v)
  21367 	}
  21368 	var sv *types.TooManyVPCAssociationAuthorizations
  21369 	if *v == nil {
  21370 		sv = &types.TooManyVPCAssociationAuthorizations{}
  21371 	} else {
  21372 		sv = *v
  21373 	}
  21374 
  21375 	for {
  21376 		t, done, err := decoder.Token()
  21377 		if err != nil {
  21378 			return err
  21379 		}
  21380 		if done {
  21381 			break
  21382 		}
  21383 		originalDecoder := decoder
  21384 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21385 		switch {
  21386 		case strings.EqualFold("message", t.Name.Local):
  21387 			val, err := decoder.Value()
  21388 			if err != nil {
  21389 				return err
  21390 			}
  21391 			if val == nil {
  21392 				break
  21393 			}
  21394 			{
  21395 				xtv := string(val)
  21396 				sv.Message = ptr.String(xtv)
  21397 			}
  21398 
  21399 		default:
  21400 			// Do nothing and ignore the unexpected tag element
  21401 			err = decoder.Decoder.Skip()
  21402 			if err != nil {
  21403 				return err
  21404 			}
  21405 
  21406 		}
  21407 		decoder = originalDecoder
  21408 	}
  21409 	*v = sv
  21410 	return nil
  21411 }
  21412 
  21413 func awsRestxml_deserializeDocumentTrafficPolicies(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
  21414 	if v == nil {
  21415 		return fmt.Errorf("unexpected nil of type %T", v)
  21416 	}
  21417 	var sv []types.TrafficPolicy
  21418 	if *v == nil {
  21419 		sv = make([]types.TrafficPolicy, 0)
  21420 	} else {
  21421 		sv = *v
  21422 	}
  21423 
  21424 	originalDecoder := decoder
  21425 	for {
  21426 		t, done, err := decoder.Token()
  21427 		if err != nil {
  21428 			return err
  21429 		}
  21430 		if done {
  21431 			break
  21432 		}
  21433 		switch {
  21434 		case strings.EqualFold("TrafficPolicy", t.Name.Local):
  21435 			var col types.TrafficPolicy
  21436 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21437 			destAddr := &col
  21438 			if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil {
  21439 				return err
  21440 			}
  21441 			col = *destAddr
  21442 			sv = append(sv, col)
  21443 
  21444 		default:
  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_deserializeDocumentTrafficPoliciesUnwrapped(v *[]types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
  21458 	var sv []types.TrafficPolicy
  21459 	if *v == nil {
  21460 		sv = make([]types.TrafficPolicy, 0)
  21461 	} else {
  21462 		sv = *v
  21463 	}
  21464 
  21465 	switch {
  21466 	default:
  21467 		var mv types.TrafficPolicy
  21468 		t := decoder.StartEl
  21469 		_ = t
  21470 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21471 		destAddr := &mv
  21472 		if err := awsRestxml_deserializeDocumentTrafficPolicy(&destAddr, nodeDecoder); err != nil {
  21473 			return err
  21474 		}
  21475 		mv = *destAddr
  21476 		sv = append(sv, mv)
  21477 	}
  21478 	*v = sv
  21479 	return nil
  21480 }
  21481 func awsRestxml_deserializeDocumentTrafficPolicy(v **types.TrafficPolicy, decoder smithyxml.NodeDecoder) error {
  21482 	if v == nil {
  21483 		return fmt.Errorf("unexpected nil of type %T", v)
  21484 	}
  21485 	var sv *types.TrafficPolicy
  21486 	if *v == nil {
  21487 		sv = &types.TrafficPolicy{}
  21488 	} else {
  21489 		sv = *v
  21490 	}
  21491 
  21492 	for {
  21493 		t, done, err := decoder.Token()
  21494 		if err != nil {
  21495 			return err
  21496 		}
  21497 		if done {
  21498 			break
  21499 		}
  21500 		originalDecoder := decoder
  21501 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21502 		switch {
  21503 		case strings.EqualFold("Comment", t.Name.Local):
  21504 			val, err := decoder.Value()
  21505 			if err != nil {
  21506 				return err
  21507 			}
  21508 			if val == nil {
  21509 				break
  21510 			}
  21511 			{
  21512 				xtv := string(val)
  21513 				sv.Comment = ptr.String(xtv)
  21514 			}
  21515 
  21516 		case strings.EqualFold("Document", t.Name.Local):
  21517 			val, err := decoder.Value()
  21518 			if err != nil {
  21519 				return err
  21520 			}
  21521 			if val == nil {
  21522 				break
  21523 			}
  21524 			{
  21525 				xtv := string(val)
  21526 				sv.Document = ptr.String(xtv)
  21527 			}
  21528 
  21529 		case strings.EqualFold("Id", t.Name.Local):
  21530 			val, err := decoder.Value()
  21531 			if err != nil {
  21532 				return err
  21533 			}
  21534 			if val == nil {
  21535 				break
  21536 			}
  21537 			{
  21538 				xtv := string(val)
  21539 				sv.Id = ptr.String(xtv)
  21540 			}
  21541 
  21542 		case strings.EqualFold("Name", t.Name.Local):
  21543 			val, err := decoder.Value()
  21544 			if err != nil {
  21545 				return err
  21546 			}
  21547 			if val == nil {
  21548 				break
  21549 			}
  21550 			{
  21551 				xtv := string(val)
  21552 				sv.Name = ptr.String(xtv)
  21553 			}
  21554 
  21555 		case strings.EqualFold("Type", t.Name.Local):
  21556 			val, err := decoder.Value()
  21557 			if err != nil {
  21558 				return err
  21559 			}
  21560 			if val == nil {
  21561 				break
  21562 			}
  21563 			{
  21564 				xtv := string(val)
  21565 				sv.Type = types.RRType(xtv)
  21566 			}
  21567 
  21568 		case strings.EqualFold("Version", t.Name.Local):
  21569 			val, err := decoder.Value()
  21570 			if err != nil {
  21571 				return err
  21572 			}
  21573 			if val == nil {
  21574 				break
  21575 			}
  21576 			{
  21577 				xtv := string(val)
  21578 				i64, err := strconv.ParseInt(xtv, 10, 64)
  21579 				if err != nil {
  21580 					return err
  21581 				}
  21582 				sv.Version = ptr.Int32(int32(i64))
  21583 			}
  21584 
  21585 		default:
  21586 			// Do nothing and ignore the unexpected tag element
  21587 			err = decoder.Decoder.Skip()
  21588 			if err != nil {
  21589 				return err
  21590 			}
  21591 
  21592 		}
  21593 		decoder = originalDecoder
  21594 	}
  21595 	*v = sv
  21596 	return nil
  21597 }
  21598 
  21599 func awsRestxml_deserializeDocumentTrafficPolicyAlreadyExists(v **types.TrafficPolicyAlreadyExists, decoder smithyxml.NodeDecoder) error {
  21600 	if v == nil {
  21601 		return fmt.Errorf("unexpected nil of type %T", v)
  21602 	}
  21603 	var sv *types.TrafficPolicyAlreadyExists
  21604 	if *v == nil {
  21605 		sv = &types.TrafficPolicyAlreadyExists{}
  21606 	} else {
  21607 		sv = *v
  21608 	}
  21609 
  21610 	for {
  21611 		t, done, err := decoder.Token()
  21612 		if err != nil {
  21613 			return err
  21614 		}
  21615 		if done {
  21616 			break
  21617 		}
  21618 		originalDecoder := decoder
  21619 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21620 		switch {
  21621 		case strings.EqualFold("message", t.Name.Local):
  21622 			val, err := decoder.Value()
  21623 			if err != nil {
  21624 				return err
  21625 			}
  21626 			if val == nil {
  21627 				break
  21628 			}
  21629 			{
  21630 				xtv := string(val)
  21631 				sv.Message = ptr.String(xtv)
  21632 			}
  21633 
  21634 		default:
  21635 			// Do nothing and ignore the unexpected tag element
  21636 			err = decoder.Decoder.Skip()
  21637 			if err != nil {
  21638 				return err
  21639 			}
  21640 
  21641 		}
  21642 		decoder = originalDecoder
  21643 	}
  21644 	*v = sv
  21645 	return nil
  21646 }
  21647 
  21648 func awsRestxml_deserializeDocumentTrafficPolicyInstance(v **types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  21649 	if v == nil {
  21650 		return fmt.Errorf("unexpected nil of type %T", v)
  21651 	}
  21652 	var sv *types.TrafficPolicyInstance
  21653 	if *v == nil {
  21654 		sv = &types.TrafficPolicyInstance{}
  21655 	} else {
  21656 		sv = *v
  21657 	}
  21658 
  21659 	for {
  21660 		t, done, err := decoder.Token()
  21661 		if err != nil {
  21662 			return err
  21663 		}
  21664 		if done {
  21665 			break
  21666 		}
  21667 		originalDecoder := decoder
  21668 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21669 		switch {
  21670 		case strings.EqualFold("HostedZoneId", t.Name.Local):
  21671 			val, err := decoder.Value()
  21672 			if err != nil {
  21673 				return err
  21674 			}
  21675 			if val == nil {
  21676 				break
  21677 			}
  21678 			{
  21679 				xtv := string(val)
  21680 				sv.HostedZoneId = ptr.String(xtv)
  21681 			}
  21682 
  21683 		case strings.EqualFold("Id", t.Name.Local):
  21684 			val, err := decoder.Value()
  21685 			if err != nil {
  21686 				return err
  21687 			}
  21688 			if val == nil {
  21689 				break
  21690 			}
  21691 			{
  21692 				xtv := string(val)
  21693 				sv.Id = ptr.String(xtv)
  21694 			}
  21695 
  21696 		case strings.EqualFold("Message", t.Name.Local):
  21697 			val, err := decoder.Value()
  21698 			if err != nil {
  21699 				return err
  21700 			}
  21701 			if val == nil {
  21702 				break
  21703 			}
  21704 			{
  21705 				xtv := string(val)
  21706 				sv.Message = ptr.String(xtv)
  21707 			}
  21708 
  21709 		case strings.EqualFold("Name", t.Name.Local):
  21710 			val, err := decoder.Value()
  21711 			if err != nil {
  21712 				return err
  21713 			}
  21714 			if val == nil {
  21715 				break
  21716 			}
  21717 			{
  21718 				xtv := string(val)
  21719 				sv.Name = ptr.String(xtv)
  21720 			}
  21721 
  21722 		case strings.EqualFold("State", t.Name.Local):
  21723 			val, err := decoder.Value()
  21724 			if err != nil {
  21725 				return err
  21726 			}
  21727 			if val == nil {
  21728 				break
  21729 			}
  21730 			{
  21731 				xtv := string(val)
  21732 				sv.State = ptr.String(xtv)
  21733 			}
  21734 
  21735 		case strings.EqualFold("TrafficPolicyId", t.Name.Local):
  21736 			val, err := decoder.Value()
  21737 			if err != nil {
  21738 				return err
  21739 			}
  21740 			if val == nil {
  21741 				break
  21742 			}
  21743 			{
  21744 				xtv := string(val)
  21745 				sv.TrafficPolicyId = ptr.String(xtv)
  21746 			}
  21747 
  21748 		case strings.EqualFold("TrafficPolicyType", t.Name.Local):
  21749 			val, err := decoder.Value()
  21750 			if err != nil {
  21751 				return err
  21752 			}
  21753 			if val == nil {
  21754 				break
  21755 			}
  21756 			{
  21757 				xtv := string(val)
  21758 				sv.TrafficPolicyType = types.RRType(xtv)
  21759 			}
  21760 
  21761 		case strings.EqualFold("TrafficPolicyVersion", t.Name.Local):
  21762 			val, err := decoder.Value()
  21763 			if err != nil {
  21764 				return err
  21765 			}
  21766 			if val == nil {
  21767 				break
  21768 			}
  21769 			{
  21770 				xtv := string(val)
  21771 				i64, err := strconv.ParseInt(xtv, 10, 64)
  21772 				if err != nil {
  21773 					return err
  21774 				}
  21775 				sv.TrafficPolicyVersion = ptr.Int32(int32(i64))
  21776 			}
  21777 
  21778 		case strings.EqualFold("TTL", t.Name.Local):
  21779 			val, err := decoder.Value()
  21780 			if err != nil {
  21781 				return err
  21782 			}
  21783 			if val == nil {
  21784 				break
  21785 			}
  21786 			{
  21787 				xtv := string(val)
  21788 				i64, err := strconv.ParseInt(xtv, 10, 64)
  21789 				if err != nil {
  21790 					return err
  21791 				}
  21792 				sv.TTL = ptr.Int64(i64)
  21793 			}
  21794 
  21795 		default:
  21796 			// Do nothing and ignore the unexpected tag element
  21797 			err = decoder.Decoder.Skip()
  21798 			if err != nil {
  21799 				return err
  21800 			}
  21801 
  21802 		}
  21803 		decoder = originalDecoder
  21804 	}
  21805 	*v = sv
  21806 	return nil
  21807 }
  21808 
  21809 func awsRestxml_deserializeDocumentTrafficPolicyInstanceAlreadyExists(v **types.TrafficPolicyInstanceAlreadyExists, decoder smithyxml.NodeDecoder) error {
  21810 	if v == nil {
  21811 		return fmt.Errorf("unexpected nil of type %T", v)
  21812 	}
  21813 	var sv *types.TrafficPolicyInstanceAlreadyExists
  21814 	if *v == nil {
  21815 		sv = &types.TrafficPolicyInstanceAlreadyExists{}
  21816 	} else {
  21817 		sv = *v
  21818 	}
  21819 
  21820 	for {
  21821 		t, done, err := decoder.Token()
  21822 		if err != nil {
  21823 			return err
  21824 		}
  21825 		if done {
  21826 			break
  21827 		}
  21828 		originalDecoder := decoder
  21829 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21830 		switch {
  21831 		case strings.EqualFold("message", t.Name.Local):
  21832 			val, err := decoder.Value()
  21833 			if err != nil {
  21834 				return err
  21835 			}
  21836 			if val == nil {
  21837 				break
  21838 			}
  21839 			{
  21840 				xtv := string(val)
  21841 				sv.Message = ptr.String(xtv)
  21842 			}
  21843 
  21844 		default:
  21845 			// Do nothing and ignore the unexpected tag element
  21846 			err = decoder.Decoder.Skip()
  21847 			if err != nil {
  21848 				return err
  21849 			}
  21850 
  21851 		}
  21852 		decoder = originalDecoder
  21853 	}
  21854 	*v = sv
  21855 	return nil
  21856 }
  21857 
  21858 func awsRestxml_deserializeDocumentTrafficPolicyInstances(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  21859 	if v == nil {
  21860 		return fmt.Errorf("unexpected nil of type %T", v)
  21861 	}
  21862 	var sv []types.TrafficPolicyInstance
  21863 	if *v == nil {
  21864 		sv = make([]types.TrafficPolicyInstance, 0)
  21865 	} else {
  21866 		sv = *v
  21867 	}
  21868 
  21869 	originalDecoder := decoder
  21870 	for {
  21871 		t, done, err := decoder.Token()
  21872 		if err != nil {
  21873 			return err
  21874 		}
  21875 		if done {
  21876 			break
  21877 		}
  21878 		switch {
  21879 		case strings.EqualFold("TrafficPolicyInstance", t.Name.Local):
  21880 			var col types.TrafficPolicyInstance
  21881 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21882 			destAddr := &col
  21883 			if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil {
  21884 				return err
  21885 			}
  21886 			col = *destAddr
  21887 			sv = append(sv, col)
  21888 
  21889 		default:
  21890 			err = decoder.Decoder.Skip()
  21891 			if err != nil {
  21892 				return err
  21893 			}
  21894 
  21895 		}
  21896 		decoder = originalDecoder
  21897 	}
  21898 	*v = sv
  21899 	return nil
  21900 }
  21901 
  21902 func awsRestxml_deserializeDocumentTrafficPolicyInstancesUnwrapped(v *[]types.TrafficPolicyInstance, decoder smithyxml.NodeDecoder) error {
  21903 	var sv []types.TrafficPolicyInstance
  21904 	if *v == nil {
  21905 		sv = make([]types.TrafficPolicyInstance, 0)
  21906 	} else {
  21907 		sv = *v
  21908 	}
  21909 
  21910 	switch {
  21911 	default:
  21912 		var mv types.TrafficPolicyInstance
  21913 		t := decoder.StartEl
  21914 		_ = t
  21915 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21916 		destAddr := &mv
  21917 		if err := awsRestxml_deserializeDocumentTrafficPolicyInstance(&destAddr, nodeDecoder); err != nil {
  21918 			return err
  21919 		}
  21920 		mv = *destAddr
  21921 		sv = append(sv, mv)
  21922 	}
  21923 	*v = sv
  21924 	return nil
  21925 }
  21926 func awsRestxml_deserializeDocumentTrafficPolicyInUse(v **types.TrafficPolicyInUse, decoder smithyxml.NodeDecoder) error {
  21927 	if v == nil {
  21928 		return fmt.Errorf("unexpected nil of type %T", v)
  21929 	}
  21930 	var sv *types.TrafficPolicyInUse
  21931 	if *v == nil {
  21932 		sv = &types.TrafficPolicyInUse{}
  21933 	} else {
  21934 		sv = *v
  21935 	}
  21936 
  21937 	for {
  21938 		t, done, err := decoder.Token()
  21939 		if err != nil {
  21940 			return err
  21941 		}
  21942 		if done {
  21943 			break
  21944 		}
  21945 		originalDecoder := decoder
  21946 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  21947 		switch {
  21948 		case strings.EqualFold("message", t.Name.Local):
  21949 			val, err := decoder.Value()
  21950 			if err != nil {
  21951 				return err
  21952 			}
  21953 			if val == nil {
  21954 				break
  21955 			}
  21956 			{
  21957 				xtv := string(val)
  21958 				sv.Message = ptr.String(xtv)
  21959 			}
  21960 
  21961 		default:
  21962 			// Do nothing and ignore the unexpected tag element
  21963 			err = decoder.Decoder.Skip()
  21964 			if err != nil {
  21965 				return err
  21966 			}
  21967 
  21968 		}
  21969 		decoder = originalDecoder
  21970 	}
  21971 	*v = sv
  21972 	return nil
  21973 }
  21974 
  21975 func awsRestxml_deserializeDocumentTrafficPolicySummaries(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
  21976 	if v == nil {
  21977 		return fmt.Errorf("unexpected nil of type %T", v)
  21978 	}
  21979 	var sv []types.TrafficPolicySummary
  21980 	if *v == nil {
  21981 		sv = make([]types.TrafficPolicySummary, 0)
  21982 	} else {
  21983 		sv = *v
  21984 	}
  21985 
  21986 	originalDecoder := decoder
  21987 	for {
  21988 		t, done, err := decoder.Token()
  21989 		if err != nil {
  21990 			return err
  21991 		}
  21992 		if done {
  21993 			break
  21994 		}
  21995 		switch {
  21996 		case strings.EqualFold("TrafficPolicySummary", t.Name.Local):
  21997 			var col types.TrafficPolicySummary
  21998 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  21999 			destAddr := &col
  22000 			if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil {
  22001 				return err
  22002 			}
  22003 			col = *destAddr
  22004 			sv = append(sv, col)
  22005 
  22006 		default:
  22007 			err = decoder.Decoder.Skip()
  22008 			if err != nil {
  22009 				return err
  22010 			}
  22011 
  22012 		}
  22013 		decoder = originalDecoder
  22014 	}
  22015 	*v = sv
  22016 	return nil
  22017 }
  22018 
  22019 func awsRestxml_deserializeDocumentTrafficPolicySummariesUnwrapped(v *[]types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
  22020 	var sv []types.TrafficPolicySummary
  22021 	if *v == nil {
  22022 		sv = make([]types.TrafficPolicySummary, 0)
  22023 	} else {
  22024 		sv = *v
  22025 	}
  22026 
  22027 	switch {
  22028 	default:
  22029 		var mv types.TrafficPolicySummary
  22030 		t := decoder.StartEl
  22031 		_ = t
  22032 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22033 		destAddr := &mv
  22034 		if err := awsRestxml_deserializeDocumentTrafficPolicySummary(&destAddr, nodeDecoder); err != nil {
  22035 			return err
  22036 		}
  22037 		mv = *destAddr
  22038 		sv = append(sv, mv)
  22039 	}
  22040 	*v = sv
  22041 	return nil
  22042 }
  22043 func awsRestxml_deserializeDocumentTrafficPolicySummary(v **types.TrafficPolicySummary, decoder smithyxml.NodeDecoder) error {
  22044 	if v == nil {
  22045 		return fmt.Errorf("unexpected nil of type %T", v)
  22046 	}
  22047 	var sv *types.TrafficPolicySummary
  22048 	if *v == nil {
  22049 		sv = &types.TrafficPolicySummary{}
  22050 	} else {
  22051 		sv = *v
  22052 	}
  22053 
  22054 	for {
  22055 		t, done, err := decoder.Token()
  22056 		if err != nil {
  22057 			return err
  22058 		}
  22059 		if done {
  22060 			break
  22061 		}
  22062 		originalDecoder := decoder
  22063 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22064 		switch {
  22065 		case strings.EqualFold("Id", t.Name.Local):
  22066 			val, err := decoder.Value()
  22067 			if err != nil {
  22068 				return err
  22069 			}
  22070 			if val == nil {
  22071 				break
  22072 			}
  22073 			{
  22074 				xtv := string(val)
  22075 				sv.Id = ptr.String(xtv)
  22076 			}
  22077 
  22078 		case strings.EqualFold("LatestVersion", t.Name.Local):
  22079 			val, err := decoder.Value()
  22080 			if err != nil {
  22081 				return err
  22082 			}
  22083 			if val == nil {
  22084 				break
  22085 			}
  22086 			{
  22087 				xtv := string(val)
  22088 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22089 				if err != nil {
  22090 					return err
  22091 				}
  22092 				sv.LatestVersion = ptr.Int32(int32(i64))
  22093 			}
  22094 
  22095 		case strings.EqualFold("Name", t.Name.Local):
  22096 			val, err := decoder.Value()
  22097 			if err != nil {
  22098 				return err
  22099 			}
  22100 			if val == nil {
  22101 				break
  22102 			}
  22103 			{
  22104 				xtv := string(val)
  22105 				sv.Name = ptr.String(xtv)
  22106 			}
  22107 
  22108 		case strings.EqualFold("TrafficPolicyCount", t.Name.Local):
  22109 			val, err := decoder.Value()
  22110 			if err != nil {
  22111 				return err
  22112 			}
  22113 			if val == nil {
  22114 				break
  22115 			}
  22116 			{
  22117 				xtv := string(val)
  22118 				i64, err := strconv.ParseInt(xtv, 10, 64)
  22119 				if err != nil {
  22120 					return err
  22121 				}
  22122 				sv.TrafficPolicyCount = ptr.Int32(int32(i64))
  22123 			}
  22124 
  22125 		case strings.EqualFold("Type", 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.Type = types.RRType(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_deserializeDocumentVPC(v **types.VPC, decoder smithyxml.NodeDecoder) error {
  22153 	if v == nil {
  22154 		return fmt.Errorf("unexpected nil of type %T", v)
  22155 	}
  22156 	var sv *types.VPC
  22157 	if *v == nil {
  22158 		sv = &types.VPC{}
  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("VPCId", 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.VPCId = ptr.String(xtv)
  22185 			}
  22186 
  22187 		case strings.EqualFold("VPCRegion", 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.VPCRegion = types.VPCRegion(xtv)
  22198 			}
  22199 
  22200 		default:
  22201 			// Do nothing and ignore the unexpected tag element
  22202 			err = decoder.Decoder.Skip()
  22203 			if err != nil {
  22204 				return err
  22205 			}
  22206 
  22207 		}
  22208 		decoder = originalDecoder
  22209 	}
  22210 	*v = sv
  22211 	return nil
  22212 }
  22213 
  22214 func awsRestxml_deserializeDocumentVPCAssociationAuthorizationNotFound(v **types.VPCAssociationAuthorizationNotFound, decoder smithyxml.NodeDecoder) error {
  22215 	if v == nil {
  22216 		return fmt.Errorf("unexpected nil of type %T", v)
  22217 	}
  22218 	var sv *types.VPCAssociationAuthorizationNotFound
  22219 	if *v == nil {
  22220 		sv = &types.VPCAssociationAuthorizationNotFound{}
  22221 	} else {
  22222 		sv = *v
  22223 	}
  22224 
  22225 	for {
  22226 		t, done, err := decoder.Token()
  22227 		if err != nil {
  22228 			return err
  22229 		}
  22230 		if done {
  22231 			break
  22232 		}
  22233 		originalDecoder := decoder
  22234 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22235 		switch {
  22236 		case strings.EqualFold("message", t.Name.Local):
  22237 			val, err := decoder.Value()
  22238 			if err != nil {
  22239 				return err
  22240 			}
  22241 			if val == nil {
  22242 				break
  22243 			}
  22244 			{
  22245 				xtv := string(val)
  22246 				sv.Message = ptr.String(xtv)
  22247 			}
  22248 
  22249 		default:
  22250 			// Do nothing and ignore the unexpected tag element
  22251 			err = decoder.Decoder.Skip()
  22252 			if err != nil {
  22253 				return err
  22254 			}
  22255 
  22256 		}
  22257 		decoder = originalDecoder
  22258 	}
  22259 	*v = sv
  22260 	return nil
  22261 }
  22262 
  22263 func awsRestxml_deserializeDocumentVPCAssociationNotFound(v **types.VPCAssociationNotFound, decoder smithyxml.NodeDecoder) error {
  22264 	if v == nil {
  22265 		return fmt.Errorf("unexpected nil of type %T", v)
  22266 	}
  22267 	var sv *types.VPCAssociationNotFound
  22268 	if *v == nil {
  22269 		sv = &types.VPCAssociationNotFound{}
  22270 	} else {
  22271 		sv = *v
  22272 	}
  22273 
  22274 	for {
  22275 		t, done, err := decoder.Token()
  22276 		if err != nil {
  22277 			return err
  22278 		}
  22279 		if done {
  22280 			break
  22281 		}
  22282 		originalDecoder := decoder
  22283 		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
  22284 		switch {
  22285 		case strings.EqualFold("message", t.Name.Local):
  22286 			val, err := decoder.Value()
  22287 			if err != nil {
  22288 				return err
  22289 			}
  22290 			if val == nil {
  22291 				break
  22292 			}
  22293 			{
  22294 				xtv := string(val)
  22295 				sv.Message = ptr.String(xtv)
  22296 			}
  22297 
  22298 		default:
  22299 			// Do nothing and ignore the unexpected tag element
  22300 			err = decoder.Decoder.Skip()
  22301 			if err != nil {
  22302 				return err
  22303 			}
  22304 
  22305 		}
  22306 		decoder = originalDecoder
  22307 	}
  22308 	*v = sv
  22309 	return nil
  22310 }
  22311 
  22312 func awsRestxml_deserializeDocumentVPCs(v *[]types.VPC, decoder smithyxml.NodeDecoder) error {
  22313 	if v == nil {
  22314 		return fmt.Errorf("unexpected nil of type %T", v)
  22315 	}
  22316 	var sv []types.VPC
  22317 	if *v == nil {
  22318 		sv = make([]types.VPC, 0)
  22319 	} else {
  22320 		sv = *v
  22321 	}
  22322 
  22323 	originalDecoder := decoder
  22324 	for {
  22325 		t, done, err := decoder.Token()
  22326 		if err != nil {
  22327 			return err
  22328 		}
  22329 		if done {
  22330 			break
  22331 		}
  22332 		switch {
  22333 		case strings.EqualFold("VPC", t.Name.Local):
  22334 			var col types.VPC
  22335 			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22336 			destAddr := &col
  22337 			if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil {
  22338 				return err
  22339 			}
  22340 			col = *destAddr
  22341 			sv = append(sv, col)
  22342 
  22343 		default:
  22344 			err = decoder.Decoder.Skip()
  22345 			if err != nil {
  22346 				return err
  22347 			}
  22348 
  22349 		}
  22350 		decoder = originalDecoder
  22351 	}
  22352 	*v = sv
  22353 	return nil
  22354 }
  22355 
  22356 func awsRestxml_deserializeDocumentVPCsUnwrapped(v *[]types.VPC, decoder smithyxml.NodeDecoder) error {
  22357 	var sv []types.VPC
  22358 	if *v == nil {
  22359 		sv = make([]types.VPC, 0)
  22360 	} else {
  22361 		sv = *v
  22362 	}
  22363 
  22364 	switch {
  22365 	default:
  22366 		var mv types.VPC
  22367 		t := decoder.StartEl
  22368 		_ = t
  22369 		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
  22370 		destAddr := &mv
  22371 		if err := awsRestxml_deserializeDocumentVPC(&destAddr, nodeDecoder); err != nil {
  22372 			return err
  22373 		}
  22374 		mv = *destAddr
  22375 		sv = append(sv, mv)
  22376 	}
  22377 	*v = sv
  22378 	return nil
  22379 }
	code.dwrz.net Go monorepo.
	Log \| Files \| Refs