code.dwrz.net

Go monorepo.
Log | Files | Refs

serializers.go (200883B)


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