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