serializers.go - src - Go monorepo.

serializers.go (223332B)
      1 // Code generated by smithy-go-codegen DO NOT EDIT.
      2 
      3 package route53
      4 
      5 import (
      6 	"bytes"
      7 	"context"
      8 	"fmt"
      9 	"github.com/aws/aws-sdk-go-v2/service/route53/types"
     10 	smithy "github.com/aws/smithy-go"
     11 	"github.com/aws/smithy-go/encoding/httpbinding"
     12 	smithyxml "github.com/aws/smithy-go/encoding/xml"
     13 	"github.com/aws/smithy-go/middleware"
     14 	smithyhttp "github.com/aws/smithy-go/transport/http"
     15 )
     16 
     17 type awsRestxml_serializeOpActivateKeySigningKey struct {
     18 }
     19 
     20 func (*awsRestxml_serializeOpActivateKeySigningKey) ID() string {
     21 	return "OperationSerializer"
     22 }
     23 
     24 func (m *awsRestxml_serializeOpActivateKeySigningKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
     25 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
     26 ) {
     27 	request, ok := in.Request.(*smithyhttp.Request)
     28 	if !ok {
     29 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
     30 	}
     31 
     32 	input, ok := in.Parameters.(*ActivateKeySigningKeyInput)
     33 	_ = input
     34 	if !ok {
     35 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
     36 	}
     37 
     38 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/activate")
     39 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
     40 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
     41 	request.Method = "POST"
     42 	var restEncoder *httpbinding.Encoder
     43 	if request.URL.RawPath == "" {
     44 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
     45 	} else {
     46 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
     47 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
     48 	}
     49 
     50 	if err != nil {
     51 		return out, metadata, &smithy.SerializationError{Err: err}
     52 	}
     53 
     54 	if err := awsRestxml_serializeOpHttpBindingsActivateKeySigningKeyInput(input, restEncoder); err != nil {
     55 		return out, metadata, &smithy.SerializationError{Err: err}
     56 	}
     57 
     58 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
     59 		return out, metadata, &smithy.SerializationError{Err: err}
     60 	}
     61 	in.Request = request
     62 
     63 	return next.HandleSerialize(ctx, in)
     64 }
     65 func awsRestxml_serializeOpHttpBindingsActivateKeySigningKeyInput(v *ActivateKeySigningKeyInput, encoder *httpbinding.Encoder) error {
     66 	if v == nil {
     67 		return fmt.Errorf("unsupported serialization of nil %T", v)
     68 	}
     69 
     70 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
     71 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
     72 	}
     73 	if v.HostedZoneId != nil {
     74 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
     75 			return err
     76 		}
     77 	}
     78 
     79 	if v.Name == nil || len(*v.Name) == 0 {
     80 		return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
     81 	}
     82 	if v.Name != nil {
     83 		if err := encoder.SetURI("Name").String(*v.Name); err != nil {
     84 			return err
     85 		}
     86 	}
     87 
     88 	return nil
     89 }
     90 
     91 type awsRestxml_serializeOpAssociateVPCWithHostedZone struct {
     92 }
     93 
     94 func (*awsRestxml_serializeOpAssociateVPCWithHostedZone) ID() string {
     95 	return "OperationSerializer"
     96 }
     97 
     98 func (m *awsRestxml_serializeOpAssociateVPCWithHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
     99 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    100 ) {
    101 	request, ok := in.Request.(*smithyhttp.Request)
    102 	if !ok {
    103 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    104 	}
    105 
    106 	input, ok := in.Parameters.(*AssociateVPCWithHostedZoneInput)
    107 	_ = input
    108 	if !ok {
    109 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    110 	}
    111 
    112 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/associatevpc")
    113 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    114 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    115 	request.Method = "POST"
    116 	var restEncoder *httpbinding.Encoder
    117 	if request.URL.RawPath == "" {
    118 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    119 	} else {
    120 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    121 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    122 	}
    123 
    124 	if err != nil {
    125 		return out, metadata, &smithy.SerializationError{Err: err}
    126 	}
    127 
    128 	if err := awsRestxml_serializeOpHttpBindingsAssociateVPCWithHostedZoneInput(input, restEncoder); err != nil {
    129 		return out, metadata, &smithy.SerializationError{Err: err}
    130 	}
    131 
    132 	restEncoder.SetHeader("Content-Type").String("application/xml")
    133 
    134 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
    135 	rootAttr := []smithyxml.Attr{}
    136 	root := smithyxml.StartElement{
    137 		Name: smithyxml.Name{
    138 			Local: "AssociateVPCWithHostedZoneRequest",
    139 		},
    140 		Attr: rootAttr,
    141 	}
    142 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
    143 	if err := awsRestxml_serializeOpDocumentAssociateVPCWithHostedZoneInput(input, xmlEncoder.RootElement(root)); err != nil {
    144 		return out, metadata, &smithy.SerializationError{Err: err}
    145 	}
    146 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
    147 		return out, metadata, &smithy.SerializationError{Err: err}
    148 	}
    149 
    150 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    151 		return out, metadata, &smithy.SerializationError{Err: err}
    152 	}
    153 	in.Request = request
    154 
    155 	return next.HandleSerialize(ctx, in)
    156 }
    157 func awsRestxml_serializeOpHttpBindingsAssociateVPCWithHostedZoneInput(v *AssociateVPCWithHostedZoneInput, encoder *httpbinding.Encoder) error {
    158 	if v == nil {
    159 		return fmt.Errorf("unsupported serialization of nil %T", v)
    160 	}
    161 
    162 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
    163 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
    164 	}
    165 	if v.HostedZoneId != nil {
    166 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
    167 			return err
    168 		}
    169 	}
    170 
    171 	return nil
    172 }
    173 
    174 func awsRestxml_serializeOpDocumentAssociateVPCWithHostedZoneInput(v *AssociateVPCWithHostedZoneInput, value smithyxml.Value) error {
    175 	defer value.Close()
    176 	if v.Comment != nil {
    177 		rootAttr := []smithyxml.Attr{}
    178 		root := smithyxml.StartElement{
    179 			Name: smithyxml.Name{
    180 				Local: "Comment",
    181 			},
    182 			Attr: rootAttr,
    183 		}
    184 		el := value.MemberElement(root)
    185 		el.String(*v.Comment)
    186 	}
    187 	if v.VPC != nil {
    188 		rootAttr := []smithyxml.Attr{}
    189 		root := smithyxml.StartElement{
    190 			Name: smithyxml.Name{
    191 				Local: "VPC",
    192 			},
    193 			Attr: rootAttr,
    194 		}
    195 		el := value.MemberElement(root)
    196 		if err := awsRestxml_serializeDocumentVPC(v.VPC, el); err != nil {
    197 			return err
    198 		}
    199 	}
    200 	return nil
    201 }
    202 
    203 type awsRestxml_serializeOpChangeCidrCollection struct {
    204 }
    205 
    206 func (*awsRestxml_serializeOpChangeCidrCollection) ID() string {
    207 	return "OperationSerializer"
    208 }
    209 
    210 func (m *awsRestxml_serializeOpChangeCidrCollection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    211 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    212 ) {
    213 	request, ok := in.Request.(*smithyhttp.Request)
    214 	if !ok {
    215 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    216 	}
    217 
    218 	input, ok := in.Parameters.(*ChangeCidrCollectionInput)
    219 	_ = input
    220 	if !ok {
    221 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    222 	}
    223 
    224 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection/{Id}")
    225 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    226 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    227 	request.Method = "POST"
    228 	var restEncoder *httpbinding.Encoder
    229 	if request.URL.RawPath == "" {
    230 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    231 	} else {
    232 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    233 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    234 	}
    235 
    236 	if err != nil {
    237 		return out, metadata, &smithy.SerializationError{Err: err}
    238 	}
    239 
    240 	if err := awsRestxml_serializeOpHttpBindingsChangeCidrCollectionInput(input, restEncoder); err != nil {
    241 		return out, metadata, &smithy.SerializationError{Err: err}
    242 	}
    243 
    244 	restEncoder.SetHeader("Content-Type").String("application/xml")
    245 
    246 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
    247 	rootAttr := []smithyxml.Attr{}
    248 	root := smithyxml.StartElement{
    249 		Name: smithyxml.Name{
    250 			Local: "ChangeCidrCollectionRequest",
    251 		},
    252 		Attr: rootAttr,
    253 	}
    254 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
    255 	if err := awsRestxml_serializeOpDocumentChangeCidrCollectionInput(input, xmlEncoder.RootElement(root)); err != nil {
    256 		return out, metadata, &smithy.SerializationError{Err: err}
    257 	}
    258 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
    259 		return out, metadata, &smithy.SerializationError{Err: err}
    260 	}
    261 
    262 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    263 		return out, metadata, &smithy.SerializationError{Err: err}
    264 	}
    265 	in.Request = request
    266 
    267 	return next.HandleSerialize(ctx, in)
    268 }
    269 func awsRestxml_serializeOpHttpBindingsChangeCidrCollectionInput(v *ChangeCidrCollectionInput, encoder *httpbinding.Encoder) error {
    270 	if v == nil {
    271 		return fmt.Errorf("unsupported serialization of nil %T", v)
    272 	}
    273 
    274 	if v.Id == nil || len(*v.Id) == 0 {
    275 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
    276 	}
    277 	if v.Id != nil {
    278 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
    279 			return err
    280 		}
    281 	}
    282 
    283 	return nil
    284 }
    285 
    286 func awsRestxml_serializeOpDocumentChangeCidrCollectionInput(v *ChangeCidrCollectionInput, value smithyxml.Value) error {
    287 	defer value.Close()
    288 	if v.Changes != nil {
    289 		rootAttr := []smithyxml.Attr{}
    290 		root := smithyxml.StartElement{
    291 			Name: smithyxml.Name{
    292 				Local: "Changes",
    293 			},
    294 			Attr: rootAttr,
    295 		}
    296 		el := value.MemberElement(root)
    297 		if err := awsRestxml_serializeDocumentCidrCollectionChanges(v.Changes, el); err != nil {
    298 			return err
    299 		}
    300 	}
    301 	if v.CollectionVersion != nil {
    302 		rootAttr := []smithyxml.Attr{}
    303 		root := smithyxml.StartElement{
    304 			Name: smithyxml.Name{
    305 				Local: "CollectionVersion",
    306 			},
    307 			Attr: rootAttr,
    308 		}
    309 		el := value.MemberElement(root)
    310 		el.Long(*v.CollectionVersion)
    311 	}
    312 	return nil
    313 }
    314 
    315 type awsRestxml_serializeOpChangeResourceRecordSets struct {
    316 }
    317 
    318 func (*awsRestxml_serializeOpChangeResourceRecordSets) ID() string {
    319 	return "OperationSerializer"
    320 }
    321 
    322 func (m *awsRestxml_serializeOpChangeResourceRecordSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    323 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    324 ) {
    325 	request, ok := in.Request.(*smithyhttp.Request)
    326 	if !ok {
    327 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    328 	}
    329 
    330 	input, ok := in.Parameters.(*ChangeResourceRecordSetsInput)
    331 	_ = input
    332 	if !ok {
    333 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    334 	}
    335 
    336 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/rrset")
    337 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    338 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    339 	request.Method = "POST"
    340 	var restEncoder *httpbinding.Encoder
    341 	if request.URL.RawPath == "" {
    342 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    343 	} else {
    344 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    345 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    346 	}
    347 
    348 	if err != nil {
    349 		return out, metadata, &smithy.SerializationError{Err: err}
    350 	}
    351 
    352 	if err := awsRestxml_serializeOpHttpBindingsChangeResourceRecordSetsInput(input, restEncoder); err != nil {
    353 		return out, metadata, &smithy.SerializationError{Err: err}
    354 	}
    355 
    356 	restEncoder.SetHeader("Content-Type").String("application/xml")
    357 
    358 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
    359 	rootAttr := []smithyxml.Attr{}
    360 	root := smithyxml.StartElement{
    361 		Name: smithyxml.Name{
    362 			Local: "ChangeResourceRecordSetsRequest",
    363 		},
    364 		Attr: rootAttr,
    365 	}
    366 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
    367 	if err := awsRestxml_serializeOpDocumentChangeResourceRecordSetsInput(input, xmlEncoder.RootElement(root)); err != nil {
    368 		return out, metadata, &smithy.SerializationError{Err: err}
    369 	}
    370 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
    371 		return out, metadata, &smithy.SerializationError{Err: err}
    372 	}
    373 
    374 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    375 		return out, metadata, &smithy.SerializationError{Err: err}
    376 	}
    377 	in.Request = request
    378 
    379 	return next.HandleSerialize(ctx, in)
    380 }
    381 func awsRestxml_serializeOpHttpBindingsChangeResourceRecordSetsInput(v *ChangeResourceRecordSetsInput, encoder *httpbinding.Encoder) error {
    382 	if v == nil {
    383 		return fmt.Errorf("unsupported serialization of nil %T", v)
    384 	}
    385 
    386 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
    387 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
    388 	}
    389 	if v.HostedZoneId != nil {
    390 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
    391 			return err
    392 		}
    393 	}
    394 
    395 	return nil
    396 }
    397 
    398 func awsRestxml_serializeOpDocumentChangeResourceRecordSetsInput(v *ChangeResourceRecordSetsInput, value smithyxml.Value) error {
    399 	defer value.Close()
    400 	if v.ChangeBatch != nil {
    401 		rootAttr := []smithyxml.Attr{}
    402 		root := smithyxml.StartElement{
    403 			Name: smithyxml.Name{
    404 				Local: "ChangeBatch",
    405 			},
    406 			Attr: rootAttr,
    407 		}
    408 		el := value.MemberElement(root)
    409 		if err := awsRestxml_serializeDocumentChangeBatch(v.ChangeBatch, el); err != nil {
    410 			return err
    411 		}
    412 	}
    413 	return nil
    414 }
    415 
    416 type awsRestxml_serializeOpChangeTagsForResource struct {
    417 }
    418 
    419 func (*awsRestxml_serializeOpChangeTagsForResource) ID() string {
    420 	return "OperationSerializer"
    421 }
    422 
    423 func (m *awsRestxml_serializeOpChangeTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    424 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    425 ) {
    426 	request, ok := in.Request.(*smithyhttp.Request)
    427 	if !ok {
    428 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    429 	}
    430 
    431 	input, ok := in.Parameters.(*ChangeTagsForResourceInput)
    432 	_ = input
    433 	if !ok {
    434 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    435 	}
    436 
    437 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/tags/{ResourceType}/{ResourceId}")
    438 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    439 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    440 	request.Method = "POST"
    441 	var restEncoder *httpbinding.Encoder
    442 	if request.URL.RawPath == "" {
    443 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    444 	} else {
    445 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    446 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    447 	}
    448 
    449 	if err != nil {
    450 		return out, metadata, &smithy.SerializationError{Err: err}
    451 	}
    452 
    453 	if err := awsRestxml_serializeOpHttpBindingsChangeTagsForResourceInput(input, restEncoder); err != nil {
    454 		return out, metadata, &smithy.SerializationError{Err: err}
    455 	}
    456 
    457 	restEncoder.SetHeader("Content-Type").String("application/xml")
    458 
    459 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
    460 	rootAttr := []smithyxml.Attr{}
    461 	root := smithyxml.StartElement{
    462 		Name: smithyxml.Name{
    463 			Local: "ChangeTagsForResourceRequest",
    464 		},
    465 		Attr: rootAttr,
    466 	}
    467 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
    468 	if err := awsRestxml_serializeOpDocumentChangeTagsForResourceInput(input, xmlEncoder.RootElement(root)); err != nil {
    469 		return out, metadata, &smithy.SerializationError{Err: err}
    470 	}
    471 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
    472 		return out, metadata, &smithy.SerializationError{Err: err}
    473 	}
    474 
    475 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    476 		return out, metadata, &smithy.SerializationError{Err: err}
    477 	}
    478 	in.Request = request
    479 
    480 	return next.HandleSerialize(ctx, in)
    481 }
    482 func awsRestxml_serializeOpHttpBindingsChangeTagsForResourceInput(v *ChangeTagsForResourceInput, encoder *httpbinding.Encoder) error {
    483 	if v == nil {
    484 		return fmt.Errorf("unsupported serialization of nil %T", v)
    485 	}
    486 
    487 	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
    488 		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")}
    489 	}
    490 	if v.ResourceId != nil {
    491 		if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil {
    492 			return err
    493 		}
    494 	}
    495 
    496 	if len(v.ResourceType) == 0 {
    497 		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceType must not be empty")}
    498 	}
    499 	if len(v.ResourceType) > 0 {
    500 		if err := encoder.SetURI("ResourceType").String(string(v.ResourceType)); err != nil {
    501 			return err
    502 		}
    503 	}
    504 
    505 	return nil
    506 }
    507 
    508 func awsRestxml_serializeOpDocumentChangeTagsForResourceInput(v *ChangeTagsForResourceInput, value smithyxml.Value) error {
    509 	defer value.Close()
    510 	if v.AddTags != nil {
    511 		rootAttr := []smithyxml.Attr{}
    512 		root := smithyxml.StartElement{
    513 			Name: smithyxml.Name{
    514 				Local: "AddTags",
    515 			},
    516 			Attr: rootAttr,
    517 		}
    518 		el := value.MemberElement(root)
    519 		if err := awsRestxml_serializeDocumentTagList(v.AddTags, el); err != nil {
    520 			return err
    521 		}
    522 	}
    523 	if v.RemoveTagKeys != nil {
    524 		rootAttr := []smithyxml.Attr{}
    525 		root := smithyxml.StartElement{
    526 			Name: smithyxml.Name{
    527 				Local: "RemoveTagKeys",
    528 			},
    529 			Attr: rootAttr,
    530 		}
    531 		el := value.MemberElement(root)
    532 		if err := awsRestxml_serializeDocumentTagKeyList(v.RemoveTagKeys, el); err != nil {
    533 			return err
    534 		}
    535 	}
    536 	return nil
    537 }
    538 
    539 type awsRestxml_serializeOpCreateCidrCollection struct {
    540 }
    541 
    542 func (*awsRestxml_serializeOpCreateCidrCollection) ID() string {
    543 	return "OperationSerializer"
    544 }
    545 
    546 func (m *awsRestxml_serializeOpCreateCidrCollection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    547 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    548 ) {
    549 	request, ok := in.Request.(*smithyhttp.Request)
    550 	if !ok {
    551 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    552 	}
    553 
    554 	input, ok := in.Parameters.(*CreateCidrCollectionInput)
    555 	_ = input
    556 	if !ok {
    557 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    558 	}
    559 
    560 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection")
    561 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    562 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    563 	request.Method = "POST"
    564 	var restEncoder *httpbinding.Encoder
    565 	if request.URL.RawPath == "" {
    566 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    567 	} else {
    568 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    569 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    570 	}
    571 
    572 	if err != nil {
    573 		return out, metadata, &smithy.SerializationError{Err: err}
    574 	}
    575 
    576 	restEncoder.SetHeader("Content-Type").String("application/xml")
    577 
    578 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
    579 	rootAttr := []smithyxml.Attr{}
    580 	root := smithyxml.StartElement{
    581 		Name: smithyxml.Name{
    582 			Local: "CreateCidrCollectionRequest",
    583 		},
    584 		Attr: rootAttr,
    585 	}
    586 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
    587 	if err := awsRestxml_serializeOpDocumentCreateCidrCollectionInput(input, xmlEncoder.RootElement(root)); err != nil {
    588 		return out, metadata, &smithy.SerializationError{Err: err}
    589 	}
    590 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
    591 		return out, metadata, &smithy.SerializationError{Err: err}
    592 	}
    593 
    594 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    595 		return out, metadata, &smithy.SerializationError{Err: err}
    596 	}
    597 	in.Request = request
    598 
    599 	return next.HandleSerialize(ctx, in)
    600 }
    601 func awsRestxml_serializeOpHttpBindingsCreateCidrCollectionInput(v *CreateCidrCollectionInput, encoder *httpbinding.Encoder) error {
    602 	if v == nil {
    603 		return fmt.Errorf("unsupported serialization of nil %T", v)
    604 	}
    605 
    606 	return nil
    607 }
    608 
    609 func awsRestxml_serializeOpDocumentCreateCidrCollectionInput(v *CreateCidrCollectionInput, value smithyxml.Value) error {
    610 	defer value.Close()
    611 	if v.CallerReference != nil {
    612 		rootAttr := []smithyxml.Attr{}
    613 		root := smithyxml.StartElement{
    614 			Name: smithyxml.Name{
    615 				Local: "CallerReference",
    616 			},
    617 			Attr: rootAttr,
    618 		}
    619 		el := value.MemberElement(root)
    620 		el.String(*v.CallerReference)
    621 	}
    622 	if v.Name != nil {
    623 		rootAttr := []smithyxml.Attr{}
    624 		root := smithyxml.StartElement{
    625 			Name: smithyxml.Name{
    626 				Local: "Name",
    627 			},
    628 			Attr: rootAttr,
    629 		}
    630 		el := value.MemberElement(root)
    631 		el.String(*v.Name)
    632 	}
    633 	return nil
    634 }
    635 
    636 type awsRestxml_serializeOpCreateHealthCheck struct {
    637 }
    638 
    639 func (*awsRestxml_serializeOpCreateHealthCheck) ID() string {
    640 	return "OperationSerializer"
    641 }
    642 
    643 func (m *awsRestxml_serializeOpCreateHealthCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    644 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    645 ) {
    646 	request, ok := in.Request.(*smithyhttp.Request)
    647 	if !ok {
    648 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    649 	}
    650 
    651 	input, ok := in.Parameters.(*CreateHealthCheckInput)
    652 	_ = input
    653 	if !ok {
    654 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    655 	}
    656 
    657 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck")
    658 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    659 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    660 	request.Method = "POST"
    661 	var restEncoder *httpbinding.Encoder
    662 	if request.URL.RawPath == "" {
    663 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    664 	} else {
    665 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    666 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    667 	}
    668 
    669 	if err != nil {
    670 		return out, metadata, &smithy.SerializationError{Err: err}
    671 	}
    672 
    673 	restEncoder.SetHeader("Content-Type").String("application/xml")
    674 
    675 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
    676 	rootAttr := []smithyxml.Attr{}
    677 	root := smithyxml.StartElement{
    678 		Name: smithyxml.Name{
    679 			Local: "CreateHealthCheckRequest",
    680 		},
    681 		Attr: rootAttr,
    682 	}
    683 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
    684 	if err := awsRestxml_serializeOpDocumentCreateHealthCheckInput(input, xmlEncoder.RootElement(root)); err != nil {
    685 		return out, metadata, &smithy.SerializationError{Err: err}
    686 	}
    687 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
    688 		return out, metadata, &smithy.SerializationError{Err: err}
    689 	}
    690 
    691 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    692 		return out, metadata, &smithy.SerializationError{Err: err}
    693 	}
    694 	in.Request = request
    695 
    696 	return next.HandleSerialize(ctx, in)
    697 }
    698 func awsRestxml_serializeOpHttpBindingsCreateHealthCheckInput(v *CreateHealthCheckInput, encoder *httpbinding.Encoder) error {
    699 	if v == nil {
    700 		return fmt.Errorf("unsupported serialization of nil %T", v)
    701 	}
    702 
    703 	return nil
    704 }
    705 
    706 func awsRestxml_serializeOpDocumentCreateHealthCheckInput(v *CreateHealthCheckInput, value smithyxml.Value) error {
    707 	defer value.Close()
    708 	if v.CallerReference != nil {
    709 		rootAttr := []smithyxml.Attr{}
    710 		root := smithyxml.StartElement{
    711 			Name: smithyxml.Name{
    712 				Local: "CallerReference",
    713 			},
    714 			Attr: rootAttr,
    715 		}
    716 		el := value.MemberElement(root)
    717 		el.String(*v.CallerReference)
    718 	}
    719 	if v.HealthCheckConfig != nil {
    720 		rootAttr := []smithyxml.Attr{}
    721 		root := smithyxml.StartElement{
    722 			Name: smithyxml.Name{
    723 				Local: "HealthCheckConfig",
    724 			},
    725 			Attr: rootAttr,
    726 		}
    727 		el := value.MemberElement(root)
    728 		if err := awsRestxml_serializeDocumentHealthCheckConfig(v.HealthCheckConfig, el); err != nil {
    729 			return err
    730 		}
    731 	}
    732 	return nil
    733 }
    734 
    735 type awsRestxml_serializeOpCreateHostedZone struct {
    736 }
    737 
    738 func (*awsRestxml_serializeOpCreateHostedZone) ID() string {
    739 	return "OperationSerializer"
    740 }
    741 
    742 func (m *awsRestxml_serializeOpCreateHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    743 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    744 ) {
    745 	request, ok := in.Request.(*smithyhttp.Request)
    746 	if !ok {
    747 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    748 	}
    749 
    750 	input, ok := in.Parameters.(*CreateHostedZoneInput)
    751 	_ = input
    752 	if !ok {
    753 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    754 	}
    755 
    756 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone")
    757 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    758 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    759 	request.Method = "POST"
    760 	var restEncoder *httpbinding.Encoder
    761 	if request.URL.RawPath == "" {
    762 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    763 	} else {
    764 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    765 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    766 	}
    767 
    768 	if err != nil {
    769 		return out, metadata, &smithy.SerializationError{Err: err}
    770 	}
    771 
    772 	restEncoder.SetHeader("Content-Type").String("application/xml")
    773 
    774 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
    775 	rootAttr := []smithyxml.Attr{}
    776 	root := smithyxml.StartElement{
    777 		Name: smithyxml.Name{
    778 			Local: "CreateHostedZoneRequest",
    779 		},
    780 		Attr: rootAttr,
    781 	}
    782 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
    783 	if err := awsRestxml_serializeOpDocumentCreateHostedZoneInput(input, xmlEncoder.RootElement(root)); err != nil {
    784 		return out, metadata, &smithy.SerializationError{Err: err}
    785 	}
    786 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
    787 		return out, metadata, &smithy.SerializationError{Err: err}
    788 	}
    789 
    790 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    791 		return out, metadata, &smithy.SerializationError{Err: err}
    792 	}
    793 	in.Request = request
    794 
    795 	return next.HandleSerialize(ctx, in)
    796 }
    797 func awsRestxml_serializeOpHttpBindingsCreateHostedZoneInput(v *CreateHostedZoneInput, encoder *httpbinding.Encoder) error {
    798 	if v == nil {
    799 		return fmt.Errorf("unsupported serialization of nil %T", v)
    800 	}
    801 
    802 	return nil
    803 }
    804 
    805 func awsRestxml_serializeOpDocumentCreateHostedZoneInput(v *CreateHostedZoneInput, value smithyxml.Value) error {
    806 	defer value.Close()
    807 	if v.CallerReference != nil {
    808 		rootAttr := []smithyxml.Attr{}
    809 		root := smithyxml.StartElement{
    810 			Name: smithyxml.Name{
    811 				Local: "CallerReference",
    812 			},
    813 			Attr: rootAttr,
    814 		}
    815 		el := value.MemberElement(root)
    816 		el.String(*v.CallerReference)
    817 	}
    818 	if v.DelegationSetId != nil {
    819 		rootAttr := []smithyxml.Attr{}
    820 		root := smithyxml.StartElement{
    821 			Name: smithyxml.Name{
    822 				Local: "DelegationSetId",
    823 			},
    824 			Attr: rootAttr,
    825 		}
    826 		el := value.MemberElement(root)
    827 		el.String(*v.DelegationSetId)
    828 	}
    829 	if v.HostedZoneConfig != nil {
    830 		rootAttr := []smithyxml.Attr{}
    831 		root := smithyxml.StartElement{
    832 			Name: smithyxml.Name{
    833 				Local: "HostedZoneConfig",
    834 			},
    835 			Attr: rootAttr,
    836 		}
    837 		el := value.MemberElement(root)
    838 		if err := awsRestxml_serializeDocumentHostedZoneConfig(v.HostedZoneConfig, el); err != nil {
    839 			return err
    840 		}
    841 	}
    842 	if v.Name != nil {
    843 		rootAttr := []smithyxml.Attr{}
    844 		root := smithyxml.StartElement{
    845 			Name: smithyxml.Name{
    846 				Local: "Name",
    847 			},
    848 			Attr: rootAttr,
    849 		}
    850 		el := value.MemberElement(root)
    851 		el.String(*v.Name)
    852 	}
    853 	if v.VPC != nil {
    854 		rootAttr := []smithyxml.Attr{}
    855 		root := smithyxml.StartElement{
    856 			Name: smithyxml.Name{
    857 				Local: "VPC",
    858 			},
    859 			Attr: rootAttr,
    860 		}
    861 		el := value.MemberElement(root)
    862 		if err := awsRestxml_serializeDocumentVPC(v.VPC, el); err != nil {
    863 			return err
    864 		}
    865 	}
    866 	return nil
    867 }
    868 
    869 type awsRestxml_serializeOpCreateKeySigningKey struct {
    870 }
    871 
    872 func (*awsRestxml_serializeOpCreateKeySigningKey) ID() string {
    873 	return "OperationSerializer"
    874 }
    875 
    876 func (m *awsRestxml_serializeOpCreateKeySigningKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    877 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    878 ) {
    879 	request, ok := in.Request.(*smithyhttp.Request)
    880 	if !ok {
    881 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    882 	}
    883 
    884 	input, ok := in.Parameters.(*CreateKeySigningKeyInput)
    885 	_ = input
    886 	if !ok {
    887 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    888 	}
    889 
    890 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/keysigningkey")
    891 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    892 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    893 	request.Method = "POST"
    894 	var restEncoder *httpbinding.Encoder
    895 	if request.URL.RawPath == "" {
    896 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    897 	} else {
    898 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    899 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    900 	}
    901 
    902 	if err != nil {
    903 		return out, metadata, &smithy.SerializationError{Err: err}
    904 	}
    905 
    906 	restEncoder.SetHeader("Content-Type").String("application/xml")
    907 
    908 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
    909 	rootAttr := []smithyxml.Attr{}
    910 	root := smithyxml.StartElement{
    911 		Name: smithyxml.Name{
    912 			Local: "CreateKeySigningKeyRequest",
    913 		},
    914 		Attr: rootAttr,
    915 	}
    916 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
    917 	if err := awsRestxml_serializeOpDocumentCreateKeySigningKeyInput(input, xmlEncoder.RootElement(root)); err != nil {
    918 		return out, metadata, &smithy.SerializationError{Err: err}
    919 	}
    920 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
    921 		return out, metadata, &smithy.SerializationError{Err: err}
    922 	}
    923 
    924 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    925 		return out, metadata, &smithy.SerializationError{Err: err}
    926 	}
    927 	in.Request = request
    928 
    929 	return next.HandleSerialize(ctx, in)
    930 }
    931 func awsRestxml_serializeOpHttpBindingsCreateKeySigningKeyInput(v *CreateKeySigningKeyInput, encoder *httpbinding.Encoder) error {
    932 	if v == nil {
    933 		return fmt.Errorf("unsupported serialization of nil %T", v)
    934 	}
    935 
    936 	return nil
    937 }
    938 
    939 func awsRestxml_serializeOpDocumentCreateKeySigningKeyInput(v *CreateKeySigningKeyInput, value smithyxml.Value) error {
    940 	defer value.Close()
    941 	if v.CallerReference != nil {
    942 		rootAttr := []smithyxml.Attr{}
    943 		root := smithyxml.StartElement{
    944 			Name: smithyxml.Name{
    945 				Local: "CallerReference",
    946 			},
    947 			Attr: rootAttr,
    948 		}
    949 		el := value.MemberElement(root)
    950 		el.String(*v.CallerReference)
    951 	}
    952 	if v.HostedZoneId != nil {
    953 		rootAttr := []smithyxml.Attr{}
    954 		root := smithyxml.StartElement{
    955 			Name: smithyxml.Name{
    956 				Local: "HostedZoneId",
    957 			},
    958 			Attr: rootAttr,
    959 		}
    960 		el := value.MemberElement(root)
    961 		el.String(*v.HostedZoneId)
    962 	}
    963 	if v.KeyManagementServiceArn != nil {
    964 		rootAttr := []smithyxml.Attr{}
    965 		root := smithyxml.StartElement{
    966 			Name: smithyxml.Name{
    967 				Local: "KeyManagementServiceArn",
    968 			},
    969 			Attr: rootAttr,
    970 		}
    971 		el := value.MemberElement(root)
    972 		el.String(*v.KeyManagementServiceArn)
    973 	}
    974 	if v.Name != nil {
    975 		rootAttr := []smithyxml.Attr{}
    976 		root := smithyxml.StartElement{
    977 			Name: smithyxml.Name{
    978 				Local: "Name",
    979 			},
    980 			Attr: rootAttr,
    981 		}
    982 		el := value.MemberElement(root)
    983 		el.String(*v.Name)
    984 	}
    985 	if v.Status != nil {
    986 		rootAttr := []smithyxml.Attr{}
    987 		root := smithyxml.StartElement{
    988 			Name: smithyxml.Name{
    989 				Local: "Status",
    990 			},
    991 			Attr: rootAttr,
    992 		}
    993 		el := value.MemberElement(root)
    994 		el.String(*v.Status)
    995 	}
    996 	return nil
    997 }
    998 
    999 type awsRestxml_serializeOpCreateQueryLoggingConfig struct {
   1000 }
   1001 
   1002 func (*awsRestxml_serializeOpCreateQueryLoggingConfig) ID() string {
   1003 	return "OperationSerializer"
   1004 }
   1005 
   1006 func (m *awsRestxml_serializeOpCreateQueryLoggingConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1007 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1008 ) {
   1009 	request, ok := in.Request.(*smithyhttp.Request)
   1010 	if !ok {
   1011 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1012 	}
   1013 
   1014 	input, ok := in.Parameters.(*CreateQueryLoggingConfigInput)
   1015 	_ = input
   1016 	if !ok {
   1017 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1018 	}
   1019 
   1020 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/queryloggingconfig")
   1021 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1022 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1023 	request.Method = "POST"
   1024 	var restEncoder *httpbinding.Encoder
   1025 	if request.URL.RawPath == "" {
   1026 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1027 	} else {
   1028 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1029 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1030 	}
   1031 
   1032 	if err != nil {
   1033 		return out, metadata, &smithy.SerializationError{Err: err}
   1034 	}
   1035 
   1036 	restEncoder.SetHeader("Content-Type").String("application/xml")
   1037 
   1038 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   1039 	rootAttr := []smithyxml.Attr{}
   1040 	root := smithyxml.StartElement{
   1041 		Name: smithyxml.Name{
   1042 			Local: "CreateQueryLoggingConfigRequest",
   1043 		},
   1044 		Attr: rootAttr,
   1045 	}
   1046 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   1047 	if err := awsRestxml_serializeOpDocumentCreateQueryLoggingConfigInput(input, xmlEncoder.RootElement(root)); err != nil {
   1048 		return out, metadata, &smithy.SerializationError{Err: err}
   1049 	}
   1050 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   1051 		return out, metadata, &smithy.SerializationError{Err: err}
   1052 	}
   1053 
   1054 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1055 		return out, metadata, &smithy.SerializationError{Err: err}
   1056 	}
   1057 	in.Request = request
   1058 
   1059 	return next.HandleSerialize(ctx, in)
   1060 }
   1061 func awsRestxml_serializeOpHttpBindingsCreateQueryLoggingConfigInput(v *CreateQueryLoggingConfigInput, encoder *httpbinding.Encoder) error {
   1062 	if v == nil {
   1063 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1064 	}
   1065 
   1066 	return nil
   1067 }
   1068 
   1069 func awsRestxml_serializeOpDocumentCreateQueryLoggingConfigInput(v *CreateQueryLoggingConfigInput, value smithyxml.Value) error {
   1070 	defer value.Close()
   1071 	if v.CloudWatchLogsLogGroupArn != nil {
   1072 		rootAttr := []smithyxml.Attr{}
   1073 		root := smithyxml.StartElement{
   1074 			Name: smithyxml.Name{
   1075 				Local: "CloudWatchLogsLogGroupArn",
   1076 			},
   1077 			Attr: rootAttr,
   1078 		}
   1079 		el := value.MemberElement(root)
   1080 		el.String(*v.CloudWatchLogsLogGroupArn)
   1081 	}
   1082 	if v.HostedZoneId != nil {
   1083 		rootAttr := []smithyxml.Attr{}
   1084 		root := smithyxml.StartElement{
   1085 			Name: smithyxml.Name{
   1086 				Local: "HostedZoneId",
   1087 			},
   1088 			Attr: rootAttr,
   1089 		}
   1090 		el := value.MemberElement(root)
   1091 		el.String(*v.HostedZoneId)
   1092 	}
   1093 	return nil
   1094 }
   1095 
   1096 type awsRestxml_serializeOpCreateReusableDelegationSet struct {
   1097 }
   1098 
   1099 func (*awsRestxml_serializeOpCreateReusableDelegationSet) ID() string {
   1100 	return "OperationSerializer"
   1101 }
   1102 
   1103 func (m *awsRestxml_serializeOpCreateReusableDelegationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1104 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1105 ) {
   1106 	request, ok := in.Request.(*smithyhttp.Request)
   1107 	if !ok {
   1108 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1109 	}
   1110 
   1111 	input, ok := in.Parameters.(*CreateReusableDelegationSetInput)
   1112 	_ = input
   1113 	if !ok {
   1114 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1115 	}
   1116 
   1117 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/delegationset")
   1118 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1119 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1120 	request.Method = "POST"
   1121 	var restEncoder *httpbinding.Encoder
   1122 	if request.URL.RawPath == "" {
   1123 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1124 	} else {
   1125 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1126 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1127 	}
   1128 
   1129 	if err != nil {
   1130 		return out, metadata, &smithy.SerializationError{Err: err}
   1131 	}
   1132 
   1133 	restEncoder.SetHeader("Content-Type").String("application/xml")
   1134 
   1135 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   1136 	rootAttr := []smithyxml.Attr{}
   1137 	root := smithyxml.StartElement{
   1138 		Name: smithyxml.Name{
   1139 			Local: "CreateReusableDelegationSetRequest",
   1140 		},
   1141 		Attr: rootAttr,
   1142 	}
   1143 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   1144 	if err := awsRestxml_serializeOpDocumentCreateReusableDelegationSetInput(input, xmlEncoder.RootElement(root)); err != nil {
   1145 		return out, metadata, &smithy.SerializationError{Err: err}
   1146 	}
   1147 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   1148 		return out, metadata, &smithy.SerializationError{Err: err}
   1149 	}
   1150 
   1151 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1152 		return out, metadata, &smithy.SerializationError{Err: err}
   1153 	}
   1154 	in.Request = request
   1155 
   1156 	return next.HandleSerialize(ctx, in)
   1157 }
   1158 func awsRestxml_serializeOpHttpBindingsCreateReusableDelegationSetInput(v *CreateReusableDelegationSetInput, encoder *httpbinding.Encoder) error {
   1159 	if v == nil {
   1160 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1161 	}
   1162 
   1163 	return nil
   1164 }
   1165 
   1166 func awsRestxml_serializeOpDocumentCreateReusableDelegationSetInput(v *CreateReusableDelegationSetInput, value smithyxml.Value) error {
   1167 	defer value.Close()
   1168 	if v.CallerReference != nil {
   1169 		rootAttr := []smithyxml.Attr{}
   1170 		root := smithyxml.StartElement{
   1171 			Name: smithyxml.Name{
   1172 				Local: "CallerReference",
   1173 			},
   1174 			Attr: rootAttr,
   1175 		}
   1176 		el := value.MemberElement(root)
   1177 		el.String(*v.CallerReference)
   1178 	}
   1179 	if v.HostedZoneId != nil {
   1180 		rootAttr := []smithyxml.Attr{}
   1181 		root := smithyxml.StartElement{
   1182 			Name: smithyxml.Name{
   1183 				Local: "HostedZoneId",
   1184 			},
   1185 			Attr: rootAttr,
   1186 		}
   1187 		el := value.MemberElement(root)
   1188 		el.String(*v.HostedZoneId)
   1189 	}
   1190 	return nil
   1191 }
   1192 
   1193 type awsRestxml_serializeOpCreateTrafficPolicy struct {
   1194 }
   1195 
   1196 func (*awsRestxml_serializeOpCreateTrafficPolicy) ID() string {
   1197 	return "OperationSerializer"
   1198 }
   1199 
   1200 func (m *awsRestxml_serializeOpCreateTrafficPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1201 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1202 ) {
   1203 	request, ok := in.Request.(*smithyhttp.Request)
   1204 	if !ok {
   1205 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1206 	}
   1207 
   1208 	input, ok := in.Parameters.(*CreateTrafficPolicyInput)
   1209 	_ = input
   1210 	if !ok {
   1211 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1212 	}
   1213 
   1214 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicy")
   1215 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1216 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1217 	request.Method = "POST"
   1218 	var restEncoder *httpbinding.Encoder
   1219 	if request.URL.RawPath == "" {
   1220 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1221 	} else {
   1222 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1223 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1224 	}
   1225 
   1226 	if err != nil {
   1227 		return out, metadata, &smithy.SerializationError{Err: err}
   1228 	}
   1229 
   1230 	restEncoder.SetHeader("Content-Type").String("application/xml")
   1231 
   1232 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   1233 	rootAttr := []smithyxml.Attr{}
   1234 	root := smithyxml.StartElement{
   1235 		Name: smithyxml.Name{
   1236 			Local: "CreateTrafficPolicyRequest",
   1237 		},
   1238 		Attr: rootAttr,
   1239 	}
   1240 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   1241 	if err := awsRestxml_serializeOpDocumentCreateTrafficPolicyInput(input, xmlEncoder.RootElement(root)); err != nil {
   1242 		return out, metadata, &smithy.SerializationError{Err: err}
   1243 	}
   1244 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   1245 		return out, metadata, &smithy.SerializationError{Err: err}
   1246 	}
   1247 
   1248 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1249 		return out, metadata, &smithy.SerializationError{Err: err}
   1250 	}
   1251 	in.Request = request
   1252 
   1253 	return next.HandleSerialize(ctx, in)
   1254 }
   1255 func awsRestxml_serializeOpHttpBindingsCreateTrafficPolicyInput(v *CreateTrafficPolicyInput, encoder *httpbinding.Encoder) error {
   1256 	if v == nil {
   1257 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1258 	}
   1259 
   1260 	return nil
   1261 }
   1262 
   1263 func awsRestxml_serializeOpDocumentCreateTrafficPolicyInput(v *CreateTrafficPolicyInput, value smithyxml.Value) error {
   1264 	defer value.Close()
   1265 	if v.Comment != nil {
   1266 		rootAttr := []smithyxml.Attr{}
   1267 		root := smithyxml.StartElement{
   1268 			Name: smithyxml.Name{
   1269 				Local: "Comment",
   1270 			},
   1271 			Attr: rootAttr,
   1272 		}
   1273 		el := value.MemberElement(root)
   1274 		el.String(*v.Comment)
   1275 	}
   1276 	if v.Document != nil {
   1277 		rootAttr := []smithyxml.Attr{}
   1278 		root := smithyxml.StartElement{
   1279 			Name: smithyxml.Name{
   1280 				Local: "Document",
   1281 			},
   1282 			Attr: rootAttr,
   1283 		}
   1284 		el := value.MemberElement(root)
   1285 		el.String(*v.Document)
   1286 	}
   1287 	if v.Name != nil {
   1288 		rootAttr := []smithyxml.Attr{}
   1289 		root := smithyxml.StartElement{
   1290 			Name: smithyxml.Name{
   1291 				Local: "Name",
   1292 			},
   1293 			Attr: rootAttr,
   1294 		}
   1295 		el := value.MemberElement(root)
   1296 		el.String(*v.Name)
   1297 	}
   1298 	return nil
   1299 }
   1300 
   1301 type awsRestxml_serializeOpCreateTrafficPolicyInstance struct {
   1302 }
   1303 
   1304 func (*awsRestxml_serializeOpCreateTrafficPolicyInstance) ID() string {
   1305 	return "OperationSerializer"
   1306 }
   1307 
   1308 func (m *awsRestxml_serializeOpCreateTrafficPolicyInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1309 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1310 ) {
   1311 	request, ok := in.Request.(*smithyhttp.Request)
   1312 	if !ok {
   1313 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1314 	}
   1315 
   1316 	input, ok := in.Parameters.(*CreateTrafficPolicyInstanceInput)
   1317 	_ = input
   1318 	if !ok {
   1319 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1320 	}
   1321 
   1322 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstance")
   1323 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1324 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1325 	request.Method = "POST"
   1326 	var restEncoder *httpbinding.Encoder
   1327 	if request.URL.RawPath == "" {
   1328 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1329 	} else {
   1330 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1331 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1332 	}
   1333 
   1334 	if err != nil {
   1335 		return out, metadata, &smithy.SerializationError{Err: err}
   1336 	}
   1337 
   1338 	restEncoder.SetHeader("Content-Type").String("application/xml")
   1339 
   1340 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   1341 	rootAttr := []smithyxml.Attr{}
   1342 	root := smithyxml.StartElement{
   1343 		Name: smithyxml.Name{
   1344 			Local: "CreateTrafficPolicyInstanceRequest",
   1345 		},
   1346 		Attr: rootAttr,
   1347 	}
   1348 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   1349 	if err := awsRestxml_serializeOpDocumentCreateTrafficPolicyInstanceInput(input, xmlEncoder.RootElement(root)); err != nil {
   1350 		return out, metadata, &smithy.SerializationError{Err: err}
   1351 	}
   1352 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   1353 		return out, metadata, &smithy.SerializationError{Err: err}
   1354 	}
   1355 
   1356 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1357 		return out, metadata, &smithy.SerializationError{Err: err}
   1358 	}
   1359 	in.Request = request
   1360 
   1361 	return next.HandleSerialize(ctx, in)
   1362 }
   1363 func awsRestxml_serializeOpHttpBindingsCreateTrafficPolicyInstanceInput(v *CreateTrafficPolicyInstanceInput, encoder *httpbinding.Encoder) error {
   1364 	if v == nil {
   1365 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1366 	}
   1367 
   1368 	return nil
   1369 }
   1370 
   1371 func awsRestxml_serializeOpDocumentCreateTrafficPolicyInstanceInput(v *CreateTrafficPolicyInstanceInput, value smithyxml.Value) error {
   1372 	defer value.Close()
   1373 	if v.HostedZoneId != nil {
   1374 		rootAttr := []smithyxml.Attr{}
   1375 		root := smithyxml.StartElement{
   1376 			Name: smithyxml.Name{
   1377 				Local: "HostedZoneId",
   1378 			},
   1379 			Attr: rootAttr,
   1380 		}
   1381 		el := value.MemberElement(root)
   1382 		el.String(*v.HostedZoneId)
   1383 	}
   1384 	if v.Name != nil {
   1385 		rootAttr := []smithyxml.Attr{}
   1386 		root := smithyxml.StartElement{
   1387 			Name: smithyxml.Name{
   1388 				Local: "Name",
   1389 			},
   1390 			Attr: rootAttr,
   1391 		}
   1392 		el := value.MemberElement(root)
   1393 		el.String(*v.Name)
   1394 	}
   1395 	if v.TrafficPolicyId != nil {
   1396 		rootAttr := []smithyxml.Attr{}
   1397 		root := smithyxml.StartElement{
   1398 			Name: smithyxml.Name{
   1399 				Local: "TrafficPolicyId",
   1400 			},
   1401 			Attr: rootAttr,
   1402 		}
   1403 		el := value.MemberElement(root)
   1404 		el.String(*v.TrafficPolicyId)
   1405 	}
   1406 	if v.TrafficPolicyVersion != nil {
   1407 		rootAttr := []smithyxml.Attr{}
   1408 		root := smithyxml.StartElement{
   1409 			Name: smithyxml.Name{
   1410 				Local: "TrafficPolicyVersion",
   1411 			},
   1412 			Attr: rootAttr,
   1413 		}
   1414 		el := value.MemberElement(root)
   1415 		el.Integer(*v.TrafficPolicyVersion)
   1416 	}
   1417 	if v.TTL != nil {
   1418 		rootAttr := []smithyxml.Attr{}
   1419 		root := smithyxml.StartElement{
   1420 			Name: smithyxml.Name{
   1421 				Local: "TTL",
   1422 			},
   1423 			Attr: rootAttr,
   1424 		}
   1425 		el := value.MemberElement(root)
   1426 		el.Long(*v.TTL)
   1427 	}
   1428 	return nil
   1429 }
   1430 
   1431 type awsRestxml_serializeOpCreateTrafficPolicyVersion struct {
   1432 }
   1433 
   1434 func (*awsRestxml_serializeOpCreateTrafficPolicyVersion) ID() string {
   1435 	return "OperationSerializer"
   1436 }
   1437 
   1438 func (m *awsRestxml_serializeOpCreateTrafficPolicyVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1439 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1440 ) {
   1441 	request, ok := in.Request.(*smithyhttp.Request)
   1442 	if !ok {
   1443 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1444 	}
   1445 
   1446 	input, ok := in.Parameters.(*CreateTrafficPolicyVersionInput)
   1447 	_ = input
   1448 	if !ok {
   1449 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1450 	}
   1451 
   1452 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicy/{Id}")
   1453 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1454 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1455 	request.Method = "POST"
   1456 	var restEncoder *httpbinding.Encoder
   1457 	if request.URL.RawPath == "" {
   1458 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1459 	} else {
   1460 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1461 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1462 	}
   1463 
   1464 	if err != nil {
   1465 		return out, metadata, &smithy.SerializationError{Err: err}
   1466 	}
   1467 
   1468 	if err := awsRestxml_serializeOpHttpBindingsCreateTrafficPolicyVersionInput(input, restEncoder); err != nil {
   1469 		return out, metadata, &smithy.SerializationError{Err: err}
   1470 	}
   1471 
   1472 	restEncoder.SetHeader("Content-Type").String("application/xml")
   1473 
   1474 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   1475 	rootAttr := []smithyxml.Attr{}
   1476 	root := smithyxml.StartElement{
   1477 		Name: smithyxml.Name{
   1478 			Local: "CreateTrafficPolicyVersionRequest",
   1479 		},
   1480 		Attr: rootAttr,
   1481 	}
   1482 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   1483 	if err := awsRestxml_serializeOpDocumentCreateTrafficPolicyVersionInput(input, xmlEncoder.RootElement(root)); err != nil {
   1484 		return out, metadata, &smithy.SerializationError{Err: err}
   1485 	}
   1486 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   1487 		return out, metadata, &smithy.SerializationError{Err: err}
   1488 	}
   1489 
   1490 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1491 		return out, metadata, &smithy.SerializationError{Err: err}
   1492 	}
   1493 	in.Request = request
   1494 
   1495 	return next.HandleSerialize(ctx, in)
   1496 }
   1497 func awsRestxml_serializeOpHttpBindingsCreateTrafficPolicyVersionInput(v *CreateTrafficPolicyVersionInput, encoder *httpbinding.Encoder) error {
   1498 	if v == nil {
   1499 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1500 	}
   1501 
   1502 	if v.Id == nil || len(*v.Id) == 0 {
   1503 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   1504 	}
   1505 	if v.Id != nil {
   1506 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   1507 			return err
   1508 		}
   1509 	}
   1510 
   1511 	return nil
   1512 }
   1513 
   1514 func awsRestxml_serializeOpDocumentCreateTrafficPolicyVersionInput(v *CreateTrafficPolicyVersionInput, value smithyxml.Value) error {
   1515 	defer value.Close()
   1516 	if v.Comment != nil {
   1517 		rootAttr := []smithyxml.Attr{}
   1518 		root := smithyxml.StartElement{
   1519 			Name: smithyxml.Name{
   1520 				Local: "Comment",
   1521 			},
   1522 			Attr: rootAttr,
   1523 		}
   1524 		el := value.MemberElement(root)
   1525 		el.String(*v.Comment)
   1526 	}
   1527 	if v.Document != nil {
   1528 		rootAttr := []smithyxml.Attr{}
   1529 		root := smithyxml.StartElement{
   1530 			Name: smithyxml.Name{
   1531 				Local: "Document",
   1532 			},
   1533 			Attr: rootAttr,
   1534 		}
   1535 		el := value.MemberElement(root)
   1536 		el.String(*v.Document)
   1537 	}
   1538 	return nil
   1539 }
   1540 
   1541 type awsRestxml_serializeOpCreateVPCAssociationAuthorization struct {
   1542 }
   1543 
   1544 func (*awsRestxml_serializeOpCreateVPCAssociationAuthorization) ID() string {
   1545 	return "OperationSerializer"
   1546 }
   1547 
   1548 func (m *awsRestxml_serializeOpCreateVPCAssociationAuthorization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1549 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1550 ) {
   1551 	request, ok := in.Request.(*smithyhttp.Request)
   1552 	if !ok {
   1553 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1554 	}
   1555 
   1556 	input, ok := in.Parameters.(*CreateVPCAssociationAuthorizationInput)
   1557 	_ = input
   1558 	if !ok {
   1559 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1560 	}
   1561 
   1562 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/authorizevpcassociation")
   1563 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1564 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1565 	request.Method = "POST"
   1566 	var restEncoder *httpbinding.Encoder
   1567 	if request.URL.RawPath == "" {
   1568 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1569 	} else {
   1570 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1571 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1572 	}
   1573 
   1574 	if err != nil {
   1575 		return out, metadata, &smithy.SerializationError{Err: err}
   1576 	}
   1577 
   1578 	if err := awsRestxml_serializeOpHttpBindingsCreateVPCAssociationAuthorizationInput(input, restEncoder); err != nil {
   1579 		return out, metadata, &smithy.SerializationError{Err: err}
   1580 	}
   1581 
   1582 	restEncoder.SetHeader("Content-Type").String("application/xml")
   1583 
   1584 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   1585 	rootAttr := []smithyxml.Attr{}
   1586 	root := smithyxml.StartElement{
   1587 		Name: smithyxml.Name{
   1588 			Local: "CreateVPCAssociationAuthorizationRequest",
   1589 		},
   1590 		Attr: rootAttr,
   1591 	}
   1592 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   1593 	if err := awsRestxml_serializeOpDocumentCreateVPCAssociationAuthorizationInput(input, xmlEncoder.RootElement(root)); err != nil {
   1594 		return out, metadata, &smithy.SerializationError{Err: err}
   1595 	}
   1596 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   1597 		return out, metadata, &smithy.SerializationError{Err: err}
   1598 	}
   1599 
   1600 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1601 		return out, metadata, &smithy.SerializationError{Err: err}
   1602 	}
   1603 	in.Request = request
   1604 
   1605 	return next.HandleSerialize(ctx, in)
   1606 }
   1607 func awsRestxml_serializeOpHttpBindingsCreateVPCAssociationAuthorizationInput(v *CreateVPCAssociationAuthorizationInput, encoder *httpbinding.Encoder) error {
   1608 	if v == nil {
   1609 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1610 	}
   1611 
   1612 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   1613 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   1614 	}
   1615 	if v.HostedZoneId != nil {
   1616 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   1617 			return err
   1618 		}
   1619 	}
   1620 
   1621 	return nil
   1622 }
   1623 
   1624 func awsRestxml_serializeOpDocumentCreateVPCAssociationAuthorizationInput(v *CreateVPCAssociationAuthorizationInput, value smithyxml.Value) error {
   1625 	defer value.Close()
   1626 	if v.VPC != nil {
   1627 		rootAttr := []smithyxml.Attr{}
   1628 		root := smithyxml.StartElement{
   1629 			Name: smithyxml.Name{
   1630 				Local: "VPC",
   1631 			},
   1632 			Attr: rootAttr,
   1633 		}
   1634 		el := value.MemberElement(root)
   1635 		if err := awsRestxml_serializeDocumentVPC(v.VPC, el); err != nil {
   1636 			return err
   1637 		}
   1638 	}
   1639 	return nil
   1640 }
   1641 
   1642 type awsRestxml_serializeOpDeactivateKeySigningKey struct {
   1643 }
   1644 
   1645 func (*awsRestxml_serializeOpDeactivateKeySigningKey) ID() string {
   1646 	return "OperationSerializer"
   1647 }
   1648 
   1649 func (m *awsRestxml_serializeOpDeactivateKeySigningKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1650 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1651 ) {
   1652 	request, ok := in.Request.(*smithyhttp.Request)
   1653 	if !ok {
   1654 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1655 	}
   1656 
   1657 	input, ok := in.Parameters.(*DeactivateKeySigningKeyInput)
   1658 	_ = input
   1659 	if !ok {
   1660 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1661 	}
   1662 
   1663 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/deactivate")
   1664 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1665 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1666 	request.Method = "POST"
   1667 	var restEncoder *httpbinding.Encoder
   1668 	if request.URL.RawPath == "" {
   1669 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1670 	} else {
   1671 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1672 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1673 	}
   1674 
   1675 	if err != nil {
   1676 		return out, metadata, &smithy.SerializationError{Err: err}
   1677 	}
   1678 
   1679 	if err := awsRestxml_serializeOpHttpBindingsDeactivateKeySigningKeyInput(input, restEncoder); err != nil {
   1680 		return out, metadata, &smithy.SerializationError{Err: err}
   1681 	}
   1682 
   1683 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1684 		return out, metadata, &smithy.SerializationError{Err: err}
   1685 	}
   1686 	in.Request = request
   1687 
   1688 	return next.HandleSerialize(ctx, in)
   1689 }
   1690 func awsRestxml_serializeOpHttpBindingsDeactivateKeySigningKeyInput(v *DeactivateKeySigningKeyInput, encoder *httpbinding.Encoder) error {
   1691 	if v == nil {
   1692 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1693 	}
   1694 
   1695 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   1696 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   1697 	}
   1698 	if v.HostedZoneId != nil {
   1699 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   1700 			return err
   1701 		}
   1702 	}
   1703 
   1704 	if v.Name == nil || len(*v.Name) == 0 {
   1705 		return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
   1706 	}
   1707 	if v.Name != nil {
   1708 		if err := encoder.SetURI("Name").String(*v.Name); err != nil {
   1709 			return err
   1710 		}
   1711 	}
   1712 
   1713 	return nil
   1714 }
   1715 
   1716 type awsRestxml_serializeOpDeleteCidrCollection struct {
   1717 }
   1718 
   1719 func (*awsRestxml_serializeOpDeleteCidrCollection) ID() string {
   1720 	return "OperationSerializer"
   1721 }
   1722 
   1723 func (m *awsRestxml_serializeOpDeleteCidrCollection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1724 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1725 ) {
   1726 	request, ok := in.Request.(*smithyhttp.Request)
   1727 	if !ok {
   1728 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1729 	}
   1730 
   1731 	input, ok := in.Parameters.(*DeleteCidrCollectionInput)
   1732 	_ = input
   1733 	if !ok {
   1734 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1735 	}
   1736 
   1737 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection/{Id}")
   1738 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1739 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1740 	request.Method = "DELETE"
   1741 	var restEncoder *httpbinding.Encoder
   1742 	if request.URL.RawPath == "" {
   1743 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1744 	} else {
   1745 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1746 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1747 	}
   1748 
   1749 	if err != nil {
   1750 		return out, metadata, &smithy.SerializationError{Err: err}
   1751 	}
   1752 
   1753 	if err := awsRestxml_serializeOpHttpBindingsDeleteCidrCollectionInput(input, restEncoder); err != nil {
   1754 		return out, metadata, &smithy.SerializationError{Err: err}
   1755 	}
   1756 
   1757 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1758 		return out, metadata, &smithy.SerializationError{Err: err}
   1759 	}
   1760 	in.Request = request
   1761 
   1762 	return next.HandleSerialize(ctx, in)
   1763 }
   1764 func awsRestxml_serializeOpHttpBindingsDeleteCidrCollectionInput(v *DeleteCidrCollectionInput, encoder *httpbinding.Encoder) error {
   1765 	if v == nil {
   1766 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1767 	}
   1768 
   1769 	if v.Id == nil || len(*v.Id) == 0 {
   1770 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   1771 	}
   1772 	if v.Id != nil {
   1773 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   1774 			return err
   1775 		}
   1776 	}
   1777 
   1778 	return nil
   1779 }
   1780 
   1781 type awsRestxml_serializeOpDeleteHealthCheck struct {
   1782 }
   1783 
   1784 func (*awsRestxml_serializeOpDeleteHealthCheck) ID() string {
   1785 	return "OperationSerializer"
   1786 }
   1787 
   1788 func (m *awsRestxml_serializeOpDeleteHealthCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1789 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1790 ) {
   1791 	request, ok := in.Request.(*smithyhttp.Request)
   1792 	if !ok {
   1793 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1794 	}
   1795 
   1796 	input, ok := in.Parameters.(*DeleteHealthCheckInput)
   1797 	_ = input
   1798 	if !ok {
   1799 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1800 	}
   1801 
   1802 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck/{HealthCheckId}")
   1803 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1804 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1805 	request.Method = "DELETE"
   1806 	var restEncoder *httpbinding.Encoder
   1807 	if request.URL.RawPath == "" {
   1808 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1809 	} else {
   1810 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1811 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1812 	}
   1813 
   1814 	if err != nil {
   1815 		return out, metadata, &smithy.SerializationError{Err: err}
   1816 	}
   1817 
   1818 	if err := awsRestxml_serializeOpHttpBindingsDeleteHealthCheckInput(input, restEncoder); err != nil {
   1819 		return out, metadata, &smithy.SerializationError{Err: err}
   1820 	}
   1821 
   1822 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1823 		return out, metadata, &smithy.SerializationError{Err: err}
   1824 	}
   1825 	in.Request = request
   1826 
   1827 	return next.HandleSerialize(ctx, in)
   1828 }
   1829 func awsRestxml_serializeOpHttpBindingsDeleteHealthCheckInput(v *DeleteHealthCheckInput, encoder *httpbinding.Encoder) error {
   1830 	if v == nil {
   1831 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1832 	}
   1833 
   1834 	if v.HealthCheckId == nil || len(*v.HealthCheckId) == 0 {
   1835 		return &smithy.SerializationError{Err: fmt.Errorf("input member HealthCheckId must not be empty")}
   1836 	}
   1837 	if v.HealthCheckId != nil {
   1838 		if err := encoder.SetURI("HealthCheckId").String(*v.HealthCheckId); err != nil {
   1839 			return err
   1840 		}
   1841 	}
   1842 
   1843 	return nil
   1844 }
   1845 
   1846 type awsRestxml_serializeOpDeleteHostedZone struct {
   1847 }
   1848 
   1849 func (*awsRestxml_serializeOpDeleteHostedZone) ID() string {
   1850 	return "OperationSerializer"
   1851 }
   1852 
   1853 func (m *awsRestxml_serializeOpDeleteHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1854 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1855 ) {
   1856 	request, ok := in.Request.(*smithyhttp.Request)
   1857 	if !ok {
   1858 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1859 	}
   1860 
   1861 	input, ok := in.Parameters.(*DeleteHostedZoneInput)
   1862 	_ = input
   1863 	if !ok {
   1864 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1865 	}
   1866 
   1867 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{Id}")
   1868 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1869 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1870 	request.Method = "DELETE"
   1871 	var restEncoder *httpbinding.Encoder
   1872 	if request.URL.RawPath == "" {
   1873 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1874 	} else {
   1875 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1876 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1877 	}
   1878 
   1879 	if err != nil {
   1880 		return out, metadata, &smithy.SerializationError{Err: err}
   1881 	}
   1882 
   1883 	if err := awsRestxml_serializeOpHttpBindingsDeleteHostedZoneInput(input, restEncoder); err != nil {
   1884 		return out, metadata, &smithy.SerializationError{Err: err}
   1885 	}
   1886 
   1887 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1888 		return out, metadata, &smithy.SerializationError{Err: err}
   1889 	}
   1890 	in.Request = request
   1891 
   1892 	return next.HandleSerialize(ctx, in)
   1893 }
   1894 func awsRestxml_serializeOpHttpBindingsDeleteHostedZoneInput(v *DeleteHostedZoneInput, encoder *httpbinding.Encoder) error {
   1895 	if v == nil {
   1896 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1897 	}
   1898 
   1899 	if v.Id == nil || len(*v.Id) == 0 {
   1900 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   1901 	}
   1902 	if v.Id != nil {
   1903 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   1904 			return err
   1905 		}
   1906 	}
   1907 
   1908 	return nil
   1909 }
   1910 
   1911 type awsRestxml_serializeOpDeleteKeySigningKey struct {
   1912 }
   1913 
   1914 func (*awsRestxml_serializeOpDeleteKeySigningKey) ID() string {
   1915 	return "OperationSerializer"
   1916 }
   1917 
   1918 func (m *awsRestxml_serializeOpDeleteKeySigningKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1919 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1920 ) {
   1921 	request, ok := in.Request.(*smithyhttp.Request)
   1922 	if !ok {
   1923 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1924 	}
   1925 
   1926 	input, ok := in.Parameters.(*DeleteKeySigningKeyInput)
   1927 	_ = input
   1928 	if !ok {
   1929 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   1930 	}
   1931 
   1932 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/keysigningkey/{HostedZoneId}/{Name}")
   1933 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   1934 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   1935 	request.Method = "DELETE"
   1936 	var restEncoder *httpbinding.Encoder
   1937 	if request.URL.RawPath == "" {
   1938 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   1939 	} else {
   1940 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   1941 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   1942 	}
   1943 
   1944 	if err != nil {
   1945 		return out, metadata, &smithy.SerializationError{Err: err}
   1946 	}
   1947 
   1948 	if err := awsRestxml_serializeOpHttpBindingsDeleteKeySigningKeyInput(input, restEncoder); err != nil {
   1949 		return out, metadata, &smithy.SerializationError{Err: err}
   1950 	}
   1951 
   1952 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   1953 		return out, metadata, &smithy.SerializationError{Err: err}
   1954 	}
   1955 	in.Request = request
   1956 
   1957 	return next.HandleSerialize(ctx, in)
   1958 }
   1959 func awsRestxml_serializeOpHttpBindingsDeleteKeySigningKeyInput(v *DeleteKeySigningKeyInput, encoder *httpbinding.Encoder) error {
   1960 	if v == nil {
   1961 		return fmt.Errorf("unsupported serialization of nil %T", v)
   1962 	}
   1963 
   1964 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   1965 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   1966 	}
   1967 	if v.HostedZoneId != nil {
   1968 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   1969 			return err
   1970 		}
   1971 	}
   1972 
   1973 	if v.Name == nil || len(*v.Name) == 0 {
   1974 		return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
   1975 	}
   1976 	if v.Name != nil {
   1977 		if err := encoder.SetURI("Name").String(*v.Name); err != nil {
   1978 			return err
   1979 		}
   1980 	}
   1981 
   1982 	return nil
   1983 }
   1984 
   1985 type awsRestxml_serializeOpDeleteQueryLoggingConfig struct {
   1986 }
   1987 
   1988 func (*awsRestxml_serializeOpDeleteQueryLoggingConfig) ID() string {
   1989 	return "OperationSerializer"
   1990 }
   1991 
   1992 func (m *awsRestxml_serializeOpDeleteQueryLoggingConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   1993 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   1994 ) {
   1995 	request, ok := in.Request.(*smithyhttp.Request)
   1996 	if !ok {
   1997 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   1998 	}
   1999 
   2000 	input, ok := in.Parameters.(*DeleteQueryLoggingConfigInput)
   2001 	_ = input
   2002 	if !ok {
   2003 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2004 	}
   2005 
   2006 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/queryloggingconfig/{Id}")
   2007 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2008 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2009 	request.Method = "DELETE"
   2010 	var restEncoder *httpbinding.Encoder
   2011 	if request.URL.RawPath == "" {
   2012 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2013 	} else {
   2014 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2015 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2016 	}
   2017 
   2018 	if err != nil {
   2019 		return out, metadata, &smithy.SerializationError{Err: err}
   2020 	}
   2021 
   2022 	if err := awsRestxml_serializeOpHttpBindingsDeleteQueryLoggingConfigInput(input, restEncoder); err != nil {
   2023 		return out, metadata, &smithy.SerializationError{Err: err}
   2024 	}
   2025 
   2026 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2027 		return out, metadata, &smithy.SerializationError{Err: err}
   2028 	}
   2029 	in.Request = request
   2030 
   2031 	return next.HandleSerialize(ctx, in)
   2032 }
   2033 func awsRestxml_serializeOpHttpBindingsDeleteQueryLoggingConfigInput(v *DeleteQueryLoggingConfigInput, encoder *httpbinding.Encoder) error {
   2034 	if v == nil {
   2035 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2036 	}
   2037 
   2038 	if v.Id == nil || len(*v.Id) == 0 {
   2039 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   2040 	}
   2041 	if v.Id != nil {
   2042 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   2043 			return err
   2044 		}
   2045 	}
   2046 
   2047 	return nil
   2048 }
   2049 
   2050 type awsRestxml_serializeOpDeleteReusableDelegationSet struct {
   2051 }
   2052 
   2053 func (*awsRestxml_serializeOpDeleteReusableDelegationSet) ID() string {
   2054 	return "OperationSerializer"
   2055 }
   2056 
   2057 func (m *awsRestxml_serializeOpDeleteReusableDelegationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2058 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2059 ) {
   2060 	request, ok := in.Request.(*smithyhttp.Request)
   2061 	if !ok {
   2062 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2063 	}
   2064 
   2065 	input, ok := in.Parameters.(*DeleteReusableDelegationSetInput)
   2066 	_ = input
   2067 	if !ok {
   2068 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2069 	}
   2070 
   2071 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/delegationset/{Id}")
   2072 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2073 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2074 	request.Method = "DELETE"
   2075 	var restEncoder *httpbinding.Encoder
   2076 	if request.URL.RawPath == "" {
   2077 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2078 	} else {
   2079 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2080 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2081 	}
   2082 
   2083 	if err != nil {
   2084 		return out, metadata, &smithy.SerializationError{Err: err}
   2085 	}
   2086 
   2087 	if err := awsRestxml_serializeOpHttpBindingsDeleteReusableDelegationSetInput(input, restEncoder); err != nil {
   2088 		return out, metadata, &smithy.SerializationError{Err: err}
   2089 	}
   2090 
   2091 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2092 		return out, metadata, &smithy.SerializationError{Err: err}
   2093 	}
   2094 	in.Request = request
   2095 
   2096 	return next.HandleSerialize(ctx, in)
   2097 }
   2098 func awsRestxml_serializeOpHttpBindingsDeleteReusableDelegationSetInput(v *DeleteReusableDelegationSetInput, encoder *httpbinding.Encoder) error {
   2099 	if v == nil {
   2100 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2101 	}
   2102 
   2103 	if v.Id == nil || len(*v.Id) == 0 {
   2104 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   2105 	}
   2106 	if v.Id != nil {
   2107 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   2108 			return err
   2109 		}
   2110 	}
   2111 
   2112 	return nil
   2113 }
   2114 
   2115 type awsRestxml_serializeOpDeleteTrafficPolicy struct {
   2116 }
   2117 
   2118 func (*awsRestxml_serializeOpDeleteTrafficPolicy) ID() string {
   2119 	return "OperationSerializer"
   2120 }
   2121 
   2122 func (m *awsRestxml_serializeOpDeleteTrafficPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2123 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2124 ) {
   2125 	request, ok := in.Request.(*smithyhttp.Request)
   2126 	if !ok {
   2127 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2128 	}
   2129 
   2130 	input, ok := in.Parameters.(*DeleteTrafficPolicyInput)
   2131 	_ = input
   2132 	if !ok {
   2133 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2134 	}
   2135 
   2136 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicy/{Id}/{Version}")
   2137 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2138 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2139 	request.Method = "DELETE"
   2140 	var restEncoder *httpbinding.Encoder
   2141 	if request.URL.RawPath == "" {
   2142 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2143 	} else {
   2144 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2145 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2146 	}
   2147 
   2148 	if err != nil {
   2149 		return out, metadata, &smithy.SerializationError{Err: err}
   2150 	}
   2151 
   2152 	if err := awsRestxml_serializeOpHttpBindingsDeleteTrafficPolicyInput(input, restEncoder); err != nil {
   2153 		return out, metadata, &smithy.SerializationError{Err: err}
   2154 	}
   2155 
   2156 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2157 		return out, metadata, &smithy.SerializationError{Err: err}
   2158 	}
   2159 	in.Request = request
   2160 
   2161 	return next.HandleSerialize(ctx, in)
   2162 }
   2163 func awsRestxml_serializeOpHttpBindingsDeleteTrafficPolicyInput(v *DeleteTrafficPolicyInput, encoder *httpbinding.Encoder) error {
   2164 	if v == nil {
   2165 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2166 	}
   2167 
   2168 	if v.Id == nil || len(*v.Id) == 0 {
   2169 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   2170 	}
   2171 	if v.Id != nil {
   2172 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   2173 			return err
   2174 		}
   2175 	}
   2176 
   2177 	if v.Version == nil {
   2178 		return &smithy.SerializationError{Err: fmt.Errorf("input member Version must not be empty")}
   2179 	}
   2180 	if v.Version != nil {
   2181 		if err := encoder.SetURI("Version").Integer(*v.Version); err != nil {
   2182 			return err
   2183 		}
   2184 	}
   2185 
   2186 	return nil
   2187 }
   2188 
   2189 type awsRestxml_serializeOpDeleteTrafficPolicyInstance struct {
   2190 }
   2191 
   2192 func (*awsRestxml_serializeOpDeleteTrafficPolicyInstance) ID() string {
   2193 	return "OperationSerializer"
   2194 }
   2195 
   2196 func (m *awsRestxml_serializeOpDeleteTrafficPolicyInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2197 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2198 ) {
   2199 	request, ok := in.Request.(*smithyhttp.Request)
   2200 	if !ok {
   2201 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2202 	}
   2203 
   2204 	input, ok := in.Parameters.(*DeleteTrafficPolicyInstanceInput)
   2205 	_ = input
   2206 	if !ok {
   2207 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2208 	}
   2209 
   2210 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstance/{Id}")
   2211 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2212 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2213 	request.Method = "DELETE"
   2214 	var restEncoder *httpbinding.Encoder
   2215 	if request.URL.RawPath == "" {
   2216 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2217 	} else {
   2218 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2219 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2220 	}
   2221 
   2222 	if err != nil {
   2223 		return out, metadata, &smithy.SerializationError{Err: err}
   2224 	}
   2225 
   2226 	if err := awsRestxml_serializeOpHttpBindingsDeleteTrafficPolicyInstanceInput(input, restEncoder); err != nil {
   2227 		return out, metadata, &smithy.SerializationError{Err: err}
   2228 	}
   2229 
   2230 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2231 		return out, metadata, &smithy.SerializationError{Err: err}
   2232 	}
   2233 	in.Request = request
   2234 
   2235 	return next.HandleSerialize(ctx, in)
   2236 }
   2237 func awsRestxml_serializeOpHttpBindingsDeleteTrafficPolicyInstanceInput(v *DeleteTrafficPolicyInstanceInput, encoder *httpbinding.Encoder) error {
   2238 	if v == nil {
   2239 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2240 	}
   2241 
   2242 	if v.Id == nil || len(*v.Id) == 0 {
   2243 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   2244 	}
   2245 	if v.Id != nil {
   2246 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   2247 			return err
   2248 		}
   2249 	}
   2250 
   2251 	return nil
   2252 }
   2253 
   2254 type awsRestxml_serializeOpDeleteVPCAssociationAuthorization struct {
   2255 }
   2256 
   2257 func (*awsRestxml_serializeOpDeleteVPCAssociationAuthorization) ID() string {
   2258 	return "OperationSerializer"
   2259 }
   2260 
   2261 func (m *awsRestxml_serializeOpDeleteVPCAssociationAuthorization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2262 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2263 ) {
   2264 	request, ok := in.Request.(*smithyhttp.Request)
   2265 	if !ok {
   2266 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2267 	}
   2268 
   2269 	input, ok := in.Parameters.(*DeleteVPCAssociationAuthorizationInput)
   2270 	_ = input
   2271 	if !ok {
   2272 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2273 	}
   2274 
   2275 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/deauthorizevpcassociation")
   2276 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2277 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2278 	request.Method = "POST"
   2279 	var restEncoder *httpbinding.Encoder
   2280 	if request.URL.RawPath == "" {
   2281 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2282 	} else {
   2283 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2284 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2285 	}
   2286 
   2287 	if err != nil {
   2288 		return out, metadata, &smithy.SerializationError{Err: err}
   2289 	}
   2290 
   2291 	if err := awsRestxml_serializeOpHttpBindingsDeleteVPCAssociationAuthorizationInput(input, restEncoder); err != nil {
   2292 		return out, metadata, &smithy.SerializationError{Err: err}
   2293 	}
   2294 
   2295 	restEncoder.SetHeader("Content-Type").String("application/xml")
   2296 
   2297 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   2298 	rootAttr := []smithyxml.Attr{}
   2299 	root := smithyxml.StartElement{
   2300 		Name: smithyxml.Name{
   2301 			Local: "DeleteVPCAssociationAuthorizationRequest",
   2302 		},
   2303 		Attr: rootAttr,
   2304 	}
   2305 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   2306 	if err := awsRestxml_serializeOpDocumentDeleteVPCAssociationAuthorizationInput(input, xmlEncoder.RootElement(root)); err != nil {
   2307 		return out, metadata, &smithy.SerializationError{Err: err}
   2308 	}
   2309 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   2310 		return out, metadata, &smithy.SerializationError{Err: err}
   2311 	}
   2312 
   2313 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2314 		return out, metadata, &smithy.SerializationError{Err: err}
   2315 	}
   2316 	in.Request = request
   2317 
   2318 	return next.HandleSerialize(ctx, in)
   2319 }
   2320 func awsRestxml_serializeOpHttpBindingsDeleteVPCAssociationAuthorizationInput(v *DeleteVPCAssociationAuthorizationInput, encoder *httpbinding.Encoder) error {
   2321 	if v == nil {
   2322 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2323 	}
   2324 
   2325 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   2326 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   2327 	}
   2328 	if v.HostedZoneId != nil {
   2329 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   2330 			return err
   2331 		}
   2332 	}
   2333 
   2334 	return nil
   2335 }
   2336 
   2337 func awsRestxml_serializeOpDocumentDeleteVPCAssociationAuthorizationInput(v *DeleteVPCAssociationAuthorizationInput, value smithyxml.Value) error {
   2338 	defer value.Close()
   2339 	if v.VPC != nil {
   2340 		rootAttr := []smithyxml.Attr{}
   2341 		root := smithyxml.StartElement{
   2342 			Name: smithyxml.Name{
   2343 				Local: "VPC",
   2344 			},
   2345 			Attr: rootAttr,
   2346 		}
   2347 		el := value.MemberElement(root)
   2348 		if err := awsRestxml_serializeDocumentVPC(v.VPC, el); err != nil {
   2349 			return err
   2350 		}
   2351 	}
   2352 	return nil
   2353 }
   2354 
   2355 type awsRestxml_serializeOpDisableHostedZoneDNSSEC struct {
   2356 }
   2357 
   2358 func (*awsRestxml_serializeOpDisableHostedZoneDNSSEC) ID() string {
   2359 	return "OperationSerializer"
   2360 }
   2361 
   2362 func (m *awsRestxml_serializeOpDisableHostedZoneDNSSEC) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2363 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2364 ) {
   2365 	request, ok := in.Request.(*smithyhttp.Request)
   2366 	if !ok {
   2367 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2368 	}
   2369 
   2370 	input, ok := in.Parameters.(*DisableHostedZoneDNSSECInput)
   2371 	_ = input
   2372 	if !ok {
   2373 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2374 	}
   2375 
   2376 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/disable-dnssec")
   2377 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2378 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2379 	request.Method = "POST"
   2380 	var restEncoder *httpbinding.Encoder
   2381 	if request.URL.RawPath == "" {
   2382 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2383 	} else {
   2384 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2385 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2386 	}
   2387 
   2388 	if err != nil {
   2389 		return out, metadata, &smithy.SerializationError{Err: err}
   2390 	}
   2391 
   2392 	if err := awsRestxml_serializeOpHttpBindingsDisableHostedZoneDNSSECInput(input, restEncoder); err != nil {
   2393 		return out, metadata, &smithy.SerializationError{Err: err}
   2394 	}
   2395 
   2396 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2397 		return out, metadata, &smithy.SerializationError{Err: err}
   2398 	}
   2399 	in.Request = request
   2400 
   2401 	return next.HandleSerialize(ctx, in)
   2402 }
   2403 func awsRestxml_serializeOpHttpBindingsDisableHostedZoneDNSSECInput(v *DisableHostedZoneDNSSECInput, encoder *httpbinding.Encoder) error {
   2404 	if v == nil {
   2405 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2406 	}
   2407 
   2408 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   2409 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   2410 	}
   2411 	if v.HostedZoneId != nil {
   2412 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   2413 			return err
   2414 		}
   2415 	}
   2416 
   2417 	return nil
   2418 }
   2419 
   2420 type awsRestxml_serializeOpDisassociateVPCFromHostedZone struct {
   2421 }
   2422 
   2423 func (*awsRestxml_serializeOpDisassociateVPCFromHostedZone) ID() string {
   2424 	return "OperationSerializer"
   2425 }
   2426 
   2427 func (m *awsRestxml_serializeOpDisassociateVPCFromHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2428 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2429 ) {
   2430 	request, ok := in.Request.(*smithyhttp.Request)
   2431 	if !ok {
   2432 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2433 	}
   2434 
   2435 	input, ok := in.Parameters.(*DisassociateVPCFromHostedZoneInput)
   2436 	_ = input
   2437 	if !ok {
   2438 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2439 	}
   2440 
   2441 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/disassociatevpc")
   2442 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2443 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2444 	request.Method = "POST"
   2445 	var restEncoder *httpbinding.Encoder
   2446 	if request.URL.RawPath == "" {
   2447 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2448 	} else {
   2449 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2450 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2451 	}
   2452 
   2453 	if err != nil {
   2454 		return out, metadata, &smithy.SerializationError{Err: err}
   2455 	}
   2456 
   2457 	if err := awsRestxml_serializeOpHttpBindingsDisassociateVPCFromHostedZoneInput(input, restEncoder); err != nil {
   2458 		return out, metadata, &smithy.SerializationError{Err: err}
   2459 	}
   2460 
   2461 	restEncoder.SetHeader("Content-Type").String("application/xml")
   2462 
   2463 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   2464 	rootAttr := []smithyxml.Attr{}
   2465 	root := smithyxml.StartElement{
   2466 		Name: smithyxml.Name{
   2467 			Local: "DisassociateVPCFromHostedZoneRequest",
   2468 		},
   2469 		Attr: rootAttr,
   2470 	}
   2471 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   2472 	if err := awsRestxml_serializeOpDocumentDisassociateVPCFromHostedZoneInput(input, xmlEncoder.RootElement(root)); err != nil {
   2473 		return out, metadata, &smithy.SerializationError{Err: err}
   2474 	}
   2475 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   2476 		return out, metadata, &smithy.SerializationError{Err: err}
   2477 	}
   2478 
   2479 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2480 		return out, metadata, &smithy.SerializationError{Err: err}
   2481 	}
   2482 	in.Request = request
   2483 
   2484 	return next.HandleSerialize(ctx, in)
   2485 }
   2486 func awsRestxml_serializeOpHttpBindingsDisassociateVPCFromHostedZoneInput(v *DisassociateVPCFromHostedZoneInput, encoder *httpbinding.Encoder) error {
   2487 	if v == nil {
   2488 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2489 	}
   2490 
   2491 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   2492 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   2493 	}
   2494 	if v.HostedZoneId != nil {
   2495 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   2496 			return err
   2497 		}
   2498 	}
   2499 
   2500 	return nil
   2501 }
   2502 
   2503 func awsRestxml_serializeOpDocumentDisassociateVPCFromHostedZoneInput(v *DisassociateVPCFromHostedZoneInput, value smithyxml.Value) error {
   2504 	defer value.Close()
   2505 	if v.Comment != nil {
   2506 		rootAttr := []smithyxml.Attr{}
   2507 		root := smithyxml.StartElement{
   2508 			Name: smithyxml.Name{
   2509 				Local: "Comment",
   2510 			},
   2511 			Attr: rootAttr,
   2512 		}
   2513 		el := value.MemberElement(root)
   2514 		el.String(*v.Comment)
   2515 	}
   2516 	if v.VPC != nil {
   2517 		rootAttr := []smithyxml.Attr{}
   2518 		root := smithyxml.StartElement{
   2519 			Name: smithyxml.Name{
   2520 				Local: "VPC",
   2521 			},
   2522 			Attr: rootAttr,
   2523 		}
   2524 		el := value.MemberElement(root)
   2525 		if err := awsRestxml_serializeDocumentVPC(v.VPC, el); err != nil {
   2526 			return err
   2527 		}
   2528 	}
   2529 	return nil
   2530 }
   2531 
   2532 type awsRestxml_serializeOpEnableHostedZoneDNSSEC struct {
   2533 }
   2534 
   2535 func (*awsRestxml_serializeOpEnableHostedZoneDNSSEC) ID() string {
   2536 	return "OperationSerializer"
   2537 }
   2538 
   2539 func (m *awsRestxml_serializeOpEnableHostedZoneDNSSEC) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2540 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2541 ) {
   2542 	request, ok := in.Request.(*smithyhttp.Request)
   2543 	if !ok {
   2544 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2545 	}
   2546 
   2547 	input, ok := in.Parameters.(*EnableHostedZoneDNSSECInput)
   2548 	_ = input
   2549 	if !ok {
   2550 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2551 	}
   2552 
   2553 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/enable-dnssec")
   2554 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2555 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2556 	request.Method = "POST"
   2557 	var restEncoder *httpbinding.Encoder
   2558 	if request.URL.RawPath == "" {
   2559 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2560 	} else {
   2561 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2562 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2563 	}
   2564 
   2565 	if err != nil {
   2566 		return out, metadata, &smithy.SerializationError{Err: err}
   2567 	}
   2568 
   2569 	if err := awsRestxml_serializeOpHttpBindingsEnableHostedZoneDNSSECInput(input, restEncoder); err != nil {
   2570 		return out, metadata, &smithy.SerializationError{Err: err}
   2571 	}
   2572 
   2573 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2574 		return out, metadata, &smithy.SerializationError{Err: err}
   2575 	}
   2576 	in.Request = request
   2577 
   2578 	return next.HandleSerialize(ctx, in)
   2579 }
   2580 func awsRestxml_serializeOpHttpBindingsEnableHostedZoneDNSSECInput(v *EnableHostedZoneDNSSECInput, encoder *httpbinding.Encoder) error {
   2581 	if v == nil {
   2582 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2583 	}
   2584 
   2585 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   2586 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   2587 	}
   2588 	if v.HostedZoneId != nil {
   2589 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   2590 			return err
   2591 		}
   2592 	}
   2593 
   2594 	return nil
   2595 }
   2596 
   2597 type awsRestxml_serializeOpGetAccountLimit struct {
   2598 }
   2599 
   2600 func (*awsRestxml_serializeOpGetAccountLimit) ID() string {
   2601 	return "OperationSerializer"
   2602 }
   2603 
   2604 func (m *awsRestxml_serializeOpGetAccountLimit) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2605 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2606 ) {
   2607 	request, ok := in.Request.(*smithyhttp.Request)
   2608 	if !ok {
   2609 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2610 	}
   2611 
   2612 	input, ok := in.Parameters.(*GetAccountLimitInput)
   2613 	_ = input
   2614 	if !ok {
   2615 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2616 	}
   2617 
   2618 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/accountlimit/{Type}")
   2619 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2620 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2621 	request.Method = "GET"
   2622 	var restEncoder *httpbinding.Encoder
   2623 	if request.URL.RawPath == "" {
   2624 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2625 	} else {
   2626 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2627 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2628 	}
   2629 
   2630 	if err != nil {
   2631 		return out, metadata, &smithy.SerializationError{Err: err}
   2632 	}
   2633 
   2634 	if err := awsRestxml_serializeOpHttpBindingsGetAccountLimitInput(input, restEncoder); err != nil {
   2635 		return out, metadata, &smithy.SerializationError{Err: err}
   2636 	}
   2637 
   2638 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2639 		return out, metadata, &smithy.SerializationError{Err: err}
   2640 	}
   2641 	in.Request = request
   2642 
   2643 	return next.HandleSerialize(ctx, in)
   2644 }
   2645 func awsRestxml_serializeOpHttpBindingsGetAccountLimitInput(v *GetAccountLimitInput, encoder *httpbinding.Encoder) error {
   2646 	if v == nil {
   2647 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2648 	}
   2649 
   2650 	if len(v.Type) == 0 {
   2651 		return &smithy.SerializationError{Err: fmt.Errorf("input member Type must not be empty")}
   2652 	}
   2653 	if len(v.Type) > 0 {
   2654 		if err := encoder.SetURI("Type").String(string(v.Type)); err != nil {
   2655 			return err
   2656 		}
   2657 	}
   2658 
   2659 	return nil
   2660 }
   2661 
   2662 type awsRestxml_serializeOpGetChange struct {
   2663 }
   2664 
   2665 func (*awsRestxml_serializeOpGetChange) ID() string {
   2666 	return "OperationSerializer"
   2667 }
   2668 
   2669 func (m *awsRestxml_serializeOpGetChange) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2670 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2671 ) {
   2672 	request, ok := in.Request.(*smithyhttp.Request)
   2673 	if !ok {
   2674 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2675 	}
   2676 
   2677 	input, ok := in.Parameters.(*GetChangeInput)
   2678 	_ = input
   2679 	if !ok {
   2680 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2681 	}
   2682 
   2683 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/change/{Id}")
   2684 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2685 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2686 	request.Method = "GET"
   2687 	var restEncoder *httpbinding.Encoder
   2688 	if request.URL.RawPath == "" {
   2689 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2690 	} else {
   2691 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2692 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2693 	}
   2694 
   2695 	if err != nil {
   2696 		return out, metadata, &smithy.SerializationError{Err: err}
   2697 	}
   2698 
   2699 	if err := awsRestxml_serializeOpHttpBindingsGetChangeInput(input, restEncoder); err != nil {
   2700 		return out, metadata, &smithy.SerializationError{Err: err}
   2701 	}
   2702 
   2703 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2704 		return out, metadata, &smithy.SerializationError{Err: err}
   2705 	}
   2706 	in.Request = request
   2707 
   2708 	return next.HandleSerialize(ctx, in)
   2709 }
   2710 func awsRestxml_serializeOpHttpBindingsGetChangeInput(v *GetChangeInput, encoder *httpbinding.Encoder) error {
   2711 	if v == nil {
   2712 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2713 	}
   2714 
   2715 	if v.Id == nil || len(*v.Id) == 0 {
   2716 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   2717 	}
   2718 	if v.Id != nil {
   2719 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   2720 			return err
   2721 		}
   2722 	}
   2723 
   2724 	return nil
   2725 }
   2726 
   2727 type awsRestxml_serializeOpGetCheckerIpRanges struct {
   2728 }
   2729 
   2730 func (*awsRestxml_serializeOpGetCheckerIpRanges) ID() string {
   2731 	return "OperationSerializer"
   2732 }
   2733 
   2734 func (m *awsRestxml_serializeOpGetCheckerIpRanges) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2735 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2736 ) {
   2737 	request, ok := in.Request.(*smithyhttp.Request)
   2738 	if !ok {
   2739 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2740 	}
   2741 
   2742 	input, ok := in.Parameters.(*GetCheckerIpRangesInput)
   2743 	_ = input
   2744 	if !ok {
   2745 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2746 	}
   2747 
   2748 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/checkeripranges")
   2749 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2750 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2751 	request.Method = "GET"
   2752 	var restEncoder *httpbinding.Encoder
   2753 	if request.URL.RawPath == "" {
   2754 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2755 	} else {
   2756 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2757 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2758 	}
   2759 
   2760 	if err != nil {
   2761 		return out, metadata, &smithy.SerializationError{Err: err}
   2762 	}
   2763 
   2764 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2765 		return out, metadata, &smithy.SerializationError{Err: err}
   2766 	}
   2767 	in.Request = request
   2768 
   2769 	return next.HandleSerialize(ctx, in)
   2770 }
   2771 func awsRestxml_serializeOpHttpBindingsGetCheckerIpRangesInput(v *GetCheckerIpRangesInput, encoder *httpbinding.Encoder) error {
   2772 	if v == nil {
   2773 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2774 	}
   2775 
   2776 	return nil
   2777 }
   2778 
   2779 type awsRestxml_serializeOpGetDNSSEC struct {
   2780 }
   2781 
   2782 func (*awsRestxml_serializeOpGetDNSSEC) ID() string {
   2783 	return "OperationSerializer"
   2784 }
   2785 
   2786 func (m *awsRestxml_serializeOpGetDNSSEC) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2787 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2788 ) {
   2789 	request, ok := in.Request.(*smithyhttp.Request)
   2790 	if !ok {
   2791 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2792 	}
   2793 
   2794 	input, ok := in.Parameters.(*GetDNSSECInput)
   2795 	_ = input
   2796 	if !ok {
   2797 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2798 	}
   2799 
   2800 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/dnssec")
   2801 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2802 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2803 	request.Method = "GET"
   2804 	var restEncoder *httpbinding.Encoder
   2805 	if request.URL.RawPath == "" {
   2806 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2807 	} else {
   2808 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2809 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2810 	}
   2811 
   2812 	if err != nil {
   2813 		return out, metadata, &smithy.SerializationError{Err: err}
   2814 	}
   2815 
   2816 	if err := awsRestxml_serializeOpHttpBindingsGetDNSSECInput(input, restEncoder); err != nil {
   2817 		return out, metadata, &smithy.SerializationError{Err: err}
   2818 	}
   2819 
   2820 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2821 		return out, metadata, &smithy.SerializationError{Err: err}
   2822 	}
   2823 	in.Request = request
   2824 
   2825 	return next.HandleSerialize(ctx, in)
   2826 }
   2827 func awsRestxml_serializeOpHttpBindingsGetDNSSECInput(v *GetDNSSECInput, encoder *httpbinding.Encoder) error {
   2828 	if v == nil {
   2829 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2830 	}
   2831 
   2832 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   2833 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   2834 	}
   2835 	if v.HostedZoneId != nil {
   2836 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   2837 			return err
   2838 		}
   2839 	}
   2840 
   2841 	return nil
   2842 }
   2843 
   2844 type awsRestxml_serializeOpGetGeoLocation struct {
   2845 }
   2846 
   2847 func (*awsRestxml_serializeOpGetGeoLocation) ID() string {
   2848 	return "OperationSerializer"
   2849 }
   2850 
   2851 func (m *awsRestxml_serializeOpGetGeoLocation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2852 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2853 ) {
   2854 	request, ok := in.Request.(*smithyhttp.Request)
   2855 	if !ok {
   2856 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2857 	}
   2858 
   2859 	input, ok := in.Parameters.(*GetGeoLocationInput)
   2860 	_ = input
   2861 	if !ok {
   2862 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2863 	}
   2864 
   2865 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/geolocation")
   2866 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2867 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2868 	request.Method = "GET"
   2869 	var restEncoder *httpbinding.Encoder
   2870 	if request.URL.RawPath == "" {
   2871 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2872 	} else {
   2873 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2874 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2875 	}
   2876 
   2877 	if err != nil {
   2878 		return out, metadata, &smithy.SerializationError{Err: err}
   2879 	}
   2880 
   2881 	if err := awsRestxml_serializeOpHttpBindingsGetGeoLocationInput(input, restEncoder); err != nil {
   2882 		return out, metadata, &smithy.SerializationError{Err: err}
   2883 	}
   2884 
   2885 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2886 		return out, metadata, &smithy.SerializationError{Err: err}
   2887 	}
   2888 	in.Request = request
   2889 
   2890 	return next.HandleSerialize(ctx, in)
   2891 }
   2892 func awsRestxml_serializeOpHttpBindingsGetGeoLocationInput(v *GetGeoLocationInput, encoder *httpbinding.Encoder) error {
   2893 	if v == nil {
   2894 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2895 	}
   2896 
   2897 	if v.ContinentCode != nil {
   2898 		encoder.SetQuery("continentcode").String(*v.ContinentCode)
   2899 	}
   2900 
   2901 	if v.CountryCode != nil {
   2902 		encoder.SetQuery("countrycode").String(*v.CountryCode)
   2903 	}
   2904 
   2905 	if v.SubdivisionCode != nil {
   2906 		encoder.SetQuery("subdivisioncode").String(*v.SubdivisionCode)
   2907 	}
   2908 
   2909 	return nil
   2910 }
   2911 
   2912 type awsRestxml_serializeOpGetHealthCheck struct {
   2913 }
   2914 
   2915 func (*awsRestxml_serializeOpGetHealthCheck) ID() string {
   2916 	return "OperationSerializer"
   2917 }
   2918 
   2919 func (m *awsRestxml_serializeOpGetHealthCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2920 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2921 ) {
   2922 	request, ok := in.Request.(*smithyhttp.Request)
   2923 	if !ok {
   2924 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2925 	}
   2926 
   2927 	input, ok := in.Parameters.(*GetHealthCheckInput)
   2928 	_ = input
   2929 	if !ok {
   2930 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2931 	}
   2932 
   2933 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck/{HealthCheckId}")
   2934 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   2935 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   2936 	request.Method = "GET"
   2937 	var restEncoder *httpbinding.Encoder
   2938 	if request.URL.RawPath == "" {
   2939 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   2940 	} else {
   2941 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   2942 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   2943 	}
   2944 
   2945 	if err != nil {
   2946 		return out, metadata, &smithy.SerializationError{Err: err}
   2947 	}
   2948 
   2949 	if err := awsRestxml_serializeOpHttpBindingsGetHealthCheckInput(input, restEncoder); err != nil {
   2950 		return out, metadata, &smithy.SerializationError{Err: err}
   2951 	}
   2952 
   2953 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   2954 		return out, metadata, &smithy.SerializationError{Err: err}
   2955 	}
   2956 	in.Request = request
   2957 
   2958 	return next.HandleSerialize(ctx, in)
   2959 }
   2960 func awsRestxml_serializeOpHttpBindingsGetHealthCheckInput(v *GetHealthCheckInput, encoder *httpbinding.Encoder) error {
   2961 	if v == nil {
   2962 		return fmt.Errorf("unsupported serialization of nil %T", v)
   2963 	}
   2964 
   2965 	if v.HealthCheckId == nil || len(*v.HealthCheckId) == 0 {
   2966 		return &smithy.SerializationError{Err: fmt.Errorf("input member HealthCheckId must not be empty")}
   2967 	}
   2968 	if v.HealthCheckId != nil {
   2969 		if err := encoder.SetURI("HealthCheckId").String(*v.HealthCheckId); err != nil {
   2970 			return err
   2971 		}
   2972 	}
   2973 
   2974 	return nil
   2975 }
   2976 
   2977 type awsRestxml_serializeOpGetHealthCheckCount struct {
   2978 }
   2979 
   2980 func (*awsRestxml_serializeOpGetHealthCheckCount) ID() string {
   2981 	return "OperationSerializer"
   2982 }
   2983 
   2984 func (m *awsRestxml_serializeOpGetHealthCheckCount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   2985 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   2986 ) {
   2987 	request, ok := in.Request.(*smithyhttp.Request)
   2988 	if !ok {
   2989 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   2990 	}
   2991 
   2992 	input, ok := in.Parameters.(*GetHealthCheckCountInput)
   2993 	_ = input
   2994 	if !ok {
   2995 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   2996 	}
   2997 
   2998 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheckcount")
   2999 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3000 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3001 	request.Method = "GET"
   3002 	var restEncoder *httpbinding.Encoder
   3003 	if request.URL.RawPath == "" {
   3004 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3005 	} else {
   3006 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3007 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3008 	}
   3009 
   3010 	if err != nil {
   3011 		return out, metadata, &smithy.SerializationError{Err: err}
   3012 	}
   3013 
   3014 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3015 		return out, metadata, &smithy.SerializationError{Err: err}
   3016 	}
   3017 	in.Request = request
   3018 
   3019 	return next.HandleSerialize(ctx, in)
   3020 }
   3021 func awsRestxml_serializeOpHttpBindingsGetHealthCheckCountInput(v *GetHealthCheckCountInput, encoder *httpbinding.Encoder) error {
   3022 	if v == nil {
   3023 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3024 	}
   3025 
   3026 	return nil
   3027 }
   3028 
   3029 type awsRestxml_serializeOpGetHealthCheckLastFailureReason struct {
   3030 }
   3031 
   3032 func (*awsRestxml_serializeOpGetHealthCheckLastFailureReason) ID() string {
   3033 	return "OperationSerializer"
   3034 }
   3035 
   3036 func (m *awsRestxml_serializeOpGetHealthCheckLastFailureReason) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3037 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3038 ) {
   3039 	request, ok := in.Request.(*smithyhttp.Request)
   3040 	if !ok {
   3041 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3042 	}
   3043 
   3044 	input, ok := in.Parameters.(*GetHealthCheckLastFailureReasonInput)
   3045 	_ = input
   3046 	if !ok {
   3047 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3048 	}
   3049 
   3050 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck/{HealthCheckId}/lastfailurereason")
   3051 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3052 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3053 	request.Method = "GET"
   3054 	var restEncoder *httpbinding.Encoder
   3055 	if request.URL.RawPath == "" {
   3056 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3057 	} else {
   3058 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3059 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3060 	}
   3061 
   3062 	if err != nil {
   3063 		return out, metadata, &smithy.SerializationError{Err: err}
   3064 	}
   3065 
   3066 	if err := awsRestxml_serializeOpHttpBindingsGetHealthCheckLastFailureReasonInput(input, restEncoder); err != nil {
   3067 		return out, metadata, &smithy.SerializationError{Err: err}
   3068 	}
   3069 
   3070 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3071 		return out, metadata, &smithy.SerializationError{Err: err}
   3072 	}
   3073 	in.Request = request
   3074 
   3075 	return next.HandleSerialize(ctx, in)
   3076 }
   3077 func awsRestxml_serializeOpHttpBindingsGetHealthCheckLastFailureReasonInput(v *GetHealthCheckLastFailureReasonInput, encoder *httpbinding.Encoder) error {
   3078 	if v == nil {
   3079 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3080 	}
   3081 
   3082 	if v.HealthCheckId == nil || len(*v.HealthCheckId) == 0 {
   3083 		return &smithy.SerializationError{Err: fmt.Errorf("input member HealthCheckId must not be empty")}
   3084 	}
   3085 	if v.HealthCheckId != nil {
   3086 		if err := encoder.SetURI("HealthCheckId").String(*v.HealthCheckId); err != nil {
   3087 			return err
   3088 		}
   3089 	}
   3090 
   3091 	return nil
   3092 }
   3093 
   3094 type awsRestxml_serializeOpGetHealthCheckStatus struct {
   3095 }
   3096 
   3097 func (*awsRestxml_serializeOpGetHealthCheckStatus) ID() string {
   3098 	return "OperationSerializer"
   3099 }
   3100 
   3101 func (m *awsRestxml_serializeOpGetHealthCheckStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3102 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3103 ) {
   3104 	request, ok := in.Request.(*smithyhttp.Request)
   3105 	if !ok {
   3106 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3107 	}
   3108 
   3109 	input, ok := in.Parameters.(*GetHealthCheckStatusInput)
   3110 	_ = input
   3111 	if !ok {
   3112 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3113 	}
   3114 
   3115 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck/{HealthCheckId}/status")
   3116 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3117 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3118 	request.Method = "GET"
   3119 	var restEncoder *httpbinding.Encoder
   3120 	if request.URL.RawPath == "" {
   3121 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3122 	} else {
   3123 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3124 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3125 	}
   3126 
   3127 	if err != nil {
   3128 		return out, metadata, &smithy.SerializationError{Err: err}
   3129 	}
   3130 
   3131 	if err := awsRestxml_serializeOpHttpBindingsGetHealthCheckStatusInput(input, restEncoder); err != nil {
   3132 		return out, metadata, &smithy.SerializationError{Err: err}
   3133 	}
   3134 
   3135 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3136 		return out, metadata, &smithy.SerializationError{Err: err}
   3137 	}
   3138 	in.Request = request
   3139 
   3140 	return next.HandleSerialize(ctx, in)
   3141 }
   3142 func awsRestxml_serializeOpHttpBindingsGetHealthCheckStatusInput(v *GetHealthCheckStatusInput, encoder *httpbinding.Encoder) error {
   3143 	if v == nil {
   3144 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3145 	}
   3146 
   3147 	if v.HealthCheckId == nil || len(*v.HealthCheckId) == 0 {
   3148 		return &smithy.SerializationError{Err: fmt.Errorf("input member HealthCheckId must not be empty")}
   3149 	}
   3150 	if v.HealthCheckId != nil {
   3151 		if err := encoder.SetURI("HealthCheckId").String(*v.HealthCheckId); err != nil {
   3152 			return err
   3153 		}
   3154 	}
   3155 
   3156 	return nil
   3157 }
   3158 
   3159 type awsRestxml_serializeOpGetHostedZone struct {
   3160 }
   3161 
   3162 func (*awsRestxml_serializeOpGetHostedZone) ID() string {
   3163 	return "OperationSerializer"
   3164 }
   3165 
   3166 func (m *awsRestxml_serializeOpGetHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3167 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3168 ) {
   3169 	request, ok := in.Request.(*smithyhttp.Request)
   3170 	if !ok {
   3171 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3172 	}
   3173 
   3174 	input, ok := in.Parameters.(*GetHostedZoneInput)
   3175 	_ = input
   3176 	if !ok {
   3177 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3178 	}
   3179 
   3180 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{Id}")
   3181 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3182 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3183 	request.Method = "GET"
   3184 	var restEncoder *httpbinding.Encoder
   3185 	if request.URL.RawPath == "" {
   3186 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3187 	} else {
   3188 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3189 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3190 	}
   3191 
   3192 	if err != nil {
   3193 		return out, metadata, &smithy.SerializationError{Err: err}
   3194 	}
   3195 
   3196 	if err := awsRestxml_serializeOpHttpBindingsGetHostedZoneInput(input, restEncoder); err != nil {
   3197 		return out, metadata, &smithy.SerializationError{Err: err}
   3198 	}
   3199 
   3200 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3201 		return out, metadata, &smithy.SerializationError{Err: err}
   3202 	}
   3203 	in.Request = request
   3204 
   3205 	return next.HandleSerialize(ctx, in)
   3206 }
   3207 func awsRestxml_serializeOpHttpBindingsGetHostedZoneInput(v *GetHostedZoneInput, encoder *httpbinding.Encoder) error {
   3208 	if v == nil {
   3209 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3210 	}
   3211 
   3212 	if v.Id == nil || len(*v.Id) == 0 {
   3213 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   3214 	}
   3215 	if v.Id != nil {
   3216 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   3217 			return err
   3218 		}
   3219 	}
   3220 
   3221 	return nil
   3222 }
   3223 
   3224 type awsRestxml_serializeOpGetHostedZoneCount struct {
   3225 }
   3226 
   3227 func (*awsRestxml_serializeOpGetHostedZoneCount) ID() string {
   3228 	return "OperationSerializer"
   3229 }
   3230 
   3231 func (m *awsRestxml_serializeOpGetHostedZoneCount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3232 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3233 ) {
   3234 	request, ok := in.Request.(*smithyhttp.Request)
   3235 	if !ok {
   3236 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3237 	}
   3238 
   3239 	input, ok := in.Parameters.(*GetHostedZoneCountInput)
   3240 	_ = input
   3241 	if !ok {
   3242 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3243 	}
   3244 
   3245 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzonecount")
   3246 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3247 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3248 	request.Method = "GET"
   3249 	var restEncoder *httpbinding.Encoder
   3250 	if request.URL.RawPath == "" {
   3251 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3252 	} else {
   3253 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3254 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3255 	}
   3256 
   3257 	if err != nil {
   3258 		return out, metadata, &smithy.SerializationError{Err: err}
   3259 	}
   3260 
   3261 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3262 		return out, metadata, &smithy.SerializationError{Err: err}
   3263 	}
   3264 	in.Request = request
   3265 
   3266 	return next.HandleSerialize(ctx, in)
   3267 }
   3268 func awsRestxml_serializeOpHttpBindingsGetHostedZoneCountInput(v *GetHostedZoneCountInput, encoder *httpbinding.Encoder) error {
   3269 	if v == nil {
   3270 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3271 	}
   3272 
   3273 	return nil
   3274 }
   3275 
   3276 type awsRestxml_serializeOpGetHostedZoneLimit struct {
   3277 }
   3278 
   3279 func (*awsRestxml_serializeOpGetHostedZoneLimit) ID() string {
   3280 	return "OperationSerializer"
   3281 }
   3282 
   3283 func (m *awsRestxml_serializeOpGetHostedZoneLimit) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3284 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3285 ) {
   3286 	request, ok := in.Request.(*smithyhttp.Request)
   3287 	if !ok {
   3288 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3289 	}
   3290 
   3291 	input, ok := in.Parameters.(*GetHostedZoneLimitInput)
   3292 	_ = input
   3293 	if !ok {
   3294 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3295 	}
   3296 
   3297 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzonelimit/{HostedZoneId}/{Type}")
   3298 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3299 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3300 	request.Method = "GET"
   3301 	var restEncoder *httpbinding.Encoder
   3302 	if request.URL.RawPath == "" {
   3303 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3304 	} else {
   3305 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3306 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3307 	}
   3308 
   3309 	if err != nil {
   3310 		return out, metadata, &smithy.SerializationError{Err: err}
   3311 	}
   3312 
   3313 	if err := awsRestxml_serializeOpHttpBindingsGetHostedZoneLimitInput(input, restEncoder); err != nil {
   3314 		return out, metadata, &smithy.SerializationError{Err: err}
   3315 	}
   3316 
   3317 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3318 		return out, metadata, &smithy.SerializationError{Err: err}
   3319 	}
   3320 	in.Request = request
   3321 
   3322 	return next.HandleSerialize(ctx, in)
   3323 }
   3324 func awsRestxml_serializeOpHttpBindingsGetHostedZoneLimitInput(v *GetHostedZoneLimitInput, encoder *httpbinding.Encoder) error {
   3325 	if v == nil {
   3326 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3327 	}
   3328 
   3329 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   3330 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   3331 	}
   3332 	if v.HostedZoneId != nil {
   3333 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   3334 			return err
   3335 		}
   3336 	}
   3337 
   3338 	if len(v.Type) == 0 {
   3339 		return &smithy.SerializationError{Err: fmt.Errorf("input member Type must not be empty")}
   3340 	}
   3341 	if len(v.Type) > 0 {
   3342 		if err := encoder.SetURI("Type").String(string(v.Type)); err != nil {
   3343 			return err
   3344 		}
   3345 	}
   3346 
   3347 	return nil
   3348 }
   3349 
   3350 type awsRestxml_serializeOpGetQueryLoggingConfig struct {
   3351 }
   3352 
   3353 func (*awsRestxml_serializeOpGetQueryLoggingConfig) ID() string {
   3354 	return "OperationSerializer"
   3355 }
   3356 
   3357 func (m *awsRestxml_serializeOpGetQueryLoggingConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3358 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3359 ) {
   3360 	request, ok := in.Request.(*smithyhttp.Request)
   3361 	if !ok {
   3362 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3363 	}
   3364 
   3365 	input, ok := in.Parameters.(*GetQueryLoggingConfigInput)
   3366 	_ = input
   3367 	if !ok {
   3368 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3369 	}
   3370 
   3371 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/queryloggingconfig/{Id}")
   3372 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3373 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3374 	request.Method = "GET"
   3375 	var restEncoder *httpbinding.Encoder
   3376 	if request.URL.RawPath == "" {
   3377 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3378 	} else {
   3379 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3380 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3381 	}
   3382 
   3383 	if err != nil {
   3384 		return out, metadata, &smithy.SerializationError{Err: err}
   3385 	}
   3386 
   3387 	if err := awsRestxml_serializeOpHttpBindingsGetQueryLoggingConfigInput(input, restEncoder); err != nil {
   3388 		return out, metadata, &smithy.SerializationError{Err: err}
   3389 	}
   3390 
   3391 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3392 		return out, metadata, &smithy.SerializationError{Err: err}
   3393 	}
   3394 	in.Request = request
   3395 
   3396 	return next.HandleSerialize(ctx, in)
   3397 }
   3398 func awsRestxml_serializeOpHttpBindingsGetQueryLoggingConfigInput(v *GetQueryLoggingConfigInput, encoder *httpbinding.Encoder) error {
   3399 	if v == nil {
   3400 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3401 	}
   3402 
   3403 	if v.Id == nil || len(*v.Id) == 0 {
   3404 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   3405 	}
   3406 	if v.Id != nil {
   3407 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   3408 			return err
   3409 		}
   3410 	}
   3411 
   3412 	return nil
   3413 }
   3414 
   3415 type awsRestxml_serializeOpGetReusableDelegationSet struct {
   3416 }
   3417 
   3418 func (*awsRestxml_serializeOpGetReusableDelegationSet) ID() string {
   3419 	return "OperationSerializer"
   3420 }
   3421 
   3422 func (m *awsRestxml_serializeOpGetReusableDelegationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3423 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3424 ) {
   3425 	request, ok := in.Request.(*smithyhttp.Request)
   3426 	if !ok {
   3427 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3428 	}
   3429 
   3430 	input, ok := in.Parameters.(*GetReusableDelegationSetInput)
   3431 	_ = input
   3432 	if !ok {
   3433 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3434 	}
   3435 
   3436 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/delegationset/{Id}")
   3437 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3438 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3439 	request.Method = "GET"
   3440 	var restEncoder *httpbinding.Encoder
   3441 	if request.URL.RawPath == "" {
   3442 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3443 	} else {
   3444 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3445 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3446 	}
   3447 
   3448 	if err != nil {
   3449 		return out, metadata, &smithy.SerializationError{Err: err}
   3450 	}
   3451 
   3452 	if err := awsRestxml_serializeOpHttpBindingsGetReusableDelegationSetInput(input, restEncoder); err != nil {
   3453 		return out, metadata, &smithy.SerializationError{Err: err}
   3454 	}
   3455 
   3456 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3457 		return out, metadata, &smithy.SerializationError{Err: err}
   3458 	}
   3459 	in.Request = request
   3460 
   3461 	return next.HandleSerialize(ctx, in)
   3462 }
   3463 func awsRestxml_serializeOpHttpBindingsGetReusableDelegationSetInput(v *GetReusableDelegationSetInput, encoder *httpbinding.Encoder) error {
   3464 	if v == nil {
   3465 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3466 	}
   3467 
   3468 	if v.Id == nil || len(*v.Id) == 0 {
   3469 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   3470 	}
   3471 	if v.Id != nil {
   3472 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   3473 			return err
   3474 		}
   3475 	}
   3476 
   3477 	return nil
   3478 }
   3479 
   3480 type awsRestxml_serializeOpGetReusableDelegationSetLimit struct {
   3481 }
   3482 
   3483 func (*awsRestxml_serializeOpGetReusableDelegationSetLimit) ID() string {
   3484 	return "OperationSerializer"
   3485 }
   3486 
   3487 func (m *awsRestxml_serializeOpGetReusableDelegationSetLimit) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3488 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3489 ) {
   3490 	request, ok := in.Request.(*smithyhttp.Request)
   3491 	if !ok {
   3492 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3493 	}
   3494 
   3495 	input, ok := in.Parameters.(*GetReusableDelegationSetLimitInput)
   3496 	_ = input
   3497 	if !ok {
   3498 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3499 	}
   3500 
   3501 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/reusabledelegationsetlimit/{DelegationSetId}/{Type}")
   3502 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3503 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3504 	request.Method = "GET"
   3505 	var restEncoder *httpbinding.Encoder
   3506 	if request.URL.RawPath == "" {
   3507 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3508 	} else {
   3509 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3510 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3511 	}
   3512 
   3513 	if err != nil {
   3514 		return out, metadata, &smithy.SerializationError{Err: err}
   3515 	}
   3516 
   3517 	if err := awsRestxml_serializeOpHttpBindingsGetReusableDelegationSetLimitInput(input, restEncoder); err != nil {
   3518 		return out, metadata, &smithy.SerializationError{Err: err}
   3519 	}
   3520 
   3521 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3522 		return out, metadata, &smithy.SerializationError{Err: err}
   3523 	}
   3524 	in.Request = request
   3525 
   3526 	return next.HandleSerialize(ctx, in)
   3527 }
   3528 func awsRestxml_serializeOpHttpBindingsGetReusableDelegationSetLimitInput(v *GetReusableDelegationSetLimitInput, encoder *httpbinding.Encoder) error {
   3529 	if v == nil {
   3530 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3531 	}
   3532 
   3533 	if v.DelegationSetId == nil || len(*v.DelegationSetId) == 0 {
   3534 		return &smithy.SerializationError{Err: fmt.Errorf("input member DelegationSetId must not be empty")}
   3535 	}
   3536 	if v.DelegationSetId != nil {
   3537 		if err := encoder.SetURI("DelegationSetId").String(*v.DelegationSetId); err != nil {
   3538 			return err
   3539 		}
   3540 	}
   3541 
   3542 	if len(v.Type) == 0 {
   3543 		return &smithy.SerializationError{Err: fmt.Errorf("input member Type must not be empty")}
   3544 	}
   3545 	if len(v.Type) > 0 {
   3546 		if err := encoder.SetURI("Type").String(string(v.Type)); err != nil {
   3547 			return err
   3548 		}
   3549 	}
   3550 
   3551 	return nil
   3552 }
   3553 
   3554 type awsRestxml_serializeOpGetTrafficPolicy struct {
   3555 }
   3556 
   3557 func (*awsRestxml_serializeOpGetTrafficPolicy) ID() string {
   3558 	return "OperationSerializer"
   3559 }
   3560 
   3561 func (m *awsRestxml_serializeOpGetTrafficPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3562 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3563 ) {
   3564 	request, ok := in.Request.(*smithyhttp.Request)
   3565 	if !ok {
   3566 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3567 	}
   3568 
   3569 	input, ok := in.Parameters.(*GetTrafficPolicyInput)
   3570 	_ = input
   3571 	if !ok {
   3572 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3573 	}
   3574 
   3575 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicy/{Id}/{Version}")
   3576 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3577 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3578 	request.Method = "GET"
   3579 	var restEncoder *httpbinding.Encoder
   3580 	if request.URL.RawPath == "" {
   3581 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3582 	} else {
   3583 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3584 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3585 	}
   3586 
   3587 	if err != nil {
   3588 		return out, metadata, &smithy.SerializationError{Err: err}
   3589 	}
   3590 
   3591 	if err := awsRestxml_serializeOpHttpBindingsGetTrafficPolicyInput(input, restEncoder); err != nil {
   3592 		return out, metadata, &smithy.SerializationError{Err: err}
   3593 	}
   3594 
   3595 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3596 		return out, metadata, &smithy.SerializationError{Err: err}
   3597 	}
   3598 	in.Request = request
   3599 
   3600 	return next.HandleSerialize(ctx, in)
   3601 }
   3602 func awsRestxml_serializeOpHttpBindingsGetTrafficPolicyInput(v *GetTrafficPolicyInput, encoder *httpbinding.Encoder) error {
   3603 	if v == nil {
   3604 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3605 	}
   3606 
   3607 	if v.Id == nil || len(*v.Id) == 0 {
   3608 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   3609 	}
   3610 	if v.Id != nil {
   3611 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   3612 			return err
   3613 		}
   3614 	}
   3615 
   3616 	if v.Version == nil {
   3617 		return &smithy.SerializationError{Err: fmt.Errorf("input member Version must not be empty")}
   3618 	}
   3619 	if v.Version != nil {
   3620 		if err := encoder.SetURI("Version").Integer(*v.Version); err != nil {
   3621 			return err
   3622 		}
   3623 	}
   3624 
   3625 	return nil
   3626 }
   3627 
   3628 type awsRestxml_serializeOpGetTrafficPolicyInstance struct {
   3629 }
   3630 
   3631 func (*awsRestxml_serializeOpGetTrafficPolicyInstance) ID() string {
   3632 	return "OperationSerializer"
   3633 }
   3634 
   3635 func (m *awsRestxml_serializeOpGetTrafficPolicyInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3636 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3637 ) {
   3638 	request, ok := in.Request.(*smithyhttp.Request)
   3639 	if !ok {
   3640 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3641 	}
   3642 
   3643 	input, ok := in.Parameters.(*GetTrafficPolicyInstanceInput)
   3644 	_ = input
   3645 	if !ok {
   3646 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3647 	}
   3648 
   3649 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstance/{Id}")
   3650 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3651 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3652 	request.Method = "GET"
   3653 	var restEncoder *httpbinding.Encoder
   3654 	if request.URL.RawPath == "" {
   3655 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3656 	} else {
   3657 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3658 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3659 	}
   3660 
   3661 	if err != nil {
   3662 		return out, metadata, &smithy.SerializationError{Err: err}
   3663 	}
   3664 
   3665 	if err := awsRestxml_serializeOpHttpBindingsGetTrafficPolicyInstanceInput(input, restEncoder); err != nil {
   3666 		return out, metadata, &smithy.SerializationError{Err: err}
   3667 	}
   3668 
   3669 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3670 		return out, metadata, &smithy.SerializationError{Err: err}
   3671 	}
   3672 	in.Request = request
   3673 
   3674 	return next.HandleSerialize(ctx, in)
   3675 }
   3676 func awsRestxml_serializeOpHttpBindingsGetTrafficPolicyInstanceInput(v *GetTrafficPolicyInstanceInput, encoder *httpbinding.Encoder) error {
   3677 	if v == nil {
   3678 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3679 	}
   3680 
   3681 	if v.Id == nil || len(*v.Id) == 0 {
   3682 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   3683 	}
   3684 	if v.Id != nil {
   3685 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   3686 			return err
   3687 		}
   3688 	}
   3689 
   3690 	return nil
   3691 }
   3692 
   3693 type awsRestxml_serializeOpGetTrafficPolicyInstanceCount struct {
   3694 }
   3695 
   3696 func (*awsRestxml_serializeOpGetTrafficPolicyInstanceCount) ID() string {
   3697 	return "OperationSerializer"
   3698 }
   3699 
   3700 func (m *awsRestxml_serializeOpGetTrafficPolicyInstanceCount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3701 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3702 ) {
   3703 	request, ok := in.Request.(*smithyhttp.Request)
   3704 	if !ok {
   3705 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3706 	}
   3707 
   3708 	input, ok := in.Parameters.(*GetTrafficPolicyInstanceCountInput)
   3709 	_ = input
   3710 	if !ok {
   3711 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3712 	}
   3713 
   3714 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstancecount")
   3715 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3716 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3717 	request.Method = "GET"
   3718 	var restEncoder *httpbinding.Encoder
   3719 	if request.URL.RawPath == "" {
   3720 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3721 	} else {
   3722 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3723 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3724 	}
   3725 
   3726 	if err != nil {
   3727 		return out, metadata, &smithy.SerializationError{Err: err}
   3728 	}
   3729 
   3730 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3731 		return out, metadata, &smithy.SerializationError{Err: err}
   3732 	}
   3733 	in.Request = request
   3734 
   3735 	return next.HandleSerialize(ctx, in)
   3736 }
   3737 func awsRestxml_serializeOpHttpBindingsGetTrafficPolicyInstanceCountInput(v *GetTrafficPolicyInstanceCountInput, encoder *httpbinding.Encoder) error {
   3738 	if v == nil {
   3739 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3740 	}
   3741 
   3742 	return nil
   3743 }
   3744 
   3745 type awsRestxml_serializeOpListCidrBlocks struct {
   3746 }
   3747 
   3748 func (*awsRestxml_serializeOpListCidrBlocks) ID() string {
   3749 	return "OperationSerializer"
   3750 }
   3751 
   3752 func (m *awsRestxml_serializeOpListCidrBlocks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3753 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3754 ) {
   3755 	request, ok := in.Request.(*smithyhttp.Request)
   3756 	if !ok {
   3757 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3758 	}
   3759 
   3760 	input, ok := in.Parameters.(*ListCidrBlocksInput)
   3761 	_ = input
   3762 	if !ok {
   3763 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3764 	}
   3765 
   3766 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection/{CollectionId}/cidrblocks")
   3767 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3768 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3769 	request.Method = "GET"
   3770 	var restEncoder *httpbinding.Encoder
   3771 	if request.URL.RawPath == "" {
   3772 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3773 	} else {
   3774 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3775 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3776 	}
   3777 
   3778 	if err != nil {
   3779 		return out, metadata, &smithy.SerializationError{Err: err}
   3780 	}
   3781 
   3782 	if err := awsRestxml_serializeOpHttpBindingsListCidrBlocksInput(input, restEncoder); err != nil {
   3783 		return out, metadata, &smithy.SerializationError{Err: err}
   3784 	}
   3785 
   3786 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3787 		return out, metadata, &smithy.SerializationError{Err: err}
   3788 	}
   3789 	in.Request = request
   3790 
   3791 	return next.HandleSerialize(ctx, in)
   3792 }
   3793 func awsRestxml_serializeOpHttpBindingsListCidrBlocksInput(v *ListCidrBlocksInput, encoder *httpbinding.Encoder) error {
   3794 	if v == nil {
   3795 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3796 	}
   3797 
   3798 	if v.CollectionId == nil || len(*v.CollectionId) == 0 {
   3799 		return &smithy.SerializationError{Err: fmt.Errorf("input member CollectionId must not be empty")}
   3800 	}
   3801 	if v.CollectionId != nil {
   3802 		if err := encoder.SetURI("CollectionId").String(*v.CollectionId); err != nil {
   3803 			return err
   3804 		}
   3805 	}
   3806 
   3807 	if v.LocationName != nil {
   3808 		encoder.SetQuery("location").String(*v.LocationName)
   3809 	}
   3810 
   3811 	if v.MaxResults != nil {
   3812 		encoder.SetQuery("maxresults").Integer(*v.MaxResults)
   3813 	}
   3814 
   3815 	if v.NextToken != nil {
   3816 		encoder.SetQuery("nexttoken").String(*v.NextToken)
   3817 	}
   3818 
   3819 	return nil
   3820 }
   3821 
   3822 type awsRestxml_serializeOpListCidrCollections struct {
   3823 }
   3824 
   3825 func (*awsRestxml_serializeOpListCidrCollections) ID() string {
   3826 	return "OperationSerializer"
   3827 }
   3828 
   3829 func (m *awsRestxml_serializeOpListCidrCollections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3830 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3831 ) {
   3832 	request, ok := in.Request.(*smithyhttp.Request)
   3833 	if !ok {
   3834 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3835 	}
   3836 
   3837 	input, ok := in.Parameters.(*ListCidrCollectionsInput)
   3838 	_ = input
   3839 	if !ok {
   3840 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3841 	}
   3842 
   3843 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection")
   3844 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3845 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3846 	request.Method = "GET"
   3847 	var restEncoder *httpbinding.Encoder
   3848 	if request.URL.RawPath == "" {
   3849 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3850 	} else {
   3851 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3852 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3853 	}
   3854 
   3855 	if err != nil {
   3856 		return out, metadata, &smithy.SerializationError{Err: err}
   3857 	}
   3858 
   3859 	if err := awsRestxml_serializeOpHttpBindingsListCidrCollectionsInput(input, restEncoder); err != nil {
   3860 		return out, metadata, &smithy.SerializationError{Err: err}
   3861 	}
   3862 
   3863 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3864 		return out, metadata, &smithy.SerializationError{Err: err}
   3865 	}
   3866 	in.Request = request
   3867 
   3868 	return next.HandleSerialize(ctx, in)
   3869 }
   3870 func awsRestxml_serializeOpHttpBindingsListCidrCollectionsInput(v *ListCidrCollectionsInput, encoder *httpbinding.Encoder) error {
   3871 	if v == nil {
   3872 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3873 	}
   3874 
   3875 	if v.MaxResults != nil {
   3876 		encoder.SetQuery("maxresults").Integer(*v.MaxResults)
   3877 	}
   3878 
   3879 	if v.NextToken != nil {
   3880 		encoder.SetQuery("nexttoken").String(*v.NextToken)
   3881 	}
   3882 
   3883 	return nil
   3884 }
   3885 
   3886 type awsRestxml_serializeOpListCidrLocations struct {
   3887 }
   3888 
   3889 func (*awsRestxml_serializeOpListCidrLocations) ID() string {
   3890 	return "OperationSerializer"
   3891 }
   3892 
   3893 func (m *awsRestxml_serializeOpListCidrLocations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3894 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3895 ) {
   3896 	request, ok := in.Request.(*smithyhttp.Request)
   3897 	if !ok {
   3898 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3899 	}
   3900 
   3901 	input, ok := in.Parameters.(*ListCidrLocationsInput)
   3902 	_ = input
   3903 	if !ok {
   3904 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3905 	}
   3906 
   3907 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection/{CollectionId}")
   3908 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3909 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3910 	request.Method = "GET"
   3911 	var restEncoder *httpbinding.Encoder
   3912 	if request.URL.RawPath == "" {
   3913 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3914 	} else {
   3915 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3916 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3917 	}
   3918 
   3919 	if err != nil {
   3920 		return out, metadata, &smithy.SerializationError{Err: err}
   3921 	}
   3922 
   3923 	if err := awsRestxml_serializeOpHttpBindingsListCidrLocationsInput(input, restEncoder); err != nil {
   3924 		return out, metadata, &smithy.SerializationError{Err: err}
   3925 	}
   3926 
   3927 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   3928 		return out, metadata, &smithy.SerializationError{Err: err}
   3929 	}
   3930 	in.Request = request
   3931 
   3932 	return next.HandleSerialize(ctx, in)
   3933 }
   3934 func awsRestxml_serializeOpHttpBindingsListCidrLocationsInput(v *ListCidrLocationsInput, encoder *httpbinding.Encoder) error {
   3935 	if v == nil {
   3936 		return fmt.Errorf("unsupported serialization of nil %T", v)
   3937 	}
   3938 
   3939 	if v.CollectionId == nil || len(*v.CollectionId) == 0 {
   3940 		return &smithy.SerializationError{Err: fmt.Errorf("input member CollectionId must not be empty")}
   3941 	}
   3942 	if v.CollectionId != nil {
   3943 		if err := encoder.SetURI("CollectionId").String(*v.CollectionId); err != nil {
   3944 			return err
   3945 		}
   3946 	}
   3947 
   3948 	if v.MaxResults != nil {
   3949 		encoder.SetQuery("maxresults").Integer(*v.MaxResults)
   3950 	}
   3951 
   3952 	if v.NextToken != nil {
   3953 		encoder.SetQuery("nexttoken").String(*v.NextToken)
   3954 	}
   3955 
   3956 	return nil
   3957 }
   3958 
   3959 type awsRestxml_serializeOpListGeoLocations struct {
   3960 }
   3961 
   3962 func (*awsRestxml_serializeOpListGeoLocations) ID() string {
   3963 	return "OperationSerializer"
   3964 }
   3965 
   3966 func (m *awsRestxml_serializeOpListGeoLocations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   3967 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   3968 ) {
   3969 	request, ok := in.Request.(*smithyhttp.Request)
   3970 	if !ok {
   3971 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   3972 	}
   3973 
   3974 	input, ok := in.Parameters.(*ListGeoLocationsInput)
   3975 	_ = input
   3976 	if !ok {
   3977 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   3978 	}
   3979 
   3980 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/geolocations")
   3981 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   3982 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   3983 	request.Method = "GET"
   3984 	var restEncoder *httpbinding.Encoder
   3985 	if request.URL.RawPath == "" {
   3986 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   3987 	} else {
   3988 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   3989 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   3990 	}
   3991 
   3992 	if err != nil {
   3993 		return out, metadata, &smithy.SerializationError{Err: err}
   3994 	}
   3995 
   3996 	if err := awsRestxml_serializeOpHttpBindingsListGeoLocationsInput(input, restEncoder); err != nil {
   3997 		return out, metadata, &smithy.SerializationError{Err: err}
   3998 	}
   3999 
   4000 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4001 		return out, metadata, &smithy.SerializationError{Err: err}
   4002 	}
   4003 	in.Request = request
   4004 
   4005 	return next.HandleSerialize(ctx, in)
   4006 }
   4007 func awsRestxml_serializeOpHttpBindingsListGeoLocationsInput(v *ListGeoLocationsInput, encoder *httpbinding.Encoder) error {
   4008 	if v == nil {
   4009 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4010 	}
   4011 
   4012 	if v.MaxItems != nil {
   4013 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4014 	}
   4015 
   4016 	if v.StartContinentCode != nil {
   4017 		encoder.SetQuery("startcontinentcode").String(*v.StartContinentCode)
   4018 	}
   4019 
   4020 	if v.StartCountryCode != nil {
   4021 		encoder.SetQuery("startcountrycode").String(*v.StartCountryCode)
   4022 	}
   4023 
   4024 	if v.StartSubdivisionCode != nil {
   4025 		encoder.SetQuery("startsubdivisioncode").String(*v.StartSubdivisionCode)
   4026 	}
   4027 
   4028 	return nil
   4029 }
   4030 
   4031 type awsRestxml_serializeOpListHealthChecks struct {
   4032 }
   4033 
   4034 func (*awsRestxml_serializeOpListHealthChecks) ID() string {
   4035 	return "OperationSerializer"
   4036 }
   4037 
   4038 func (m *awsRestxml_serializeOpListHealthChecks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4039 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4040 ) {
   4041 	request, ok := in.Request.(*smithyhttp.Request)
   4042 	if !ok {
   4043 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4044 	}
   4045 
   4046 	input, ok := in.Parameters.(*ListHealthChecksInput)
   4047 	_ = input
   4048 	if !ok {
   4049 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4050 	}
   4051 
   4052 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck")
   4053 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4054 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4055 	request.Method = "GET"
   4056 	var restEncoder *httpbinding.Encoder
   4057 	if request.URL.RawPath == "" {
   4058 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4059 	} else {
   4060 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4061 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4062 	}
   4063 
   4064 	if err != nil {
   4065 		return out, metadata, &smithy.SerializationError{Err: err}
   4066 	}
   4067 
   4068 	if err := awsRestxml_serializeOpHttpBindingsListHealthChecksInput(input, restEncoder); err != nil {
   4069 		return out, metadata, &smithy.SerializationError{Err: err}
   4070 	}
   4071 
   4072 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4073 		return out, metadata, &smithy.SerializationError{Err: err}
   4074 	}
   4075 	in.Request = request
   4076 
   4077 	return next.HandleSerialize(ctx, in)
   4078 }
   4079 func awsRestxml_serializeOpHttpBindingsListHealthChecksInput(v *ListHealthChecksInput, encoder *httpbinding.Encoder) error {
   4080 	if v == nil {
   4081 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4082 	}
   4083 
   4084 	if v.Marker != nil {
   4085 		encoder.SetQuery("marker").String(*v.Marker)
   4086 	}
   4087 
   4088 	if v.MaxItems != nil {
   4089 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4090 	}
   4091 
   4092 	return nil
   4093 }
   4094 
   4095 type awsRestxml_serializeOpListHostedZones struct {
   4096 }
   4097 
   4098 func (*awsRestxml_serializeOpListHostedZones) ID() string {
   4099 	return "OperationSerializer"
   4100 }
   4101 
   4102 func (m *awsRestxml_serializeOpListHostedZones) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4103 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4104 ) {
   4105 	request, ok := in.Request.(*smithyhttp.Request)
   4106 	if !ok {
   4107 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4108 	}
   4109 
   4110 	input, ok := in.Parameters.(*ListHostedZonesInput)
   4111 	_ = input
   4112 	if !ok {
   4113 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4114 	}
   4115 
   4116 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone")
   4117 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4118 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4119 	request.Method = "GET"
   4120 	var restEncoder *httpbinding.Encoder
   4121 	if request.URL.RawPath == "" {
   4122 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4123 	} else {
   4124 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4125 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4126 	}
   4127 
   4128 	if err != nil {
   4129 		return out, metadata, &smithy.SerializationError{Err: err}
   4130 	}
   4131 
   4132 	if err := awsRestxml_serializeOpHttpBindingsListHostedZonesInput(input, restEncoder); err != nil {
   4133 		return out, metadata, &smithy.SerializationError{Err: err}
   4134 	}
   4135 
   4136 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4137 		return out, metadata, &smithy.SerializationError{Err: err}
   4138 	}
   4139 	in.Request = request
   4140 
   4141 	return next.HandleSerialize(ctx, in)
   4142 }
   4143 func awsRestxml_serializeOpHttpBindingsListHostedZonesInput(v *ListHostedZonesInput, encoder *httpbinding.Encoder) error {
   4144 	if v == nil {
   4145 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4146 	}
   4147 
   4148 	if v.DelegationSetId != nil {
   4149 		encoder.SetQuery("delegationsetid").String(*v.DelegationSetId)
   4150 	}
   4151 
   4152 	if len(v.HostedZoneType) > 0 {
   4153 		encoder.SetQuery("hostedzonetype").String(string(v.HostedZoneType))
   4154 	}
   4155 
   4156 	if v.Marker != nil {
   4157 		encoder.SetQuery("marker").String(*v.Marker)
   4158 	}
   4159 
   4160 	if v.MaxItems != nil {
   4161 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4162 	}
   4163 
   4164 	return nil
   4165 }
   4166 
   4167 type awsRestxml_serializeOpListHostedZonesByName struct {
   4168 }
   4169 
   4170 func (*awsRestxml_serializeOpListHostedZonesByName) ID() string {
   4171 	return "OperationSerializer"
   4172 }
   4173 
   4174 func (m *awsRestxml_serializeOpListHostedZonesByName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4175 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4176 ) {
   4177 	request, ok := in.Request.(*smithyhttp.Request)
   4178 	if !ok {
   4179 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4180 	}
   4181 
   4182 	input, ok := in.Parameters.(*ListHostedZonesByNameInput)
   4183 	_ = input
   4184 	if !ok {
   4185 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4186 	}
   4187 
   4188 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzonesbyname")
   4189 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4190 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4191 	request.Method = "GET"
   4192 	var restEncoder *httpbinding.Encoder
   4193 	if request.URL.RawPath == "" {
   4194 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4195 	} else {
   4196 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4197 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4198 	}
   4199 
   4200 	if err != nil {
   4201 		return out, metadata, &smithy.SerializationError{Err: err}
   4202 	}
   4203 
   4204 	if err := awsRestxml_serializeOpHttpBindingsListHostedZonesByNameInput(input, restEncoder); err != nil {
   4205 		return out, metadata, &smithy.SerializationError{Err: err}
   4206 	}
   4207 
   4208 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4209 		return out, metadata, &smithy.SerializationError{Err: err}
   4210 	}
   4211 	in.Request = request
   4212 
   4213 	return next.HandleSerialize(ctx, in)
   4214 }
   4215 func awsRestxml_serializeOpHttpBindingsListHostedZonesByNameInput(v *ListHostedZonesByNameInput, encoder *httpbinding.Encoder) error {
   4216 	if v == nil {
   4217 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4218 	}
   4219 
   4220 	if v.DNSName != nil {
   4221 		encoder.SetQuery("dnsname").String(*v.DNSName)
   4222 	}
   4223 
   4224 	if v.HostedZoneId != nil {
   4225 		encoder.SetQuery("hostedzoneid").String(*v.HostedZoneId)
   4226 	}
   4227 
   4228 	if v.MaxItems != nil {
   4229 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4230 	}
   4231 
   4232 	return nil
   4233 }
   4234 
   4235 type awsRestxml_serializeOpListHostedZonesByVPC struct {
   4236 }
   4237 
   4238 func (*awsRestxml_serializeOpListHostedZonesByVPC) ID() string {
   4239 	return "OperationSerializer"
   4240 }
   4241 
   4242 func (m *awsRestxml_serializeOpListHostedZonesByVPC) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4243 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4244 ) {
   4245 	request, ok := in.Request.(*smithyhttp.Request)
   4246 	if !ok {
   4247 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4248 	}
   4249 
   4250 	input, ok := in.Parameters.(*ListHostedZonesByVPCInput)
   4251 	_ = input
   4252 	if !ok {
   4253 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4254 	}
   4255 
   4256 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzonesbyvpc")
   4257 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4258 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4259 	request.Method = "GET"
   4260 	var restEncoder *httpbinding.Encoder
   4261 	if request.URL.RawPath == "" {
   4262 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4263 	} else {
   4264 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4265 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4266 	}
   4267 
   4268 	if err != nil {
   4269 		return out, metadata, &smithy.SerializationError{Err: err}
   4270 	}
   4271 
   4272 	if err := awsRestxml_serializeOpHttpBindingsListHostedZonesByVPCInput(input, restEncoder); err != nil {
   4273 		return out, metadata, &smithy.SerializationError{Err: err}
   4274 	}
   4275 
   4276 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4277 		return out, metadata, &smithy.SerializationError{Err: err}
   4278 	}
   4279 	in.Request = request
   4280 
   4281 	return next.HandleSerialize(ctx, in)
   4282 }
   4283 func awsRestxml_serializeOpHttpBindingsListHostedZonesByVPCInput(v *ListHostedZonesByVPCInput, encoder *httpbinding.Encoder) error {
   4284 	if v == nil {
   4285 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4286 	}
   4287 
   4288 	if v.MaxItems != nil {
   4289 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4290 	}
   4291 
   4292 	if v.NextToken != nil {
   4293 		encoder.SetQuery("nexttoken").String(*v.NextToken)
   4294 	}
   4295 
   4296 	if v.VPCId != nil {
   4297 		encoder.SetQuery("vpcid").String(*v.VPCId)
   4298 	}
   4299 
   4300 	if len(v.VPCRegion) > 0 {
   4301 		encoder.SetQuery("vpcregion").String(string(v.VPCRegion))
   4302 	}
   4303 
   4304 	return nil
   4305 }
   4306 
   4307 type awsRestxml_serializeOpListQueryLoggingConfigs struct {
   4308 }
   4309 
   4310 func (*awsRestxml_serializeOpListQueryLoggingConfigs) ID() string {
   4311 	return "OperationSerializer"
   4312 }
   4313 
   4314 func (m *awsRestxml_serializeOpListQueryLoggingConfigs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4315 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4316 ) {
   4317 	request, ok := in.Request.(*smithyhttp.Request)
   4318 	if !ok {
   4319 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4320 	}
   4321 
   4322 	input, ok := in.Parameters.(*ListQueryLoggingConfigsInput)
   4323 	_ = input
   4324 	if !ok {
   4325 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4326 	}
   4327 
   4328 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/queryloggingconfig")
   4329 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4330 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4331 	request.Method = "GET"
   4332 	var restEncoder *httpbinding.Encoder
   4333 	if request.URL.RawPath == "" {
   4334 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4335 	} else {
   4336 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4337 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4338 	}
   4339 
   4340 	if err != nil {
   4341 		return out, metadata, &smithy.SerializationError{Err: err}
   4342 	}
   4343 
   4344 	if err := awsRestxml_serializeOpHttpBindingsListQueryLoggingConfigsInput(input, restEncoder); err != nil {
   4345 		return out, metadata, &smithy.SerializationError{Err: err}
   4346 	}
   4347 
   4348 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4349 		return out, metadata, &smithy.SerializationError{Err: err}
   4350 	}
   4351 	in.Request = request
   4352 
   4353 	return next.HandleSerialize(ctx, in)
   4354 }
   4355 func awsRestxml_serializeOpHttpBindingsListQueryLoggingConfigsInput(v *ListQueryLoggingConfigsInput, encoder *httpbinding.Encoder) error {
   4356 	if v == nil {
   4357 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4358 	}
   4359 
   4360 	if v.HostedZoneId != nil {
   4361 		encoder.SetQuery("hostedzoneid").String(*v.HostedZoneId)
   4362 	}
   4363 
   4364 	if v.MaxResults != nil {
   4365 		encoder.SetQuery("maxresults").Integer(*v.MaxResults)
   4366 	}
   4367 
   4368 	if v.NextToken != nil {
   4369 		encoder.SetQuery("nexttoken").String(*v.NextToken)
   4370 	}
   4371 
   4372 	return nil
   4373 }
   4374 
   4375 type awsRestxml_serializeOpListResourceRecordSets struct {
   4376 }
   4377 
   4378 func (*awsRestxml_serializeOpListResourceRecordSets) ID() string {
   4379 	return "OperationSerializer"
   4380 }
   4381 
   4382 func (m *awsRestxml_serializeOpListResourceRecordSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4383 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4384 ) {
   4385 	request, ok := in.Request.(*smithyhttp.Request)
   4386 	if !ok {
   4387 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4388 	}
   4389 
   4390 	input, ok := in.Parameters.(*ListResourceRecordSetsInput)
   4391 	_ = input
   4392 	if !ok {
   4393 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4394 	}
   4395 
   4396 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/rrset")
   4397 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4398 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4399 	request.Method = "GET"
   4400 	var restEncoder *httpbinding.Encoder
   4401 	if request.URL.RawPath == "" {
   4402 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4403 	} else {
   4404 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4405 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4406 	}
   4407 
   4408 	if err != nil {
   4409 		return out, metadata, &smithy.SerializationError{Err: err}
   4410 	}
   4411 
   4412 	if err := awsRestxml_serializeOpHttpBindingsListResourceRecordSetsInput(input, restEncoder); err != nil {
   4413 		return out, metadata, &smithy.SerializationError{Err: err}
   4414 	}
   4415 
   4416 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4417 		return out, metadata, &smithy.SerializationError{Err: err}
   4418 	}
   4419 	in.Request = request
   4420 
   4421 	return next.HandleSerialize(ctx, in)
   4422 }
   4423 func awsRestxml_serializeOpHttpBindingsListResourceRecordSetsInput(v *ListResourceRecordSetsInput, encoder *httpbinding.Encoder) error {
   4424 	if v == nil {
   4425 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4426 	}
   4427 
   4428 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   4429 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   4430 	}
   4431 	if v.HostedZoneId != nil {
   4432 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   4433 			return err
   4434 		}
   4435 	}
   4436 
   4437 	if v.MaxItems != nil {
   4438 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4439 	}
   4440 
   4441 	if v.StartRecordIdentifier != nil {
   4442 		encoder.SetQuery("identifier").String(*v.StartRecordIdentifier)
   4443 	}
   4444 
   4445 	if v.StartRecordName != nil {
   4446 		encoder.SetQuery("name").String(*v.StartRecordName)
   4447 	}
   4448 
   4449 	if len(v.StartRecordType) > 0 {
   4450 		encoder.SetQuery("type").String(string(v.StartRecordType))
   4451 	}
   4452 
   4453 	return nil
   4454 }
   4455 
   4456 type awsRestxml_serializeOpListReusableDelegationSets struct {
   4457 }
   4458 
   4459 func (*awsRestxml_serializeOpListReusableDelegationSets) ID() string {
   4460 	return "OperationSerializer"
   4461 }
   4462 
   4463 func (m *awsRestxml_serializeOpListReusableDelegationSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4464 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4465 ) {
   4466 	request, ok := in.Request.(*smithyhttp.Request)
   4467 	if !ok {
   4468 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4469 	}
   4470 
   4471 	input, ok := in.Parameters.(*ListReusableDelegationSetsInput)
   4472 	_ = input
   4473 	if !ok {
   4474 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4475 	}
   4476 
   4477 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/delegationset")
   4478 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4479 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4480 	request.Method = "GET"
   4481 	var restEncoder *httpbinding.Encoder
   4482 	if request.URL.RawPath == "" {
   4483 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4484 	} else {
   4485 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4486 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4487 	}
   4488 
   4489 	if err != nil {
   4490 		return out, metadata, &smithy.SerializationError{Err: err}
   4491 	}
   4492 
   4493 	if err := awsRestxml_serializeOpHttpBindingsListReusableDelegationSetsInput(input, restEncoder); err != nil {
   4494 		return out, metadata, &smithy.SerializationError{Err: err}
   4495 	}
   4496 
   4497 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4498 		return out, metadata, &smithy.SerializationError{Err: err}
   4499 	}
   4500 	in.Request = request
   4501 
   4502 	return next.HandleSerialize(ctx, in)
   4503 }
   4504 func awsRestxml_serializeOpHttpBindingsListReusableDelegationSetsInput(v *ListReusableDelegationSetsInput, encoder *httpbinding.Encoder) error {
   4505 	if v == nil {
   4506 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4507 	}
   4508 
   4509 	if v.Marker != nil {
   4510 		encoder.SetQuery("marker").String(*v.Marker)
   4511 	}
   4512 
   4513 	if v.MaxItems != nil {
   4514 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4515 	}
   4516 
   4517 	return nil
   4518 }
   4519 
   4520 type awsRestxml_serializeOpListTagsForResource struct {
   4521 }
   4522 
   4523 func (*awsRestxml_serializeOpListTagsForResource) ID() string {
   4524 	return "OperationSerializer"
   4525 }
   4526 
   4527 func (m *awsRestxml_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4528 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4529 ) {
   4530 	request, ok := in.Request.(*smithyhttp.Request)
   4531 	if !ok {
   4532 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4533 	}
   4534 
   4535 	input, ok := in.Parameters.(*ListTagsForResourceInput)
   4536 	_ = input
   4537 	if !ok {
   4538 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4539 	}
   4540 
   4541 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/tags/{ResourceType}/{ResourceId}")
   4542 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4543 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4544 	request.Method = "GET"
   4545 	var restEncoder *httpbinding.Encoder
   4546 	if request.URL.RawPath == "" {
   4547 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4548 	} else {
   4549 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4550 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4551 	}
   4552 
   4553 	if err != nil {
   4554 		return out, metadata, &smithy.SerializationError{Err: err}
   4555 	}
   4556 
   4557 	if err := awsRestxml_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil {
   4558 		return out, metadata, &smithy.SerializationError{Err: err}
   4559 	}
   4560 
   4561 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4562 		return out, metadata, &smithy.SerializationError{Err: err}
   4563 	}
   4564 	in.Request = request
   4565 
   4566 	return next.HandleSerialize(ctx, in)
   4567 }
   4568 func awsRestxml_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error {
   4569 	if v == nil {
   4570 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4571 	}
   4572 
   4573 	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
   4574 		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")}
   4575 	}
   4576 	if v.ResourceId != nil {
   4577 		if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil {
   4578 			return err
   4579 		}
   4580 	}
   4581 
   4582 	if len(v.ResourceType) == 0 {
   4583 		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceType must not be empty")}
   4584 	}
   4585 	if len(v.ResourceType) > 0 {
   4586 		if err := encoder.SetURI("ResourceType").String(string(v.ResourceType)); err != nil {
   4587 			return err
   4588 		}
   4589 	}
   4590 
   4591 	return nil
   4592 }
   4593 
   4594 type awsRestxml_serializeOpListTagsForResources struct {
   4595 }
   4596 
   4597 func (*awsRestxml_serializeOpListTagsForResources) ID() string {
   4598 	return "OperationSerializer"
   4599 }
   4600 
   4601 func (m *awsRestxml_serializeOpListTagsForResources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4602 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4603 ) {
   4604 	request, ok := in.Request.(*smithyhttp.Request)
   4605 	if !ok {
   4606 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4607 	}
   4608 
   4609 	input, ok := in.Parameters.(*ListTagsForResourcesInput)
   4610 	_ = input
   4611 	if !ok {
   4612 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4613 	}
   4614 
   4615 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/tags/{ResourceType}")
   4616 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4617 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4618 	request.Method = "POST"
   4619 	var restEncoder *httpbinding.Encoder
   4620 	if request.URL.RawPath == "" {
   4621 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4622 	} else {
   4623 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4624 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4625 	}
   4626 
   4627 	if err != nil {
   4628 		return out, metadata, &smithy.SerializationError{Err: err}
   4629 	}
   4630 
   4631 	if err := awsRestxml_serializeOpHttpBindingsListTagsForResourcesInput(input, restEncoder); err != nil {
   4632 		return out, metadata, &smithy.SerializationError{Err: err}
   4633 	}
   4634 
   4635 	restEncoder.SetHeader("Content-Type").String("application/xml")
   4636 
   4637 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   4638 	rootAttr := []smithyxml.Attr{}
   4639 	root := smithyxml.StartElement{
   4640 		Name: smithyxml.Name{
   4641 			Local: "ListTagsForResourcesRequest",
   4642 		},
   4643 		Attr: rootAttr,
   4644 	}
   4645 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   4646 	if err := awsRestxml_serializeOpDocumentListTagsForResourcesInput(input, xmlEncoder.RootElement(root)); err != nil {
   4647 		return out, metadata, &smithy.SerializationError{Err: err}
   4648 	}
   4649 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   4650 		return out, metadata, &smithy.SerializationError{Err: err}
   4651 	}
   4652 
   4653 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4654 		return out, metadata, &smithy.SerializationError{Err: err}
   4655 	}
   4656 	in.Request = request
   4657 
   4658 	return next.HandleSerialize(ctx, in)
   4659 }
   4660 func awsRestxml_serializeOpHttpBindingsListTagsForResourcesInput(v *ListTagsForResourcesInput, encoder *httpbinding.Encoder) error {
   4661 	if v == nil {
   4662 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4663 	}
   4664 
   4665 	if len(v.ResourceType) == 0 {
   4666 		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceType must not be empty")}
   4667 	}
   4668 	if len(v.ResourceType) > 0 {
   4669 		if err := encoder.SetURI("ResourceType").String(string(v.ResourceType)); err != nil {
   4670 			return err
   4671 		}
   4672 	}
   4673 
   4674 	return nil
   4675 }
   4676 
   4677 func awsRestxml_serializeOpDocumentListTagsForResourcesInput(v *ListTagsForResourcesInput, value smithyxml.Value) error {
   4678 	defer value.Close()
   4679 	if v.ResourceIds != nil {
   4680 		rootAttr := []smithyxml.Attr{}
   4681 		root := smithyxml.StartElement{
   4682 			Name: smithyxml.Name{
   4683 				Local: "ResourceIds",
   4684 			},
   4685 			Attr: rootAttr,
   4686 		}
   4687 		el := value.MemberElement(root)
   4688 		if err := awsRestxml_serializeDocumentTagResourceIdList(v.ResourceIds, el); err != nil {
   4689 			return err
   4690 		}
   4691 	}
   4692 	return nil
   4693 }
   4694 
   4695 type awsRestxml_serializeOpListTrafficPolicies struct {
   4696 }
   4697 
   4698 func (*awsRestxml_serializeOpListTrafficPolicies) ID() string {
   4699 	return "OperationSerializer"
   4700 }
   4701 
   4702 func (m *awsRestxml_serializeOpListTrafficPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4703 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4704 ) {
   4705 	request, ok := in.Request.(*smithyhttp.Request)
   4706 	if !ok {
   4707 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4708 	}
   4709 
   4710 	input, ok := in.Parameters.(*ListTrafficPoliciesInput)
   4711 	_ = input
   4712 	if !ok {
   4713 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4714 	}
   4715 
   4716 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicies")
   4717 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4718 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4719 	request.Method = "GET"
   4720 	var restEncoder *httpbinding.Encoder
   4721 	if request.URL.RawPath == "" {
   4722 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4723 	} else {
   4724 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4725 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4726 	}
   4727 
   4728 	if err != nil {
   4729 		return out, metadata, &smithy.SerializationError{Err: err}
   4730 	}
   4731 
   4732 	if err := awsRestxml_serializeOpHttpBindingsListTrafficPoliciesInput(input, restEncoder); err != nil {
   4733 		return out, metadata, &smithy.SerializationError{Err: err}
   4734 	}
   4735 
   4736 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4737 		return out, metadata, &smithy.SerializationError{Err: err}
   4738 	}
   4739 	in.Request = request
   4740 
   4741 	return next.HandleSerialize(ctx, in)
   4742 }
   4743 func awsRestxml_serializeOpHttpBindingsListTrafficPoliciesInput(v *ListTrafficPoliciesInput, encoder *httpbinding.Encoder) error {
   4744 	if v == nil {
   4745 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4746 	}
   4747 
   4748 	if v.MaxItems != nil {
   4749 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4750 	}
   4751 
   4752 	if v.TrafficPolicyIdMarker != nil {
   4753 		encoder.SetQuery("trafficpolicyid").String(*v.TrafficPolicyIdMarker)
   4754 	}
   4755 
   4756 	return nil
   4757 }
   4758 
   4759 type awsRestxml_serializeOpListTrafficPolicyInstances struct {
   4760 }
   4761 
   4762 func (*awsRestxml_serializeOpListTrafficPolicyInstances) ID() string {
   4763 	return "OperationSerializer"
   4764 }
   4765 
   4766 func (m *awsRestxml_serializeOpListTrafficPolicyInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4767 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4768 ) {
   4769 	request, ok := in.Request.(*smithyhttp.Request)
   4770 	if !ok {
   4771 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4772 	}
   4773 
   4774 	input, ok := in.Parameters.(*ListTrafficPolicyInstancesInput)
   4775 	_ = input
   4776 	if !ok {
   4777 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4778 	}
   4779 
   4780 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstances")
   4781 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4782 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4783 	request.Method = "GET"
   4784 	var restEncoder *httpbinding.Encoder
   4785 	if request.URL.RawPath == "" {
   4786 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4787 	} else {
   4788 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4789 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4790 	}
   4791 
   4792 	if err != nil {
   4793 		return out, metadata, &smithy.SerializationError{Err: err}
   4794 	}
   4795 
   4796 	if err := awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesInput(input, restEncoder); err != nil {
   4797 		return out, metadata, &smithy.SerializationError{Err: err}
   4798 	}
   4799 
   4800 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4801 		return out, metadata, &smithy.SerializationError{Err: err}
   4802 	}
   4803 	in.Request = request
   4804 
   4805 	return next.HandleSerialize(ctx, in)
   4806 }
   4807 func awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesInput(v *ListTrafficPolicyInstancesInput, encoder *httpbinding.Encoder) error {
   4808 	if v == nil {
   4809 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4810 	}
   4811 
   4812 	if v.HostedZoneIdMarker != nil {
   4813 		encoder.SetQuery("hostedzoneid").String(*v.HostedZoneIdMarker)
   4814 	}
   4815 
   4816 	if v.MaxItems != nil {
   4817 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4818 	}
   4819 
   4820 	if v.TrafficPolicyInstanceNameMarker != nil {
   4821 		encoder.SetQuery("trafficpolicyinstancename").String(*v.TrafficPolicyInstanceNameMarker)
   4822 	}
   4823 
   4824 	if len(v.TrafficPolicyInstanceTypeMarker) > 0 {
   4825 		encoder.SetQuery("trafficpolicyinstancetype").String(string(v.TrafficPolicyInstanceTypeMarker))
   4826 	}
   4827 
   4828 	return nil
   4829 }
   4830 
   4831 type awsRestxml_serializeOpListTrafficPolicyInstancesByHostedZone struct {
   4832 }
   4833 
   4834 func (*awsRestxml_serializeOpListTrafficPolicyInstancesByHostedZone) ID() string {
   4835 	return "OperationSerializer"
   4836 }
   4837 
   4838 func (m *awsRestxml_serializeOpListTrafficPolicyInstancesByHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4839 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4840 ) {
   4841 	request, ok := in.Request.(*smithyhttp.Request)
   4842 	if !ok {
   4843 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4844 	}
   4845 
   4846 	input, ok := in.Parameters.(*ListTrafficPolicyInstancesByHostedZoneInput)
   4847 	_ = input
   4848 	if !ok {
   4849 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4850 	}
   4851 
   4852 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstances/hostedzone")
   4853 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4854 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4855 	request.Method = "GET"
   4856 	var restEncoder *httpbinding.Encoder
   4857 	if request.URL.RawPath == "" {
   4858 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4859 	} else {
   4860 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4861 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4862 	}
   4863 
   4864 	if err != nil {
   4865 		return out, metadata, &smithy.SerializationError{Err: err}
   4866 	}
   4867 
   4868 	if err := awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesByHostedZoneInput(input, restEncoder); err != nil {
   4869 		return out, metadata, &smithy.SerializationError{Err: err}
   4870 	}
   4871 
   4872 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4873 		return out, metadata, &smithy.SerializationError{Err: err}
   4874 	}
   4875 	in.Request = request
   4876 
   4877 	return next.HandleSerialize(ctx, in)
   4878 }
   4879 func awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesByHostedZoneInput(v *ListTrafficPolicyInstancesByHostedZoneInput, encoder *httpbinding.Encoder) error {
   4880 	if v == nil {
   4881 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4882 	}
   4883 
   4884 	if v.HostedZoneId != nil {
   4885 		encoder.SetQuery("id").String(*v.HostedZoneId)
   4886 	}
   4887 
   4888 	if v.MaxItems != nil {
   4889 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4890 	}
   4891 
   4892 	if v.TrafficPolicyInstanceNameMarker != nil {
   4893 		encoder.SetQuery("trafficpolicyinstancename").String(*v.TrafficPolicyInstanceNameMarker)
   4894 	}
   4895 
   4896 	if len(v.TrafficPolicyInstanceTypeMarker) > 0 {
   4897 		encoder.SetQuery("trafficpolicyinstancetype").String(string(v.TrafficPolicyInstanceTypeMarker))
   4898 	}
   4899 
   4900 	return nil
   4901 }
   4902 
   4903 type awsRestxml_serializeOpListTrafficPolicyInstancesByPolicy struct {
   4904 }
   4905 
   4906 func (*awsRestxml_serializeOpListTrafficPolicyInstancesByPolicy) ID() string {
   4907 	return "OperationSerializer"
   4908 }
   4909 
   4910 func (m *awsRestxml_serializeOpListTrafficPolicyInstancesByPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4911 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4912 ) {
   4913 	request, ok := in.Request.(*smithyhttp.Request)
   4914 	if !ok {
   4915 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4916 	}
   4917 
   4918 	input, ok := in.Parameters.(*ListTrafficPolicyInstancesByPolicyInput)
   4919 	_ = input
   4920 	if !ok {
   4921 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   4922 	}
   4923 
   4924 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstances/trafficpolicy")
   4925 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   4926 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   4927 	request.Method = "GET"
   4928 	var restEncoder *httpbinding.Encoder
   4929 	if request.URL.RawPath == "" {
   4930 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   4931 	} else {
   4932 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   4933 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   4934 	}
   4935 
   4936 	if err != nil {
   4937 		return out, metadata, &smithy.SerializationError{Err: err}
   4938 	}
   4939 
   4940 	if err := awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesByPolicyInput(input, restEncoder); err != nil {
   4941 		return out, metadata, &smithy.SerializationError{Err: err}
   4942 	}
   4943 
   4944 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   4945 		return out, metadata, &smithy.SerializationError{Err: err}
   4946 	}
   4947 	in.Request = request
   4948 
   4949 	return next.HandleSerialize(ctx, in)
   4950 }
   4951 func awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesByPolicyInput(v *ListTrafficPolicyInstancesByPolicyInput, encoder *httpbinding.Encoder) error {
   4952 	if v == nil {
   4953 		return fmt.Errorf("unsupported serialization of nil %T", v)
   4954 	}
   4955 
   4956 	if v.HostedZoneIdMarker != nil {
   4957 		encoder.SetQuery("hostedzoneid").String(*v.HostedZoneIdMarker)
   4958 	}
   4959 
   4960 	if v.MaxItems != nil {
   4961 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   4962 	}
   4963 
   4964 	if v.TrafficPolicyId != nil {
   4965 		encoder.SetQuery("id").String(*v.TrafficPolicyId)
   4966 	}
   4967 
   4968 	if v.TrafficPolicyInstanceNameMarker != nil {
   4969 		encoder.SetQuery("trafficpolicyinstancename").String(*v.TrafficPolicyInstanceNameMarker)
   4970 	}
   4971 
   4972 	if len(v.TrafficPolicyInstanceTypeMarker) > 0 {
   4973 		encoder.SetQuery("trafficpolicyinstancetype").String(string(v.TrafficPolicyInstanceTypeMarker))
   4974 	}
   4975 
   4976 	if v.TrafficPolicyVersion != nil {
   4977 		encoder.SetQuery("version").Integer(*v.TrafficPolicyVersion)
   4978 	}
   4979 
   4980 	return nil
   4981 }
   4982 
   4983 type awsRestxml_serializeOpListTrafficPolicyVersions struct {
   4984 }
   4985 
   4986 func (*awsRestxml_serializeOpListTrafficPolicyVersions) ID() string {
   4987 	return "OperationSerializer"
   4988 }
   4989 
   4990 func (m *awsRestxml_serializeOpListTrafficPolicyVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   4991 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   4992 ) {
   4993 	request, ok := in.Request.(*smithyhttp.Request)
   4994 	if !ok {
   4995 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   4996 	}
   4997 
   4998 	input, ok := in.Parameters.(*ListTrafficPolicyVersionsInput)
   4999 	_ = input
   5000 	if !ok {
   5001 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   5002 	}
   5003 
   5004 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicies/{Id}/versions")
   5005 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   5006 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   5007 	request.Method = "GET"
   5008 	var restEncoder *httpbinding.Encoder
   5009 	if request.URL.RawPath == "" {
   5010 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   5011 	} else {
   5012 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   5013 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   5014 	}
   5015 
   5016 	if err != nil {
   5017 		return out, metadata, &smithy.SerializationError{Err: err}
   5018 	}
   5019 
   5020 	if err := awsRestxml_serializeOpHttpBindingsListTrafficPolicyVersionsInput(input, restEncoder); err != nil {
   5021 		return out, metadata, &smithy.SerializationError{Err: err}
   5022 	}
   5023 
   5024 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   5025 		return out, metadata, &smithy.SerializationError{Err: err}
   5026 	}
   5027 	in.Request = request
   5028 
   5029 	return next.HandleSerialize(ctx, in)
   5030 }
   5031 func awsRestxml_serializeOpHttpBindingsListTrafficPolicyVersionsInput(v *ListTrafficPolicyVersionsInput, encoder *httpbinding.Encoder) error {
   5032 	if v == nil {
   5033 		return fmt.Errorf("unsupported serialization of nil %T", v)
   5034 	}
   5035 
   5036 	if v.Id == nil || len(*v.Id) == 0 {
   5037 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   5038 	}
   5039 	if v.Id != nil {
   5040 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   5041 			return err
   5042 		}
   5043 	}
   5044 
   5045 	if v.MaxItems != nil {
   5046 		encoder.SetQuery("maxitems").Integer(*v.MaxItems)
   5047 	}
   5048 
   5049 	if v.TrafficPolicyVersionMarker != nil {
   5050 		encoder.SetQuery("trafficpolicyversion").String(*v.TrafficPolicyVersionMarker)
   5051 	}
   5052 
   5053 	return nil
   5054 }
   5055 
   5056 type awsRestxml_serializeOpListVPCAssociationAuthorizations struct {
   5057 }
   5058 
   5059 func (*awsRestxml_serializeOpListVPCAssociationAuthorizations) ID() string {
   5060 	return "OperationSerializer"
   5061 }
   5062 
   5063 func (m *awsRestxml_serializeOpListVPCAssociationAuthorizations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   5064 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   5065 ) {
   5066 	request, ok := in.Request.(*smithyhttp.Request)
   5067 	if !ok {
   5068 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   5069 	}
   5070 
   5071 	input, ok := in.Parameters.(*ListVPCAssociationAuthorizationsInput)
   5072 	_ = input
   5073 	if !ok {
   5074 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   5075 	}
   5076 
   5077 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/authorizevpcassociation")
   5078 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   5079 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   5080 	request.Method = "GET"
   5081 	var restEncoder *httpbinding.Encoder
   5082 	if request.URL.RawPath == "" {
   5083 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   5084 	} else {
   5085 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   5086 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   5087 	}
   5088 
   5089 	if err != nil {
   5090 		return out, metadata, &smithy.SerializationError{Err: err}
   5091 	}
   5092 
   5093 	if err := awsRestxml_serializeOpHttpBindingsListVPCAssociationAuthorizationsInput(input, restEncoder); err != nil {
   5094 		return out, metadata, &smithy.SerializationError{Err: err}
   5095 	}
   5096 
   5097 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   5098 		return out, metadata, &smithy.SerializationError{Err: err}
   5099 	}
   5100 	in.Request = request
   5101 
   5102 	return next.HandleSerialize(ctx, in)
   5103 }
   5104 func awsRestxml_serializeOpHttpBindingsListVPCAssociationAuthorizationsInput(v *ListVPCAssociationAuthorizationsInput, encoder *httpbinding.Encoder) error {
   5105 	if v == nil {
   5106 		return fmt.Errorf("unsupported serialization of nil %T", v)
   5107 	}
   5108 
   5109 	if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 {
   5110 		return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")}
   5111 	}
   5112 	if v.HostedZoneId != nil {
   5113 		if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil {
   5114 			return err
   5115 		}
   5116 	}
   5117 
   5118 	if v.MaxResults != nil {
   5119 		encoder.SetQuery("maxresults").Integer(*v.MaxResults)
   5120 	}
   5121 
   5122 	if v.NextToken != nil {
   5123 		encoder.SetQuery("nexttoken").String(*v.NextToken)
   5124 	}
   5125 
   5126 	return nil
   5127 }
   5128 
   5129 type awsRestxml_serializeOpTestDNSAnswer struct {
   5130 }
   5131 
   5132 func (*awsRestxml_serializeOpTestDNSAnswer) ID() string {
   5133 	return "OperationSerializer"
   5134 }
   5135 
   5136 func (m *awsRestxml_serializeOpTestDNSAnswer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   5137 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   5138 ) {
   5139 	request, ok := in.Request.(*smithyhttp.Request)
   5140 	if !ok {
   5141 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   5142 	}
   5143 
   5144 	input, ok := in.Parameters.(*TestDNSAnswerInput)
   5145 	_ = input
   5146 	if !ok {
   5147 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   5148 	}
   5149 
   5150 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/testdnsanswer")
   5151 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   5152 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   5153 	request.Method = "GET"
   5154 	var restEncoder *httpbinding.Encoder
   5155 	if request.URL.RawPath == "" {
   5156 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   5157 	} else {
   5158 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   5159 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   5160 	}
   5161 
   5162 	if err != nil {
   5163 		return out, metadata, &smithy.SerializationError{Err: err}
   5164 	}
   5165 
   5166 	if err := awsRestxml_serializeOpHttpBindingsTestDNSAnswerInput(input, restEncoder); err != nil {
   5167 		return out, metadata, &smithy.SerializationError{Err: err}
   5168 	}
   5169 
   5170 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   5171 		return out, metadata, &smithy.SerializationError{Err: err}
   5172 	}
   5173 	in.Request = request
   5174 
   5175 	return next.HandleSerialize(ctx, in)
   5176 }
   5177 func awsRestxml_serializeOpHttpBindingsTestDNSAnswerInput(v *TestDNSAnswerInput, encoder *httpbinding.Encoder) error {
   5178 	if v == nil {
   5179 		return fmt.Errorf("unsupported serialization of nil %T", v)
   5180 	}
   5181 
   5182 	if v.EDNS0ClientSubnetIP != nil {
   5183 		encoder.SetQuery("edns0clientsubnetip").String(*v.EDNS0ClientSubnetIP)
   5184 	}
   5185 
   5186 	if v.EDNS0ClientSubnetMask != nil {
   5187 		encoder.SetQuery("edns0clientsubnetmask").String(*v.EDNS0ClientSubnetMask)
   5188 	}
   5189 
   5190 	if v.HostedZoneId != nil {
   5191 		encoder.SetQuery("hostedzoneid").String(*v.HostedZoneId)
   5192 	}
   5193 
   5194 	if v.RecordName != nil {
   5195 		encoder.SetQuery("recordname").String(*v.RecordName)
   5196 	}
   5197 
   5198 	if len(v.RecordType) > 0 {
   5199 		encoder.SetQuery("recordtype").String(string(v.RecordType))
   5200 	}
   5201 
   5202 	if v.ResolverIP != nil {
   5203 		encoder.SetQuery("resolverip").String(*v.ResolverIP)
   5204 	}
   5205 
   5206 	return nil
   5207 }
   5208 
   5209 type awsRestxml_serializeOpUpdateHealthCheck struct {
   5210 }
   5211 
   5212 func (*awsRestxml_serializeOpUpdateHealthCheck) ID() string {
   5213 	return "OperationSerializer"
   5214 }
   5215 
   5216 func (m *awsRestxml_serializeOpUpdateHealthCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   5217 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   5218 ) {
   5219 	request, ok := in.Request.(*smithyhttp.Request)
   5220 	if !ok {
   5221 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   5222 	}
   5223 
   5224 	input, ok := in.Parameters.(*UpdateHealthCheckInput)
   5225 	_ = input
   5226 	if !ok {
   5227 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   5228 	}
   5229 
   5230 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck/{HealthCheckId}")
   5231 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   5232 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   5233 	request.Method = "POST"
   5234 	var restEncoder *httpbinding.Encoder
   5235 	if request.URL.RawPath == "" {
   5236 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   5237 	} else {
   5238 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   5239 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   5240 	}
   5241 
   5242 	if err != nil {
   5243 		return out, metadata, &smithy.SerializationError{Err: err}
   5244 	}
   5245 
   5246 	if err := awsRestxml_serializeOpHttpBindingsUpdateHealthCheckInput(input, restEncoder); err != nil {
   5247 		return out, metadata, &smithy.SerializationError{Err: err}
   5248 	}
   5249 
   5250 	restEncoder.SetHeader("Content-Type").String("application/xml")
   5251 
   5252 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   5253 	rootAttr := []smithyxml.Attr{}
   5254 	root := smithyxml.StartElement{
   5255 		Name: smithyxml.Name{
   5256 			Local: "UpdateHealthCheckRequest",
   5257 		},
   5258 		Attr: rootAttr,
   5259 	}
   5260 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   5261 	if err := awsRestxml_serializeOpDocumentUpdateHealthCheckInput(input, xmlEncoder.RootElement(root)); err != nil {
   5262 		return out, metadata, &smithy.SerializationError{Err: err}
   5263 	}
   5264 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   5265 		return out, metadata, &smithy.SerializationError{Err: err}
   5266 	}
   5267 
   5268 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   5269 		return out, metadata, &smithy.SerializationError{Err: err}
   5270 	}
   5271 	in.Request = request
   5272 
   5273 	return next.HandleSerialize(ctx, in)
   5274 }
   5275 func awsRestxml_serializeOpHttpBindingsUpdateHealthCheckInput(v *UpdateHealthCheckInput, encoder *httpbinding.Encoder) error {
   5276 	if v == nil {
   5277 		return fmt.Errorf("unsupported serialization of nil %T", v)
   5278 	}
   5279 
   5280 	if v.HealthCheckId == nil || len(*v.HealthCheckId) == 0 {
   5281 		return &smithy.SerializationError{Err: fmt.Errorf("input member HealthCheckId must not be empty")}
   5282 	}
   5283 	if v.HealthCheckId != nil {
   5284 		if err := encoder.SetURI("HealthCheckId").String(*v.HealthCheckId); err != nil {
   5285 			return err
   5286 		}
   5287 	}
   5288 
   5289 	return nil
   5290 }
   5291 
   5292 func awsRestxml_serializeOpDocumentUpdateHealthCheckInput(v *UpdateHealthCheckInput, value smithyxml.Value) error {
   5293 	defer value.Close()
   5294 	if v.AlarmIdentifier != nil {
   5295 		rootAttr := []smithyxml.Attr{}
   5296 		root := smithyxml.StartElement{
   5297 			Name: smithyxml.Name{
   5298 				Local: "AlarmIdentifier",
   5299 			},
   5300 			Attr: rootAttr,
   5301 		}
   5302 		el := value.MemberElement(root)
   5303 		if err := awsRestxml_serializeDocumentAlarmIdentifier(v.AlarmIdentifier, el); err != nil {
   5304 			return err
   5305 		}
   5306 	}
   5307 	if v.ChildHealthChecks != nil {
   5308 		rootAttr := []smithyxml.Attr{}
   5309 		root := smithyxml.StartElement{
   5310 			Name: smithyxml.Name{
   5311 				Local: "ChildHealthChecks",
   5312 			},
   5313 			Attr: rootAttr,
   5314 		}
   5315 		el := value.MemberElement(root)
   5316 		if err := awsRestxml_serializeDocumentChildHealthCheckList(v.ChildHealthChecks, el); err != nil {
   5317 			return err
   5318 		}
   5319 	}
   5320 	if v.Disabled != nil {
   5321 		rootAttr := []smithyxml.Attr{}
   5322 		root := smithyxml.StartElement{
   5323 			Name: smithyxml.Name{
   5324 				Local: "Disabled",
   5325 			},
   5326 			Attr: rootAttr,
   5327 		}
   5328 		el := value.MemberElement(root)
   5329 		el.Boolean(*v.Disabled)
   5330 	}
   5331 	if v.EnableSNI != nil {
   5332 		rootAttr := []smithyxml.Attr{}
   5333 		root := smithyxml.StartElement{
   5334 			Name: smithyxml.Name{
   5335 				Local: "EnableSNI",
   5336 			},
   5337 			Attr: rootAttr,
   5338 		}
   5339 		el := value.MemberElement(root)
   5340 		el.Boolean(*v.EnableSNI)
   5341 	}
   5342 	if v.FailureThreshold != nil {
   5343 		rootAttr := []smithyxml.Attr{}
   5344 		root := smithyxml.StartElement{
   5345 			Name: smithyxml.Name{
   5346 				Local: "FailureThreshold",
   5347 			},
   5348 			Attr: rootAttr,
   5349 		}
   5350 		el := value.MemberElement(root)
   5351 		el.Integer(*v.FailureThreshold)
   5352 	}
   5353 	if v.FullyQualifiedDomainName != nil {
   5354 		rootAttr := []smithyxml.Attr{}
   5355 		root := smithyxml.StartElement{
   5356 			Name: smithyxml.Name{
   5357 				Local: "FullyQualifiedDomainName",
   5358 			},
   5359 			Attr: rootAttr,
   5360 		}
   5361 		el := value.MemberElement(root)
   5362 		el.String(*v.FullyQualifiedDomainName)
   5363 	}
   5364 	if v.HealthCheckVersion != nil {
   5365 		rootAttr := []smithyxml.Attr{}
   5366 		root := smithyxml.StartElement{
   5367 			Name: smithyxml.Name{
   5368 				Local: "HealthCheckVersion",
   5369 			},
   5370 			Attr: rootAttr,
   5371 		}
   5372 		el := value.MemberElement(root)
   5373 		el.Long(*v.HealthCheckVersion)
   5374 	}
   5375 	if v.HealthThreshold != nil {
   5376 		rootAttr := []smithyxml.Attr{}
   5377 		root := smithyxml.StartElement{
   5378 			Name: smithyxml.Name{
   5379 				Local: "HealthThreshold",
   5380 			},
   5381 			Attr: rootAttr,
   5382 		}
   5383 		el := value.MemberElement(root)
   5384 		el.Integer(*v.HealthThreshold)
   5385 	}
   5386 	if len(v.InsufficientDataHealthStatus) > 0 {
   5387 		rootAttr := []smithyxml.Attr{}
   5388 		root := smithyxml.StartElement{
   5389 			Name: smithyxml.Name{
   5390 				Local: "InsufficientDataHealthStatus",
   5391 			},
   5392 			Attr: rootAttr,
   5393 		}
   5394 		el := value.MemberElement(root)
   5395 		el.String(string(v.InsufficientDataHealthStatus))
   5396 	}
   5397 	if v.Inverted != nil {
   5398 		rootAttr := []smithyxml.Attr{}
   5399 		root := smithyxml.StartElement{
   5400 			Name: smithyxml.Name{
   5401 				Local: "Inverted",
   5402 			},
   5403 			Attr: rootAttr,
   5404 		}
   5405 		el := value.MemberElement(root)
   5406 		el.Boolean(*v.Inverted)
   5407 	}
   5408 	if v.IPAddress != nil {
   5409 		rootAttr := []smithyxml.Attr{}
   5410 		root := smithyxml.StartElement{
   5411 			Name: smithyxml.Name{
   5412 				Local: "IPAddress",
   5413 			},
   5414 			Attr: rootAttr,
   5415 		}
   5416 		el := value.MemberElement(root)
   5417 		el.String(*v.IPAddress)
   5418 	}
   5419 	if v.Port != nil {
   5420 		rootAttr := []smithyxml.Attr{}
   5421 		root := smithyxml.StartElement{
   5422 			Name: smithyxml.Name{
   5423 				Local: "Port",
   5424 			},
   5425 			Attr: rootAttr,
   5426 		}
   5427 		el := value.MemberElement(root)
   5428 		el.Integer(*v.Port)
   5429 	}
   5430 	if v.Regions != nil {
   5431 		rootAttr := []smithyxml.Attr{}
   5432 		root := smithyxml.StartElement{
   5433 			Name: smithyxml.Name{
   5434 				Local: "Regions",
   5435 			},
   5436 			Attr: rootAttr,
   5437 		}
   5438 		el := value.MemberElement(root)
   5439 		if err := awsRestxml_serializeDocumentHealthCheckRegionList(v.Regions, el); err != nil {
   5440 			return err
   5441 		}
   5442 	}
   5443 	if v.ResetElements != nil {
   5444 		rootAttr := []smithyxml.Attr{}
   5445 		root := smithyxml.StartElement{
   5446 			Name: smithyxml.Name{
   5447 				Local: "ResetElements",
   5448 			},
   5449 			Attr: rootAttr,
   5450 		}
   5451 		el := value.MemberElement(root)
   5452 		if err := awsRestxml_serializeDocumentResettableElementNameList(v.ResetElements, el); err != nil {
   5453 			return err
   5454 		}
   5455 	}
   5456 	if v.ResourcePath != nil {
   5457 		rootAttr := []smithyxml.Attr{}
   5458 		root := smithyxml.StartElement{
   5459 			Name: smithyxml.Name{
   5460 				Local: "ResourcePath",
   5461 			},
   5462 			Attr: rootAttr,
   5463 		}
   5464 		el := value.MemberElement(root)
   5465 		el.String(*v.ResourcePath)
   5466 	}
   5467 	if v.SearchString != nil {
   5468 		rootAttr := []smithyxml.Attr{}
   5469 		root := smithyxml.StartElement{
   5470 			Name: smithyxml.Name{
   5471 				Local: "SearchString",
   5472 			},
   5473 			Attr: rootAttr,
   5474 		}
   5475 		el := value.MemberElement(root)
   5476 		el.String(*v.SearchString)
   5477 	}
   5478 	return nil
   5479 }
   5480 
   5481 type awsRestxml_serializeOpUpdateHostedZoneComment struct {
   5482 }
   5483 
   5484 func (*awsRestxml_serializeOpUpdateHostedZoneComment) ID() string {
   5485 	return "OperationSerializer"
   5486 }
   5487 
   5488 func (m *awsRestxml_serializeOpUpdateHostedZoneComment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   5489 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   5490 ) {
   5491 	request, ok := in.Request.(*smithyhttp.Request)
   5492 	if !ok {
   5493 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   5494 	}
   5495 
   5496 	input, ok := in.Parameters.(*UpdateHostedZoneCommentInput)
   5497 	_ = input
   5498 	if !ok {
   5499 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   5500 	}
   5501 
   5502 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{Id}")
   5503 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   5504 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   5505 	request.Method = "POST"
   5506 	var restEncoder *httpbinding.Encoder
   5507 	if request.URL.RawPath == "" {
   5508 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   5509 	} else {
   5510 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   5511 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   5512 	}
   5513 
   5514 	if err != nil {
   5515 		return out, metadata, &smithy.SerializationError{Err: err}
   5516 	}
   5517 
   5518 	if err := awsRestxml_serializeOpHttpBindingsUpdateHostedZoneCommentInput(input, restEncoder); err != nil {
   5519 		return out, metadata, &smithy.SerializationError{Err: err}
   5520 	}
   5521 
   5522 	restEncoder.SetHeader("Content-Type").String("application/xml")
   5523 
   5524 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   5525 	rootAttr := []smithyxml.Attr{}
   5526 	root := smithyxml.StartElement{
   5527 		Name: smithyxml.Name{
   5528 			Local: "UpdateHostedZoneCommentRequest",
   5529 		},
   5530 		Attr: rootAttr,
   5531 	}
   5532 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   5533 	if err := awsRestxml_serializeOpDocumentUpdateHostedZoneCommentInput(input, xmlEncoder.RootElement(root)); err != nil {
   5534 		return out, metadata, &smithy.SerializationError{Err: err}
   5535 	}
   5536 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   5537 		return out, metadata, &smithy.SerializationError{Err: err}
   5538 	}
   5539 
   5540 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   5541 		return out, metadata, &smithy.SerializationError{Err: err}
   5542 	}
   5543 	in.Request = request
   5544 
   5545 	return next.HandleSerialize(ctx, in)
   5546 }
   5547 func awsRestxml_serializeOpHttpBindingsUpdateHostedZoneCommentInput(v *UpdateHostedZoneCommentInput, encoder *httpbinding.Encoder) error {
   5548 	if v == nil {
   5549 		return fmt.Errorf("unsupported serialization of nil %T", v)
   5550 	}
   5551 
   5552 	if v.Id == nil || len(*v.Id) == 0 {
   5553 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   5554 	}
   5555 	if v.Id != nil {
   5556 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   5557 			return err
   5558 		}
   5559 	}
   5560 
   5561 	return nil
   5562 }
   5563 
   5564 func awsRestxml_serializeOpDocumentUpdateHostedZoneCommentInput(v *UpdateHostedZoneCommentInput, value smithyxml.Value) error {
   5565 	defer value.Close()
   5566 	if v.Comment != nil {
   5567 		rootAttr := []smithyxml.Attr{}
   5568 		root := smithyxml.StartElement{
   5569 			Name: smithyxml.Name{
   5570 				Local: "Comment",
   5571 			},
   5572 			Attr: rootAttr,
   5573 		}
   5574 		el := value.MemberElement(root)
   5575 		el.String(*v.Comment)
   5576 	}
   5577 	return nil
   5578 }
   5579 
   5580 type awsRestxml_serializeOpUpdateTrafficPolicyComment struct {
   5581 }
   5582 
   5583 func (*awsRestxml_serializeOpUpdateTrafficPolicyComment) ID() string {
   5584 	return "OperationSerializer"
   5585 }
   5586 
   5587 func (m *awsRestxml_serializeOpUpdateTrafficPolicyComment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   5588 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   5589 ) {
   5590 	request, ok := in.Request.(*smithyhttp.Request)
   5591 	if !ok {
   5592 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   5593 	}
   5594 
   5595 	input, ok := in.Parameters.(*UpdateTrafficPolicyCommentInput)
   5596 	_ = input
   5597 	if !ok {
   5598 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   5599 	}
   5600 
   5601 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicy/{Id}/{Version}")
   5602 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   5603 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   5604 	request.Method = "POST"
   5605 	var restEncoder *httpbinding.Encoder
   5606 	if request.URL.RawPath == "" {
   5607 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   5608 	} else {
   5609 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   5610 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   5611 	}
   5612 
   5613 	if err != nil {
   5614 		return out, metadata, &smithy.SerializationError{Err: err}
   5615 	}
   5616 
   5617 	if err := awsRestxml_serializeOpHttpBindingsUpdateTrafficPolicyCommentInput(input, restEncoder); err != nil {
   5618 		return out, metadata, &smithy.SerializationError{Err: err}
   5619 	}
   5620 
   5621 	restEncoder.SetHeader("Content-Type").String("application/xml")
   5622 
   5623 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   5624 	rootAttr := []smithyxml.Attr{}
   5625 	root := smithyxml.StartElement{
   5626 		Name: smithyxml.Name{
   5627 			Local: "UpdateTrafficPolicyCommentRequest",
   5628 		},
   5629 		Attr: rootAttr,
   5630 	}
   5631 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   5632 	if err := awsRestxml_serializeOpDocumentUpdateTrafficPolicyCommentInput(input, xmlEncoder.RootElement(root)); err != nil {
   5633 		return out, metadata, &smithy.SerializationError{Err: err}
   5634 	}
   5635 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   5636 		return out, metadata, &smithy.SerializationError{Err: err}
   5637 	}
   5638 
   5639 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   5640 		return out, metadata, &smithy.SerializationError{Err: err}
   5641 	}
   5642 	in.Request = request
   5643 
   5644 	return next.HandleSerialize(ctx, in)
   5645 }
   5646 func awsRestxml_serializeOpHttpBindingsUpdateTrafficPolicyCommentInput(v *UpdateTrafficPolicyCommentInput, encoder *httpbinding.Encoder) error {
   5647 	if v == nil {
   5648 		return fmt.Errorf("unsupported serialization of nil %T", v)
   5649 	}
   5650 
   5651 	if v.Id == nil || len(*v.Id) == 0 {
   5652 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   5653 	}
   5654 	if v.Id != nil {
   5655 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   5656 			return err
   5657 		}
   5658 	}
   5659 
   5660 	if v.Version == nil {
   5661 		return &smithy.SerializationError{Err: fmt.Errorf("input member Version must not be empty")}
   5662 	}
   5663 	if v.Version != nil {
   5664 		if err := encoder.SetURI("Version").Integer(*v.Version); err != nil {
   5665 			return err
   5666 		}
   5667 	}
   5668 
   5669 	return nil
   5670 }
   5671 
   5672 func awsRestxml_serializeOpDocumentUpdateTrafficPolicyCommentInput(v *UpdateTrafficPolicyCommentInput, value smithyxml.Value) error {
   5673 	defer value.Close()
   5674 	if v.Comment != nil {
   5675 		rootAttr := []smithyxml.Attr{}
   5676 		root := smithyxml.StartElement{
   5677 			Name: smithyxml.Name{
   5678 				Local: "Comment",
   5679 			},
   5680 			Attr: rootAttr,
   5681 		}
   5682 		el := value.MemberElement(root)
   5683 		el.String(*v.Comment)
   5684 	}
   5685 	return nil
   5686 }
   5687 
   5688 type awsRestxml_serializeOpUpdateTrafficPolicyInstance struct {
   5689 }
   5690 
   5691 func (*awsRestxml_serializeOpUpdateTrafficPolicyInstance) ID() string {
   5692 	return "OperationSerializer"
   5693 }
   5694 
   5695 func (m *awsRestxml_serializeOpUpdateTrafficPolicyInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   5696 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   5697 ) {
   5698 	request, ok := in.Request.(*smithyhttp.Request)
   5699 	if !ok {
   5700 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
   5701 	}
   5702 
   5703 	input, ok := in.Parameters.(*UpdateTrafficPolicyInstanceInput)
   5704 	_ = input
   5705 	if !ok {
   5706 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
   5707 	}
   5708 
   5709 	opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstance/{Id}")
   5710 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
   5711 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
   5712 	request.Method = "POST"
   5713 	var restEncoder *httpbinding.Encoder
   5714 	if request.URL.RawPath == "" {
   5715 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
   5716 	} else {
   5717 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
   5718 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
   5719 	}
   5720 
   5721 	if err != nil {
   5722 		return out, metadata, &smithy.SerializationError{Err: err}
   5723 	}
   5724 
   5725 	if err := awsRestxml_serializeOpHttpBindingsUpdateTrafficPolicyInstanceInput(input, restEncoder); err != nil {
   5726 		return out, metadata, &smithy.SerializationError{Err: err}
   5727 	}
   5728 
   5729 	restEncoder.SetHeader("Content-Type").String("application/xml")
   5730 
   5731 	xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))
   5732 	rootAttr := []smithyxml.Attr{}
   5733 	root := smithyxml.StartElement{
   5734 		Name: smithyxml.Name{
   5735 			Local: "UpdateTrafficPolicyInstanceRequest",
   5736 		},
   5737 		Attr: rootAttr,
   5738 	}
   5739 	root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/"))
   5740 	if err := awsRestxml_serializeOpDocumentUpdateTrafficPolicyInstanceInput(input, xmlEncoder.RootElement(root)); err != nil {
   5741 		return out, metadata, &smithy.SerializationError{Err: err}
   5742 	}
   5743 	if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil {
   5744 		return out, metadata, &smithy.SerializationError{Err: err}
   5745 	}
   5746 
   5747 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
   5748 		return out, metadata, &smithy.SerializationError{Err: err}
   5749 	}
   5750 	in.Request = request
   5751 
   5752 	return next.HandleSerialize(ctx, in)
   5753 }
   5754 func awsRestxml_serializeOpHttpBindingsUpdateTrafficPolicyInstanceInput(v *UpdateTrafficPolicyInstanceInput, encoder *httpbinding.Encoder) error {
   5755 	if v == nil {
   5756 		return fmt.Errorf("unsupported serialization of nil %T", v)
   5757 	}
   5758 
   5759 	if v.Id == nil || len(*v.Id) == 0 {
   5760 		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
   5761 	}
   5762 	if v.Id != nil {
   5763 		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
   5764 			return err
   5765 		}
   5766 	}
   5767 
   5768 	return nil
   5769 }
   5770 
   5771 func awsRestxml_serializeOpDocumentUpdateTrafficPolicyInstanceInput(v *UpdateTrafficPolicyInstanceInput, value smithyxml.Value) error {
   5772 	defer value.Close()
   5773 	if v.TrafficPolicyId != nil {
   5774 		rootAttr := []smithyxml.Attr{}
   5775 		root := smithyxml.StartElement{
   5776 			Name: smithyxml.Name{
   5777 				Local: "TrafficPolicyId",
   5778 			},
   5779 			Attr: rootAttr,
   5780 		}
   5781 		el := value.MemberElement(root)
   5782 		el.String(*v.TrafficPolicyId)
   5783 	}
   5784 	if v.TrafficPolicyVersion != nil {
   5785 		rootAttr := []smithyxml.Attr{}
   5786 		root := smithyxml.StartElement{
   5787 			Name: smithyxml.Name{
   5788 				Local: "TrafficPolicyVersion",
   5789 			},
   5790 			Attr: rootAttr,
   5791 		}
   5792 		el := value.MemberElement(root)
   5793 		el.Integer(*v.TrafficPolicyVersion)
   5794 	}
   5795 	if v.TTL != nil {
   5796 		rootAttr := []smithyxml.Attr{}
   5797 		root := smithyxml.StartElement{
   5798 			Name: smithyxml.Name{
   5799 				Local: "TTL",
   5800 			},
   5801 			Attr: rootAttr,
   5802 		}
   5803 		el := value.MemberElement(root)
   5804 		el.Long(*v.TTL)
   5805 	}
   5806 	return nil
   5807 }
   5808 
   5809 func awsRestxml_serializeDocumentAlarmIdentifier(v *types.AlarmIdentifier, value smithyxml.Value) error {
   5810 	defer value.Close()
   5811 	if v.Name != nil {
   5812 		rootAttr := []smithyxml.Attr{}
   5813 		root := smithyxml.StartElement{
   5814 			Name: smithyxml.Name{
   5815 				Local: "Name",
   5816 			},
   5817 			Attr: rootAttr,
   5818 		}
   5819 		el := value.MemberElement(root)
   5820 		el.String(*v.Name)
   5821 	}
   5822 	if len(v.Region) > 0 {
   5823 		rootAttr := []smithyxml.Attr{}
   5824 		root := smithyxml.StartElement{
   5825 			Name: smithyxml.Name{
   5826 				Local: "Region",
   5827 			},
   5828 			Attr: rootAttr,
   5829 		}
   5830 		el := value.MemberElement(root)
   5831 		el.String(string(v.Region))
   5832 	}
   5833 	return nil
   5834 }
   5835 
   5836 func awsRestxml_serializeDocumentAliasTarget(v *types.AliasTarget, value smithyxml.Value) error {
   5837 	defer value.Close()
   5838 	if v.DNSName != nil {
   5839 		rootAttr := []smithyxml.Attr{}
   5840 		root := smithyxml.StartElement{
   5841 			Name: smithyxml.Name{
   5842 				Local: "DNSName",
   5843 			},
   5844 			Attr: rootAttr,
   5845 		}
   5846 		el := value.MemberElement(root)
   5847 		el.String(*v.DNSName)
   5848 	}
   5849 	{
   5850 		rootAttr := []smithyxml.Attr{}
   5851 		root := smithyxml.StartElement{
   5852 			Name: smithyxml.Name{
   5853 				Local: "EvaluateTargetHealth",
   5854 			},
   5855 			Attr: rootAttr,
   5856 		}
   5857 		el := value.MemberElement(root)
   5858 		el.Boolean(v.EvaluateTargetHealth)
   5859 	}
   5860 	if v.HostedZoneId != nil {
   5861 		rootAttr := []smithyxml.Attr{}
   5862 		root := smithyxml.StartElement{
   5863 			Name: smithyxml.Name{
   5864 				Local: "HostedZoneId",
   5865 			},
   5866 			Attr: rootAttr,
   5867 		}
   5868 		el := value.MemberElement(root)
   5869 		el.String(*v.HostedZoneId)
   5870 	}
   5871 	return nil
   5872 }
   5873 
   5874 func awsRestxml_serializeDocumentChange(v *types.Change, value smithyxml.Value) error {
   5875 	defer value.Close()
   5876 	if len(v.Action) > 0 {
   5877 		rootAttr := []smithyxml.Attr{}
   5878 		root := smithyxml.StartElement{
   5879 			Name: smithyxml.Name{
   5880 				Local: "Action",
   5881 			},
   5882 			Attr: rootAttr,
   5883 		}
   5884 		el := value.MemberElement(root)
   5885 		el.String(string(v.Action))
   5886 	}
   5887 	if v.ResourceRecordSet != nil {
   5888 		rootAttr := []smithyxml.Attr{}
   5889 		root := smithyxml.StartElement{
   5890 			Name: smithyxml.Name{
   5891 				Local: "ResourceRecordSet",
   5892 			},
   5893 			Attr: rootAttr,
   5894 		}
   5895 		el := value.MemberElement(root)
   5896 		if err := awsRestxml_serializeDocumentResourceRecordSet(v.ResourceRecordSet, el); err != nil {
   5897 			return err
   5898 		}
   5899 	}
   5900 	return nil
   5901 }
   5902 
   5903 func awsRestxml_serializeDocumentChangeBatch(v *types.ChangeBatch, value smithyxml.Value) error {
   5904 	defer value.Close()
   5905 	if v.Changes != nil {
   5906 		rootAttr := []smithyxml.Attr{}
   5907 		root := smithyxml.StartElement{
   5908 			Name: smithyxml.Name{
   5909 				Local: "Changes",
   5910 			},
   5911 			Attr: rootAttr,
   5912 		}
   5913 		el := value.MemberElement(root)
   5914 		if err := awsRestxml_serializeDocumentChanges(v.Changes, el); err != nil {
   5915 			return err
   5916 		}
   5917 	}
   5918 	if v.Comment != nil {
   5919 		rootAttr := []smithyxml.Attr{}
   5920 		root := smithyxml.StartElement{
   5921 			Name: smithyxml.Name{
   5922 				Local: "Comment",
   5923 			},
   5924 			Attr: rootAttr,
   5925 		}
   5926 		el := value.MemberElement(root)
   5927 		el.String(*v.Comment)
   5928 	}
   5929 	return nil
   5930 }
   5931 
   5932 func awsRestxml_serializeDocumentChanges(v []types.Change, value smithyxml.Value) error {
   5933 	var array *smithyxml.Array
   5934 	if !value.IsFlattened() {
   5935 		defer value.Close()
   5936 	}
   5937 	customMemberNameAttr := []smithyxml.Attr{}
   5938 	customMemberName := smithyxml.StartElement{
   5939 		Name: smithyxml.Name{
   5940 			Local: "Change",
   5941 		},
   5942 		Attr: customMemberNameAttr,
   5943 	}
   5944 	array = value.ArrayWithCustomName(customMemberName)
   5945 	for i := range v {
   5946 		am := array.Member()
   5947 		if err := awsRestxml_serializeDocumentChange(&v[i], am); err != nil {
   5948 			return err
   5949 		}
   5950 	}
   5951 	return nil
   5952 }
   5953 
   5954 func awsRestxml_serializeDocumentChildHealthCheckList(v []string, value smithyxml.Value) error {
   5955 	var array *smithyxml.Array
   5956 	if !value.IsFlattened() {
   5957 		defer value.Close()
   5958 	}
   5959 	customMemberNameAttr := []smithyxml.Attr{}
   5960 	customMemberName := smithyxml.StartElement{
   5961 		Name: smithyxml.Name{
   5962 			Local: "ChildHealthCheck",
   5963 		},
   5964 		Attr: customMemberNameAttr,
   5965 	}
   5966 	array = value.ArrayWithCustomName(customMemberName)
   5967 	for i := range v {
   5968 		am := array.Member()
   5969 		am.String(v[i])
   5970 	}
   5971 	return nil
   5972 }
   5973 
   5974 func awsRestxml_serializeDocumentCidrCollectionChange(v *types.CidrCollectionChange, value smithyxml.Value) error {
   5975 	defer value.Close()
   5976 	if len(v.Action) > 0 {
   5977 		rootAttr := []smithyxml.Attr{}
   5978 		root := smithyxml.StartElement{
   5979 			Name: smithyxml.Name{
   5980 				Local: "Action",
   5981 			},
   5982 			Attr: rootAttr,
   5983 		}
   5984 		el := value.MemberElement(root)
   5985 		el.String(string(v.Action))
   5986 	}
   5987 	if v.CidrList != nil {
   5988 		rootAttr := []smithyxml.Attr{}
   5989 		root := smithyxml.StartElement{
   5990 			Name: smithyxml.Name{
   5991 				Local: "CidrList",
   5992 			},
   5993 			Attr: rootAttr,
   5994 		}
   5995 		el := value.MemberElement(root)
   5996 		if err := awsRestxml_serializeDocumentCidrList(v.CidrList, el); err != nil {
   5997 			return err
   5998 		}
   5999 	}
   6000 	if v.LocationName != nil {
   6001 		rootAttr := []smithyxml.Attr{}
   6002 		root := smithyxml.StartElement{
   6003 			Name: smithyxml.Name{
   6004 				Local: "LocationName",
   6005 			},
   6006 			Attr: rootAttr,
   6007 		}
   6008 		el := value.MemberElement(root)
   6009 		el.String(*v.LocationName)
   6010 	}
   6011 	return nil
   6012 }
   6013 
   6014 func awsRestxml_serializeDocumentCidrCollectionChanges(v []types.CidrCollectionChange, value smithyxml.Value) error {
   6015 	var array *smithyxml.Array
   6016 	if !value.IsFlattened() {
   6017 		defer value.Close()
   6018 	}
   6019 	array = value.Array()
   6020 	for i := range v {
   6021 		am := array.Member()
   6022 		if err := awsRestxml_serializeDocumentCidrCollectionChange(&v[i], am); err != nil {
   6023 			return err
   6024 		}
   6025 	}
   6026 	return nil
   6027 }
   6028 
   6029 func awsRestxml_serializeDocumentCidrList(v []string, value smithyxml.Value) error {
   6030 	var array *smithyxml.Array
   6031 	if !value.IsFlattened() {
   6032 		defer value.Close()
   6033 	}
   6034 	customMemberNameAttr := []smithyxml.Attr{}
   6035 	customMemberName := smithyxml.StartElement{
   6036 		Name: smithyxml.Name{
   6037 			Local: "Cidr",
   6038 		},
   6039 		Attr: customMemberNameAttr,
   6040 	}
   6041 	array = value.ArrayWithCustomName(customMemberName)
   6042 	for i := range v {
   6043 		am := array.Member()
   6044 		am.String(v[i])
   6045 	}
   6046 	return nil
   6047 }
   6048 
   6049 func awsRestxml_serializeDocumentCidrRoutingConfig(v *types.CidrRoutingConfig, value smithyxml.Value) error {
   6050 	defer value.Close()
   6051 	if v.CollectionId != nil {
   6052 		rootAttr := []smithyxml.Attr{}
   6053 		root := smithyxml.StartElement{
   6054 			Name: smithyxml.Name{
   6055 				Local: "CollectionId",
   6056 			},
   6057 			Attr: rootAttr,
   6058 		}
   6059 		el := value.MemberElement(root)
   6060 		el.String(*v.CollectionId)
   6061 	}
   6062 	if v.LocationName != nil {
   6063 		rootAttr := []smithyxml.Attr{}
   6064 		root := smithyxml.StartElement{
   6065 			Name: smithyxml.Name{
   6066 				Local: "LocationName",
   6067 			},
   6068 			Attr: rootAttr,
   6069 		}
   6070 		el := value.MemberElement(root)
   6071 		el.String(*v.LocationName)
   6072 	}
   6073 	return nil
   6074 }
   6075 
   6076 func awsRestxml_serializeDocumentCoordinates(v *types.Coordinates, value smithyxml.Value) error {
   6077 	defer value.Close()
   6078 	if v.Latitude != nil {
   6079 		rootAttr := []smithyxml.Attr{}
   6080 		root := smithyxml.StartElement{
   6081 			Name: smithyxml.Name{
   6082 				Local: "Latitude",
   6083 			},
   6084 			Attr: rootAttr,
   6085 		}
   6086 		el := value.MemberElement(root)
   6087 		el.String(*v.Latitude)
   6088 	}
   6089 	if v.Longitude != nil {
   6090 		rootAttr := []smithyxml.Attr{}
   6091 		root := smithyxml.StartElement{
   6092 			Name: smithyxml.Name{
   6093 				Local: "Longitude",
   6094 			},
   6095 			Attr: rootAttr,
   6096 		}
   6097 		el := value.MemberElement(root)
   6098 		el.String(*v.Longitude)
   6099 	}
   6100 	return nil
   6101 }
   6102 
   6103 func awsRestxml_serializeDocumentGeoLocation(v *types.GeoLocation, value smithyxml.Value) error {
   6104 	defer value.Close()
   6105 	if v.ContinentCode != nil {
   6106 		rootAttr := []smithyxml.Attr{}
   6107 		root := smithyxml.StartElement{
   6108 			Name: smithyxml.Name{
   6109 				Local: "ContinentCode",
   6110 			},
   6111 			Attr: rootAttr,
   6112 		}
   6113 		el := value.MemberElement(root)
   6114 		el.String(*v.ContinentCode)
   6115 	}
   6116 	if v.CountryCode != nil {
   6117 		rootAttr := []smithyxml.Attr{}
   6118 		root := smithyxml.StartElement{
   6119 			Name: smithyxml.Name{
   6120 				Local: "CountryCode",
   6121 			},
   6122 			Attr: rootAttr,
   6123 		}
   6124 		el := value.MemberElement(root)
   6125 		el.String(*v.CountryCode)
   6126 	}
   6127 	if v.SubdivisionCode != nil {
   6128 		rootAttr := []smithyxml.Attr{}
   6129 		root := smithyxml.StartElement{
   6130 			Name: smithyxml.Name{
   6131 				Local: "SubdivisionCode",
   6132 			},
   6133 			Attr: rootAttr,
   6134 		}
   6135 		el := value.MemberElement(root)
   6136 		el.String(*v.SubdivisionCode)
   6137 	}
   6138 	return nil
   6139 }
   6140 
   6141 func awsRestxml_serializeDocumentGeoProximityLocation(v *types.GeoProximityLocation, value smithyxml.Value) error {
   6142 	defer value.Close()
   6143 	if v.AWSRegion != nil {
   6144 		rootAttr := []smithyxml.Attr{}
   6145 		root := smithyxml.StartElement{
   6146 			Name: smithyxml.Name{
   6147 				Local: "AWSRegion",
   6148 			},
   6149 			Attr: rootAttr,
   6150 		}
   6151 		el := value.MemberElement(root)
   6152 		el.String(*v.AWSRegion)
   6153 	}
   6154 	if v.Bias != nil {
   6155 		rootAttr := []smithyxml.Attr{}
   6156 		root := smithyxml.StartElement{
   6157 			Name: smithyxml.Name{
   6158 				Local: "Bias",
   6159 			},
   6160 			Attr: rootAttr,
   6161 		}
   6162 		el := value.MemberElement(root)
   6163 		el.Integer(*v.Bias)
   6164 	}
   6165 	if v.Coordinates != nil {
   6166 		rootAttr := []smithyxml.Attr{}
   6167 		root := smithyxml.StartElement{
   6168 			Name: smithyxml.Name{
   6169 				Local: "Coordinates",
   6170 			},
   6171 			Attr: rootAttr,
   6172 		}
   6173 		el := value.MemberElement(root)
   6174 		if err := awsRestxml_serializeDocumentCoordinates(v.Coordinates, el); err != nil {
   6175 			return err
   6176 		}
   6177 	}
   6178 	if v.LocalZoneGroup != nil {
   6179 		rootAttr := []smithyxml.Attr{}
   6180 		root := smithyxml.StartElement{
   6181 			Name: smithyxml.Name{
   6182 				Local: "LocalZoneGroup",
   6183 			},
   6184 			Attr: rootAttr,
   6185 		}
   6186 		el := value.MemberElement(root)
   6187 		el.String(*v.LocalZoneGroup)
   6188 	}
   6189 	return nil
   6190 }
   6191 
   6192 func awsRestxml_serializeDocumentHealthCheckConfig(v *types.HealthCheckConfig, value smithyxml.Value) error {
   6193 	defer value.Close()
   6194 	if v.AlarmIdentifier != nil {
   6195 		rootAttr := []smithyxml.Attr{}
   6196 		root := smithyxml.StartElement{
   6197 			Name: smithyxml.Name{
   6198 				Local: "AlarmIdentifier",
   6199 			},
   6200 			Attr: rootAttr,
   6201 		}
   6202 		el := value.MemberElement(root)
   6203 		if err := awsRestxml_serializeDocumentAlarmIdentifier(v.AlarmIdentifier, el); err != nil {
   6204 			return err
   6205 		}
   6206 	}
   6207 	if v.ChildHealthChecks != nil {
   6208 		rootAttr := []smithyxml.Attr{}
   6209 		root := smithyxml.StartElement{
   6210 			Name: smithyxml.Name{
   6211 				Local: "ChildHealthChecks",
   6212 			},
   6213 			Attr: rootAttr,
   6214 		}
   6215 		el := value.MemberElement(root)
   6216 		if err := awsRestxml_serializeDocumentChildHealthCheckList(v.ChildHealthChecks, el); err != nil {
   6217 			return err
   6218 		}
   6219 	}
   6220 	if v.Disabled != nil {
   6221 		rootAttr := []smithyxml.Attr{}
   6222 		root := smithyxml.StartElement{
   6223 			Name: smithyxml.Name{
   6224 				Local: "Disabled",
   6225 			},
   6226 			Attr: rootAttr,
   6227 		}
   6228 		el := value.MemberElement(root)
   6229 		el.Boolean(*v.Disabled)
   6230 	}
   6231 	if v.EnableSNI != nil {
   6232 		rootAttr := []smithyxml.Attr{}
   6233 		root := smithyxml.StartElement{
   6234 			Name: smithyxml.Name{
   6235 				Local: "EnableSNI",
   6236 			},
   6237 			Attr: rootAttr,
   6238 		}
   6239 		el := value.MemberElement(root)
   6240 		el.Boolean(*v.EnableSNI)
   6241 	}
   6242 	if v.FailureThreshold != nil {
   6243 		rootAttr := []smithyxml.Attr{}
   6244 		root := smithyxml.StartElement{
   6245 			Name: smithyxml.Name{
   6246 				Local: "FailureThreshold",
   6247 			},
   6248 			Attr: rootAttr,
   6249 		}
   6250 		el := value.MemberElement(root)
   6251 		el.Integer(*v.FailureThreshold)
   6252 	}
   6253 	if v.FullyQualifiedDomainName != nil {
   6254 		rootAttr := []smithyxml.Attr{}
   6255 		root := smithyxml.StartElement{
   6256 			Name: smithyxml.Name{
   6257 				Local: "FullyQualifiedDomainName",
   6258 			},
   6259 			Attr: rootAttr,
   6260 		}
   6261 		el := value.MemberElement(root)
   6262 		el.String(*v.FullyQualifiedDomainName)
   6263 	}
   6264 	if v.HealthThreshold != nil {
   6265 		rootAttr := []smithyxml.Attr{}
   6266 		root := smithyxml.StartElement{
   6267 			Name: smithyxml.Name{
   6268 				Local: "HealthThreshold",
   6269 			},
   6270 			Attr: rootAttr,
   6271 		}
   6272 		el := value.MemberElement(root)
   6273 		el.Integer(*v.HealthThreshold)
   6274 	}
   6275 	if len(v.InsufficientDataHealthStatus) > 0 {
   6276 		rootAttr := []smithyxml.Attr{}
   6277 		root := smithyxml.StartElement{
   6278 			Name: smithyxml.Name{
   6279 				Local: "InsufficientDataHealthStatus",
   6280 			},
   6281 			Attr: rootAttr,
   6282 		}
   6283 		el := value.MemberElement(root)
   6284 		el.String(string(v.InsufficientDataHealthStatus))
   6285 	}
   6286 	if v.Inverted != nil {
   6287 		rootAttr := []smithyxml.Attr{}
   6288 		root := smithyxml.StartElement{
   6289 			Name: smithyxml.Name{
   6290 				Local: "Inverted",
   6291 			},
   6292 			Attr: rootAttr,
   6293 		}
   6294 		el := value.MemberElement(root)
   6295 		el.Boolean(*v.Inverted)
   6296 	}
   6297 	if v.IPAddress != nil {
   6298 		rootAttr := []smithyxml.Attr{}
   6299 		root := smithyxml.StartElement{
   6300 			Name: smithyxml.Name{
   6301 				Local: "IPAddress",
   6302 			},
   6303 			Attr: rootAttr,
   6304 		}
   6305 		el := value.MemberElement(root)
   6306 		el.String(*v.IPAddress)
   6307 	}
   6308 	if v.MeasureLatency != nil {
   6309 		rootAttr := []smithyxml.Attr{}
   6310 		root := smithyxml.StartElement{
   6311 			Name: smithyxml.Name{
   6312 				Local: "MeasureLatency",
   6313 			},
   6314 			Attr: rootAttr,
   6315 		}
   6316 		el := value.MemberElement(root)
   6317 		el.Boolean(*v.MeasureLatency)
   6318 	}
   6319 	if v.Port != nil {
   6320 		rootAttr := []smithyxml.Attr{}
   6321 		root := smithyxml.StartElement{
   6322 			Name: smithyxml.Name{
   6323 				Local: "Port",
   6324 			},
   6325 			Attr: rootAttr,
   6326 		}
   6327 		el := value.MemberElement(root)
   6328 		el.Integer(*v.Port)
   6329 	}
   6330 	if v.Regions != nil {
   6331 		rootAttr := []smithyxml.Attr{}
   6332 		root := smithyxml.StartElement{
   6333 			Name: smithyxml.Name{
   6334 				Local: "Regions",
   6335 			},
   6336 			Attr: rootAttr,
   6337 		}
   6338 		el := value.MemberElement(root)
   6339 		if err := awsRestxml_serializeDocumentHealthCheckRegionList(v.Regions, el); err != nil {
   6340 			return err
   6341 		}
   6342 	}
   6343 	if v.RequestInterval != nil {
   6344 		rootAttr := []smithyxml.Attr{}
   6345 		root := smithyxml.StartElement{
   6346 			Name: smithyxml.Name{
   6347 				Local: "RequestInterval",
   6348 			},
   6349 			Attr: rootAttr,
   6350 		}
   6351 		el := value.MemberElement(root)
   6352 		el.Integer(*v.RequestInterval)
   6353 	}
   6354 	if v.ResourcePath != nil {
   6355 		rootAttr := []smithyxml.Attr{}
   6356 		root := smithyxml.StartElement{
   6357 			Name: smithyxml.Name{
   6358 				Local: "ResourcePath",
   6359 			},
   6360 			Attr: rootAttr,
   6361 		}
   6362 		el := value.MemberElement(root)
   6363 		el.String(*v.ResourcePath)
   6364 	}
   6365 	if v.RoutingControlArn != nil {
   6366 		rootAttr := []smithyxml.Attr{}
   6367 		root := smithyxml.StartElement{
   6368 			Name: smithyxml.Name{
   6369 				Local: "RoutingControlArn",
   6370 			},
   6371 			Attr: rootAttr,
   6372 		}
   6373 		el := value.MemberElement(root)
   6374 		el.String(*v.RoutingControlArn)
   6375 	}
   6376 	if v.SearchString != nil {
   6377 		rootAttr := []smithyxml.Attr{}
   6378 		root := smithyxml.StartElement{
   6379 			Name: smithyxml.Name{
   6380 				Local: "SearchString",
   6381 			},
   6382 			Attr: rootAttr,
   6383 		}
   6384 		el := value.MemberElement(root)
   6385 		el.String(*v.SearchString)
   6386 	}
   6387 	if len(v.Type) > 0 {
   6388 		rootAttr := []smithyxml.Attr{}
   6389 		root := smithyxml.StartElement{
   6390 			Name: smithyxml.Name{
   6391 				Local: "Type",
   6392 			},
   6393 			Attr: rootAttr,
   6394 		}
   6395 		el := value.MemberElement(root)
   6396 		el.String(string(v.Type))
   6397 	}
   6398 	return nil
   6399 }
   6400 
   6401 func awsRestxml_serializeDocumentHealthCheckRegionList(v []types.HealthCheckRegion, value smithyxml.Value) error {
   6402 	var array *smithyxml.Array
   6403 	if !value.IsFlattened() {
   6404 		defer value.Close()
   6405 	}
   6406 	customMemberNameAttr := []smithyxml.Attr{}
   6407 	customMemberName := smithyxml.StartElement{
   6408 		Name: smithyxml.Name{
   6409 			Local: "Region",
   6410 		},
   6411 		Attr: customMemberNameAttr,
   6412 	}
   6413 	array = value.ArrayWithCustomName(customMemberName)
   6414 	for i := range v {
   6415 		am := array.Member()
   6416 		am.String(string(v[i]))
   6417 	}
   6418 	return nil
   6419 }
   6420 
   6421 func awsRestxml_serializeDocumentHostedZoneConfig(v *types.HostedZoneConfig, value smithyxml.Value) error {
   6422 	defer value.Close()
   6423 	if v.Comment != nil {
   6424 		rootAttr := []smithyxml.Attr{}
   6425 		root := smithyxml.StartElement{
   6426 			Name: smithyxml.Name{
   6427 				Local: "Comment",
   6428 			},
   6429 			Attr: rootAttr,
   6430 		}
   6431 		el := value.MemberElement(root)
   6432 		el.String(*v.Comment)
   6433 	}
   6434 	if v.PrivateZone {
   6435 		rootAttr := []smithyxml.Attr{}
   6436 		root := smithyxml.StartElement{
   6437 			Name: smithyxml.Name{
   6438 				Local: "PrivateZone",
   6439 			},
   6440 			Attr: rootAttr,
   6441 		}
   6442 		el := value.MemberElement(root)
   6443 		el.Boolean(v.PrivateZone)
   6444 	}
   6445 	return nil
   6446 }
   6447 
   6448 func awsRestxml_serializeDocumentResettableElementNameList(v []types.ResettableElementName, value smithyxml.Value) error {
   6449 	var array *smithyxml.Array
   6450 	if !value.IsFlattened() {
   6451 		defer value.Close()
   6452 	}
   6453 	customMemberNameAttr := []smithyxml.Attr{}
   6454 	customMemberName := smithyxml.StartElement{
   6455 		Name: smithyxml.Name{
   6456 			Local: "ResettableElementName",
   6457 		},
   6458 		Attr: customMemberNameAttr,
   6459 	}
   6460 	array = value.ArrayWithCustomName(customMemberName)
   6461 	for i := range v {
   6462 		am := array.Member()
   6463 		am.String(string(v[i]))
   6464 	}
   6465 	return nil
   6466 }
   6467 
   6468 func awsRestxml_serializeDocumentResourceRecord(v *types.ResourceRecord, value smithyxml.Value) error {
   6469 	defer value.Close()
   6470 	if v.Value != nil {
   6471 		rootAttr := []smithyxml.Attr{}
   6472 		root := smithyxml.StartElement{
   6473 			Name: smithyxml.Name{
   6474 				Local: "Value",
   6475 			},
   6476 			Attr: rootAttr,
   6477 		}
   6478 		el := value.MemberElement(root)
   6479 		el.String(*v.Value)
   6480 	}
   6481 	return nil
   6482 }
   6483 
   6484 func awsRestxml_serializeDocumentResourceRecords(v []types.ResourceRecord, value smithyxml.Value) error {
   6485 	var array *smithyxml.Array
   6486 	if !value.IsFlattened() {
   6487 		defer value.Close()
   6488 	}
   6489 	customMemberNameAttr := []smithyxml.Attr{}
   6490 	customMemberName := smithyxml.StartElement{
   6491 		Name: smithyxml.Name{
   6492 			Local: "ResourceRecord",
   6493 		},
   6494 		Attr: customMemberNameAttr,
   6495 	}
   6496 	array = value.ArrayWithCustomName(customMemberName)
   6497 	for i := range v {
   6498 		am := array.Member()
   6499 		if err := awsRestxml_serializeDocumentResourceRecord(&v[i], am); err != nil {
   6500 			return err
   6501 		}
   6502 	}
   6503 	return nil
   6504 }
   6505 
   6506 func awsRestxml_serializeDocumentResourceRecordSet(v *types.ResourceRecordSet, value smithyxml.Value) error {
   6507 	defer value.Close()
   6508 	if v.AliasTarget != nil {
   6509 		rootAttr := []smithyxml.Attr{}
   6510 		root := smithyxml.StartElement{
   6511 			Name: smithyxml.Name{
   6512 				Local: "AliasTarget",
   6513 			},
   6514 			Attr: rootAttr,
   6515 		}
   6516 		el := value.MemberElement(root)
   6517 		if err := awsRestxml_serializeDocumentAliasTarget(v.AliasTarget, el); err != nil {
   6518 			return err
   6519 		}
   6520 	}
   6521 	if v.CidrRoutingConfig != nil {
   6522 		rootAttr := []smithyxml.Attr{}
   6523 		root := smithyxml.StartElement{
   6524 			Name: smithyxml.Name{
   6525 				Local: "CidrRoutingConfig",
   6526 			},
   6527 			Attr: rootAttr,
   6528 		}
   6529 		el := value.MemberElement(root)
   6530 		if err := awsRestxml_serializeDocumentCidrRoutingConfig(v.CidrRoutingConfig, el); err != nil {
   6531 			return err
   6532 		}
   6533 	}
   6534 	if len(v.Failover) > 0 {
   6535 		rootAttr := []smithyxml.Attr{}
   6536 		root := smithyxml.StartElement{
   6537 			Name: smithyxml.Name{
   6538 				Local: "Failover",
   6539 			},
   6540 			Attr: rootAttr,
   6541 		}
   6542 		el := value.MemberElement(root)
   6543 		el.String(string(v.Failover))
   6544 	}
   6545 	if v.GeoLocation != nil {
   6546 		rootAttr := []smithyxml.Attr{}
   6547 		root := smithyxml.StartElement{
   6548 			Name: smithyxml.Name{
   6549 				Local: "GeoLocation",
   6550 			},
   6551 			Attr: rootAttr,
   6552 		}
   6553 		el := value.MemberElement(root)
   6554 		if err := awsRestxml_serializeDocumentGeoLocation(v.GeoLocation, el); err != nil {
   6555 			return err
   6556 		}
   6557 	}
   6558 	if v.GeoProximityLocation != nil {
   6559 		rootAttr := []smithyxml.Attr{}
   6560 		root := smithyxml.StartElement{
   6561 			Name: smithyxml.Name{
   6562 				Local: "GeoProximityLocation",
   6563 			},
   6564 			Attr: rootAttr,
   6565 		}
   6566 		el := value.MemberElement(root)
   6567 		if err := awsRestxml_serializeDocumentGeoProximityLocation(v.GeoProximityLocation, el); err != nil {
   6568 			return err
   6569 		}
   6570 	}
   6571 	if v.HealthCheckId != nil {
   6572 		rootAttr := []smithyxml.Attr{}
   6573 		root := smithyxml.StartElement{
   6574 			Name: smithyxml.Name{
   6575 				Local: "HealthCheckId",
   6576 			},
   6577 			Attr: rootAttr,
   6578 		}
   6579 		el := value.MemberElement(root)
   6580 		el.String(*v.HealthCheckId)
   6581 	}
   6582 	if v.MultiValueAnswer != nil {
   6583 		rootAttr := []smithyxml.Attr{}
   6584 		root := smithyxml.StartElement{
   6585 			Name: smithyxml.Name{
   6586 				Local: "MultiValueAnswer",
   6587 			},
   6588 			Attr: rootAttr,
   6589 		}
   6590 		el := value.MemberElement(root)
   6591 		el.Boolean(*v.MultiValueAnswer)
   6592 	}
   6593 	if v.Name != nil {
   6594 		rootAttr := []smithyxml.Attr{}
   6595 		root := smithyxml.StartElement{
   6596 			Name: smithyxml.Name{
   6597 				Local: "Name",
   6598 			},
   6599 			Attr: rootAttr,
   6600 		}
   6601 		el := value.MemberElement(root)
   6602 		el.String(*v.Name)
   6603 	}
   6604 	if len(v.Region) > 0 {
   6605 		rootAttr := []smithyxml.Attr{}
   6606 		root := smithyxml.StartElement{
   6607 			Name: smithyxml.Name{
   6608 				Local: "Region",
   6609 			},
   6610 			Attr: rootAttr,
   6611 		}
   6612 		el := value.MemberElement(root)
   6613 		el.String(string(v.Region))
   6614 	}
   6615 	if v.ResourceRecords != nil {
   6616 		rootAttr := []smithyxml.Attr{}
   6617 		root := smithyxml.StartElement{
   6618 			Name: smithyxml.Name{
   6619 				Local: "ResourceRecords",
   6620 			},
   6621 			Attr: rootAttr,
   6622 		}
   6623 		el := value.MemberElement(root)
   6624 		if err := awsRestxml_serializeDocumentResourceRecords(v.ResourceRecords, el); err != nil {
   6625 			return err
   6626 		}
   6627 	}
   6628 	if v.SetIdentifier != nil {
   6629 		rootAttr := []smithyxml.Attr{}
   6630 		root := smithyxml.StartElement{
   6631 			Name: smithyxml.Name{
   6632 				Local: "SetIdentifier",
   6633 			},
   6634 			Attr: rootAttr,
   6635 		}
   6636 		el := value.MemberElement(root)
   6637 		el.String(*v.SetIdentifier)
   6638 	}
   6639 	if v.TrafficPolicyInstanceId != nil {
   6640 		rootAttr := []smithyxml.Attr{}
   6641 		root := smithyxml.StartElement{
   6642 			Name: smithyxml.Name{
   6643 				Local: "TrafficPolicyInstanceId",
   6644 			},
   6645 			Attr: rootAttr,
   6646 		}
   6647 		el := value.MemberElement(root)
   6648 		el.String(*v.TrafficPolicyInstanceId)
   6649 	}
   6650 	if v.TTL != nil {
   6651 		rootAttr := []smithyxml.Attr{}
   6652 		root := smithyxml.StartElement{
   6653 			Name: smithyxml.Name{
   6654 				Local: "TTL",
   6655 			},
   6656 			Attr: rootAttr,
   6657 		}
   6658 		el := value.MemberElement(root)
   6659 		el.Long(*v.TTL)
   6660 	}
   6661 	if len(v.Type) > 0 {
   6662 		rootAttr := []smithyxml.Attr{}
   6663 		root := smithyxml.StartElement{
   6664 			Name: smithyxml.Name{
   6665 				Local: "Type",
   6666 			},
   6667 			Attr: rootAttr,
   6668 		}
   6669 		el := value.MemberElement(root)
   6670 		el.String(string(v.Type))
   6671 	}
   6672 	if v.Weight != nil {
   6673 		rootAttr := []smithyxml.Attr{}
   6674 		root := smithyxml.StartElement{
   6675 			Name: smithyxml.Name{
   6676 				Local: "Weight",
   6677 			},
   6678 			Attr: rootAttr,
   6679 		}
   6680 		el := value.MemberElement(root)
   6681 		el.Long(*v.Weight)
   6682 	}
   6683 	return nil
   6684 }
   6685 
   6686 func awsRestxml_serializeDocumentTag(v *types.Tag, value smithyxml.Value) error {
   6687 	defer value.Close()
   6688 	if v.Key != nil {
   6689 		rootAttr := []smithyxml.Attr{}
   6690 		root := smithyxml.StartElement{
   6691 			Name: smithyxml.Name{
   6692 				Local: "Key",
   6693 			},
   6694 			Attr: rootAttr,
   6695 		}
   6696 		el := value.MemberElement(root)
   6697 		el.String(*v.Key)
   6698 	}
   6699 	if v.Value != nil {
   6700 		rootAttr := []smithyxml.Attr{}
   6701 		root := smithyxml.StartElement{
   6702 			Name: smithyxml.Name{
   6703 				Local: "Value",
   6704 			},
   6705 			Attr: rootAttr,
   6706 		}
   6707 		el := value.MemberElement(root)
   6708 		el.String(*v.Value)
   6709 	}
   6710 	return nil
   6711 }
   6712 
   6713 func awsRestxml_serializeDocumentTagKeyList(v []string, value smithyxml.Value) error {
   6714 	var array *smithyxml.Array
   6715 	if !value.IsFlattened() {
   6716 		defer value.Close()
   6717 	}
   6718 	customMemberNameAttr := []smithyxml.Attr{}
   6719 	customMemberName := smithyxml.StartElement{
   6720 		Name: smithyxml.Name{
   6721 			Local: "Key",
   6722 		},
   6723 		Attr: customMemberNameAttr,
   6724 	}
   6725 	array = value.ArrayWithCustomName(customMemberName)
   6726 	for i := range v {
   6727 		am := array.Member()
   6728 		am.String(v[i])
   6729 	}
   6730 	return nil
   6731 }
   6732 
   6733 func awsRestxml_serializeDocumentTagList(v []types.Tag, value smithyxml.Value) error {
   6734 	var array *smithyxml.Array
   6735 	if !value.IsFlattened() {
   6736 		defer value.Close()
   6737 	}
   6738 	customMemberNameAttr := []smithyxml.Attr{}
   6739 	customMemberName := smithyxml.StartElement{
   6740 		Name: smithyxml.Name{
   6741 			Local: "Tag",
   6742 		},
   6743 		Attr: customMemberNameAttr,
   6744 	}
   6745 	array = value.ArrayWithCustomName(customMemberName)
   6746 	for i := range v {
   6747 		am := array.Member()
   6748 		if err := awsRestxml_serializeDocumentTag(&v[i], am); err != nil {
   6749 			return err
   6750 		}
   6751 	}
   6752 	return nil
   6753 }
   6754 
   6755 func awsRestxml_serializeDocumentTagResourceIdList(v []string, value smithyxml.Value) error {
   6756 	var array *smithyxml.Array
   6757 	if !value.IsFlattened() {
   6758 		defer value.Close()
   6759 	}
   6760 	customMemberNameAttr := []smithyxml.Attr{}
   6761 	customMemberName := smithyxml.StartElement{
   6762 		Name: smithyxml.Name{
   6763 			Local: "ResourceId",
   6764 		},
   6765 		Attr: customMemberNameAttr,
   6766 	}
   6767 	array = value.ArrayWithCustomName(customMemberName)
   6768 	for i := range v {
   6769 		am := array.Member()
   6770 		am.String(v[i])
   6771 	}
   6772 	return nil
   6773 }
   6774 
   6775 func awsRestxml_serializeDocumentVPC(v *types.VPC, value smithyxml.Value) error {
   6776 	defer value.Close()
   6777 	if v.VPCId != nil {
   6778 		rootAttr := []smithyxml.Attr{}
   6779 		root := smithyxml.StartElement{
   6780 			Name: smithyxml.Name{
   6781 				Local: "VPCId",
   6782 			},
   6783 			Attr: rootAttr,
   6784 		}
   6785 		el := value.MemberElement(root)
   6786 		el.String(*v.VPCId)
   6787 	}
   6788 	if len(v.VPCRegion) > 0 {
   6789 		rootAttr := []smithyxml.Attr{}
   6790 		root := smithyxml.StartElement{
   6791 			Name: smithyxml.Name{
   6792 				Local: "VPCRegion",
   6793 			},
   6794 			Attr: rootAttr,
   6795 		}
   6796 		el := value.MemberElement(root)
   6797 		el.String(string(v.VPCRegion))
   6798 	}
   6799 	return nil
   6800 }
	src Go monorepo.
	git clone git://code.dwrz.net/src
	Log \| Files \| Refs