serializers.go raw
1 // Code generated by smithy-go-codegen DO NOT EDIT.
2
3 package lightsail
4
5 import (
6 "bytes"
7 "context"
8 "fmt"
9 "github.com/aws/aws-sdk-go-v2/service/lightsail/types"
10 smithy "github.com/aws/smithy-go"
11 "github.com/aws/smithy-go/encoding/httpbinding"
12 smithyjson "github.com/aws/smithy-go/encoding/json"
13 "github.com/aws/smithy-go/middleware"
14 smithytime "github.com/aws/smithy-go/time"
15 "github.com/aws/smithy-go/tracing"
16 smithyhttp "github.com/aws/smithy-go/transport/http"
17 "math"
18 "path"
19 )
20
21 type awsAwsjson11_serializeOpAllocateStaticIp struct {
22 }
23
24 func (*awsAwsjson11_serializeOpAllocateStaticIp) ID() string {
25 return "OperationSerializer"
26 }
27
28 func (m *awsAwsjson11_serializeOpAllocateStaticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
29 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
30 ) {
31 _, span := tracing.StartSpan(ctx, "OperationSerializer")
32 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
33 defer endTimer()
34 defer span.End()
35 request, ok := in.Request.(*smithyhttp.Request)
36 if !ok {
37 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
38 }
39
40 input, ok := in.Parameters.(*AllocateStaticIpInput)
41 _ = input
42 if !ok {
43 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
44 }
45
46 operationPath := "/"
47 if len(request.Request.URL.Path) == 0 {
48 request.Request.URL.Path = operationPath
49 } else {
50 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
51 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
52 request.Request.URL.Path += "/"
53 }
54 }
55 request.Request.Method = "POST"
56 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
57 if err != nil {
58 return out, metadata, &smithy.SerializationError{Err: err}
59 }
60 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
61 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AllocateStaticIp")
62
63 jsonEncoder := smithyjson.NewEncoder()
64 if err := awsAwsjson11_serializeOpDocumentAllocateStaticIpInput(input, jsonEncoder.Value); err != nil {
65 return out, metadata, &smithy.SerializationError{Err: err}
66 }
67
68 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
69 return out, metadata, &smithy.SerializationError{Err: err}
70 }
71
72 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
73 return out, metadata, &smithy.SerializationError{Err: err}
74 }
75 in.Request = request
76
77 endTimer()
78 span.End()
79 return next.HandleSerialize(ctx, in)
80 }
81
82 type awsAwsjson11_serializeOpAttachCertificateToDistribution struct {
83 }
84
85 func (*awsAwsjson11_serializeOpAttachCertificateToDistribution) ID() string {
86 return "OperationSerializer"
87 }
88
89 func (m *awsAwsjson11_serializeOpAttachCertificateToDistribution) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
90 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
91 ) {
92 _, span := tracing.StartSpan(ctx, "OperationSerializer")
93 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
94 defer endTimer()
95 defer span.End()
96 request, ok := in.Request.(*smithyhttp.Request)
97 if !ok {
98 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
99 }
100
101 input, ok := in.Parameters.(*AttachCertificateToDistributionInput)
102 _ = input
103 if !ok {
104 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
105 }
106
107 operationPath := "/"
108 if len(request.Request.URL.Path) == 0 {
109 request.Request.URL.Path = operationPath
110 } else {
111 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
112 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
113 request.Request.URL.Path += "/"
114 }
115 }
116 request.Request.Method = "POST"
117 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
118 if err != nil {
119 return out, metadata, &smithy.SerializationError{Err: err}
120 }
121 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
122 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AttachCertificateToDistribution")
123
124 jsonEncoder := smithyjson.NewEncoder()
125 if err := awsAwsjson11_serializeOpDocumentAttachCertificateToDistributionInput(input, jsonEncoder.Value); err != nil {
126 return out, metadata, &smithy.SerializationError{Err: err}
127 }
128
129 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
130 return out, metadata, &smithy.SerializationError{Err: err}
131 }
132
133 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
134 return out, metadata, &smithy.SerializationError{Err: err}
135 }
136 in.Request = request
137
138 endTimer()
139 span.End()
140 return next.HandleSerialize(ctx, in)
141 }
142
143 type awsAwsjson11_serializeOpAttachDisk struct {
144 }
145
146 func (*awsAwsjson11_serializeOpAttachDisk) ID() string {
147 return "OperationSerializer"
148 }
149
150 func (m *awsAwsjson11_serializeOpAttachDisk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
151 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
152 ) {
153 _, span := tracing.StartSpan(ctx, "OperationSerializer")
154 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
155 defer endTimer()
156 defer span.End()
157 request, ok := in.Request.(*smithyhttp.Request)
158 if !ok {
159 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
160 }
161
162 input, ok := in.Parameters.(*AttachDiskInput)
163 _ = input
164 if !ok {
165 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
166 }
167
168 operationPath := "/"
169 if len(request.Request.URL.Path) == 0 {
170 request.Request.URL.Path = operationPath
171 } else {
172 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
173 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
174 request.Request.URL.Path += "/"
175 }
176 }
177 request.Request.Method = "POST"
178 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
179 if err != nil {
180 return out, metadata, &smithy.SerializationError{Err: err}
181 }
182 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
183 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AttachDisk")
184
185 jsonEncoder := smithyjson.NewEncoder()
186 if err := awsAwsjson11_serializeOpDocumentAttachDiskInput(input, jsonEncoder.Value); err != nil {
187 return out, metadata, &smithy.SerializationError{Err: err}
188 }
189
190 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
191 return out, metadata, &smithy.SerializationError{Err: err}
192 }
193
194 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
195 return out, metadata, &smithy.SerializationError{Err: err}
196 }
197 in.Request = request
198
199 endTimer()
200 span.End()
201 return next.HandleSerialize(ctx, in)
202 }
203
204 type awsAwsjson11_serializeOpAttachInstancesToLoadBalancer struct {
205 }
206
207 func (*awsAwsjson11_serializeOpAttachInstancesToLoadBalancer) ID() string {
208 return "OperationSerializer"
209 }
210
211 func (m *awsAwsjson11_serializeOpAttachInstancesToLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
212 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
213 ) {
214 _, span := tracing.StartSpan(ctx, "OperationSerializer")
215 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
216 defer endTimer()
217 defer span.End()
218 request, ok := in.Request.(*smithyhttp.Request)
219 if !ok {
220 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
221 }
222
223 input, ok := in.Parameters.(*AttachInstancesToLoadBalancerInput)
224 _ = input
225 if !ok {
226 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
227 }
228
229 operationPath := "/"
230 if len(request.Request.URL.Path) == 0 {
231 request.Request.URL.Path = operationPath
232 } else {
233 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
234 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
235 request.Request.URL.Path += "/"
236 }
237 }
238 request.Request.Method = "POST"
239 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
240 if err != nil {
241 return out, metadata, &smithy.SerializationError{Err: err}
242 }
243 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
244 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AttachInstancesToLoadBalancer")
245
246 jsonEncoder := smithyjson.NewEncoder()
247 if err := awsAwsjson11_serializeOpDocumentAttachInstancesToLoadBalancerInput(input, jsonEncoder.Value); err != nil {
248 return out, metadata, &smithy.SerializationError{Err: err}
249 }
250
251 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
252 return out, metadata, &smithy.SerializationError{Err: err}
253 }
254
255 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
256 return out, metadata, &smithy.SerializationError{Err: err}
257 }
258 in.Request = request
259
260 endTimer()
261 span.End()
262 return next.HandleSerialize(ctx, in)
263 }
264
265 type awsAwsjson11_serializeOpAttachLoadBalancerTlsCertificate struct {
266 }
267
268 func (*awsAwsjson11_serializeOpAttachLoadBalancerTlsCertificate) ID() string {
269 return "OperationSerializer"
270 }
271
272 func (m *awsAwsjson11_serializeOpAttachLoadBalancerTlsCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
273 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
274 ) {
275 _, span := tracing.StartSpan(ctx, "OperationSerializer")
276 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
277 defer endTimer()
278 defer span.End()
279 request, ok := in.Request.(*smithyhttp.Request)
280 if !ok {
281 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
282 }
283
284 input, ok := in.Parameters.(*AttachLoadBalancerTlsCertificateInput)
285 _ = input
286 if !ok {
287 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
288 }
289
290 operationPath := "/"
291 if len(request.Request.URL.Path) == 0 {
292 request.Request.URL.Path = operationPath
293 } else {
294 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
295 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
296 request.Request.URL.Path += "/"
297 }
298 }
299 request.Request.Method = "POST"
300 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
301 if err != nil {
302 return out, metadata, &smithy.SerializationError{Err: err}
303 }
304 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
305 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AttachLoadBalancerTlsCertificate")
306
307 jsonEncoder := smithyjson.NewEncoder()
308 if err := awsAwsjson11_serializeOpDocumentAttachLoadBalancerTlsCertificateInput(input, jsonEncoder.Value); err != nil {
309 return out, metadata, &smithy.SerializationError{Err: err}
310 }
311
312 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
313 return out, metadata, &smithy.SerializationError{Err: err}
314 }
315
316 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
317 return out, metadata, &smithy.SerializationError{Err: err}
318 }
319 in.Request = request
320
321 endTimer()
322 span.End()
323 return next.HandleSerialize(ctx, in)
324 }
325
326 type awsAwsjson11_serializeOpAttachStaticIp struct {
327 }
328
329 func (*awsAwsjson11_serializeOpAttachStaticIp) ID() string {
330 return "OperationSerializer"
331 }
332
333 func (m *awsAwsjson11_serializeOpAttachStaticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
334 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
335 ) {
336 _, span := tracing.StartSpan(ctx, "OperationSerializer")
337 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
338 defer endTimer()
339 defer span.End()
340 request, ok := in.Request.(*smithyhttp.Request)
341 if !ok {
342 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
343 }
344
345 input, ok := in.Parameters.(*AttachStaticIpInput)
346 _ = input
347 if !ok {
348 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
349 }
350
351 operationPath := "/"
352 if len(request.Request.URL.Path) == 0 {
353 request.Request.URL.Path = operationPath
354 } else {
355 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
356 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
357 request.Request.URL.Path += "/"
358 }
359 }
360 request.Request.Method = "POST"
361 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
362 if err != nil {
363 return out, metadata, &smithy.SerializationError{Err: err}
364 }
365 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
366 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AttachStaticIp")
367
368 jsonEncoder := smithyjson.NewEncoder()
369 if err := awsAwsjson11_serializeOpDocumentAttachStaticIpInput(input, jsonEncoder.Value); err != nil {
370 return out, metadata, &smithy.SerializationError{Err: err}
371 }
372
373 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
374 return out, metadata, &smithy.SerializationError{Err: err}
375 }
376
377 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
378 return out, metadata, &smithy.SerializationError{Err: err}
379 }
380 in.Request = request
381
382 endTimer()
383 span.End()
384 return next.HandleSerialize(ctx, in)
385 }
386
387 type awsAwsjson11_serializeOpCloseInstancePublicPorts struct {
388 }
389
390 func (*awsAwsjson11_serializeOpCloseInstancePublicPorts) ID() string {
391 return "OperationSerializer"
392 }
393
394 func (m *awsAwsjson11_serializeOpCloseInstancePublicPorts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
395 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
396 ) {
397 _, span := tracing.StartSpan(ctx, "OperationSerializer")
398 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
399 defer endTimer()
400 defer span.End()
401 request, ok := in.Request.(*smithyhttp.Request)
402 if !ok {
403 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
404 }
405
406 input, ok := in.Parameters.(*CloseInstancePublicPortsInput)
407 _ = input
408 if !ok {
409 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
410 }
411
412 operationPath := "/"
413 if len(request.Request.URL.Path) == 0 {
414 request.Request.URL.Path = operationPath
415 } else {
416 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
417 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
418 request.Request.URL.Path += "/"
419 }
420 }
421 request.Request.Method = "POST"
422 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
423 if err != nil {
424 return out, metadata, &smithy.SerializationError{Err: err}
425 }
426 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
427 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CloseInstancePublicPorts")
428
429 jsonEncoder := smithyjson.NewEncoder()
430 if err := awsAwsjson11_serializeOpDocumentCloseInstancePublicPortsInput(input, jsonEncoder.Value); err != nil {
431 return out, metadata, &smithy.SerializationError{Err: err}
432 }
433
434 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
435 return out, metadata, &smithy.SerializationError{Err: err}
436 }
437
438 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
439 return out, metadata, &smithy.SerializationError{Err: err}
440 }
441 in.Request = request
442
443 endTimer()
444 span.End()
445 return next.HandleSerialize(ctx, in)
446 }
447
448 type awsAwsjson11_serializeOpCopySnapshot struct {
449 }
450
451 func (*awsAwsjson11_serializeOpCopySnapshot) ID() string {
452 return "OperationSerializer"
453 }
454
455 func (m *awsAwsjson11_serializeOpCopySnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
456 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
457 ) {
458 _, span := tracing.StartSpan(ctx, "OperationSerializer")
459 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
460 defer endTimer()
461 defer span.End()
462 request, ok := in.Request.(*smithyhttp.Request)
463 if !ok {
464 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
465 }
466
467 input, ok := in.Parameters.(*CopySnapshotInput)
468 _ = input
469 if !ok {
470 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
471 }
472
473 operationPath := "/"
474 if len(request.Request.URL.Path) == 0 {
475 request.Request.URL.Path = operationPath
476 } else {
477 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
478 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
479 request.Request.URL.Path += "/"
480 }
481 }
482 request.Request.Method = "POST"
483 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
484 if err != nil {
485 return out, metadata, &smithy.SerializationError{Err: err}
486 }
487 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
488 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CopySnapshot")
489
490 jsonEncoder := smithyjson.NewEncoder()
491 if err := awsAwsjson11_serializeOpDocumentCopySnapshotInput(input, jsonEncoder.Value); err != nil {
492 return out, metadata, &smithy.SerializationError{Err: err}
493 }
494
495 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
496 return out, metadata, &smithy.SerializationError{Err: err}
497 }
498
499 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
500 return out, metadata, &smithy.SerializationError{Err: err}
501 }
502 in.Request = request
503
504 endTimer()
505 span.End()
506 return next.HandleSerialize(ctx, in)
507 }
508
509 type awsAwsjson11_serializeOpCreateBucket struct {
510 }
511
512 func (*awsAwsjson11_serializeOpCreateBucket) ID() string {
513 return "OperationSerializer"
514 }
515
516 func (m *awsAwsjson11_serializeOpCreateBucket) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
517 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
518 ) {
519 _, span := tracing.StartSpan(ctx, "OperationSerializer")
520 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
521 defer endTimer()
522 defer span.End()
523 request, ok := in.Request.(*smithyhttp.Request)
524 if !ok {
525 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
526 }
527
528 input, ok := in.Parameters.(*CreateBucketInput)
529 _ = input
530 if !ok {
531 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
532 }
533
534 operationPath := "/"
535 if len(request.Request.URL.Path) == 0 {
536 request.Request.URL.Path = operationPath
537 } else {
538 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
539 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
540 request.Request.URL.Path += "/"
541 }
542 }
543 request.Request.Method = "POST"
544 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
545 if err != nil {
546 return out, metadata, &smithy.SerializationError{Err: err}
547 }
548 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
549 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateBucket")
550
551 jsonEncoder := smithyjson.NewEncoder()
552 if err := awsAwsjson11_serializeOpDocumentCreateBucketInput(input, jsonEncoder.Value); err != nil {
553 return out, metadata, &smithy.SerializationError{Err: err}
554 }
555
556 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
557 return out, metadata, &smithy.SerializationError{Err: err}
558 }
559
560 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
561 return out, metadata, &smithy.SerializationError{Err: err}
562 }
563 in.Request = request
564
565 endTimer()
566 span.End()
567 return next.HandleSerialize(ctx, in)
568 }
569
570 type awsAwsjson11_serializeOpCreateBucketAccessKey struct {
571 }
572
573 func (*awsAwsjson11_serializeOpCreateBucketAccessKey) ID() string {
574 return "OperationSerializer"
575 }
576
577 func (m *awsAwsjson11_serializeOpCreateBucketAccessKey) 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.(*CreateBucketAccessKeyInput)
590 _ = input
591 if !ok {
592 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
593 }
594
595 operationPath := "/"
596 if len(request.Request.URL.Path) == 0 {
597 request.Request.URL.Path = operationPath
598 } else {
599 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
600 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
601 request.Request.URL.Path += "/"
602 }
603 }
604 request.Request.Method = "POST"
605 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
606 if err != nil {
607 return out, metadata, &smithy.SerializationError{Err: err}
608 }
609 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
610 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateBucketAccessKey")
611
612 jsonEncoder := smithyjson.NewEncoder()
613 if err := awsAwsjson11_serializeOpDocumentCreateBucketAccessKeyInput(input, jsonEncoder.Value); err != nil {
614 return out, metadata, &smithy.SerializationError{Err: err}
615 }
616
617 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
618 return out, metadata, &smithy.SerializationError{Err: err}
619 }
620
621 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
622 return out, metadata, &smithy.SerializationError{Err: err}
623 }
624 in.Request = request
625
626 endTimer()
627 span.End()
628 return next.HandleSerialize(ctx, in)
629 }
630
631 type awsAwsjson11_serializeOpCreateCertificate struct {
632 }
633
634 func (*awsAwsjson11_serializeOpCreateCertificate) ID() string {
635 return "OperationSerializer"
636 }
637
638 func (m *awsAwsjson11_serializeOpCreateCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
639 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
640 ) {
641 _, span := tracing.StartSpan(ctx, "OperationSerializer")
642 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
643 defer endTimer()
644 defer span.End()
645 request, ok := in.Request.(*smithyhttp.Request)
646 if !ok {
647 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
648 }
649
650 input, ok := in.Parameters.(*CreateCertificateInput)
651 _ = input
652 if !ok {
653 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
654 }
655
656 operationPath := "/"
657 if len(request.Request.URL.Path) == 0 {
658 request.Request.URL.Path = operationPath
659 } else {
660 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
661 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
662 request.Request.URL.Path += "/"
663 }
664 }
665 request.Request.Method = "POST"
666 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
667 if err != nil {
668 return out, metadata, &smithy.SerializationError{Err: err}
669 }
670 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
671 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateCertificate")
672
673 jsonEncoder := smithyjson.NewEncoder()
674 if err := awsAwsjson11_serializeOpDocumentCreateCertificateInput(input, jsonEncoder.Value); err != nil {
675 return out, metadata, &smithy.SerializationError{Err: err}
676 }
677
678 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
679 return out, metadata, &smithy.SerializationError{Err: err}
680 }
681
682 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
683 return out, metadata, &smithy.SerializationError{Err: err}
684 }
685 in.Request = request
686
687 endTimer()
688 span.End()
689 return next.HandleSerialize(ctx, in)
690 }
691
692 type awsAwsjson11_serializeOpCreateCloudFormationStack struct {
693 }
694
695 func (*awsAwsjson11_serializeOpCreateCloudFormationStack) ID() string {
696 return "OperationSerializer"
697 }
698
699 func (m *awsAwsjson11_serializeOpCreateCloudFormationStack) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
700 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
701 ) {
702 _, span := tracing.StartSpan(ctx, "OperationSerializer")
703 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
704 defer endTimer()
705 defer span.End()
706 request, ok := in.Request.(*smithyhttp.Request)
707 if !ok {
708 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
709 }
710
711 input, ok := in.Parameters.(*CreateCloudFormationStackInput)
712 _ = input
713 if !ok {
714 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
715 }
716
717 operationPath := "/"
718 if len(request.Request.URL.Path) == 0 {
719 request.Request.URL.Path = operationPath
720 } else {
721 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
722 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
723 request.Request.URL.Path += "/"
724 }
725 }
726 request.Request.Method = "POST"
727 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
728 if err != nil {
729 return out, metadata, &smithy.SerializationError{Err: err}
730 }
731 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
732 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateCloudFormationStack")
733
734 jsonEncoder := smithyjson.NewEncoder()
735 if err := awsAwsjson11_serializeOpDocumentCreateCloudFormationStackInput(input, jsonEncoder.Value); err != nil {
736 return out, metadata, &smithy.SerializationError{Err: err}
737 }
738
739 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
740 return out, metadata, &smithy.SerializationError{Err: err}
741 }
742
743 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
744 return out, metadata, &smithy.SerializationError{Err: err}
745 }
746 in.Request = request
747
748 endTimer()
749 span.End()
750 return next.HandleSerialize(ctx, in)
751 }
752
753 type awsAwsjson11_serializeOpCreateContactMethod struct {
754 }
755
756 func (*awsAwsjson11_serializeOpCreateContactMethod) ID() string {
757 return "OperationSerializer"
758 }
759
760 func (m *awsAwsjson11_serializeOpCreateContactMethod) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
761 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
762 ) {
763 _, span := tracing.StartSpan(ctx, "OperationSerializer")
764 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
765 defer endTimer()
766 defer span.End()
767 request, ok := in.Request.(*smithyhttp.Request)
768 if !ok {
769 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
770 }
771
772 input, ok := in.Parameters.(*CreateContactMethodInput)
773 _ = input
774 if !ok {
775 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
776 }
777
778 operationPath := "/"
779 if len(request.Request.URL.Path) == 0 {
780 request.Request.URL.Path = operationPath
781 } else {
782 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
783 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
784 request.Request.URL.Path += "/"
785 }
786 }
787 request.Request.Method = "POST"
788 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
789 if err != nil {
790 return out, metadata, &smithy.SerializationError{Err: err}
791 }
792 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
793 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateContactMethod")
794
795 jsonEncoder := smithyjson.NewEncoder()
796 if err := awsAwsjson11_serializeOpDocumentCreateContactMethodInput(input, jsonEncoder.Value); err != nil {
797 return out, metadata, &smithy.SerializationError{Err: err}
798 }
799
800 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
801 return out, metadata, &smithy.SerializationError{Err: err}
802 }
803
804 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
805 return out, metadata, &smithy.SerializationError{Err: err}
806 }
807 in.Request = request
808
809 endTimer()
810 span.End()
811 return next.HandleSerialize(ctx, in)
812 }
813
814 type awsAwsjson11_serializeOpCreateContainerService struct {
815 }
816
817 func (*awsAwsjson11_serializeOpCreateContainerService) ID() string {
818 return "OperationSerializer"
819 }
820
821 func (m *awsAwsjson11_serializeOpCreateContainerService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
822 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
823 ) {
824 _, span := tracing.StartSpan(ctx, "OperationSerializer")
825 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
826 defer endTimer()
827 defer span.End()
828 request, ok := in.Request.(*smithyhttp.Request)
829 if !ok {
830 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
831 }
832
833 input, ok := in.Parameters.(*CreateContainerServiceInput)
834 _ = input
835 if !ok {
836 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
837 }
838
839 operationPath := "/"
840 if len(request.Request.URL.Path) == 0 {
841 request.Request.URL.Path = operationPath
842 } else {
843 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
844 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
845 request.Request.URL.Path += "/"
846 }
847 }
848 request.Request.Method = "POST"
849 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
850 if err != nil {
851 return out, metadata, &smithy.SerializationError{Err: err}
852 }
853 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
854 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateContainerService")
855
856 jsonEncoder := smithyjson.NewEncoder()
857 if err := awsAwsjson11_serializeOpDocumentCreateContainerServiceInput(input, jsonEncoder.Value); err != nil {
858 return out, metadata, &smithy.SerializationError{Err: err}
859 }
860
861 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
862 return out, metadata, &smithy.SerializationError{Err: err}
863 }
864
865 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
866 return out, metadata, &smithy.SerializationError{Err: err}
867 }
868 in.Request = request
869
870 endTimer()
871 span.End()
872 return next.HandleSerialize(ctx, in)
873 }
874
875 type awsAwsjson11_serializeOpCreateContainerServiceDeployment struct {
876 }
877
878 func (*awsAwsjson11_serializeOpCreateContainerServiceDeployment) ID() string {
879 return "OperationSerializer"
880 }
881
882 func (m *awsAwsjson11_serializeOpCreateContainerServiceDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
883 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
884 ) {
885 _, span := tracing.StartSpan(ctx, "OperationSerializer")
886 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
887 defer endTimer()
888 defer span.End()
889 request, ok := in.Request.(*smithyhttp.Request)
890 if !ok {
891 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
892 }
893
894 input, ok := in.Parameters.(*CreateContainerServiceDeploymentInput)
895 _ = input
896 if !ok {
897 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
898 }
899
900 operationPath := "/"
901 if len(request.Request.URL.Path) == 0 {
902 request.Request.URL.Path = operationPath
903 } else {
904 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
905 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
906 request.Request.URL.Path += "/"
907 }
908 }
909 request.Request.Method = "POST"
910 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
911 if err != nil {
912 return out, metadata, &smithy.SerializationError{Err: err}
913 }
914 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
915 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateContainerServiceDeployment")
916
917 jsonEncoder := smithyjson.NewEncoder()
918 if err := awsAwsjson11_serializeOpDocumentCreateContainerServiceDeploymentInput(input, jsonEncoder.Value); err != nil {
919 return out, metadata, &smithy.SerializationError{Err: err}
920 }
921
922 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
923 return out, metadata, &smithy.SerializationError{Err: err}
924 }
925
926 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
927 return out, metadata, &smithy.SerializationError{Err: err}
928 }
929 in.Request = request
930
931 endTimer()
932 span.End()
933 return next.HandleSerialize(ctx, in)
934 }
935
936 type awsAwsjson11_serializeOpCreateContainerServiceRegistryLogin struct {
937 }
938
939 func (*awsAwsjson11_serializeOpCreateContainerServiceRegistryLogin) ID() string {
940 return "OperationSerializer"
941 }
942
943 func (m *awsAwsjson11_serializeOpCreateContainerServiceRegistryLogin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
944 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
945 ) {
946 _, span := tracing.StartSpan(ctx, "OperationSerializer")
947 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
948 defer endTimer()
949 defer span.End()
950 request, ok := in.Request.(*smithyhttp.Request)
951 if !ok {
952 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
953 }
954
955 input, ok := in.Parameters.(*CreateContainerServiceRegistryLoginInput)
956 _ = input
957 if !ok {
958 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
959 }
960
961 operationPath := "/"
962 if len(request.Request.URL.Path) == 0 {
963 request.Request.URL.Path = operationPath
964 } else {
965 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
966 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
967 request.Request.URL.Path += "/"
968 }
969 }
970 request.Request.Method = "POST"
971 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
972 if err != nil {
973 return out, metadata, &smithy.SerializationError{Err: err}
974 }
975 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
976 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateContainerServiceRegistryLogin")
977
978 jsonEncoder := smithyjson.NewEncoder()
979 if err := awsAwsjson11_serializeOpDocumentCreateContainerServiceRegistryLoginInput(input, jsonEncoder.Value); err != nil {
980 return out, metadata, &smithy.SerializationError{Err: err}
981 }
982
983 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
984 return out, metadata, &smithy.SerializationError{Err: err}
985 }
986
987 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
988 return out, metadata, &smithy.SerializationError{Err: err}
989 }
990 in.Request = request
991
992 endTimer()
993 span.End()
994 return next.HandleSerialize(ctx, in)
995 }
996
997 type awsAwsjson11_serializeOpCreateDisk struct {
998 }
999
1000 func (*awsAwsjson11_serializeOpCreateDisk) ID() string {
1001 return "OperationSerializer"
1002 }
1003
1004 func (m *awsAwsjson11_serializeOpCreateDisk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1005 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1006 ) {
1007 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1008 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1009 defer endTimer()
1010 defer span.End()
1011 request, ok := in.Request.(*smithyhttp.Request)
1012 if !ok {
1013 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1014 }
1015
1016 input, ok := in.Parameters.(*CreateDiskInput)
1017 _ = input
1018 if !ok {
1019 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1020 }
1021
1022 operationPath := "/"
1023 if len(request.Request.URL.Path) == 0 {
1024 request.Request.URL.Path = operationPath
1025 } else {
1026 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1027 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1028 request.Request.URL.Path += "/"
1029 }
1030 }
1031 request.Request.Method = "POST"
1032 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1033 if err != nil {
1034 return out, metadata, &smithy.SerializationError{Err: err}
1035 }
1036 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1037 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDisk")
1038
1039 jsonEncoder := smithyjson.NewEncoder()
1040 if err := awsAwsjson11_serializeOpDocumentCreateDiskInput(input, jsonEncoder.Value); err != nil {
1041 return out, metadata, &smithy.SerializationError{Err: err}
1042 }
1043
1044 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1045 return out, metadata, &smithy.SerializationError{Err: err}
1046 }
1047
1048 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1049 return out, metadata, &smithy.SerializationError{Err: err}
1050 }
1051 in.Request = request
1052
1053 endTimer()
1054 span.End()
1055 return next.HandleSerialize(ctx, in)
1056 }
1057
1058 type awsAwsjson11_serializeOpCreateDiskFromSnapshot struct {
1059 }
1060
1061 func (*awsAwsjson11_serializeOpCreateDiskFromSnapshot) ID() string {
1062 return "OperationSerializer"
1063 }
1064
1065 func (m *awsAwsjson11_serializeOpCreateDiskFromSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1066 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1067 ) {
1068 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1069 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1070 defer endTimer()
1071 defer span.End()
1072 request, ok := in.Request.(*smithyhttp.Request)
1073 if !ok {
1074 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1075 }
1076
1077 input, ok := in.Parameters.(*CreateDiskFromSnapshotInput)
1078 _ = input
1079 if !ok {
1080 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1081 }
1082
1083 operationPath := "/"
1084 if len(request.Request.URL.Path) == 0 {
1085 request.Request.URL.Path = operationPath
1086 } else {
1087 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1088 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1089 request.Request.URL.Path += "/"
1090 }
1091 }
1092 request.Request.Method = "POST"
1093 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1094 if err != nil {
1095 return out, metadata, &smithy.SerializationError{Err: err}
1096 }
1097 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1098 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDiskFromSnapshot")
1099
1100 jsonEncoder := smithyjson.NewEncoder()
1101 if err := awsAwsjson11_serializeOpDocumentCreateDiskFromSnapshotInput(input, jsonEncoder.Value); err != nil {
1102 return out, metadata, &smithy.SerializationError{Err: err}
1103 }
1104
1105 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1106 return out, metadata, &smithy.SerializationError{Err: err}
1107 }
1108
1109 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1110 return out, metadata, &smithy.SerializationError{Err: err}
1111 }
1112 in.Request = request
1113
1114 endTimer()
1115 span.End()
1116 return next.HandleSerialize(ctx, in)
1117 }
1118
1119 type awsAwsjson11_serializeOpCreateDiskSnapshot struct {
1120 }
1121
1122 func (*awsAwsjson11_serializeOpCreateDiskSnapshot) ID() string {
1123 return "OperationSerializer"
1124 }
1125
1126 func (m *awsAwsjson11_serializeOpCreateDiskSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1127 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1128 ) {
1129 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1130 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1131 defer endTimer()
1132 defer span.End()
1133 request, ok := in.Request.(*smithyhttp.Request)
1134 if !ok {
1135 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1136 }
1137
1138 input, ok := in.Parameters.(*CreateDiskSnapshotInput)
1139 _ = input
1140 if !ok {
1141 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1142 }
1143
1144 operationPath := "/"
1145 if len(request.Request.URL.Path) == 0 {
1146 request.Request.URL.Path = operationPath
1147 } else {
1148 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1149 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1150 request.Request.URL.Path += "/"
1151 }
1152 }
1153 request.Request.Method = "POST"
1154 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1155 if err != nil {
1156 return out, metadata, &smithy.SerializationError{Err: err}
1157 }
1158 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1159 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDiskSnapshot")
1160
1161 jsonEncoder := smithyjson.NewEncoder()
1162 if err := awsAwsjson11_serializeOpDocumentCreateDiskSnapshotInput(input, jsonEncoder.Value); err != nil {
1163 return out, metadata, &smithy.SerializationError{Err: err}
1164 }
1165
1166 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1167 return out, metadata, &smithy.SerializationError{Err: err}
1168 }
1169
1170 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1171 return out, metadata, &smithy.SerializationError{Err: err}
1172 }
1173 in.Request = request
1174
1175 endTimer()
1176 span.End()
1177 return next.HandleSerialize(ctx, in)
1178 }
1179
1180 type awsAwsjson11_serializeOpCreateDistribution struct {
1181 }
1182
1183 func (*awsAwsjson11_serializeOpCreateDistribution) ID() string {
1184 return "OperationSerializer"
1185 }
1186
1187 func (m *awsAwsjson11_serializeOpCreateDistribution) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1188 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1189 ) {
1190 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1191 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1192 defer endTimer()
1193 defer span.End()
1194 request, ok := in.Request.(*smithyhttp.Request)
1195 if !ok {
1196 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1197 }
1198
1199 input, ok := in.Parameters.(*CreateDistributionInput)
1200 _ = input
1201 if !ok {
1202 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1203 }
1204
1205 operationPath := "/"
1206 if len(request.Request.URL.Path) == 0 {
1207 request.Request.URL.Path = operationPath
1208 } else {
1209 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1210 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1211 request.Request.URL.Path += "/"
1212 }
1213 }
1214 request.Request.Method = "POST"
1215 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1216 if err != nil {
1217 return out, metadata, &smithy.SerializationError{Err: err}
1218 }
1219 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1220 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDistribution")
1221
1222 jsonEncoder := smithyjson.NewEncoder()
1223 if err := awsAwsjson11_serializeOpDocumentCreateDistributionInput(input, jsonEncoder.Value); err != nil {
1224 return out, metadata, &smithy.SerializationError{Err: err}
1225 }
1226
1227 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1228 return out, metadata, &smithy.SerializationError{Err: err}
1229 }
1230
1231 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1232 return out, metadata, &smithy.SerializationError{Err: err}
1233 }
1234 in.Request = request
1235
1236 endTimer()
1237 span.End()
1238 return next.HandleSerialize(ctx, in)
1239 }
1240
1241 type awsAwsjson11_serializeOpCreateDomain struct {
1242 }
1243
1244 func (*awsAwsjson11_serializeOpCreateDomain) ID() string {
1245 return "OperationSerializer"
1246 }
1247
1248 func (m *awsAwsjson11_serializeOpCreateDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1249 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1250 ) {
1251 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1252 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1253 defer endTimer()
1254 defer span.End()
1255 request, ok := in.Request.(*smithyhttp.Request)
1256 if !ok {
1257 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1258 }
1259
1260 input, ok := in.Parameters.(*CreateDomainInput)
1261 _ = input
1262 if !ok {
1263 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1264 }
1265
1266 operationPath := "/"
1267 if len(request.Request.URL.Path) == 0 {
1268 request.Request.URL.Path = operationPath
1269 } else {
1270 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1271 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1272 request.Request.URL.Path += "/"
1273 }
1274 }
1275 request.Request.Method = "POST"
1276 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1277 if err != nil {
1278 return out, metadata, &smithy.SerializationError{Err: err}
1279 }
1280 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1281 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDomain")
1282
1283 jsonEncoder := smithyjson.NewEncoder()
1284 if err := awsAwsjson11_serializeOpDocumentCreateDomainInput(input, jsonEncoder.Value); err != nil {
1285 return out, metadata, &smithy.SerializationError{Err: err}
1286 }
1287
1288 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1289 return out, metadata, &smithy.SerializationError{Err: err}
1290 }
1291
1292 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1293 return out, metadata, &smithy.SerializationError{Err: err}
1294 }
1295 in.Request = request
1296
1297 endTimer()
1298 span.End()
1299 return next.HandleSerialize(ctx, in)
1300 }
1301
1302 type awsAwsjson11_serializeOpCreateDomainEntry struct {
1303 }
1304
1305 func (*awsAwsjson11_serializeOpCreateDomainEntry) ID() string {
1306 return "OperationSerializer"
1307 }
1308
1309 func (m *awsAwsjson11_serializeOpCreateDomainEntry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1310 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1311 ) {
1312 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1313 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1314 defer endTimer()
1315 defer span.End()
1316 request, ok := in.Request.(*smithyhttp.Request)
1317 if !ok {
1318 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1319 }
1320
1321 input, ok := in.Parameters.(*CreateDomainEntryInput)
1322 _ = input
1323 if !ok {
1324 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1325 }
1326
1327 operationPath := "/"
1328 if len(request.Request.URL.Path) == 0 {
1329 request.Request.URL.Path = operationPath
1330 } else {
1331 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1332 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1333 request.Request.URL.Path += "/"
1334 }
1335 }
1336 request.Request.Method = "POST"
1337 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1338 if err != nil {
1339 return out, metadata, &smithy.SerializationError{Err: err}
1340 }
1341 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1342 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDomainEntry")
1343
1344 jsonEncoder := smithyjson.NewEncoder()
1345 if err := awsAwsjson11_serializeOpDocumentCreateDomainEntryInput(input, jsonEncoder.Value); err != nil {
1346 return out, metadata, &smithy.SerializationError{Err: err}
1347 }
1348
1349 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1350 return out, metadata, &smithy.SerializationError{Err: err}
1351 }
1352
1353 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1354 return out, metadata, &smithy.SerializationError{Err: err}
1355 }
1356 in.Request = request
1357
1358 endTimer()
1359 span.End()
1360 return next.HandleSerialize(ctx, in)
1361 }
1362
1363 type awsAwsjson11_serializeOpCreateGUISessionAccessDetails struct {
1364 }
1365
1366 func (*awsAwsjson11_serializeOpCreateGUISessionAccessDetails) ID() string {
1367 return "OperationSerializer"
1368 }
1369
1370 func (m *awsAwsjson11_serializeOpCreateGUISessionAccessDetails) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1371 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1372 ) {
1373 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1374 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1375 defer endTimer()
1376 defer span.End()
1377 request, ok := in.Request.(*smithyhttp.Request)
1378 if !ok {
1379 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1380 }
1381
1382 input, ok := in.Parameters.(*CreateGUISessionAccessDetailsInput)
1383 _ = input
1384 if !ok {
1385 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1386 }
1387
1388 operationPath := "/"
1389 if len(request.Request.URL.Path) == 0 {
1390 request.Request.URL.Path = operationPath
1391 } else {
1392 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1393 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1394 request.Request.URL.Path += "/"
1395 }
1396 }
1397 request.Request.Method = "POST"
1398 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1399 if err != nil {
1400 return out, metadata, &smithy.SerializationError{Err: err}
1401 }
1402 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1403 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateGUISessionAccessDetails")
1404
1405 jsonEncoder := smithyjson.NewEncoder()
1406 if err := awsAwsjson11_serializeOpDocumentCreateGUISessionAccessDetailsInput(input, jsonEncoder.Value); err != nil {
1407 return out, metadata, &smithy.SerializationError{Err: err}
1408 }
1409
1410 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1411 return out, metadata, &smithy.SerializationError{Err: err}
1412 }
1413
1414 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1415 return out, metadata, &smithy.SerializationError{Err: err}
1416 }
1417 in.Request = request
1418
1419 endTimer()
1420 span.End()
1421 return next.HandleSerialize(ctx, in)
1422 }
1423
1424 type awsAwsjson11_serializeOpCreateInstances struct {
1425 }
1426
1427 func (*awsAwsjson11_serializeOpCreateInstances) ID() string {
1428 return "OperationSerializer"
1429 }
1430
1431 func (m *awsAwsjson11_serializeOpCreateInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1432 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1433 ) {
1434 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1435 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1436 defer endTimer()
1437 defer span.End()
1438 request, ok := in.Request.(*smithyhttp.Request)
1439 if !ok {
1440 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1441 }
1442
1443 input, ok := in.Parameters.(*CreateInstancesInput)
1444 _ = input
1445 if !ok {
1446 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1447 }
1448
1449 operationPath := "/"
1450 if len(request.Request.URL.Path) == 0 {
1451 request.Request.URL.Path = operationPath
1452 } else {
1453 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1454 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1455 request.Request.URL.Path += "/"
1456 }
1457 }
1458 request.Request.Method = "POST"
1459 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1460 if err != nil {
1461 return out, metadata, &smithy.SerializationError{Err: err}
1462 }
1463 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1464 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateInstances")
1465
1466 jsonEncoder := smithyjson.NewEncoder()
1467 if err := awsAwsjson11_serializeOpDocumentCreateInstancesInput(input, jsonEncoder.Value); err != nil {
1468 return out, metadata, &smithy.SerializationError{Err: err}
1469 }
1470
1471 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1472 return out, metadata, &smithy.SerializationError{Err: err}
1473 }
1474
1475 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1476 return out, metadata, &smithy.SerializationError{Err: err}
1477 }
1478 in.Request = request
1479
1480 endTimer()
1481 span.End()
1482 return next.HandleSerialize(ctx, in)
1483 }
1484
1485 type awsAwsjson11_serializeOpCreateInstancesFromSnapshot struct {
1486 }
1487
1488 func (*awsAwsjson11_serializeOpCreateInstancesFromSnapshot) ID() string {
1489 return "OperationSerializer"
1490 }
1491
1492 func (m *awsAwsjson11_serializeOpCreateInstancesFromSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1493 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1494 ) {
1495 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1496 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1497 defer endTimer()
1498 defer span.End()
1499 request, ok := in.Request.(*smithyhttp.Request)
1500 if !ok {
1501 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1502 }
1503
1504 input, ok := in.Parameters.(*CreateInstancesFromSnapshotInput)
1505 _ = input
1506 if !ok {
1507 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1508 }
1509
1510 operationPath := "/"
1511 if len(request.Request.URL.Path) == 0 {
1512 request.Request.URL.Path = operationPath
1513 } else {
1514 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1515 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1516 request.Request.URL.Path += "/"
1517 }
1518 }
1519 request.Request.Method = "POST"
1520 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1521 if err != nil {
1522 return out, metadata, &smithy.SerializationError{Err: err}
1523 }
1524 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1525 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateInstancesFromSnapshot")
1526
1527 jsonEncoder := smithyjson.NewEncoder()
1528 if err := awsAwsjson11_serializeOpDocumentCreateInstancesFromSnapshotInput(input, jsonEncoder.Value); err != nil {
1529 return out, metadata, &smithy.SerializationError{Err: err}
1530 }
1531
1532 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1533 return out, metadata, &smithy.SerializationError{Err: err}
1534 }
1535
1536 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1537 return out, metadata, &smithy.SerializationError{Err: err}
1538 }
1539 in.Request = request
1540
1541 endTimer()
1542 span.End()
1543 return next.HandleSerialize(ctx, in)
1544 }
1545
1546 type awsAwsjson11_serializeOpCreateInstanceSnapshot struct {
1547 }
1548
1549 func (*awsAwsjson11_serializeOpCreateInstanceSnapshot) ID() string {
1550 return "OperationSerializer"
1551 }
1552
1553 func (m *awsAwsjson11_serializeOpCreateInstanceSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1554 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1555 ) {
1556 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1557 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1558 defer endTimer()
1559 defer span.End()
1560 request, ok := in.Request.(*smithyhttp.Request)
1561 if !ok {
1562 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1563 }
1564
1565 input, ok := in.Parameters.(*CreateInstanceSnapshotInput)
1566 _ = input
1567 if !ok {
1568 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1569 }
1570
1571 operationPath := "/"
1572 if len(request.Request.URL.Path) == 0 {
1573 request.Request.URL.Path = operationPath
1574 } else {
1575 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1576 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1577 request.Request.URL.Path += "/"
1578 }
1579 }
1580 request.Request.Method = "POST"
1581 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1582 if err != nil {
1583 return out, metadata, &smithy.SerializationError{Err: err}
1584 }
1585 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1586 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateInstanceSnapshot")
1587
1588 jsonEncoder := smithyjson.NewEncoder()
1589 if err := awsAwsjson11_serializeOpDocumentCreateInstanceSnapshotInput(input, jsonEncoder.Value); err != nil {
1590 return out, metadata, &smithy.SerializationError{Err: err}
1591 }
1592
1593 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1594 return out, metadata, &smithy.SerializationError{Err: err}
1595 }
1596
1597 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1598 return out, metadata, &smithy.SerializationError{Err: err}
1599 }
1600 in.Request = request
1601
1602 endTimer()
1603 span.End()
1604 return next.HandleSerialize(ctx, in)
1605 }
1606
1607 type awsAwsjson11_serializeOpCreateKeyPair struct {
1608 }
1609
1610 func (*awsAwsjson11_serializeOpCreateKeyPair) ID() string {
1611 return "OperationSerializer"
1612 }
1613
1614 func (m *awsAwsjson11_serializeOpCreateKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1615 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1616 ) {
1617 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1618 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1619 defer endTimer()
1620 defer span.End()
1621 request, ok := in.Request.(*smithyhttp.Request)
1622 if !ok {
1623 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1624 }
1625
1626 input, ok := in.Parameters.(*CreateKeyPairInput)
1627 _ = input
1628 if !ok {
1629 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1630 }
1631
1632 operationPath := "/"
1633 if len(request.Request.URL.Path) == 0 {
1634 request.Request.URL.Path = operationPath
1635 } else {
1636 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1637 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1638 request.Request.URL.Path += "/"
1639 }
1640 }
1641 request.Request.Method = "POST"
1642 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1643 if err != nil {
1644 return out, metadata, &smithy.SerializationError{Err: err}
1645 }
1646 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1647 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateKeyPair")
1648
1649 jsonEncoder := smithyjson.NewEncoder()
1650 if err := awsAwsjson11_serializeOpDocumentCreateKeyPairInput(input, jsonEncoder.Value); err != nil {
1651 return out, metadata, &smithy.SerializationError{Err: err}
1652 }
1653
1654 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1655 return out, metadata, &smithy.SerializationError{Err: err}
1656 }
1657
1658 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1659 return out, metadata, &smithy.SerializationError{Err: err}
1660 }
1661 in.Request = request
1662
1663 endTimer()
1664 span.End()
1665 return next.HandleSerialize(ctx, in)
1666 }
1667
1668 type awsAwsjson11_serializeOpCreateLoadBalancer struct {
1669 }
1670
1671 func (*awsAwsjson11_serializeOpCreateLoadBalancer) ID() string {
1672 return "OperationSerializer"
1673 }
1674
1675 func (m *awsAwsjson11_serializeOpCreateLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1676 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1677 ) {
1678 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1679 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1680 defer endTimer()
1681 defer span.End()
1682 request, ok := in.Request.(*smithyhttp.Request)
1683 if !ok {
1684 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1685 }
1686
1687 input, ok := in.Parameters.(*CreateLoadBalancerInput)
1688 _ = input
1689 if !ok {
1690 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1691 }
1692
1693 operationPath := "/"
1694 if len(request.Request.URL.Path) == 0 {
1695 request.Request.URL.Path = operationPath
1696 } else {
1697 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1698 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1699 request.Request.URL.Path += "/"
1700 }
1701 }
1702 request.Request.Method = "POST"
1703 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1704 if err != nil {
1705 return out, metadata, &smithy.SerializationError{Err: err}
1706 }
1707 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1708 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateLoadBalancer")
1709
1710 jsonEncoder := smithyjson.NewEncoder()
1711 if err := awsAwsjson11_serializeOpDocumentCreateLoadBalancerInput(input, jsonEncoder.Value); err != nil {
1712 return out, metadata, &smithy.SerializationError{Err: err}
1713 }
1714
1715 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1716 return out, metadata, &smithy.SerializationError{Err: err}
1717 }
1718
1719 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1720 return out, metadata, &smithy.SerializationError{Err: err}
1721 }
1722 in.Request = request
1723
1724 endTimer()
1725 span.End()
1726 return next.HandleSerialize(ctx, in)
1727 }
1728
1729 type awsAwsjson11_serializeOpCreateLoadBalancerTlsCertificate struct {
1730 }
1731
1732 func (*awsAwsjson11_serializeOpCreateLoadBalancerTlsCertificate) ID() string {
1733 return "OperationSerializer"
1734 }
1735
1736 func (m *awsAwsjson11_serializeOpCreateLoadBalancerTlsCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1737 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1738 ) {
1739 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1740 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1741 defer endTimer()
1742 defer span.End()
1743 request, ok := in.Request.(*smithyhttp.Request)
1744 if !ok {
1745 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1746 }
1747
1748 input, ok := in.Parameters.(*CreateLoadBalancerTlsCertificateInput)
1749 _ = input
1750 if !ok {
1751 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1752 }
1753
1754 operationPath := "/"
1755 if len(request.Request.URL.Path) == 0 {
1756 request.Request.URL.Path = operationPath
1757 } else {
1758 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1759 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1760 request.Request.URL.Path += "/"
1761 }
1762 }
1763 request.Request.Method = "POST"
1764 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1765 if err != nil {
1766 return out, metadata, &smithy.SerializationError{Err: err}
1767 }
1768 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1769 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateLoadBalancerTlsCertificate")
1770
1771 jsonEncoder := smithyjson.NewEncoder()
1772 if err := awsAwsjson11_serializeOpDocumentCreateLoadBalancerTlsCertificateInput(input, jsonEncoder.Value); err != nil {
1773 return out, metadata, &smithy.SerializationError{Err: err}
1774 }
1775
1776 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1777 return out, metadata, &smithy.SerializationError{Err: err}
1778 }
1779
1780 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1781 return out, metadata, &smithy.SerializationError{Err: err}
1782 }
1783 in.Request = request
1784
1785 endTimer()
1786 span.End()
1787 return next.HandleSerialize(ctx, in)
1788 }
1789
1790 type awsAwsjson11_serializeOpCreateRelationalDatabase struct {
1791 }
1792
1793 func (*awsAwsjson11_serializeOpCreateRelationalDatabase) ID() string {
1794 return "OperationSerializer"
1795 }
1796
1797 func (m *awsAwsjson11_serializeOpCreateRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1798 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1799 ) {
1800 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1801 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1802 defer endTimer()
1803 defer span.End()
1804 request, ok := in.Request.(*smithyhttp.Request)
1805 if !ok {
1806 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1807 }
1808
1809 input, ok := in.Parameters.(*CreateRelationalDatabaseInput)
1810 _ = input
1811 if !ok {
1812 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1813 }
1814
1815 operationPath := "/"
1816 if len(request.Request.URL.Path) == 0 {
1817 request.Request.URL.Path = operationPath
1818 } else {
1819 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1820 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1821 request.Request.URL.Path += "/"
1822 }
1823 }
1824 request.Request.Method = "POST"
1825 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1826 if err != nil {
1827 return out, metadata, &smithy.SerializationError{Err: err}
1828 }
1829 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1830 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateRelationalDatabase")
1831
1832 jsonEncoder := smithyjson.NewEncoder()
1833 if err := awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
1834 return out, metadata, &smithy.SerializationError{Err: err}
1835 }
1836
1837 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1838 return out, metadata, &smithy.SerializationError{Err: err}
1839 }
1840
1841 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1842 return out, metadata, &smithy.SerializationError{Err: err}
1843 }
1844 in.Request = request
1845
1846 endTimer()
1847 span.End()
1848 return next.HandleSerialize(ctx, in)
1849 }
1850
1851 type awsAwsjson11_serializeOpCreateRelationalDatabaseFromSnapshot struct {
1852 }
1853
1854 func (*awsAwsjson11_serializeOpCreateRelationalDatabaseFromSnapshot) ID() string {
1855 return "OperationSerializer"
1856 }
1857
1858 func (m *awsAwsjson11_serializeOpCreateRelationalDatabaseFromSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1859 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1860 ) {
1861 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1862 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1863 defer endTimer()
1864 defer span.End()
1865 request, ok := in.Request.(*smithyhttp.Request)
1866 if !ok {
1867 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1868 }
1869
1870 input, ok := in.Parameters.(*CreateRelationalDatabaseFromSnapshotInput)
1871 _ = input
1872 if !ok {
1873 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1874 }
1875
1876 operationPath := "/"
1877 if len(request.Request.URL.Path) == 0 {
1878 request.Request.URL.Path = operationPath
1879 } else {
1880 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1881 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1882 request.Request.URL.Path += "/"
1883 }
1884 }
1885 request.Request.Method = "POST"
1886 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1887 if err != nil {
1888 return out, metadata, &smithy.SerializationError{Err: err}
1889 }
1890 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1891 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateRelationalDatabaseFromSnapshot")
1892
1893 jsonEncoder := smithyjson.NewEncoder()
1894 if err := awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseFromSnapshotInput(input, jsonEncoder.Value); err != nil {
1895 return out, metadata, &smithy.SerializationError{Err: err}
1896 }
1897
1898 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1899 return out, metadata, &smithy.SerializationError{Err: err}
1900 }
1901
1902 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1903 return out, metadata, &smithy.SerializationError{Err: err}
1904 }
1905 in.Request = request
1906
1907 endTimer()
1908 span.End()
1909 return next.HandleSerialize(ctx, in)
1910 }
1911
1912 type awsAwsjson11_serializeOpCreateRelationalDatabaseSnapshot struct {
1913 }
1914
1915 func (*awsAwsjson11_serializeOpCreateRelationalDatabaseSnapshot) ID() string {
1916 return "OperationSerializer"
1917 }
1918
1919 func (m *awsAwsjson11_serializeOpCreateRelationalDatabaseSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1920 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1921 ) {
1922 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1923 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1924 defer endTimer()
1925 defer span.End()
1926 request, ok := in.Request.(*smithyhttp.Request)
1927 if !ok {
1928 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1929 }
1930
1931 input, ok := in.Parameters.(*CreateRelationalDatabaseSnapshotInput)
1932 _ = input
1933 if !ok {
1934 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1935 }
1936
1937 operationPath := "/"
1938 if len(request.Request.URL.Path) == 0 {
1939 request.Request.URL.Path = operationPath
1940 } else {
1941 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1942 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1943 request.Request.URL.Path += "/"
1944 }
1945 }
1946 request.Request.Method = "POST"
1947 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1948 if err != nil {
1949 return out, metadata, &smithy.SerializationError{Err: err}
1950 }
1951 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1952 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateRelationalDatabaseSnapshot")
1953
1954 jsonEncoder := smithyjson.NewEncoder()
1955 if err := awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseSnapshotInput(input, jsonEncoder.Value); err != nil {
1956 return out, metadata, &smithy.SerializationError{Err: err}
1957 }
1958
1959 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1960 return out, metadata, &smithy.SerializationError{Err: err}
1961 }
1962
1963 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1964 return out, metadata, &smithy.SerializationError{Err: err}
1965 }
1966 in.Request = request
1967
1968 endTimer()
1969 span.End()
1970 return next.HandleSerialize(ctx, in)
1971 }
1972
1973 type awsAwsjson11_serializeOpDeleteAlarm struct {
1974 }
1975
1976 func (*awsAwsjson11_serializeOpDeleteAlarm) ID() string {
1977 return "OperationSerializer"
1978 }
1979
1980 func (m *awsAwsjson11_serializeOpDeleteAlarm) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1981 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1982 ) {
1983 _, span := tracing.StartSpan(ctx, "OperationSerializer")
1984 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
1985 defer endTimer()
1986 defer span.End()
1987 request, ok := in.Request.(*smithyhttp.Request)
1988 if !ok {
1989 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1990 }
1991
1992 input, ok := in.Parameters.(*DeleteAlarmInput)
1993 _ = input
1994 if !ok {
1995 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1996 }
1997
1998 operationPath := "/"
1999 if len(request.Request.URL.Path) == 0 {
2000 request.Request.URL.Path = operationPath
2001 } else {
2002 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2003 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2004 request.Request.URL.Path += "/"
2005 }
2006 }
2007 request.Request.Method = "POST"
2008 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2009 if err != nil {
2010 return out, metadata, &smithy.SerializationError{Err: err}
2011 }
2012 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2013 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteAlarm")
2014
2015 jsonEncoder := smithyjson.NewEncoder()
2016 if err := awsAwsjson11_serializeOpDocumentDeleteAlarmInput(input, jsonEncoder.Value); err != nil {
2017 return out, metadata, &smithy.SerializationError{Err: err}
2018 }
2019
2020 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2021 return out, metadata, &smithy.SerializationError{Err: err}
2022 }
2023
2024 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2025 return out, metadata, &smithy.SerializationError{Err: err}
2026 }
2027 in.Request = request
2028
2029 endTimer()
2030 span.End()
2031 return next.HandleSerialize(ctx, in)
2032 }
2033
2034 type awsAwsjson11_serializeOpDeleteAutoSnapshot struct {
2035 }
2036
2037 func (*awsAwsjson11_serializeOpDeleteAutoSnapshot) ID() string {
2038 return "OperationSerializer"
2039 }
2040
2041 func (m *awsAwsjson11_serializeOpDeleteAutoSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2042 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2043 ) {
2044 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2045 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2046 defer endTimer()
2047 defer span.End()
2048 request, ok := in.Request.(*smithyhttp.Request)
2049 if !ok {
2050 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2051 }
2052
2053 input, ok := in.Parameters.(*DeleteAutoSnapshotInput)
2054 _ = input
2055 if !ok {
2056 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2057 }
2058
2059 operationPath := "/"
2060 if len(request.Request.URL.Path) == 0 {
2061 request.Request.URL.Path = operationPath
2062 } else {
2063 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2064 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2065 request.Request.URL.Path += "/"
2066 }
2067 }
2068 request.Request.Method = "POST"
2069 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2070 if err != nil {
2071 return out, metadata, &smithy.SerializationError{Err: err}
2072 }
2073 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2074 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteAutoSnapshot")
2075
2076 jsonEncoder := smithyjson.NewEncoder()
2077 if err := awsAwsjson11_serializeOpDocumentDeleteAutoSnapshotInput(input, jsonEncoder.Value); err != nil {
2078 return out, metadata, &smithy.SerializationError{Err: err}
2079 }
2080
2081 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2082 return out, metadata, &smithy.SerializationError{Err: err}
2083 }
2084
2085 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2086 return out, metadata, &smithy.SerializationError{Err: err}
2087 }
2088 in.Request = request
2089
2090 endTimer()
2091 span.End()
2092 return next.HandleSerialize(ctx, in)
2093 }
2094
2095 type awsAwsjson11_serializeOpDeleteBucket struct {
2096 }
2097
2098 func (*awsAwsjson11_serializeOpDeleteBucket) ID() string {
2099 return "OperationSerializer"
2100 }
2101
2102 func (m *awsAwsjson11_serializeOpDeleteBucket) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2103 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2104 ) {
2105 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2106 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2107 defer endTimer()
2108 defer span.End()
2109 request, ok := in.Request.(*smithyhttp.Request)
2110 if !ok {
2111 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2112 }
2113
2114 input, ok := in.Parameters.(*DeleteBucketInput)
2115 _ = input
2116 if !ok {
2117 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2118 }
2119
2120 operationPath := "/"
2121 if len(request.Request.URL.Path) == 0 {
2122 request.Request.URL.Path = operationPath
2123 } else {
2124 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2125 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2126 request.Request.URL.Path += "/"
2127 }
2128 }
2129 request.Request.Method = "POST"
2130 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2131 if err != nil {
2132 return out, metadata, &smithy.SerializationError{Err: err}
2133 }
2134 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2135 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteBucket")
2136
2137 jsonEncoder := smithyjson.NewEncoder()
2138 if err := awsAwsjson11_serializeOpDocumentDeleteBucketInput(input, jsonEncoder.Value); err != nil {
2139 return out, metadata, &smithy.SerializationError{Err: err}
2140 }
2141
2142 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2143 return out, metadata, &smithy.SerializationError{Err: err}
2144 }
2145
2146 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2147 return out, metadata, &smithy.SerializationError{Err: err}
2148 }
2149 in.Request = request
2150
2151 endTimer()
2152 span.End()
2153 return next.HandleSerialize(ctx, in)
2154 }
2155
2156 type awsAwsjson11_serializeOpDeleteBucketAccessKey struct {
2157 }
2158
2159 func (*awsAwsjson11_serializeOpDeleteBucketAccessKey) ID() string {
2160 return "OperationSerializer"
2161 }
2162
2163 func (m *awsAwsjson11_serializeOpDeleteBucketAccessKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2164 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2165 ) {
2166 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2167 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2168 defer endTimer()
2169 defer span.End()
2170 request, ok := in.Request.(*smithyhttp.Request)
2171 if !ok {
2172 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2173 }
2174
2175 input, ok := in.Parameters.(*DeleteBucketAccessKeyInput)
2176 _ = input
2177 if !ok {
2178 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2179 }
2180
2181 operationPath := "/"
2182 if len(request.Request.URL.Path) == 0 {
2183 request.Request.URL.Path = operationPath
2184 } else {
2185 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2186 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2187 request.Request.URL.Path += "/"
2188 }
2189 }
2190 request.Request.Method = "POST"
2191 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2192 if err != nil {
2193 return out, metadata, &smithy.SerializationError{Err: err}
2194 }
2195 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2196 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteBucketAccessKey")
2197
2198 jsonEncoder := smithyjson.NewEncoder()
2199 if err := awsAwsjson11_serializeOpDocumentDeleteBucketAccessKeyInput(input, jsonEncoder.Value); err != nil {
2200 return out, metadata, &smithy.SerializationError{Err: err}
2201 }
2202
2203 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2204 return out, metadata, &smithy.SerializationError{Err: err}
2205 }
2206
2207 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2208 return out, metadata, &smithy.SerializationError{Err: err}
2209 }
2210 in.Request = request
2211
2212 endTimer()
2213 span.End()
2214 return next.HandleSerialize(ctx, in)
2215 }
2216
2217 type awsAwsjson11_serializeOpDeleteCertificate struct {
2218 }
2219
2220 func (*awsAwsjson11_serializeOpDeleteCertificate) ID() string {
2221 return "OperationSerializer"
2222 }
2223
2224 func (m *awsAwsjson11_serializeOpDeleteCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2225 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2226 ) {
2227 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2228 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2229 defer endTimer()
2230 defer span.End()
2231 request, ok := in.Request.(*smithyhttp.Request)
2232 if !ok {
2233 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2234 }
2235
2236 input, ok := in.Parameters.(*DeleteCertificateInput)
2237 _ = input
2238 if !ok {
2239 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2240 }
2241
2242 operationPath := "/"
2243 if len(request.Request.URL.Path) == 0 {
2244 request.Request.URL.Path = operationPath
2245 } else {
2246 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2247 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2248 request.Request.URL.Path += "/"
2249 }
2250 }
2251 request.Request.Method = "POST"
2252 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2253 if err != nil {
2254 return out, metadata, &smithy.SerializationError{Err: err}
2255 }
2256 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2257 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteCertificate")
2258
2259 jsonEncoder := smithyjson.NewEncoder()
2260 if err := awsAwsjson11_serializeOpDocumentDeleteCertificateInput(input, jsonEncoder.Value); err != nil {
2261 return out, metadata, &smithy.SerializationError{Err: err}
2262 }
2263
2264 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2265 return out, metadata, &smithy.SerializationError{Err: err}
2266 }
2267
2268 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2269 return out, metadata, &smithy.SerializationError{Err: err}
2270 }
2271 in.Request = request
2272
2273 endTimer()
2274 span.End()
2275 return next.HandleSerialize(ctx, in)
2276 }
2277
2278 type awsAwsjson11_serializeOpDeleteContactMethod struct {
2279 }
2280
2281 func (*awsAwsjson11_serializeOpDeleteContactMethod) ID() string {
2282 return "OperationSerializer"
2283 }
2284
2285 func (m *awsAwsjson11_serializeOpDeleteContactMethod) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2286 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2287 ) {
2288 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2289 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2290 defer endTimer()
2291 defer span.End()
2292 request, ok := in.Request.(*smithyhttp.Request)
2293 if !ok {
2294 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2295 }
2296
2297 input, ok := in.Parameters.(*DeleteContactMethodInput)
2298 _ = input
2299 if !ok {
2300 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2301 }
2302
2303 operationPath := "/"
2304 if len(request.Request.URL.Path) == 0 {
2305 request.Request.URL.Path = operationPath
2306 } else {
2307 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2308 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2309 request.Request.URL.Path += "/"
2310 }
2311 }
2312 request.Request.Method = "POST"
2313 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2314 if err != nil {
2315 return out, metadata, &smithy.SerializationError{Err: err}
2316 }
2317 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2318 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteContactMethod")
2319
2320 jsonEncoder := smithyjson.NewEncoder()
2321 if err := awsAwsjson11_serializeOpDocumentDeleteContactMethodInput(input, jsonEncoder.Value); err != nil {
2322 return out, metadata, &smithy.SerializationError{Err: err}
2323 }
2324
2325 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2326 return out, metadata, &smithy.SerializationError{Err: err}
2327 }
2328
2329 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2330 return out, metadata, &smithy.SerializationError{Err: err}
2331 }
2332 in.Request = request
2333
2334 endTimer()
2335 span.End()
2336 return next.HandleSerialize(ctx, in)
2337 }
2338
2339 type awsAwsjson11_serializeOpDeleteContainerImage struct {
2340 }
2341
2342 func (*awsAwsjson11_serializeOpDeleteContainerImage) ID() string {
2343 return "OperationSerializer"
2344 }
2345
2346 func (m *awsAwsjson11_serializeOpDeleteContainerImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2347 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2348 ) {
2349 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2350 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2351 defer endTimer()
2352 defer span.End()
2353 request, ok := in.Request.(*smithyhttp.Request)
2354 if !ok {
2355 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2356 }
2357
2358 input, ok := in.Parameters.(*DeleteContainerImageInput)
2359 _ = input
2360 if !ok {
2361 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2362 }
2363
2364 operationPath := "/"
2365 if len(request.Request.URL.Path) == 0 {
2366 request.Request.URL.Path = operationPath
2367 } else {
2368 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2369 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2370 request.Request.URL.Path += "/"
2371 }
2372 }
2373 request.Request.Method = "POST"
2374 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2375 if err != nil {
2376 return out, metadata, &smithy.SerializationError{Err: err}
2377 }
2378 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2379 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteContainerImage")
2380
2381 jsonEncoder := smithyjson.NewEncoder()
2382 if err := awsAwsjson11_serializeOpDocumentDeleteContainerImageInput(input, jsonEncoder.Value); err != nil {
2383 return out, metadata, &smithy.SerializationError{Err: err}
2384 }
2385
2386 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2387 return out, metadata, &smithy.SerializationError{Err: err}
2388 }
2389
2390 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2391 return out, metadata, &smithy.SerializationError{Err: err}
2392 }
2393 in.Request = request
2394
2395 endTimer()
2396 span.End()
2397 return next.HandleSerialize(ctx, in)
2398 }
2399
2400 type awsAwsjson11_serializeOpDeleteContainerService struct {
2401 }
2402
2403 func (*awsAwsjson11_serializeOpDeleteContainerService) ID() string {
2404 return "OperationSerializer"
2405 }
2406
2407 func (m *awsAwsjson11_serializeOpDeleteContainerService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2408 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2409 ) {
2410 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2411 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2412 defer endTimer()
2413 defer span.End()
2414 request, ok := in.Request.(*smithyhttp.Request)
2415 if !ok {
2416 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2417 }
2418
2419 input, ok := in.Parameters.(*DeleteContainerServiceInput)
2420 _ = input
2421 if !ok {
2422 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2423 }
2424
2425 operationPath := "/"
2426 if len(request.Request.URL.Path) == 0 {
2427 request.Request.URL.Path = operationPath
2428 } else {
2429 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2430 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2431 request.Request.URL.Path += "/"
2432 }
2433 }
2434 request.Request.Method = "POST"
2435 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2436 if err != nil {
2437 return out, metadata, &smithy.SerializationError{Err: err}
2438 }
2439 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2440 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteContainerService")
2441
2442 jsonEncoder := smithyjson.NewEncoder()
2443 if err := awsAwsjson11_serializeOpDocumentDeleteContainerServiceInput(input, jsonEncoder.Value); err != nil {
2444 return out, metadata, &smithy.SerializationError{Err: err}
2445 }
2446
2447 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2448 return out, metadata, &smithy.SerializationError{Err: err}
2449 }
2450
2451 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2452 return out, metadata, &smithy.SerializationError{Err: err}
2453 }
2454 in.Request = request
2455
2456 endTimer()
2457 span.End()
2458 return next.HandleSerialize(ctx, in)
2459 }
2460
2461 type awsAwsjson11_serializeOpDeleteDisk struct {
2462 }
2463
2464 func (*awsAwsjson11_serializeOpDeleteDisk) ID() string {
2465 return "OperationSerializer"
2466 }
2467
2468 func (m *awsAwsjson11_serializeOpDeleteDisk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2469 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2470 ) {
2471 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2472 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2473 defer endTimer()
2474 defer span.End()
2475 request, ok := in.Request.(*smithyhttp.Request)
2476 if !ok {
2477 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2478 }
2479
2480 input, ok := in.Parameters.(*DeleteDiskInput)
2481 _ = input
2482 if !ok {
2483 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2484 }
2485
2486 operationPath := "/"
2487 if len(request.Request.URL.Path) == 0 {
2488 request.Request.URL.Path = operationPath
2489 } else {
2490 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2491 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2492 request.Request.URL.Path += "/"
2493 }
2494 }
2495 request.Request.Method = "POST"
2496 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2497 if err != nil {
2498 return out, metadata, &smithy.SerializationError{Err: err}
2499 }
2500 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2501 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteDisk")
2502
2503 jsonEncoder := smithyjson.NewEncoder()
2504 if err := awsAwsjson11_serializeOpDocumentDeleteDiskInput(input, jsonEncoder.Value); err != nil {
2505 return out, metadata, &smithy.SerializationError{Err: err}
2506 }
2507
2508 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2509 return out, metadata, &smithy.SerializationError{Err: err}
2510 }
2511
2512 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2513 return out, metadata, &smithy.SerializationError{Err: err}
2514 }
2515 in.Request = request
2516
2517 endTimer()
2518 span.End()
2519 return next.HandleSerialize(ctx, in)
2520 }
2521
2522 type awsAwsjson11_serializeOpDeleteDiskSnapshot struct {
2523 }
2524
2525 func (*awsAwsjson11_serializeOpDeleteDiskSnapshot) ID() string {
2526 return "OperationSerializer"
2527 }
2528
2529 func (m *awsAwsjson11_serializeOpDeleteDiskSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2530 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2531 ) {
2532 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2533 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2534 defer endTimer()
2535 defer span.End()
2536 request, ok := in.Request.(*smithyhttp.Request)
2537 if !ok {
2538 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2539 }
2540
2541 input, ok := in.Parameters.(*DeleteDiskSnapshotInput)
2542 _ = input
2543 if !ok {
2544 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2545 }
2546
2547 operationPath := "/"
2548 if len(request.Request.URL.Path) == 0 {
2549 request.Request.URL.Path = operationPath
2550 } else {
2551 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2552 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2553 request.Request.URL.Path += "/"
2554 }
2555 }
2556 request.Request.Method = "POST"
2557 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2558 if err != nil {
2559 return out, metadata, &smithy.SerializationError{Err: err}
2560 }
2561 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2562 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteDiskSnapshot")
2563
2564 jsonEncoder := smithyjson.NewEncoder()
2565 if err := awsAwsjson11_serializeOpDocumentDeleteDiskSnapshotInput(input, jsonEncoder.Value); err != nil {
2566 return out, metadata, &smithy.SerializationError{Err: err}
2567 }
2568
2569 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2570 return out, metadata, &smithy.SerializationError{Err: err}
2571 }
2572
2573 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2574 return out, metadata, &smithy.SerializationError{Err: err}
2575 }
2576 in.Request = request
2577
2578 endTimer()
2579 span.End()
2580 return next.HandleSerialize(ctx, in)
2581 }
2582
2583 type awsAwsjson11_serializeOpDeleteDistribution struct {
2584 }
2585
2586 func (*awsAwsjson11_serializeOpDeleteDistribution) ID() string {
2587 return "OperationSerializer"
2588 }
2589
2590 func (m *awsAwsjson11_serializeOpDeleteDistribution) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2591 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2592 ) {
2593 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2594 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2595 defer endTimer()
2596 defer span.End()
2597 request, ok := in.Request.(*smithyhttp.Request)
2598 if !ok {
2599 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2600 }
2601
2602 input, ok := in.Parameters.(*DeleteDistributionInput)
2603 _ = input
2604 if !ok {
2605 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2606 }
2607
2608 operationPath := "/"
2609 if len(request.Request.URL.Path) == 0 {
2610 request.Request.URL.Path = operationPath
2611 } else {
2612 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2613 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2614 request.Request.URL.Path += "/"
2615 }
2616 }
2617 request.Request.Method = "POST"
2618 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2619 if err != nil {
2620 return out, metadata, &smithy.SerializationError{Err: err}
2621 }
2622 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2623 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteDistribution")
2624
2625 jsonEncoder := smithyjson.NewEncoder()
2626 if err := awsAwsjson11_serializeOpDocumentDeleteDistributionInput(input, jsonEncoder.Value); err != nil {
2627 return out, metadata, &smithy.SerializationError{Err: err}
2628 }
2629
2630 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2631 return out, metadata, &smithy.SerializationError{Err: err}
2632 }
2633
2634 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2635 return out, metadata, &smithy.SerializationError{Err: err}
2636 }
2637 in.Request = request
2638
2639 endTimer()
2640 span.End()
2641 return next.HandleSerialize(ctx, in)
2642 }
2643
2644 type awsAwsjson11_serializeOpDeleteDomain struct {
2645 }
2646
2647 func (*awsAwsjson11_serializeOpDeleteDomain) ID() string {
2648 return "OperationSerializer"
2649 }
2650
2651 func (m *awsAwsjson11_serializeOpDeleteDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2652 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2653 ) {
2654 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2655 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2656 defer endTimer()
2657 defer span.End()
2658 request, ok := in.Request.(*smithyhttp.Request)
2659 if !ok {
2660 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2661 }
2662
2663 input, ok := in.Parameters.(*DeleteDomainInput)
2664 _ = input
2665 if !ok {
2666 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2667 }
2668
2669 operationPath := "/"
2670 if len(request.Request.URL.Path) == 0 {
2671 request.Request.URL.Path = operationPath
2672 } else {
2673 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2674 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2675 request.Request.URL.Path += "/"
2676 }
2677 }
2678 request.Request.Method = "POST"
2679 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2680 if err != nil {
2681 return out, metadata, &smithy.SerializationError{Err: err}
2682 }
2683 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2684 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteDomain")
2685
2686 jsonEncoder := smithyjson.NewEncoder()
2687 if err := awsAwsjson11_serializeOpDocumentDeleteDomainInput(input, jsonEncoder.Value); err != nil {
2688 return out, metadata, &smithy.SerializationError{Err: err}
2689 }
2690
2691 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2692 return out, metadata, &smithy.SerializationError{Err: err}
2693 }
2694
2695 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2696 return out, metadata, &smithy.SerializationError{Err: err}
2697 }
2698 in.Request = request
2699
2700 endTimer()
2701 span.End()
2702 return next.HandleSerialize(ctx, in)
2703 }
2704
2705 type awsAwsjson11_serializeOpDeleteDomainEntry struct {
2706 }
2707
2708 func (*awsAwsjson11_serializeOpDeleteDomainEntry) ID() string {
2709 return "OperationSerializer"
2710 }
2711
2712 func (m *awsAwsjson11_serializeOpDeleteDomainEntry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2713 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2714 ) {
2715 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2716 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2717 defer endTimer()
2718 defer span.End()
2719 request, ok := in.Request.(*smithyhttp.Request)
2720 if !ok {
2721 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2722 }
2723
2724 input, ok := in.Parameters.(*DeleteDomainEntryInput)
2725 _ = input
2726 if !ok {
2727 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2728 }
2729
2730 operationPath := "/"
2731 if len(request.Request.URL.Path) == 0 {
2732 request.Request.URL.Path = operationPath
2733 } else {
2734 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2735 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2736 request.Request.URL.Path += "/"
2737 }
2738 }
2739 request.Request.Method = "POST"
2740 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2741 if err != nil {
2742 return out, metadata, &smithy.SerializationError{Err: err}
2743 }
2744 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2745 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteDomainEntry")
2746
2747 jsonEncoder := smithyjson.NewEncoder()
2748 if err := awsAwsjson11_serializeOpDocumentDeleteDomainEntryInput(input, jsonEncoder.Value); err != nil {
2749 return out, metadata, &smithy.SerializationError{Err: err}
2750 }
2751
2752 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2753 return out, metadata, &smithy.SerializationError{Err: err}
2754 }
2755
2756 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2757 return out, metadata, &smithy.SerializationError{Err: err}
2758 }
2759 in.Request = request
2760
2761 endTimer()
2762 span.End()
2763 return next.HandleSerialize(ctx, in)
2764 }
2765
2766 type awsAwsjson11_serializeOpDeleteInstance struct {
2767 }
2768
2769 func (*awsAwsjson11_serializeOpDeleteInstance) ID() string {
2770 return "OperationSerializer"
2771 }
2772
2773 func (m *awsAwsjson11_serializeOpDeleteInstance) 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.(*DeleteInstanceInput)
2786 _ = input
2787 if !ok {
2788 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2789 }
2790
2791 operationPath := "/"
2792 if len(request.Request.URL.Path) == 0 {
2793 request.Request.URL.Path = operationPath
2794 } else {
2795 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2796 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2797 request.Request.URL.Path += "/"
2798 }
2799 }
2800 request.Request.Method = "POST"
2801 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2802 if err != nil {
2803 return out, metadata, &smithy.SerializationError{Err: err}
2804 }
2805 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2806 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteInstance")
2807
2808 jsonEncoder := smithyjson.NewEncoder()
2809 if err := awsAwsjson11_serializeOpDocumentDeleteInstanceInput(input, jsonEncoder.Value); err != nil {
2810 return out, metadata, &smithy.SerializationError{Err: err}
2811 }
2812
2813 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2814 return out, metadata, &smithy.SerializationError{Err: err}
2815 }
2816
2817 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2818 return out, metadata, &smithy.SerializationError{Err: err}
2819 }
2820 in.Request = request
2821
2822 endTimer()
2823 span.End()
2824 return next.HandleSerialize(ctx, in)
2825 }
2826
2827 type awsAwsjson11_serializeOpDeleteInstanceSnapshot struct {
2828 }
2829
2830 func (*awsAwsjson11_serializeOpDeleteInstanceSnapshot) ID() string {
2831 return "OperationSerializer"
2832 }
2833
2834 func (m *awsAwsjson11_serializeOpDeleteInstanceSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2835 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2836 ) {
2837 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2838 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2839 defer endTimer()
2840 defer span.End()
2841 request, ok := in.Request.(*smithyhttp.Request)
2842 if !ok {
2843 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2844 }
2845
2846 input, ok := in.Parameters.(*DeleteInstanceSnapshotInput)
2847 _ = input
2848 if !ok {
2849 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2850 }
2851
2852 operationPath := "/"
2853 if len(request.Request.URL.Path) == 0 {
2854 request.Request.URL.Path = operationPath
2855 } else {
2856 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2857 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2858 request.Request.URL.Path += "/"
2859 }
2860 }
2861 request.Request.Method = "POST"
2862 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2863 if err != nil {
2864 return out, metadata, &smithy.SerializationError{Err: err}
2865 }
2866 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2867 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteInstanceSnapshot")
2868
2869 jsonEncoder := smithyjson.NewEncoder()
2870 if err := awsAwsjson11_serializeOpDocumentDeleteInstanceSnapshotInput(input, jsonEncoder.Value); err != nil {
2871 return out, metadata, &smithy.SerializationError{Err: err}
2872 }
2873
2874 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2875 return out, metadata, &smithy.SerializationError{Err: err}
2876 }
2877
2878 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2879 return out, metadata, &smithy.SerializationError{Err: err}
2880 }
2881 in.Request = request
2882
2883 endTimer()
2884 span.End()
2885 return next.HandleSerialize(ctx, in)
2886 }
2887
2888 type awsAwsjson11_serializeOpDeleteKeyPair struct {
2889 }
2890
2891 func (*awsAwsjson11_serializeOpDeleteKeyPair) ID() string {
2892 return "OperationSerializer"
2893 }
2894
2895 func (m *awsAwsjson11_serializeOpDeleteKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2896 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2897 ) {
2898 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2899 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2900 defer endTimer()
2901 defer span.End()
2902 request, ok := in.Request.(*smithyhttp.Request)
2903 if !ok {
2904 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2905 }
2906
2907 input, ok := in.Parameters.(*DeleteKeyPairInput)
2908 _ = input
2909 if !ok {
2910 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2911 }
2912
2913 operationPath := "/"
2914 if len(request.Request.URL.Path) == 0 {
2915 request.Request.URL.Path = operationPath
2916 } else {
2917 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2918 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2919 request.Request.URL.Path += "/"
2920 }
2921 }
2922 request.Request.Method = "POST"
2923 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2924 if err != nil {
2925 return out, metadata, &smithy.SerializationError{Err: err}
2926 }
2927 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2928 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteKeyPair")
2929
2930 jsonEncoder := smithyjson.NewEncoder()
2931 if err := awsAwsjson11_serializeOpDocumentDeleteKeyPairInput(input, jsonEncoder.Value); err != nil {
2932 return out, metadata, &smithy.SerializationError{Err: err}
2933 }
2934
2935 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2936 return out, metadata, &smithy.SerializationError{Err: err}
2937 }
2938
2939 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2940 return out, metadata, &smithy.SerializationError{Err: err}
2941 }
2942 in.Request = request
2943
2944 endTimer()
2945 span.End()
2946 return next.HandleSerialize(ctx, in)
2947 }
2948
2949 type awsAwsjson11_serializeOpDeleteKnownHostKeys struct {
2950 }
2951
2952 func (*awsAwsjson11_serializeOpDeleteKnownHostKeys) ID() string {
2953 return "OperationSerializer"
2954 }
2955
2956 func (m *awsAwsjson11_serializeOpDeleteKnownHostKeys) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2957 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2958 ) {
2959 _, span := tracing.StartSpan(ctx, "OperationSerializer")
2960 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
2961 defer endTimer()
2962 defer span.End()
2963 request, ok := in.Request.(*smithyhttp.Request)
2964 if !ok {
2965 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2966 }
2967
2968 input, ok := in.Parameters.(*DeleteKnownHostKeysInput)
2969 _ = input
2970 if !ok {
2971 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2972 }
2973
2974 operationPath := "/"
2975 if len(request.Request.URL.Path) == 0 {
2976 request.Request.URL.Path = operationPath
2977 } else {
2978 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2979 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2980 request.Request.URL.Path += "/"
2981 }
2982 }
2983 request.Request.Method = "POST"
2984 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2985 if err != nil {
2986 return out, metadata, &smithy.SerializationError{Err: err}
2987 }
2988 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2989 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteKnownHostKeys")
2990
2991 jsonEncoder := smithyjson.NewEncoder()
2992 if err := awsAwsjson11_serializeOpDocumentDeleteKnownHostKeysInput(input, jsonEncoder.Value); err != nil {
2993 return out, metadata, &smithy.SerializationError{Err: err}
2994 }
2995
2996 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2997 return out, metadata, &smithy.SerializationError{Err: err}
2998 }
2999
3000 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3001 return out, metadata, &smithy.SerializationError{Err: err}
3002 }
3003 in.Request = request
3004
3005 endTimer()
3006 span.End()
3007 return next.HandleSerialize(ctx, in)
3008 }
3009
3010 type awsAwsjson11_serializeOpDeleteLoadBalancer struct {
3011 }
3012
3013 func (*awsAwsjson11_serializeOpDeleteLoadBalancer) ID() string {
3014 return "OperationSerializer"
3015 }
3016
3017 func (m *awsAwsjson11_serializeOpDeleteLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3018 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3019 ) {
3020 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3021 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3022 defer endTimer()
3023 defer span.End()
3024 request, ok := in.Request.(*smithyhttp.Request)
3025 if !ok {
3026 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3027 }
3028
3029 input, ok := in.Parameters.(*DeleteLoadBalancerInput)
3030 _ = input
3031 if !ok {
3032 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3033 }
3034
3035 operationPath := "/"
3036 if len(request.Request.URL.Path) == 0 {
3037 request.Request.URL.Path = operationPath
3038 } else {
3039 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3040 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3041 request.Request.URL.Path += "/"
3042 }
3043 }
3044 request.Request.Method = "POST"
3045 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3046 if err != nil {
3047 return out, metadata, &smithy.SerializationError{Err: err}
3048 }
3049 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3050 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteLoadBalancer")
3051
3052 jsonEncoder := smithyjson.NewEncoder()
3053 if err := awsAwsjson11_serializeOpDocumentDeleteLoadBalancerInput(input, jsonEncoder.Value); err != nil {
3054 return out, metadata, &smithy.SerializationError{Err: err}
3055 }
3056
3057 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3058 return out, metadata, &smithy.SerializationError{Err: err}
3059 }
3060
3061 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3062 return out, metadata, &smithy.SerializationError{Err: err}
3063 }
3064 in.Request = request
3065
3066 endTimer()
3067 span.End()
3068 return next.HandleSerialize(ctx, in)
3069 }
3070
3071 type awsAwsjson11_serializeOpDeleteLoadBalancerTlsCertificate struct {
3072 }
3073
3074 func (*awsAwsjson11_serializeOpDeleteLoadBalancerTlsCertificate) ID() string {
3075 return "OperationSerializer"
3076 }
3077
3078 func (m *awsAwsjson11_serializeOpDeleteLoadBalancerTlsCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3079 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3080 ) {
3081 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3082 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3083 defer endTimer()
3084 defer span.End()
3085 request, ok := in.Request.(*smithyhttp.Request)
3086 if !ok {
3087 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3088 }
3089
3090 input, ok := in.Parameters.(*DeleteLoadBalancerTlsCertificateInput)
3091 _ = input
3092 if !ok {
3093 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3094 }
3095
3096 operationPath := "/"
3097 if len(request.Request.URL.Path) == 0 {
3098 request.Request.URL.Path = operationPath
3099 } else {
3100 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3101 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3102 request.Request.URL.Path += "/"
3103 }
3104 }
3105 request.Request.Method = "POST"
3106 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3107 if err != nil {
3108 return out, metadata, &smithy.SerializationError{Err: err}
3109 }
3110 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3111 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteLoadBalancerTlsCertificate")
3112
3113 jsonEncoder := smithyjson.NewEncoder()
3114 if err := awsAwsjson11_serializeOpDocumentDeleteLoadBalancerTlsCertificateInput(input, jsonEncoder.Value); err != nil {
3115 return out, metadata, &smithy.SerializationError{Err: err}
3116 }
3117
3118 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3119 return out, metadata, &smithy.SerializationError{Err: err}
3120 }
3121
3122 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3123 return out, metadata, &smithy.SerializationError{Err: err}
3124 }
3125 in.Request = request
3126
3127 endTimer()
3128 span.End()
3129 return next.HandleSerialize(ctx, in)
3130 }
3131
3132 type awsAwsjson11_serializeOpDeleteRelationalDatabase struct {
3133 }
3134
3135 func (*awsAwsjson11_serializeOpDeleteRelationalDatabase) ID() string {
3136 return "OperationSerializer"
3137 }
3138
3139 func (m *awsAwsjson11_serializeOpDeleteRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3140 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3141 ) {
3142 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3143 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3144 defer endTimer()
3145 defer span.End()
3146 request, ok := in.Request.(*smithyhttp.Request)
3147 if !ok {
3148 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3149 }
3150
3151 input, ok := in.Parameters.(*DeleteRelationalDatabaseInput)
3152 _ = input
3153 if !ok {
3154 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3155 }
3156
3157 operationPath := "/"
3158 if len(request.Request.URL.Path) == 0 {
3159 request.Request.URL.Path = operationPath
3160 } else {
3161 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3162 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3163 request.Request.URL.Path += "/"
3164 }
3165 }
3166 request.Request.Method = "POST"
3167 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3168 if err != nil {
3169 return out, metadata, &smithy.SerializationError{Err: err}
3170 }
3171 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3172 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteRelationalDatabase")
3173
3174 jsonEncoder := smithyjson.NewEncoder()
3175 if err := awsAwsjson11_serializeOpDocumentDeleteRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
3176 return out, metadata, &smithy.SerializationError{Err: err}
3177 }
3178
3179 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3180 return out, metadata, &smithy.SerializationError{Err: err}
3181 }
3182
3183 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3184 return out, metadata, &smithy.SerializationError{Err: err}
3185 }
3186 in.Request = request
3187
3188 endTimer()
3189 span.End()
3190 return next.HandleSerialize(ctx, in)
3191 }
3192
3193 type awsAwsjson11_serializeOpDeleteRelationalDatabaseSnapshot struct {
3194 }
3195
3196 func (*awsAwsjson11_serializeOpDeleteRelationalDatabaseSnapshot) ID() string {
3197 return "OperationSerializer"
3198 }
3199
3200 func (m *awsAwsjson11_serializeOpDeleteRelationalDatabaseSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3201 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3202 ) {
3203 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3204 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3205 defer endTimer()
3206 defer span.End()
3207 request, ok := in.Request.(*smithyhttp.Request)
3208 if !ok {
3209 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3210 }
3211
3212 input, ok := in.Parameters.(*DeleteRelationalDatabaseSnapshotInput)
3213 _ = input
3214 if !ok {
3215 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3216 }
3217
3218 operationPath := "/"
3219 if len(request.Request.URL.Path) == 0 {
3220 request.Request.URL.Path = operationPath
3221 } else {
3222 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3223 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3224 request.Request.URL.Path += "/"
3225 }
3226 }
3227 request.Request.Method = "POST"
3228 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3229 if err != nil {
3230 return out, metadata, &smithy.SerializationError{Err: err}
3231 }
3232 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3233 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteRelationalDatabaseSnapshot")
3234
3235 jsonEncoder := smithyjson.NewEncoder()
3236 if err := awsAwsjson11_serializeOpDocumentDeleteRelationalDatabaseSnapshotInput(input, jsonEncoder.Value); err != nil {
3237 return out, metadata, &smithy.SerializationError{Err: err}
3238 }
3239
3240 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3241 return out, metadata, &smithy.SerializationError{Err: err}
3242 }
3243
3244 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3245 return out, metadata, &smithy.SerializationError{Err: err}
3246 }
3247 in.Request = request
3248
3249 endTimer()
3250 span.End()
3251 return next.HandleSerialize(ctx, in)
3252 }
3253
3254 type awsAwsjson11_serializeOpDetachCertificateFromDistribution struct {
3255 }
3256
3257 func (*awsAwsjson11_serializeOpDetachCertificateFromDistribution) ID() string {
3258 return "OperationSerializer"
3259 }
3260
3261 func (m *awsAwsjson11_serializeOpDetachCertificateFromDistribution) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3262 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3263 ) {
3264 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3265 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3266 defer endTimer()
3267 defer span.End()
3268 request, ok := in.Request.(*smithyhttp.Request)
3269 if !ok {
3270 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3271 }
3272
3273 input, ok := in.Parameters.(*DetachCertificateFromDistributionInput)
3274 _ = input
3275 if !ok {
3276 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3277 }
3278
3279 operationPath := "/"
3280 if len(request.Request.URL.Path) == 0 {
3281 request.Request.URL.Path = operationPath
3282 } else {
3283 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3284 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3285 request.Request.URL.Path += "/"
3286 }
3287 }
3288 request.Request.Method = "POST"
3289 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3290 if err != nil {
3291 return out, metadata, &smithy.SerializationError{Err: err}
3292 }
3293 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3294 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DetachCertificateFromDistribution")
3295
3296 jsonEncoder := smithyjson.NewEncoder()
3297 if err := awsAwsjson11_serializeOpDocumentDetachCertificateFromDistributionInput(input, jsonEncoder.Value); err != nil {
3298 return out, metadata, &smithy.SerializationError{Err: err}
3299 }
3300
3301 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3302 return out, metadata, &smithy.SerializationError{Err: err}
3303 }
3304
3305 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3306 return out, metadata, &smithy.SerializationError{Err: err}
3307 }
3308 in.Request = request
3309
3310 endTimer()
3311 span.End()
3312 return next.HandleSerialize(ctx, in)
3313 }
3314
3315 type awsAwsjson11_serializeOpDetachDisk struct {
3316 }
3317
3318 func (*awsAwsjson11_serializeOpDetachDisk) ID() string {
3319 return "OperationSerializer"
3320 }
3321
3322 func (m *awsAwsjson11_serializeOpDetachDisk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3323 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3324 ) {
3325 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3326 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3327 defer endTimer()
3328 defer span.End()
3329 request, ok := in.Request.(*smithyhttp.Request)
3330 if !ok {
3331 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3332 }
3333
3334 input, ok := in.Parameters.(*DetachDiskInput)
3335 _ = input
3336 if !ok {
3337 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3338 }
3339
3340 operationPath := "/"
3341 if len(request.Request.URL.Path) == 0 {
3342 request.Request.URL.Path = operationPath
3343 } else {
3344 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3345 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3346 request.Request.URL.Path += "/"
3347 }
3348 }
3349 request.Request.Method = "POST"
3350 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3351 if err != nil {
3352 return out, metadata, &smithy.SerializationError{Err: err}
3353 }
3354 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3355 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DetachDisk")
3356
3357 jsonEncoder := smithyjson.NewEncoder()
3358 if err := awsAwsjson11_serializeOpDocumentDetachDiskInput(input, jsonEncoder.Value); err != nil {
3359 return out, metadata, &smithy.SerializationError{Err: err}
3360 }
3361
3362 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3363 return out, metadata, &smithy.SerializationError{Err: err}
3364 }
3365
3366 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3367 return out, metadata, &smithy.SerializationError{Err: err}
3368 }
3369 in.Request = request
3370
3371 endTimer()
3372 span.End()
3373 return next.HandleSerialize(ctx, in)
3374 }
3375
3376 type awsAwsjson11_serializeOpDetachInstancesFromLoadBalancer struct {
3377 }
3378
3379 func (*awsAwsjson11_serializeOpDetachInstancesFromLoadBalancer) ID() string {
3380 return "OperationSerializer"
3381 }
3382
3383 func (m *awsAwsjson11_serializeOpDetachInstancesFromLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3384 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3385 ) {
3386 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3387 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3388 defer endTimer()
3389 defer span.End()
3390 request, ok := in.Request.(*smithyhttp.Request)
3391 if !ok {
3392 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3393 }
3394
3395 input, ok := in.Parameters.(*DetachInstancesFromLoadBalancerInput)
3396 _ = input
3397 if !ok {
3398 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3399 }
3400
3401 operationPath := "/"
3402 if len(request.Request.URL.Path) == 0 {
3403 request.Request.URL.Path = operationPath
3404 } else {
3405 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3406 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3407 request.Request.URL.Path += "/"
3408 }
3409 }
3410 request.Request.Method = "POST"
3411 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3412 if err != nil {
3413 return out, metadata, &smithy.SerializationError{Err: err}
3414 }
3415 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3416 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DetachInstancesFromLoadBalancer")
3417
3418 jsonEncoder := smithyjson.NewEncoder()
3419 if err := awsAwsjson11_serializeOpDocumentDetachInstancesFromLoadBalancerInput(input, jsonEncoder.Value); err != nil {
3420 return out, metadata, &smithy.SerializationError{Err: err}
3421 }
3422
3423 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3424 return out, metadata, &smithy.SerializationError{Err: err}
3425 }
3426
3427 if request.Request, err = httpBindingEncoder.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
3437 type awsAwsjson11_serializeOpDetachStaticIp struct {
3438 }
3439
3440 func (*awsAwsjson11_serializeOpDetachStaticIp) ID() string {
3441 return "OperationSerializer"
3442 }
3443
3444 func (m *awsAwsjson11_serializeOpDetachStaticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3445 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3446 ) {
3447 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3448 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3449 defer endTimer()
3450 defer span.End()
3451 request, ok := in.Request.(*smithyhttp.Request)
3452 if !ok {
3453 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3454 }
3455
3456 input, ok := in.Parameters.(*DetachStaticIpInput)
3457 _ = input
3458 if !ok {
3459 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3460 }
3461
3462 operationPath := "/"
3463 if len(request.Request.URL.Path) == 0 {
3464 request.Request.URL.Path = operationPath
3465 } else {
3466 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3467 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3468 request.Request.URL.Path += "/"
3469 }
3470 }
3471 request.Request.Method = "POST"
3472 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3473 if err != nil {
3474 return out, metadata, &smithy.SerializationError{Err: err}
3475 }
3476 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3477 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DetachStaticIp")
3478
3479 jsonEncoder := smithyjson.NewEncoder()
3480 if err := awsAwsjson11_serializeOpDocumentDetachStaticIpInput(input, jsonEncoder.Value); err != nil {
3481 return out, metadata, &smithy.SerializationError{Err: err}
3482 }
3483
3484 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3485 return out, metadata, &smithy.SerializationError{Err: err}
3486 }
3487
3488 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3489 return out, metadata, &smithy.SerializationError{Err: err}
3490 }
3491 in.Request = request
3492
3493 endTimer()
3494 span.End()
3495 return next.HandleSerialize(ctx, in)
3496 }
3497
3498 type awsAwsjson11_serializeOpDisableAddOn struct {
3499 }
3500
3501 func (*awsAwsjson11_serializeOpDisableAddOn) ID() string {
3502 return "OperationSerializer"
3503 }
3504
3505 func (m *awsAwsjson11_serializeOpDisableAddOn) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3506 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3507 ) {
3508 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3509 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3510 defer endTimer()
3511 defer span.End()
3512 request, ok := in.Request.(*smithyhttp.Request)
3513 if !ok {
3514 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3515 }
3516
3517 input, ok := in.Parameters.(*DisableAddOnInput)
3518 _ = input
3519 if !ok {
3520 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3521 }
3522
3523 operationPath := "/"
3524 if len(request.Request.URL.Path) == 0 {
3525 request.Request.URL.Path = operationPath
3526 } else {
3527 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3528 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3529 request.Request.URL.Path += "/"
3530 }
3531 }
3532 request.Request.Method = "POST"
3533 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3534 if err != nil {
3535 return out, metadata, &smithy.SerializationError{Err: err}
3536 }
3537 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3538 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DisableAddOn")
3539
3540 jsonEncoder := smithyjson.NewEncoder()
3541 if err := awsAwsjson11_serializeOpDocumentDisableAddOnInput(input, jsonEncoder.Value); err != nil {
3542 return out, metadata, &smithy.SerializationError{Err: err}
3543 }
3544
3545 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3546 return out, metadata, &smithy.SerializationError{Err: err}
3547 }
3548
3549 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3550 return out, metadata, &smithy.SerializationError{Err: err}
3551 }
3552 in.Request = request
3553
3554 endTimer()
3555 span.End()
3556 return next.HandleSerialize(ctx, in)
3557 }
3558
3559 type awsAwsjson11_serializeOpDownloadDefaultKeyPair struct {
3560 }
3561
3562 func (*awsAwsjson11_serializeOpDownloadDefaultKeyPair) ID() string {
3563 return "OperationSerializer"
3564 }
3565
3566 func (m *awsAwsjson11_serializeOpDownloadDefaultKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3567 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3568 ) {
3569 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3570 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3571 defer endTimer()
3572 defer span.End()
3573 request, ok := in.Request.(*smithyhttp.Request)
3574 if !ok {
3575 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3576 }
3577
3578 input, ok := in.Parameters.(*DownloadDefaultKeyPairInput)
3579 _ = input
3580 if !ok {
3581 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3582 }
3583
3584 operationPath := "/"
3585 if len(request.Request.URL.Path) == 0 {
3586 request.Request.URL.Path = operationPath
3587 } else {
3588 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3589 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3590 request.Request.URL.Path += "/"
3591 }
3592 }
3593 request.Request.Method = "POST"
3594 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3595 if err != nil {
3596 return out, metadata, &smithy.SerializationError{Err: err}
3597 }
3598 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3599 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DownloadDefaultKeyPair")
3600
3601 jsonEncoder := smithyjson.NewEncoder()
3602 if err := awsAwsjson11_serializeOpDocumentDownloadDefaultKeyPairInput(input, jsonEncoder.Value); err != nil {
3603 return out, metadata, &smithy.SerializationError{Err: err}
3604 }
3605
3606 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3607 return out, metadata, &smithy.SerializationError{Err: err}
3608 }
3609
3610 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3611 return out, metadata, &smithy.SerializationError{Err: err}
3612 }
3613 in.Request = request
3614
3615 endTimer()
3616 span.End()
3617 return next.HandleSerialize(ctx, in)
3618 }
3619
3620 type awsAwsjson11_serializeOpEnableAddOn struct {
3621 }
3622
3623 func (*awsAwsjson11_serializeOpEnableAddOn) ID() string {
3624 return "OperationSerializer"
3625 }
3626
3627 func (m *awsAwsjson11_serializeOpEnableAddOn) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3628 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3629 ) {
3630 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3631 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3632 defer endTimer()
3633 defer span.End()
3634 request, ok := in.Request.(*smithyhttp.Request)
3635 if !ok {
3636 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3637 }
3638
3639 input, ok := in.Parameters.(*EnableAddOnInput)
3640 _ = input
3641 if !ok {
3642 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3643 }
3644
3645 operationPath := "/"
3646 if len(request.Request.URL.Path) == 0 {
3647 request.Request.URL.Path = operationPath
3648 } else {
3649 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3650 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3651 request.Request.URL.Path += "/"
3652 }
3653 }
3654 request.Request.Method = "POST"
3655 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3656 if err != nil {
3657 return out, metadata, &smithy.SerializationError{Err: err}
3658 }
3659 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3660 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.EnableAddOn")
3661
3662 jsonEncoder := smithyjson.NewEncoder()
3663 if err := awsAwsjson11_serializeOpDocumentEnableAddOnInput(input, jsonEncoder.Value); err != nil {
3664 return out, metadata, &smithy.SerializationError{Err: err}
3665 }
3666
3667 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3668 return out, metadata, &smithy.SerializationError{Err: err}
3669 }
3670
3671 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3672 return out, metadata, &smithy.SerializationError{Err: err}
3673 }
3674 in.Request = request
3675
3676 endTimer()
3677 span.End()
3678 return next.HandleSerialize(ctx, in)
3679 }
3680
3681 type awsAwsjson11_serializeOpExportSnapshot struct {
3682 }
3683
3684 func (*awsAwsjson11_serializeOpExportSnapshot) ID() string {
3685 return "OperationSerializer"
3686 }
3687
3688 func (m *awsAwsjson11_serializeOpExportSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3689 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3690 ) {
3691 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3692 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3693 defer endTimer()
3694 defer span.End()
3695 request, ok := in.Request.(*smithyhttp.Request)
3696 if !ok {
3697 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3698 }
3699
3700 input, ok := in.Parameters.(*ExportSnapshotInput)
3701 _ = input
3702 if !ok {
3703 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3704 }
3705
3706 operationPath := "/"
3707 if len(request.Request.URL.Path) == 0 {
3708 request.Request.URL.Path = operationPath
3709 } else {
3710 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3711 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3712 request.Request.URL.Path += "/"
3713 }
3714 }
3715 request.Request.Method = "POST"
3716 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3717 if err != nil {
3718 return out, metadata, &smithy.SerializationError{Err: err}
3719 }
3720 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3721 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.ExportSnapshot")
3722
3723 jsonEncoder := smithyjson.NewEncoder()
3724 if err := awsAwsjson11_serializeOpDocumentExportSnapshotInput(input, jsonEncoder.Value); err != nil {
3725 return out, metadata, &smithy.SerializationError{Err: err}
3726 }
3727
3728 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3729 return out, metadata, &smithy.SerializationError{Err: err}
3730 }
3731
3732 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3733 return out, metadata, &smithy.SerializationError{Err: err}
3734 }
3735 in.Request = request
3736
3737 endTimer()
3738 span.End()
3739 return next.HandleSerialize(ctx, in)
3740 }
3741
3742 type awsAwsjson11_serializeOpGetActiveNames struct {
3743 }
3744
3745 func (*awsAwsjson11_serializeOpGetActiveNames) ID() string {
3746 return "OperationSerializer"
3747 }
3748
3749 func (m *awsAwsjson11_serializeOpGetActiveNames) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3750 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3751 ) {
3752 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3753 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3754 defer endTimer()
3755 defer span.End()
3756 request, ok := in.Request.(*smithyhttp.Request)
3757 if !ok {
3758 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3759 }
3760
3761 input, ok := in.Parameters.(*GetActiveNamesInput)
3762 _ = input
3763 if !ok {
3764 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3765 }
3766
3767 operationPath := "/"
3768 if len(request.Request.URL.Path) == 0 {
3769 request.Request.URL.Path = operationPath
3770 } else {
3771 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3772 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3773 request.Request.URL.Path += "/"
3774 }
3775 }
3776 request.Request.Method = "POST"
3777 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3778 if err != nil {
3779 return out, metadata, &smithy.SerializationError{Err: err}
3780 }
3781 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3782 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetActiveNames")
3783
3784 jsonEncoder := smithyjson.NewEncoder()
3785 if err := awsAwsjson11_serializeOpDocumentGetActiveNamesInput(input, jsonEncoder.Value); err != nil {
3786 return out, metadata, &smithy.SerializationError{Err: err}
3787 }
3788
3789 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3790 return out, metadata, &smithy.SerializationError{Err: err}
3791 }
3792
3793 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3794 return out, metadata, &smithy.SerializationError{Err: err}
3795 }
3796 in.Request = request
3797
3798 endTimer()
3799 span.End()
3800 return next.HandleSerialize(ctx, in)
3801 }
3802
3803 type awsAwsjson11_serializeOpGetAlarms struct {
3804 }
3805
3806 func (*awsAwsjson11_serializeOpGetAlarms) ID() string {
3807 return "OperationSerializer"
3808 }
3809
3810 func (m *awsAwsjson11_serializeOpGetAlarms) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3811 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3812 ) {
3813 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3814 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3815 defer endTimer()
3816 defer span.End()
3817 request, ok := in.Request.(*smithyhttp.Request)
3818 if !ok {
3819 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3820 }
3821
3822 input, ok := in.Parameters.(*GetAlarmsInput)
3823 _ = input
3824 if !ok {
3825 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3826 }
3827
3828 operationPath := "/"
3829 if len(request.Request.URL.Path) == 0 {
3830 request.Request.URL.Path = operationPath
3831 } else {
3832 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3833 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3834 request.Request.URL.Path += "/"
3835 }
3836 }
3837 request.Request.Method = "POST"
3838 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3839 if err != nil {
3840 return out, metadata, &smithy.SerializationError{Err: err}
3841 }
3842 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3843 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetAlarms")
3844
3845 jsonEncoder := smithyjson.NewEncoder()
3846 if err := awsAwsjson11_serializeOpDocumentGetAlarmsInput(input, jsonEncoder.Value); err != nil {
3847 return out, metadata, &smithy.SerializationError{Err: err}
3848 }
3849
3850 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3851 return out, metadata, &smithy.SerializationError{Err: err}
3852 }
3853
3854 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3855 return out, metadata, &smithy.SerializationError{Err: err}
3856 }
3857 in.Request = request
3858
3859 endTimer()
3860 span.End()
3861 return next.HandleSerialize(ctx, in)
3862 }
3863
3864 type awsAwsjson11_serializeOpGetAutoSnapshots struct {
3865 }
3866
3867 func (*awsAwsjson11_serializeOpGetAutoSnapshots) ID() string {
3868 return "OperationSerializer"
3869 }
3870
3871 func (m *awsAwsjson11_serializeOpGetAutoSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3872 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3873 ) {
3874 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3875 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3876 defer endTimer()
3877 defer span.End()
3878 request, ok := in.Request.(*smithyhttp.Request)
3879 if !ok {
3880 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3881 }
3882
3883 input, ok := in.Parameters.(*GetAutoSnapshotsInput)
3884 _ = input
3885 if !ok {
3886 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3887 }
3888
3889 operationPath := "/"
3890 if len(request.Request.URL.Path) == 0 {
3891 request.Request.URL.Path = operationPath
3892 } else {
3893 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3894 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3895 request.Request.URL.Path += "/"
3896 }
3897 }
3898 request.Request.Method = "POST"
3899 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3900 if err != nil {
3901 return out, metadata, &smithy.SerializationError{Err: err}
3902 }
3903 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3904 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetAutoSnapshots")
3905
3906 jsonEncoder := smithyjson.NewEncoder()
3907 if err := awsAwsjson11_serializeOpDocumentGetAutoSnapshotsInput(input, jsonEncoder.Value); err != nil {
3908 return out, metadata, &smithy.SerializationError{Err: err}
3909 }
3910
3911 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3912 return out, metadata, &smithy.SerializationError{Err: err}
3913 }
3914
3915 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3916 return out, metadata, &smithy.SerializationError{Err: err}
3917 }
3918 in.Request = request
3919
3920 endTimer()
3921 span.End()
3922 return next.HandleSerialize(ctx, in)
3923 }
3924
3925 type awsAwsjson11_serializeOpGetBlueprints struct {
3926 }
3927
3928 func (*awsAwsjson11_serializeOpGetBlueprints) ID() string {
3929 return "OperationSerializer"
3930 }
3931
3932 func (m *awsAwsjson11_serializeOpGetBlueprints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3933 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3934 ) {
3935 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3936 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3937 defer endTimer()
3938 defer span.End()
3939 request, ok := in.Request.(*smithyhttp.Request)
3940 if !ok {
3941 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3942 }
3943
3944 input, ok := in.Parameters.(*GetBlueprintsInput)
3945 _ = input
3946 if !ok {
3947 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3948 }
3949
3950 operationPath := "/"
3951 if len(request.Request.URL.Path) == 0 {
3952 request.Request.URL.Path = operationPath
3953 } else {
3954 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
3955 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
3956 request.Request.URL.Path += "/"
3957 }
3958 }
3959 request.Request.Method = "POST"
3960 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3961 if err != nil {
3962 return out, metadata, &smithy.SerializationError{Err: err}
3963 }
3964 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3965 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetBlueprints")
3966
3967 jsonEncoder := smithyjson.NewEncoder()
3968 if err := awsAwsjson11_serializeOpDocumentGetBlueprintsInput(input, jsonEncoder.Value); err != nil {
3969 return out, metadata, &smithy.SerializationError{Err: err}
3970 }
3971
3972 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3973 return out, metadata, &smithy.SerializationError{Err: err}
3974 }
3975
3976 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3977 return out, metadata, &smithy.SerializationError{Err: err}
3978 }
3979 in.Request = request
3980
3981 endTimer()
3982 span.End()
3983 return next.HandleSerialize(ctx, in)
3984 }
3985
3986 type awsAwsjson11_serializeOpGetBucketAccessKeys struct {
3987 }
3988
3989 func (*awsAwsjson11_serializeOpGetBucketAccessKeys) ID() string {
3990 return "OperationSerializer"
3991 }
3992
3993 func (m *awsAwsjson11_serializeOpGetBucketAccessKeys) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3994 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3995 ) {
3996 _, span := tracing.StartSpan(ctx, "OperationSerializer")
3997 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
3998 defer endTimer()
3999 defer span.End()
4000 request, ok := in.Request.(*smithyhttp.Request)
4001 if !ok {
4002 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4003 }
4004
4005 input, ok := in.Parameters.(*GetBucketAccessKeysInput)
4006 _ = input
4007 if !ok {
4008 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4009 }
4010
4011 operationPath := "/"
4012 if len(request.Request.URL.Path) == 0 {
4013 request.Request.URL.Path = operationPath
4014 } else {
4015 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4016 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4017 request.Request.URL.Path += "/"
4018 }
4019 }
4020 request.Request.Method = "POST"
4021 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4022 if err != nil {
4023 return out, metadata, &smithy.SerializationError{Err: err}
4024 }
4025 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4026 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetBucketAccessKeys")
4027
4028 jsonEncoder := smithyjson.NewEncoder()
4029 if err := awsAwsjson11_serializeOpDocumentGetBucketAccessKeysInput(input, jsonEncoder.Value); err != nil {
4030 return out, metadata, &smithy.SerializationError{Err: err}
4031 }
4032
4033 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4034 return out, metadata, &smithy.SerializationError{Err: err}
4035 }
4036
4037 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4038 return out, metadata, &smithy.SerializationError{Err: err}
4039 }
4040 in.Request = request
4041
4042 endTimer()
4043 span.End()
4044 return next.HandleSerialize(ctx, in)
4045 }
4046
4047 type awsAwsjson11_serializeOpGetBucketBundles struct {
4048 }
4049
4050 func (*awsAwsjson11_serializeOpGetBucketBundles) ID() string {
4051 return "OperationSerializer"
4052 }
4053
4054 func (m *awsAwsjson11_serializeOpGetBucketBundles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4055 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4056 ) {
4057 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4058 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4059 defer endTimer()
4060 defer span.End()
4061 request, ok := in.Request.(*smithyhttp.Request)
4062 if !ok {
4063 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4064 }
4065
4066 input, ok := in.Parameters.(*GetBucketBundlesInput)
4067 _ = input
4068 if !ok {
4069 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4070 }
4071
4072 operationPath := "/"
4073 if len(request.Request.URL.Path) == 0 {
4074 request.Request.URL.Path = operationPath
4075 } else {
4076 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4077 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4078 request.Request.URL.Path += "/"
4079 }
4080 }
4081 request.Request.Method = "POST"
4082 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4083 if err != nil {
4084 return out, metadata, &smithy.SerializationError{Err: err}
4085 }
4086 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4087 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetBucketBundles")
4088
4089 jsonEncoder := smithyjson.NewEncoder()
4090 if err := awsAwsjson11_serializeOpDocumentGetBucketBundlesInput(input, jsonEncoder.Value); err != nil {
4091 return out, metadata, &smithy.SerializationError{Err: err}
4092 }
4093
4094 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4095 return out, metadata, &smithy.SerializationError{Err: err}
4096 }
4097
4098 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4099 return out, metadata, &smithy.SerializationError{Err: err}
4100 }
4101 in.Request = request
4102
4103 endTimer()
4104 span.End()
4105 return next.HandleSerialize(ctx, in)
4106 }
4107
4108 type awsAwsjson11_serializeOpGetBucketMetricData struct {
4109 }
4110
4111 func (*awsAwsjson11_serializeOpGetBucketMetricData) ID() string {
4112 return "OperationSerializer"
4113 }
4114
4115 func (m *awsAwsjson11_serializeOpGetBucketMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4116 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4117 ) {
4118 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4119 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4120 defer endTimer()
4121 defer span.End()
4122 request, ok := in.Request.(*smithyhttp.Request)
4123 if !ok {
4124 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4125 }
4126
4127 input, ok := in.Parameters.(*GetBucketMetricDataInput)
4128 _ = input
4129 if !ok {
4130 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4131 }
4132
4133 operationPath := "/"
4134 if len(request.Request.URL.Path) == 0 {
4135 request.Request.URL.Path = operationPath
4136 } else {
4137 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4138 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4139 request.Request.URL.Path += "/"
4140 }
4141 }
4142 request.Request.Method = "POST"
4143 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4144 if err != nil {
4145 return out, metadata, &smithy.SerializationError{Err: err}
4146 }
4147 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4148 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetBucketMetricData")
4149
4150 jsonEncoder := smithyjson.NewEncoder()
4151 if err := awsAwsjson11_serializeOpDocumentGetBucketMetricDataInput(input, jsonEncoder.Value); err != nil {
4152 return out, metadata, &smithy.SerializationError{Err: err}
4153 }
4154
4155 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4156 return out, metadata, &smithy.SerializationError{Err: err}
4157 }
4158
4159 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4160 return out, metadata, &smithy.SerializationError{Err: err}
4161 }
4162 in.Request = request
4163
4164 endTimer()
4165 span.End()
4166 return next.HandleSerialize(ctx, in)
4167 }
4168
4169 type awsAwsjson11_serializeOpGetBuckets struct {
4170 }
4171
4172 func (*awsAwsjson11_serializeOpGetBuckets) ID() string {
4173 return "OperationSerializer"
4174 }
4175
4176 func (m *awsAwsjson11_serializeOpGetBuckets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4177 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4178 ) {
4179 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4180 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4181 defer endTimer()
4182 defer span.End()
4183 request, ok := in.Request.(*smithyhttp.Request)
4184 if !ok {
4185 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4186 }
4187
4188 input, ok := in.Parameters.(*GetBucketsInput)
4189 _ = input
4190 if !ok {
4191 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4192 }
4193
4194 operationPath := "/"
4195 if len(request.Request.URL.Path) == 0 {
4196 request.Request.URL.Path = operationPath
4197 } else {
4198 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4199 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4200 request.Request.URL.Path += "/"
4201 }
4202 }
4203 request.Request.Method = "POST"
4204 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4205 if err != nil {
4206 return out, metadata, &smithy.SerializationError{Err: err}
4207 }
4208 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4209 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetBuckets")
4210
4211 jsonEncoder := smithyjson.NewEncoder()
4212 if err := awsAwsjson11_serializeOpDocumentGetBucketsInput(input, jsonEncoder.Value); err != nil {
4213 return out, metadata, &smithy.SerializationError{Err: err}
4214 }
4215
4216 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4217 return out, metadata, &smithy.SerializationError{Err: err}
4218 }
4219
4220 if request.Request, err = httpBindingEncoder.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
4230 type awsAwsjson11_serializeOpGetBundles struct {
4231 }
4232
4233 func (*awsAwsjson11_serializeOpGetBundles) ID() string {
4234 return "OperationSerializer"
4235 }
4236
4237 func (m *awsAwsjson11_serializeOpGetBundles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4238 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4239 ) {
4240 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4241 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4242 defer endTimer()
4243 defer span.End()
4244 request, ok := in.Request.(*smithyhttp.Request)
4245 if !ok {
4246 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4247 }
4248
4249 input, ok := in.Parameters.(*GetBundlesInput)
4250 _ = input
4251 if !ok {
4252 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4253 }
4254
4255 operationPath := "/"
4256 if len(request.Request.URL.Path) == 0 {
4257 request.Request.URL.Path = operationPath
4258 } else {
4259 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4260 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4261 request.Request.URL.Path += "/"
4262 }
4263 }
4264 request.Request.Method = "POST"
4265 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4266 if err != nil {
4267 return out, metadata, &smithy.SerializationError{Err: err}
4268 }
4269 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4270 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetBundles")
4271
4272 jsonEncoder := smithyjson.NewEncoder()
4273 if err := awsAwsjson11_serializeOpDocumentGetBundlesInput(input, jsonEncoder.Value); err != nil {
4274 return out, metadata, &smithy.SerializationError{Err: err}
4275 }
4276
4277 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4278 return out, metadata, &smithy.SerializationError{Err: err}
4279 }
4280
4281 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4282 return out, metadata, &smithy.SerializationError{Err: err}
4283 }
4284 in.Request = request
4285
4286 endTimer()
4287 span.End()
4288 return next.HandleSerialize(ctx, in)
4289 }
4290
4291 type awsAwsjson11_serializeOpGetCertificates struct {
4292 }
4293
4294 func (*awsAwsjson11_serializeOpGetCertificates) ID() string {
4295 return "OperationSerializer"
4296 }
4297
4298 func (m *awsAwsjson11_serializeOpGetCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4299 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4300 ) {
4301 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4302 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4303 defer endTimer()
4304 defer span.End()
4305 request, ok := in.Request.(*smithyhttp.Request)
4306 if !ok {
4307 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4308 }
4309
4310 input, ok := in.Parameters.(*GetCertificatesInput)
4311 _ = input
4312 if !ok {
4313 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4314 }
4315
4316 operationPath := "/"
4317 if len(request.Request.URL.Path) == 0 {
4318 request.Request.URL.Path = operationPath
4319 } else {
4320 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4321 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4322 request.Request.URL.Path += "/"
4323 }
4324 }
4325 request.Request.Method = "POST"
4326 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4327 if err != nil {
4328 return out, metadata, &smithy.SerializationError{Err: err}
4329 }
4330 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4331 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetCertificates")
4332
4333 jsonEncoder := smithyjson.NewEncoder()
4334 if err := awsAwsjson11_serializeOpDocumentGetCertificatesInput(input, jsonEncoder.Value); err != nil {
4335 return out, metadata, &smithy.SerializationError{Err: err}
4336 }
4337
4338 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4339 return out, metadata, &smithy.SerializationError{Err: err}
4340 }
4341
4342 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4343 return out, metadata, &smithy.SerializationError{Err: err}
4344 }
4345 in.Request = request
4346
4347 endTimer()
4348 span.End()
4349 return next.HandleSerialize(ctx, in)
4350 }
4351
4352 type awsAwsjson11_serializeOpGetCloudFormationStackRecords struct {
4353 }
4354
4355 func (*awsAwsjson11_serializeOpGetCloudFormationStackRecords) ID() string {
4356 return "OperationSerializer"
4357 }
4358
4359 func (m *awsAwsjson11_serializeOpGetCloudFormationStackRecords) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4360 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4361 ) {
4362 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4363 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4364 defer endTimer()
4365 defer span.End()
4366 request, ok := in.Request.(*smithyhttp.Request)
4367 if !ok {
4368 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4369 }
4370
4371 input, ok := in.Parameters.(*GetCloudFormationStackRecordsInput)
4372 _ = input
4373 if !ok {
4374 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4375 }
4376
4377 operationPath := "/"
4378 if len(request.Request.URL.Path) == 0 {
4379 request.Request.URL.Path = operationPath
4380 } else {
4381 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4382 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4383 request.Request.URL.Path += "/"
4384 }
4385 }
4386 request.Request.Method = "POST"
4387 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4388 if err != nil {
4389 return out, metadata, &smithy.SerializationError{Err: err}
4390 }
4391 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4392 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetCloudFormationStackRecords")
4393
4394 jsonEncoder := smithyjson.NewEncoder()
4395 if err := awsAwsjson11_serializeOpDocumentGetCloudFormationStackRecordsInput(input, jsonEncoder.Value); err != nil {
4396 return out, metadata, &smithy.SerializationError{Err: err}
4397 }
4398
4399 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4400 return out, metadata, &smithy.SerializationError{Err: err}
4401 }
4402
4403 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4404 return out, metadata, &smithy.SerializationError{Err: err}
4405 }
4406 in.Request = request
4407
4408 endTimer()
4409 span.End()
4410 return next.HandleSerialize(ctx, in)
4411 }
4412
4413 type awsAwsjson11_serializeOpGetContactMethods struct {
4414 }
4415
4416 func (*awsAwsjson11_serializeOpGetContactMethods) ID() string {
4417 return "OperationSerializer"
4418 }
4419
4420 func (m *awsAwsjson11_serializeOpGetContactMethods) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4421 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4422 ) {
4423 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4424 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4425 defer endTimer()
4426 defer span.End()
4427 request, ok := in.Request.(*smithyhttp.Request)
4428 if !ok {
4429 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4430 }
4431
4432 input, ok := in.Parameters.(*GetContactMethodsInput)
4433 _ = input
4434 if !ok {
4435 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4436 }
4437
4438 operationPath := "/"
4439 if len(request.Request.URL.Path) == 0 {
4440 request.Request.URL.Path = operationPath
4441 } else {
4442 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4443 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4444 request.Request.URL.Path += "/"
4445 }
4446 }
4447 request.Request.Method = "POST"
4448 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4449 if err != nil {
4450 return out, metadata, &smithy.SerializationError{Err: err}
4451 }
4452 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4453 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContactMethods")
4454
4455 jsonEncoder := smithyjson.NewEncoder()
4456 if err := awsAwsjson11_serializeOpDocumentGetContactMethodsInput(input, jsonEncoder.Value); err != nil {
4457 return out, metadata, &smithy.SerializationError{Err: err}
4458 }
4459
4460 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4461 return out, metadata, &smithy.SerializationError{Err: err}
4462 }
4463
4464 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4465 return out, metadata, &smithy.SerializationError{Err: err}
4466 }
4467 in.Request = request
4468
4469 endTimer()
4470 span.End()
4471 return next.HandleSerialize(ctx, in)
4472 }
4473
4474 type awsAwsjson11_serializeOpGetContainerAPIMetadata struct {
4475 }
4476
4477 func (*awsAwsjson11_serializeOpGetContainerAPIMetadata) ID() string {
4478 return "OperationSerializer"
4479 }
4480
4481 func (m *awsAwsjson11_serializeOpGetContainerAPIMetadata) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4482 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4483 ) {
4484 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4485 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4486 defer endTimer()
4487 defer span.End()
4488 request, ok := in.Request.(*smithyhttp.Request)
4489 if !ok {
4490 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4491 }
4492
4493 input, ok := in.Parameters.(*GetContainerAPIMetadataInput)
4494 _ = input
4495 if !ok {
4496 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4497 }
4498
4499 operationPath := "/"
4500 if len(request.Request.URL.Path) == 0 {
4501 request.Request.URL.Path = operationPath
4502 } else {
4503 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4504 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4505 request.Request.URL.Path += "/"
4506 }
4507 }
4508 request.Request.Method = "POST"
4509 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4510 if err != nil {
4511 return out, metadata, &smithy.SerializationError{Err: err}
4512 }
4513 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4514 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerAPIMetadata")
4515
4516 jsonEncoder := smithyjson.NewEncoder()
4517 if err := awsAwsjson11_serializeOpDocumentGetContainerAPIMetadataInput(input, jsonEncoder.Value); err != nil {
4518 return out, metadata, &smithy.SerializationError{Err: err}
4519 }
4520
4521 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4522 return out, metadata, &smithy.SerializationError{Err: err}
4523 }
4524
4525 if request.Request, err = httpBindingEncoder.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
4535 type awsAwsjson11_serializeOpGetContainerImages struct {
4536 }
4537
4538 func (*awsAwsjson11_serializeOpGetContainerImages) ID() string {
4539 return "OperationSerializer"
4540 }
4541
4542 func (m *awsAwsjson11_serializeOpGetContainerImages) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4543 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4544 ) {
4545 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4546 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4547 defer endTimer()
4548 defer span.End()
4549 request, ok := in.Request.(*smithyhttp.Request)
4550 if !ok {
4551 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4552 }
4553
4554 input, ok := in.Parameters.(*GetContainerImagesInput)
4555 _ = input
4556 if !ok {
4557 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4558 }
4559
4560 operationPath := "/"
4561 if len(request.Request.URL.Path) == 0 {
4562 request.Request.URL.Path = operationPath
4563 } else {
4564 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4565 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4566 request.Request.URL.Path += "/"
4567 }
4568 }
4569 request.Request.Method = "POST"
4570 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4571 if err != nil {
4572 return out, metadata, &smithy.SerializationError{Err: err}
4573 }
4574 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4575 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerImages")
4576
4577 jsonEncoder := smithyjson.NewEncoder()
4578 if err := awsAwsjson11_serializeOpDocumentGetContainerImagesInput(input, jsonEncoder.Value); err != nil {
4579 return out, metadata, &smithy.SerializationError{Err: err}
4580 }
4581
4582 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4583 return out, metadata, &smithy.SerializationError{Err: err}
4584 }
4585
4586 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4587 return out, metadata, &smithy.SerializationError{Err: err}
4588 }
4589 in.Request = request
4590
4591 endTimer()
4592 span.End()
4593 return next.HandleSerialize(ctx, in)
4594 }
4595
4596 type awsAwsjson11_serializeOpGetContainerLog struct {
4597 }
4598
4599 func (*awsAwsjson11_serializeOpGetContainerLog) ID() string {
4600 return "OperationSerializer"
4601 }
4602
4603 func (m *awsAwsjson11_serializeOpGetContainerLog) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4604 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4605 ) {
4606 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4607 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4608 defer endTimer()
4609 defer span.End()
4610 request, ok := in.Request.(*smithyhttp.Request)
4611 if !ok {
4612 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4613 }
4614
4615 input, ok := in.Parameters.(*GetContainerLogInput)
4616 _ = input
4617 if !ok {
4618 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4619 }
4620
4621 operationPath := "/"
4622 if len(request.Request.URL.Path) == 0 {
4623 request.Request.URL.Path = operationPath
4624 } else {
4625 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4626 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4627 request.Request.URL.Path += "/"
4628 }
4629 }
4630 request.Request.Method = "POST"
4631 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4632 if err != nil {
4633 return out, metadata, &smithy.SerializationError{Err: err}
4634 }
4635 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4636 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerLog")
4637
4638 jsonEncoder := smithyjson.NewEncoder()
4639 if err := awsAwsjson11_serializeOpDocumentGetContainerLogInput(input, jsonEncoder.Value); err != nil {
4640 return out, metadata, &smithy.SerializationError{Err: err}
4641 }
4642
4643 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4644 return out, metadata, &smithy.SerializationError{Err: err}
4645 }
4646
4647 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4648 return out, metadata, &smithy.SerializationError{Err: err}
4649 }
4650 in.Request = request
4651
4652 endTimer()
4653 span.End()
4654 return next.HandleSerialize(ctx, in)
4655 }
4656
4657 type awsAwsjson11_serializeOpGetContainerServiceDeployments struct {
4658 }
4659
4660 func (*awsAwsjson11_serializeOpGetContainerServiceDeployments) ID() string {
4661 return "OperationSerializer"
4662 }
4663
4664 func (m *awsAwsjson11_serializeOpGetContainerServiceDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4665 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4666 ) {
4667 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4668 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4669 defer endTimer()
4670 defer span.End()
4671 request, ok := in.Request.(*smithyhttp.Request)
4672 if !ok {
4673 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4674 }
4675
4676 input, ok := in.Parameters.(*GetContainerServiceDeploymentsInput)
4677 _ = input
4678 if !ok {
4679 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4680 }
4681
4682 operationPath := "/"
4683 if len(request.Request.URL.Path) == 0 {
4684 request.Request.URL.Path = operationPath
4685 } else {
4686 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4687 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4688 request.Request.URL.Path += "/"
4689 }
4690 }
4691 request.Request.Method = "POST"
4692 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4693 if err != nil {
4694 return out, metadata, &smithy.SerializationError{Err: err}
4695 }
4696 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4697 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerServiceDeployments")
4698
4699 jsonEncoder := smithyjson.NewEncoder()
4700 if err := awsAwsjson11_serializeOpDocumentGetContainerServiceDeploymentsInput(input, jsonEncoder.Value); err != nil {
4701 return out, metadata, &smithy.SerializationError{Err: err}
4702 }
4703
4704 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4705 return out, metadata, &smithy.SerializationError{Err: err}
4706 }
4707
4708 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4709 return out, metadata, &smithy.SerializationError{Err: err}
4710 }
4711 in.Request = request
4712
4713 endTimer()
4714 span.End()
4715 return next.HandleSerialize(ctx, in)
4716 }
4717
4718 type awsAwsjson11_serializeOpGetContainerServiceMetricData struct {
4719 }
4720
4721 func (*awsAwsjson11_serializeOpGetContainerServiceMetricData) ID() string {
4722 return "OperationSerializer"
4723 }
4724
4725 func (m *awsAwsjson11_serializeOpGetContainerServiceMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4726 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4727 ) {
4728 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4729 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4730 defer endTimer()
4731 defer span.End()
4732 request, ok := in.Request.(*smithyhttp.Request)
4733 if !ok {
4734 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4735 }
4736
4737 input, ok := in.Parameters.(*GetContainerServiceMetricDataInput)
4738 _ = input
4739 if !ok {
4740 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4741 }
4742
4743 operationPath := "/"
4744 if len(request.Request.URL.Path) == 0 {
4745 request.Request.URL.Path = operationPath
4746 } else {
4747 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4748 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4749 request.Request.URL.Path += "/"
4750 }
4751 }
4752 request.Request.Method = "POST"
4753 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4754 if err != nil {
4755 return out, metadata, &smithy.SerializationError{Err: err}
4756 }
4757 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4758 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerServiceMetricData")
4759
4760 jsonEncoder := smithyjson.NewEncoder()
4761 if err := awsAwsjson11_serializeOpDocumentGetContainerServiceMetricDataInput(input, jsonEncoder.Value); err != nil {
4762 return out, metadata, &smithy.SerializationError{Err: err}
4763 }
4764
4765 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4766 return out, metadata, &smithy.SerializationError{Err: err}
4767 }
4768
4769 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4770 return out, metadata, &smithy.SerializationError{Err: err}
4771 }
4772 in.Request = request
4773
4774 endTimer()
4775 span.End()
4776 return next.HandleSerialize(ctx, in)
4777 }
4778
4779 type awsAwsjson11_serializeOpGetContainerServicePowers struct {
4780 }
4781
4782 func (*awsAwsjson11_serializeOpGetContainerServicePowers) ID() string {
4783 return "OperationSerializer"
4784 }
4785
4786 func (m *awsAwsjson11_serializeOpGetContainerServicePowers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4787 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4788 ) {
4789 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4790 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4791 defer endTimer()
4792 defer span.End()
4793 request, ok := in.Request.(*smithyhttp.Request)
4794 if !ok {
4795 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4796 }
4797
4798 input, ok := in.Parameters.(*GetContainerServicePowersInput)
4799 _ = input
4800 if !ok {
4801 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4802 }
4803
4804 operationPath := "/"
4805 if len(request.Request.URL.Path) == 0 {
4806 request.Request.URL.Path = operationPath
4807 } else {
4808 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4809 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4810 request.Request.URL.Path += "/"
4811 }
4812 }
4813 request.Request.Method = "POST"
4814 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4815 if err != nil {
4816 return out, metadata, &smithy.SerializationError{Err: err}
4817 }
4818 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4819 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerServicePowers")
4820
4821 jsonEncoder := smithyjson.NewEncoder()
4822 if err := awsAwsjson11_serializeOpDocumentGetContainerServicePowersInput(input, jsonEncoder.Value); err != nil {
4823 return out, metadata, &smithy.SerializationError{Err: err}
4824 }
4825
4826 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4827 return out, metadata, &smithy.SerializationError{Err: err}
4828 }
4829
4830 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4831 return out, metadata, &smithy.SerializationError{Err: err}
4832 }
4833 in.Request = request
4834
4835 endTimer()
4836 span.End()
4837 return next.HandleSerialize(ctx, in)
4838 }
4839
4840 type awsAwsjson11_serializeOpGetContainerServices struct {
4841 }
4842
4843 func (*awsAwsjson11_serializeOpGetContainerServices) ID() string {
4844 return "OperationSerializer"
4845 }
4846
4847 func (m *awsAwsjson11_serializeOpGetContainerServices) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4848 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4849 ) {
4850 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4851 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4852 defer endTimer()
4853 defer span.End()
4854 request, ok := in.Request.(*smithyhttp.Request)
4855 if !ok {
4856 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4857 }
4858
4859 input, ok := in.Parameters.(*GetContainerServicesInput)
4860 _ = input
4861 if !ok {
4862 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4863 }
4864
4865 operationPath := "/"
4866 if len(request.Request.URL.Path) == 0 {
4867 request.Request.URL.Path = operationPath
4868 } else {
4869 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4870 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4871 request.Request.URL.Path += "/"
4872 }
4873 }
4874 request.Request.Method = "POST"
4875 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4876 if err != nil {
4877 return out, metadata, &smithy.SerializationError{Err: err}
4878 }
4879 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4880 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerServices")
4881
4882 jsonEncoder := smithyjson.NewEncoder()
4883 if err := awsAwsjson11_serializeOpDocumentGetContainerServicesInput(input, jsonEncoder.Value); err != nil {
4884 return out, metadata, &smithy.SerializationError{Err: err}
4885 }
4886
4887 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4888 return out, metadata, &smithy.SerializationError{Err: err}
4889 }
4890
4891 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4892 return out, metadata, &smithy.SerializationError{Err: err}
4893 }
4894 in.Request = request
4895
4896 endTimer()
4897 span.End()
4898 return next.HandleSerialize(ctx, in)
4899 }
4900
4901 type awsAwsjson11_serializeOpGetCostEstimate struct {
4902 }
4903
4904 func (*awsAwsjson11_serializeOpGetCostEstimate) ID() string {
4905 return "OperationSerializer"
4906 }
4907
4908 func (m *awsAwsjson11_serializeOpGetCostEstimate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4909 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4910 ) {
4911 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4912 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4913 defer endTimer()
4914 defer span.End()
4915 request, ok := in.Request.(*smithyhttp.Request)
4916 if !ok {
4917 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4918 }
4919
4920 input, ok := in.Parameters.(*GetCostEstimateInput)
4921 _ = input
4922 if !ok {
4923 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4924 }
4925
4926 operationPath := "/"
4927 if len(request.Request.URL.Path) == 0 {
4928 request.Request.URL.Path = operationPath
4929 } else {
4930 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4931 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4932 request.Request.URL.Path += "/"
4933 }
4934 }
4935 request.Request.Method = "POST"
4936 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4937 if err != nil {
4938 return out, metadata, &smithy.SerializationError{Err: err}
4939 }
4940 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4941 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetCostEstimate")
4942
4943 jsonEncoder := smithyjson.NewEncoder()
4944 if err := awsAwsjson11_serializeOpDocumentGetCostEstimateInput(input, jsonEncoder.Value); err != nil {
4945 return out, metadata, &smithy.SerializationError{Err: err}
4946 }
4947
4948 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4949 return out, metadata, &smithy.SerializationError{Err: err}
4950 }
4951
4952 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4953 return out, metadata, &smithy.SerializationError{Err: err}
4954 }
4955 in.Request = request
4956
4957 endTimer()
4958 span.End()
4959 return next.HandleSerialize(ctx, in)
4960 }
4961
4962 type awsAwsjson11_serializeOpGetDisk struct {
4963 }
4964
4965 func (*awsAwsjson11_serializeOpGetDisk) ID() string {
4966 return "OperationSerializer"
4967 }
4968
4969 func (m *awsAwsjson11_serializeOpGetDisk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4970 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4971 ) {
4972 _, span := tracing.StartSpan(ctx, "OperationSerializer")
4973 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
4974 defer endTimer()
4975 defer span.End()
4976 request, ok := in.Request.(*smithyhttp.Request)
4977 if !ok {
4978 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4979 }
4980
4981 input, ok := in.Parameters.(*GetDiskInput)
4982 _ = input
4983 if !ok {
4984 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4985 }
4986
4987 operationPath := "/"
4988 if len(request.Request.URL.Path) == 0 {
4989 request.Request.URL.Path = operationPath
4990 } else {
4991 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
4992 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
4993 request.Request.URL.Path += "/"
4994 }
4995 }
4996 request.Request.Method = "POST"
4997 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4998 if err != nil {
4999 return out, metadata, &smithy.SerializationError{Err: err}
5000 }
5001 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5002 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDisk")
5003
5004 jsonEncoder := smithyjson.NewEncoder()
5005 if err := awsAwsjson11_serializeOpDocumentGetDiskInput(input, jsonEncoder.Value); err != nil {
5006 return out, metadata, &smithy.SerializationError{Err: err}
5007 }
5008
5009 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5010 return out, metadata, &smithy.SerializationError{Err: err}
5011 }
5012
5013 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5014 return out, metadata, &smithy.SerializationError{Err: err}
5015 }
5016 in.Request = request
5017
5018 endTimer()
5019 span.End()
5020 return next.HandleSerialize(ctx, in)
5021 }
5022
5023 type awsAwsjson11_serializeOpGetDisks struct {
5024 }
5025
5026 func (*awsAwsjson11_serializeOpGetDisks) ID() string {
5027 return "OperationSerializer"
5028 }
5029
5030 func (m *awsAwsjson11_serializeOpGetDisks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5031 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5032 ) {
5033 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5034 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5035 defer endTimer()
5036 defer span.End()
5037 request, ok := in.Request.(*smithyhttp.Request)
5038 if !ok {
5039 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5040 }
5041
5042 input, ok := in.Parameters.(*GetDisksInput)
5043 _ = input
5044 if !ok {
5045 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5046 }
5047
5048 operationPath := "/"
5049 if len(request.Request.URL.Path) == 0 {
5050 request.Request.URL.Path = operationPath
5051 } else {
5052 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5053 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5054 request.Request.URL.Path += "/"
5055 }
5056 }
5057 request.Request.Method = "POST"
5058 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5059 if err != nil {
5060 return out, metadata, &smithy.SerializationError{Err: err}
5061 }
5062 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5063 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDisks")
5064
5065 jsonEncoder := smithyjson.NewEncoder()
5066 if err := awsAwsjson11_serializeOpDocumentGetDisksInput(input, jsonEncoder.Value); err != nil {
5067 return out, metadata, &smithy.SerializationError{Err: err}
5068 }
5069
5070 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5071 return out, metadata, &smithy.SerializationError{Err: err}
5072 }
5073
5074 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5075 return out, metadata, &smithy.SerializationError{Err: err}
5076 }
5077 in.Request = request
5078
5079 endTimer()
5080 span.End()
5081 return next.HandleSerialize(ctx, in)
5082 }
5083
5084 type awsAwsjson11_serializeOpGetDiskSnapshot struct {
5085 }
5086
5087 func (*awsAwsjson11_serializeOpGetDiskSnapshot) ID() string {
5088 return "OperationSerializer"
5089 }
5090
5091 func (m *awsAwsjson11_serializeOpGetDiskSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5092 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5093 ) {
5094 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5095 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5096 defer endTimer()
5097 defer span.End()
5098 request, ok := in.Request.(*smithyhttp.Request)
5099 if !ok {
5100 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5101 }
5102
5103 input, ok := in.Parameters.(*GetDiskSnapshotInput)
5104 _ = input
5105 if !ok {
5106 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5107 }
5108
5109 operationPath := "/"
5110 if len(request.Request.URL.Path) == 0 {
5111 request.Request.URL.Path = operationPath
5112 } else {
5113 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5114 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5115 request.Request.URL.Path += "/"
5116 }
5117 }
5118 request.Request.Method = "POST"
5119 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5120 if err != nil {
5121 return out, metadata, &smithy.SerializationError{Err: err}
5122 }
5123 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5124 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDiskSnapshot")
5125
5126 jsonEncoder := smithyjson.NewEncoder()
5127 if err := awsAwsjson11_serializeOpDocumentGetDiskSnapshotInput(input, jsonEncoder.Value); err != nil {
5128 return out, metadata, &smithy.SerializationError{Err: err}
5129 }
5130
5131 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5132 return out, metadata, &smithy.SerializationError{Err: err}
5133 }
5134
5135 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5136 return out, metadata, &smithy.SerializationError{Err: err}
5137 }
5138 in.Request = request
5139
5140 endTimer()
5141 span.End()
5142 return next.HandleSerialize(ctx, in)
5143 }
5144
5145 type awsAwsjson11_serializeOpGetDiskSnapshots struct {
5146 }
5147
5148 func (*awsAwsjson11_serializeOpGetDiskSnapshots) ID() string {
5149 return "OperationSerializer"
5150 }
5151
5152 func (m *awsAwsjson11_serializeOpGetDiskSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5153 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5154 ) {
5155 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5156 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5157 defer endTimer()
5158 defer span.End()
5159 request, ok := in.Request.(*smithyhttp.Request)
5160 if !ok {
5161 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5162 }
5163
5164 input, ok := in.Parameters.(*GetDiskSnapshotsInput)
5165 _ = input
5166 if !ok {
5167 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5168 }
5169
5170 operationPath := "/"
5171 if len(request.Request.URL.Path) == 0 {
5172 request.Request.URL.Path = operationPath
5173 } else {
5174 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5175 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5176 request.Request.URL.Path += "/"
5177 }
5178 }
5179 request.Request.Method = "POST"
5180 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5181 if err != nil {
5182 return out, metadata, &smithy.SerializationError{Err: err}
5183 }
5184 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5185 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDiskSnapshots")
5186
5187 jsonEncoder := smithyjson.NewEncoder()
5188 if err := awsAwsjson11_serializeOpDocumentGetDiskSnapshotsInput(input, jsonEncoder.Value); err != nil {
5189 return out, metadata, &smithy.SerializationError{Err: err}
5190 }
5191
5192 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5193 return out, metadata, &smithy.SerializationError{Err: err}
5194 }
5195
5196 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5197 return out, metadata, &smithy.SerializationError{Err: err}
5198 }
5199 in.Request = request
5200
5201 endTimer()
5202 span.End()
5203 return next.HandleSerialize(ctx, in)
5204 }
5205
5206 type awsAwsjson11_serializeOpGetDistributionBundles struct {
5207 }
5208
5209 func (*awsAwsjson11_serializeOpGetDistributionBundles) ID() string {
5210 return "OperationSerializer"
5211 }
5212
5213 func (m *awsAwsjson11_serializeOpGetDistributionBundles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5214 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5215 ) {
5216 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5217 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5218 defer endTimer()
5219 defer span.End()
5220 request, ok := in.Request.(*smithyhttp.Request)
5221 if !ok {
5222 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5223 }
5224
5225 input, ok := in.Parameters.(*GetDistributionBundlesInput)
5226 _ = input
5227 if !ok {
5228 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5229 }
5230
5231 operationPath := "/"
5232 if len(request.Request.URL.Path) == 0 {
5233 request.Request.URL.Path = operationPath
5234 } else {
5235 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5236 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5237 request.Request.URL.Path += "/"
5238 }
5239 }
5240 request.Request.Method = "POST"
5241 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5242 if err != nil {
5243 return out, metadata, &smithy.SerializationError{Err: err}
5244 }
5245 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5246 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDistributionBundles")
5247
5248 jsonEncoder := smithyjson.NewEncoder()
5249 if err := awsAwsjson11_serializeOpDocumentGetDistributionBundlesInput(input, jsonEncoder.Value); err != nil {
5250 return out, metadata, &smithy.SerializationError{Err: err}
5251 }
5252
5253 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5254 return out, metadata, &smithy.SerializationError{Err: err}
5255 }
5256
5257 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5258 return out, metadata, &smithy.SerializationError{Err: err}
5259 }
5260 in.Request = request
5261
5262 endTimer()
5263 span.End()
5264 return next.HandleSerialize(ctx, in)
5265 }
5266
5267 type awsAwsjson11_serializeOpGetDistributionLatestCacheReset struct {
5268 }
5269
5270 func (*awsAwsjson11_serializeOpGetDistributionLatestCacheReset) ID() string {
5271 return "OperationSerializer"
5272 }
5273
5274 func (m *awsAwsjson11_serializeOpGetDistributionLatestCacheReset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5275 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5276 ) {
5277 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5278 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5279 defer endTimer()
5280 defer span.End()
5281 request, ok := in.Request.(*smithyhttp.Request)
5282 if !ok {
5283 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5284 }
5285
5286 input, ok := in.Parameters.(*GetDistributionLatestCacheResetInput)
5287 _ = input
5288 if !ok {
5289 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5290 }
5291
5292 operationPath := "/"
5293 if len(request.Request.URL.Path) == 0 {
5294 request.Request.URL.Path = operationPath
5295 } else {
5296 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5297 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5298 request.Request.URL.Path += "/"
5299 }
5300 }
5301 request.Request.Method = "POST"
5302 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5303 if err != nil {
5304 return out, metadata, &smithy.SerializationError{Err: err}
5305 }
5306 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5307 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDistributionLatestCacheReset")
5308
5309 jsonEncoder := smithyjson.NewEncoder()
5310 if err := awsAwsjson11_serializeOpDocumentGetDistributionLatestCacheResetInput(input, jsonEncoder.Value); err != nil {
5311 return out, metadata, &smithy.SerializationError{Err: err}
5312 }
5313
5314 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5315 return out, metadata, &smithy.SerializationError{Err: err}
5316 }
5317
5318 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5319 return out, metadata, &smithy.SerializationError{Err: err}
5320 }
5321 in.Request = request
5322
5323 endTimer()
5324 span.End()
5325 return next.HandleSerialize(ctx, in)
5326 }
5327
5328 type awsAwsjson11_serializeOpGetDistributionMetricData struct {
5329 }
5330
5331 func (*awsAwsjson11_serializeOpGetDistributionMetricData) ID() string {
5332 return "OperationSerializer"
5333 }
5334
5335 func (m *awsAwsjson11_serializeOpGetDistributionMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5336 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5337 ) {
5338 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5339 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5340 defer endTimer()
5341 defer span.End()
5342 request, ok := in.Request.(*smithyhttp.Request)
5343 if !ok {
5344 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5345 }
5346
5347 input, ok := in.Parameters.(*GetDistributionMetricDataInput)
5348 _ = input
5349 if !ok {
5350 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5351 }
5352
5353 operationPath := "/"
5354 if len(request.Request.URL.Path) == 0 {
5355 request.Request.URL.Path = operationPath
5356 } else {
5357 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5358 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5359 request.Request.URL.Path += "/"
5360 }
5361 }
5362 request.Request.Method = "POST"
5363 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5364 if err != nil {
5365 return out, metadata, &smithy.SerializationError{Err: err}
5366 }
5367 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5368 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDistributionMetricData")
5369
5370 jsonEncoder := smithyjson.NewEncoder()
5371 if err := awsAwsjson11_serializeOpDocumentGetDistributionMetricDataInput(input, jsonEncoder.Value); err != nil {
5372 return out, metadata, &smithy.SerializationError{Err: err}
5373 }
5374
5375 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5376 return out, metadata, &smithy.SerializationError{Err: err}
5377 }
5378
5379 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5380 return out, metadata, &smithy.SerializationError{Err: err}
5381 }
5382 in.Request = request
5383
5384 endTimer()
5385 span.End()
5386 return next.HandleSerialize(ctx, in)
5387 }
5388
5389 type awsAwsjson11_serializeOpGetDistributions struct {
5390 }
5391
5392 func (*awsAwsjson11_serializeOpGetDistributions) ID() string {
5393 return "OperationSerializer"
5394 }
5395
5396 func (m *awsAwsjson11_serializeOpGetDistributions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5397 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5398 ) {
5399 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5400 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5401 defer endTimer()
5402 defer span.End()
5403 request, ok := in.Request.(*smithyhttp.Request)
5404 if !ok {
5405 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5406 }
5407
5408 input, ok := in.Parameters.(*GetDistributionsInput)
5409 _ = input
5410 if !ok {
5411 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5412 }
5413
5414 operationPath := "/"
5415 if len(request.Request.URL.Path) == 0 {
5416 request.Request.URL.Path = operationPath
5417 } else {
5418 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5419 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5420 request.Request.URL.Path += "/"
5421 }
5422 }
5423 request.Request.Method = "POST"
5424 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5425 if err != nil {
5426 return out, metadata, &smithy.SerializationError{Err: err}
5427 }
5428 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5429 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDistributions")
5430
5431 jsonEncoder := smithyjson.NewEncoder()
5432 if err := awsAwsjson11_serializeOpDocumentGetDistributionsInput(input, jsonEncoder.Value); err != nil {
5433 return out, metadata, &smithy.SerializationError{Err: err}
5434 }
5435
5436 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5437 return out, metadata, &smithy.SerializationError{Err: err}
5438 }
5439
5440 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5441 return out, metadata, &smithy.SerializationError{Err: err}
5442 }
5443 in.Request = request
5444
5445 endTimer()
5446 span.End()
5447 return next.HandleSerialize(ctx, in)
5448 }
5449
5450 type awsAwsjson11_serializeOpGetDomain struct {
5451 }
5452
5453 func (*awsAwsjson11_serializeOpGetDomain) ID() string {
5454 return "OperationSerializer"
5455 }
5456
5457 func (m *awsAwsjson11_serializeOpGetDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5458 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5459 ) {
5460 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5461 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5462 defer endTimer()
5463 defer span.End()
5464 request, ok := in.Request.(*smithyhttp.Request)
5465 if !ok {
5466 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5467 }
5468
5469 input, ok := in.Parameters.(*GetDomainInput)
5470 _ = input
5471 if !ok {
5472 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5473 }
5474
5475 operationPath := "/"
5476 if len(request.Request.URL.Path) == 0 {
5477 request.Request.URL.Path = operationPath
5478 } else {
5479 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5480 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5481 request.Request.URL.Path += "/"
5482 }
5483 }
5484 request.Request.Method = "POST"
5485 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5486 if err != nil {
5487 return out, metadata, &smithy.SerializationError{Err: err}
5488 }
5489 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5490 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDomain")
5491
5492 jsonEncoder := smithyjson.NewEncoder()
5493 if err := awsAwsjson11_serializeOpDocumentGetDomainInput(input, jsonEncoder.Value); err != nil {
5494 return out, metadata, &smithy.SerializationError{Err: err}
5495 }
5496
5497 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5498 return out, metadata, &smithy.SerializationError{Err: err}
5499 }
5500
5501 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5502 return out, metadata, &smithy.SerializationError{Err: err}
5503 }
5504 in.Request = request
5505
5506 endTimer()
5507 span.End()
5508 return next.HandleSerialize(ctx, in)
5509 }
5510
5511 type awsAwsjson11_serializeOpGetDomains struct {
5512 }
5513
5514 func (*awsAwsjson11_serializeOpGetDomains) ID() string {
5515 return "OperationSerializer"
5516 }
5517
5518 func (m *awsAwsjson11_serializeOpGetDomains) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5519 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5520 ) {
5521 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5522 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5523 defer endTimer()
5524 defer span.End()
5525 request, ok := in.Request.(*smithyhttp.Request)
5526 if !ok {
5527 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5528 }
5529
5530 input, ok := in.Parameters.(*GetDomainsInput)
5531 _ = input
5532 if !ok {
5533 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5534 }
5535
5536 operationPath := "/"
5537 if len(request.Request.URL.Path) == 0 {
5538 request.Request.URL.Path = operationPath
5539 } else {
5540 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5541 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5542 request.Request.URL.Path += "/"
5543 }
5544 }
5545 request.Request.Method = "POST"
5546 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5547 if err != nil {
5548 return out, metadata, &smithy.SerializationError{Err: err}
5549 }
5550 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5551 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDomains")
5552
5553 jsonEncoder := smithyjson.NewEncoder()
5554 if err := awsAwsjson11_serializeOpDocumentGetDomainsInput(input, jsonEncoder.Value); err != nil {
5555 return out, metadata, &smithy.SerializationError{Err: err}
5556 }
5557
5558 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5559 return out, metadata, &smithy.SerializationError{Err: err}
5560 }
5561
5562 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5563 return out, metadata, &smithy.SerializationError{Err: err}
5564 }
5565 in.Request = request
5566
5567 endTimer()
5568 span.End()
5569 return next.HandleSerialize(ctx, in)
5570 }
5571
5572 type awsAwsjson11_serializeOpGetExportSnapshotRecords struct {
5573 }
5574
5575 func (*awsAwsjson11_serializeOpGetExportSnapshotRecords) ID() string {
5576 return "OperationSerializer"
5577 }
5578
5579 func (m *awsAwsjson11_serializeOpGetExportSnapshotRecords) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5580 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5581 ) {
5582 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5583 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5584 defer endTimer()
5585 defer span.End()
5586 request, ok := in.Request.(*smithyhttp.Request)
5587 if !ok {
5588 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5589 }
5590
5591 input, ok := in.Parameters.(*GetExportSnapshotRecordsInput)
5592 _ = input
5593 if !ok {
5594 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5595 }
5596
5597 operationPath := "/"
5598 if len(request.Request.URL.Path) == 0 {
5599 request.Request.URL.Path = operationPath
5600 } else {
5601 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5602 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5603 request.Request.URL.Path += "/"
5604 }
5605 }
5606 request.Request.Method = "POST"
5607 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5608 if err != nil {
5609 return out, metadata, &smithy.SerializationError{Err: err}
5610 }
5611 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5612 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetExportSnapshotRecords")
5613
5614 jsonEncoder := smithyjson.NewEncoder()
5615 if err := awsAwsjson11_serializeOpDocumentGetExportSnapshotRecordsInput(input, jsonEncoder.Value); err != nil {
5616 return out, metadata, &smithy.SerializationError{Err: err}
5617 }
5618
5619 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5620 return out, metadata, &smithy.SerializationError{Err: err}
5621 }
5622
5623 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5624 return out, metadata, &smithy.SerializationError{Err: err}
5625 }
5626 in.Request = request
5627
5628 endTimer()
5629 span.End()
5630 return next.HandleSerialize(ctx, in)
5631 }
5632
5633 type awsAwsjson11_serializeOpGetInstance struct {
5634 }
5635
5636 func (*awsAwsjson11_serializeOpGetInstance) ID() string {
5637 return "OperationSerializer"
5638 }
5639
5640 func (m *awsAwsjson11_serializeOpGetInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5641 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5642 ) {
5643 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5644 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5645 defer endTimer()
5646 defer span.End()
5647 request, ok := in.Request.(*smithyhttp.Request)
5648 if !ok {
5649 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5650 }
5651
5652 input, ok := in.Parameters.(*GetInstanceInput)
5653 _ = input
5654 if !ok {
5655 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5656 }
5657
5658 operationPath := "/"
5659 if len(request.Request.URL.Path) == 0 {
5660 request.Request.URL.Path = operationPath
5661 } else {
5662 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5663 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5664 request.Request.URL.Path += "/"
5665 }
5666 }
5667 request.Request.Method = "POST"
5668 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5669 if err != nil {
5670 return out, metadata, &smithy.SerializationError{Err: err}
5671 }
5672 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5673 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstance")
5674
5675 jsonEncoder := smithyjson.NewEncoder()
5676 if err := awsAwsjson11_serializeOpDocumentGetInstanceInput(input, jsonEncoder.Value); err != nil {
5677 return out, metadata, &smithy.SerializationError{Err: err}
5678 }
5679
5680 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5681 return out, metadata, &smithy.SerializationError{Err: err}
5682 }
5683
5684 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5685 return out, metadata, &smithy.SerializationError{Err: err}
5686 }
5687 in.Request = request
5688
5689 endTimer()
5690 span.End()
5691 return next.HandleSerialize(ctx, in)
5692 }
5693
5694 type awsAwsjson11_serializeOpGetInstanceAccessDetails struct {
5695 }
5696
5697 func (*awsAwsjson11_serializeOpGetInstanceAccessDetails) ID() string {
5698 return "OperationSerializer"
5699 }
5700
5701 func (m *awsAwsjson11_serializeOpGetInstanceAccessDetails) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5702 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5703 ) {
5704 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5705 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5706 defer endTimer()
5707 defer span.End()
5708 request, ok := in.Request.(*smithyhttp.Request)
5709 if !ok {
5710 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5711 }
5712
5713 input, ok := in.Parameters.(*GetInstanceAccessDetailsInput)
5714 _ = input
5715 if !ok {
5716 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5717 }
5718
5719 operationPath := "/"
5720 if len(request.Request.URL.Path) == 0 {
5721 request.Request.URL.Path = operationPath
5722 } else {
5723 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5724 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5725 request.Request.URL.Path += "/"
5726 }
5727 }
5728 request.Request.Method = "POST"
5729 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5730 if err != nil {
5731 return out, metadata, &smithy.SerializationError{Err: err}
5732 }
5733 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5734 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstanceAccessDetails")
5735
5736 jsonEncoder := smithyjson.NewEncoder()
5737 if err := awsAwsjson11_serializeOpDocumentGetInstanceAccessDetailsInput(input, jsonEncoder.Value); err != nil {
5738 return out, metadata, &smithy.SerializationError{Err: err}
5739 }
5740
5741 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5742 return out, metadata, &smithy.SerializationError{Err: err}
5743 }
5744
5745 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5746 return out, metadata, &smithy.SerializationError{Err: err}
5747 }
5748 in.Request = request
5749
5750 endTimer()
5751 span.End()
5752 return next.HandleSerialize(ctx, in)
5753 }
5754
5755 type awsAwsjson11_serializeOpGetInstanceMetricData struct {
5756 }
5757
5758 func (*awsAwsjson11_serializeOpGetInstanceMetricData) ID() string {
5759 return "OperationSerializer"
5760 }
5761
5762 func (m *awsAwsjson11_serializeOpGetInstanceMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5763 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5764 ) {
5765 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5766 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5767 defer endTimer()
5768 defer span.End()
5769 request, ok := in.Request.(*smithyhttp.Request)
5770 if !ok {
5771 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5772 }
5773
5774 input, ok := in.Parameters.(*GetInstanceMetricDataInput)
5775 _ = input
5776 if !ok {
5777 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5778 }
5779
5780 operationPath := "/"
5781 if len(request.Request.URL.Path) == 0 {
5782 request.Request.URL.Path = operationPath
5783 } else {
5784 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5785 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5786 request.Request.URL.Path += "/"
5787 }
5788 }
5789 request.Request.Method = "POST"
5790 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5791 if err != nil {
5792 return out, metadata, &smithy.SerializationError{Err: err}
5793 }
5794 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5795 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstanceMetricData")
5796
5797 jsonEncoder := smithyjson.NewEncoder()
5798 if err := awsAwsjson11_serializeOpDocumentGetInstanceMetricDataInput(input, jsonEncoder.Value); err != nil {
5799 return out, metadata, &smithy.SerializationError{Err: err}
5800 }
5801
5802 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5803 return out, metadata, &smithy.SerializationError{Err: err}
5804 }
5805
5806 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5807 return out, metadata, &smithy.SerializationError{Err: err}
5808 }
5809 in.Request = request
5810
5811 endTimer()
5812 span.End()
5813 return next.HandleSerialize(ctx, in)
5814 }
5815
5816 type awsAwsjson11_serializeOpGetInstancePortStates struct {
5817 }
5818
5819 func (*awsAwsjson11_serializeOpGetInstancePortStates) ID() string {
5820 return "OperationSerializer"
5821 }
5822
5823 func (m *awsAwsjson11_serializeOpGetInstancePortStates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5824 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5825 ) {
5826 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5827 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5828 defer endTimer()
5829 defer span.End()
5830 request, ok := in.Request.(*smithyhttp.Request)
5831 if !ok {
5832 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5833 }
5834
5835 input, ok := in.Parameters.(*GetInstancePortStatesInput)
5836 _ = input
5837 if !ok {
5838 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5839 }
5840
5841 operationPath := "/"
5842 if len(request.Request.URL.Path) == 0 {
5843 request.Request.URL.Path = operationPath
5844 } else {
5845 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5846 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5847 request.Request.URL.Path += "/"
5848 }
5849 }
5850 request.Request.Method = "POST"
5851 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5852 if err != nil {
5853 return out, metadata, &smithy.SerializationError{Err: err}
5854 }
5855 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5856 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstancePortStates")
5857
5858 jsonEncoder := smithyjson.NewEncoder()
5859 if err := awsAwsjson11_serializeOpDocumentGetInstancePortStatesInput(input, jsonEncoder.Value); err != nil {
5860 return out, metadata, &smithy.SerializationError{Err: err}
5861 }
5862
5863 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5864 return out, metadata, &smithy.SerializationError{Err: err}
5865 }
5866
5867 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5868 return out, metadata, &smithy.SerializationError{Err: err}
5869 }
5870 in.Request = request
5871
5872 endTimer()
5873 span.End()
5874 return next.HandleSerialize(ctx, in)
5875 }
5876
5877 type awsAwsjson11_serializeOpGetInstances struct {
5878 }
5879
5880 func (*awsAwsjson11_serializeOpGetInstances) ID() string {
5881 return "OperationSerializer"
5882 }
5883
5884 func (m *awsAwsjson11_serializeOpGetInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5885 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5886 ) {
5887 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5888 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5889 defer endTimer()
5890 defer span.End()
5891 request, ok := in.Request.(*smithyhttp.Request)
5892 if !ok {
5893 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5894 }
5895
5896 input, ok := in.Parameters.(*GetInstancesInput)
5897 _ = input
5898 if !ok {
5899 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5900 }
5901
5902 operationPath := "/"
5903 if len(request.Request.URL.Path) == 0 {
5904 request.Request.URL.Path = operationPath
5905 } else {
5906 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5907 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5908 request.Request.URL.Path += "/"
5909 }
5910 }
5911 request.Request.Method = "POST"
5912 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5913 if err != nil {
5914 return out, metadata, &smithy.SerializationError{Err: err}
5915 }
5916 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5917 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstances")
5918
5919 jsonEncoder := smithyjson.NewEncoder()
5920 if err := awsAwsjson11_serializeOpDocumentGetInstancesInput(input, jsonEncoder.Value); err != nil {
5921 return out, metadata, &smithy.SerializationError{Err: err}
5922 }
5923
5924 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5925 return out, metadata, &smithy.SerializationError{Err: err}
5926 }
5927
5928 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5929 return out, metadata, &smithy.SerializationError{Err: err}
5930 }
5931 in.Request = request
5932
5933 endTimer()
5934 span.End()
5935 return next.HandleSerialize(ctx, in)
5936 }
5937
5938 type awsAwsjson11_serializeOpGetInstanceSnapshot struct {
5939 }
5940
5941 func (*awsAwsjson11_serializeOpGetInstanceSnapshot) ID() string {
5942 return "OperationSerializer"
5943 }
5944
5945 func (m *awsAwsjson11_serializeOpGetInstanceSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5946 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5947 ) {
5948 _, span := tracing.StartSpan(ctx, "OperationSerializer")
5949 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
5950 defer endTimer()
5951 defer span.End()
5952 request, ok := in.Request.(*smithyhttp.Request)
5953 if !ok {
5954 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5955 }
5956
5957 input, ok := in.Parameters.(*GetInstanceSnapshotInput)
5958 _ = input
5959 if !ok {
5960 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5961 }
5962
5963 operationPath := "/"
5964 if len(request.Request.URL.Path) == 0 {
5965 request.Request.URL.Path = operationPath
5966 } else {
5967 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
5968 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
5969 request.Request.URL.Path += "/"
5970 }
5971 }
5972 request.Request.Method = "POST"
5973 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5974 if err != nil {
5975 return out, metadata, &smithy.SerializationError{Err: err}
5976 }
5977 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5978 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstanceSnapshot")
5979
5980 jsonEncoder := smithyjson.NewEncoder()
5981 if err := awsAwsjson11_serializeOpDocumentGetInstanceSnapshotInput(input, jsonEncoder.Value); err != nil {
5982 return out, metadata, &smithy.SerializationError{Err: err}
5983 }
5984
5985 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5986 return out, metadata, &smithy.SerializationError{Err: err}
5987 }
5988
5989 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5990 return out, metadata, &smithy.SerializationError{Err: err}
5991 }
5992 in.Request = request
5993
5994 endTimer()
5995 span.End()
5996 return next.HandleSerialize(ctx, in)
5997 }
5998
5999 type awsAwsjson11_serializeOpGetInstanceSnapshots struct {
6000 }
6001
6002 func (*awsAwsjson11_serializeOpGetInstanceSnapshots) ID() string {
6003 return "OperationSerializer"
6004 }
6005
6006 func (m *awsAwsjson11_serializeOpGetInstanceSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6007 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6008 ) {
6009 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6010 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6011 defer endTimer()
6012 defer span.End()
6013 request, ok := in.Request.(*smithyhttp.Request)
6014 if !ok {
6015 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6016 }
6017
6018 input, ok := in.Parameters.(*GetInstanceSnapshotsInput)
6019 _ = input
6020 if !ok {
6021 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6022 }
6023
6024 operationPath := "/"
6025 if len(request.Request.URL.Path) == 0 {
6026 request.Request.URL.Path = operationPath
6027 } else {
6028 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6029 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6030 request.Request.URL.Path += "/"
6031 }
6032 }
6033 request.Request.Method = "POST"
6034 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6035 if err != nil {
6036 return out, metadata, &smithy.SerializationError{Err: err}
6037 }
6038 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6039 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstanceSnapshots")
6040
6041 jsonEncoder := smithyjson.NewEncoder()
6042 if err := awsAwsjson11_serializeOpDocumentGetInstanceSnapshotsInput(input, jsonEncoder.Value); err != nil {
6043 return out, metadata, &smithy.SerializationError{Err: err}
6044 }
6045
6046 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6047 return out, metadata, &smithy.SerializationError{Err: err}
6048 }
6049
6050 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6051 return out, metadata, &smithy.SerializationError{Err: err}
6052 }
6053 in.Request = request
6054
6055 endTimer()
6056 span.End()
6057 return next.HandleSerialize(ctx, in)
6058 }
6059
6060 type awsAwsjson11_serializeOpGetInstanceState struct {
6061 }
6062
6063 func (*awsAwsjson11_serializeOpGetInstanceState) ID() string {
6064 return "OperationSerializer"
6065 }
6066
6067 func (m *awsAwsjson11_serializeOpGetInstanceState) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6068 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6069 ) {
6070 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6071 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6072 defer endTimer()
6073 defer span.End()
6074 request, ok := in.Request.(*smithyhttp.Request)
6075 if !ok {
6076 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6077 }
6078
6079 input, ok := in.Parameters.(*GetInstanceStateInput)
6080 _ = input
6081 if !ok {
6082 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6083 }
6084
6085 operationPath := "/"
6086 if len(request.Request.URL.Path) == 0 {
6087 request.Request.URL.Path = operationPath
6088 } else {
6089 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6090 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6091 request.Request.URL.Path += "/"
6092 }
6093 }
6094 request.Request.Method = "POST"
6095 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6096 if err != nil {
6097 return out, metadata, &smithy.SerializationError{Err: err}
6098 }
6099 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6100 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstanceState")
6101
6102 jsonEncoder := smithyjson.NewEncoder()
6103 if err := awsAwsjson11_serializeOpDocumentGetInstanceStateInput(input, jsonEncoder.Value); err != nil {
6104 return out, metadata, &smithy.SerializationError{Err: err}
6105 }
6106
6107 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6108 return out, metadata, &smithy.SerializationError{Err: err}
6109 }
6110
6111 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6112 return out, metadata, &smithy.SerializationError{Err: err}
6113 }
6114 in.Request = request
6115
6116 endTimer()
6117 span.End()
6118 return next.HandleSerialize(ctx, in)
6119 }
6120
6121 type awsAwsjson11_serializeOpGetKeyPair struct {
6122 }
6123
6124 func (*awsAwsjson11_serializeOpGetKeyPair) ID() string {
6125 return "OperationSerializer"
6126 }
6127
6128 func (m *awsAwsjson11_serializeOpGetKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6129 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6130 ) {
6131 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6132 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6133 defer endTimer()
6134 defer span.End()
6135 request, ok := in.Request.(*smithyhttp.Request)
6136 if !ok {
6137 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6138 }
6139
6140 input, ok := in.Parameters.(*GetKeyPairInput)
6141 _ = input
6142 if !ok {
6143 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6144 }
6145
6146 operationPath := "/"
6147 if len(request.Request.URL.Path) == 0 {
6148 request.Request.URL.Path = operationPath
6149 } else {
6150 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6151 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6152 request.Request.URL.Path += "/"
6153 }
6154 }
6155 request.Request.Method = "POST"
6156 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6157 if err != nil {
6158 return out, metadata, &smithy.SerializationError{Err: err}
6159 }
6160 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6161 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetKeyPair")
6162
6163 jsonEncoder := smithyjson.NewEncoder()
6164 if err := awsAwsjson11_serializeOpDocumentGetKeyPairInput(input, jsonEncoder.Value); err != nil {
6165 return out, metadata, &smithy.SerializationError{Err: err}
6166 }
6167
6168 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6169 return out, metadata, &smithy.SerializationError{Err: err}
6170 }
6171
6172 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6173 return out, metadata, &smithy.SerializationError{Err: err}
6174 }
6175 in.Request = request
6176
6177 endTimer()
6178 span.End()
6179 return next.HandleSerialize(ctx, in)
6180 }
6181
6182 type awsAwsjson11_serializeOpGetKeyPairs struct {
6183 }
6184
6185 func (*awsAwsjson11_serializeOpGetKeyPairs) ID() string {
6186 return "OperationSerializer"
6187 }
6188
6189 func (m *awsAwsjson11_serializeOpGetKeyPairs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6190 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6191 ) {
6192 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6193 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6194 defer endTimer()
6195 defer span.End()
6196 request, ok := in.Request.(*smithyhttp.Request)
6197 if !ok {
6198 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6199 }
6200
6201 input, ok := in.Parameters.(*GetKeyPairsInput)
6202 _ = input
6203 if !ok {
6204 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6205 }
6206
6207 operationPath := "/"
6208 if len(request.Request.URL.Path) == 0 {
6209 request.Request.URL.Path = operationPath
6210 } else {
6211 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6212 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6213 request.Request.URL.Path += "/"
6214 }
6215 }
6216 request.Request.Method = "POST"
6217 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6218 if err != nil {
6219 return out, metadata, &smithy.SerializationError{Err: err}
6220 }
6221 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6222 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetKeyPairs")
6223
6224 jsonEncoder := smithyjson.NewEncoder()
6225 if err := awsAwsjson11_serializeOpDocumentGetKeyPairsInput(input, jsonEncoder.Value); err != nil {
6226 return out, metadata, &smithy.SerializationError{Err: err}
6227 }
6228
6229 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6230 return out, metadata, &smithy.SerializationError{Err: err}
6231 }
6232
6233 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6234 return out, metadata, &smithy.SerializationError{Err: err}
6235 }
6236 in.Request = request
6237
6238 endTimer()
6239 span.End()
6240 return next.HandleSerialize(ctx, in)
6241 }
6242
6243 type awsAwsjson11_serializeOpGetLoadBalancer struct {
6244 }
6245
6246 func (*awsAwsjson11_serializeOpGetLoadBalancer) ID() string {
6247 return "OperationSerializer"
6248 }
6249
6250 func (m *awsAwsjson11_serializeOpGetLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6251 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6252 ) {
6253 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6254 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6255 defer endTimer()
6256 defer span.End()
6257 request, ok := in.Request.(*smithyhttp.Request)
6258 if !ok {
6259 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6260 }
6261
6262 input, ok := in.Parameters.(*GetLoadBalancerInput)
6263 _ = input
6264 if !ok {
6265 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6266 }
6267
6268 operationPath := "/"
6269 if len(request.Request.URL.Path) == 0 {
6270 request.Request.URL.Path = operationPath
6271 } else {
6272 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6273 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6274 request.Request.URL.Path += "/"
6275 }
6276 }
6277 request.Request.Method = "POST"
6278 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6279 if err != nil {
6280 return out, metadata, &smithy.SerializationError{Err: err}
6281 }
6282 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6283 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetLoadBalancer")
6284
6285 jsonEncoder := smithyjson.NewEncoder()
6286 if err := awsAwsjson11_serializeOpDocumentGetLoadBalancerInput(input, jsonEncoder.Value); err != nil {
6287 return out, metadata, &smithy.SerializationError{Err: err}
6288 }
6289
6290 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6291 return out, metadata, &smithy.SerializationError{Err: err}
6292 }
6293
6294 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6295 return out, metadata, &smithy.SerializationError{Err: err}
6296 }
6297 in.Request = request
6298
6299 endTimer()
6300 span.End()
6301 return next.HandleSerialize(ctx, in)
6302 }
6303
6304 type awsAwsjson11_serializeOpGetLoadBalancerMetricData struct {
6305 }
6306
6307 func (*awsAwsjson11_serializeOpGetLoadBalancerMetricData) ID() string {
6308 return "OperationSerializer"
6309 }
6310
6311 func (m *awsAwsjson11_serializeOpGetLoadBalancerMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6312 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6313 ) {
6314 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6315 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6316 defer endTimer()
6317 defer span.End()
6318 request, ok := in.Request.(*smithyhttp.Request)
6319 if !ok {
6320 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6321 }
6322
6323 input, ok := in.Parameters.(*GetLoadBalancerMetricDataInput)
6324 _ = input
6325 if !ok {
6326 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6327 }
6328
6329 operationPath := "/"
6330 if len(request.Request.URL.Path) == 0 {
6331 request.Request.URL.Path = operationPath
6332 } else {
6333 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6334 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6335 request.Request.URL.Path += "/"
6336 }
6337 }
6338 request.Request.Method = "POST"
6339 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6340 if err != nil {
6341 return out, metadata, &smithy.SerializationError{Err: err}
6342 }
6343 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6344 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetLoadBalancerMetricData")
6345
6346 jsonEncoder := smithyjson.NewEncoder()
6347 if err := awsAwsjson11_serializeOpDocumentGetLoadBalancerMetricDataInput(input, jsonEncoder.Value); err != nil {
6348 return out, metadata, &smithy.SerializationError{Err: err}
6349 }
6350
6351 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6352 return out, metadata, &smithy.SerializationError{Err: err}
6353 }
6354
6355 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6356 return out, metadata, &smithy.SerializationError{Err: err}
6357 }
6358 in.Request = request
6359
6360 endTimer()
6361 span.End()
6362 return next.HandleSerialize(ctx, in)
6363 }
6364
6365 type awsAwsjson11_serializeOpGetLoadBalancers struct {
6366 }
6367
6368 func (*awsAwsjson11_serializeOpGetLoadBalancers) ID() string {
6369 return "OperationSerializer"
6370 }
6371
6372 func (m *awsAwsjson11_serializeOpGetLoadBalancers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6373 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6374 ) {
6375 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6376 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6377 defer endTimer()
6378 defer span.End()
6379 request, ok := in.Request.(*smithyhttp.Request)
6380 if !ok {
6381 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6382 }
6383
6384 input, ok := in.Parameters.(*GetLoadBalancersInput)
6385 _ = input
6386 if !ok {
6387 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6388 }
6389
6390 operationPath := "/"
6391 if len(request.Request.URL.Path) == 0 {
6392 request.Request.URL.Path = operationPath
6393 } else {
6394 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6395 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6396 request.Request.URL.Path += "/"
6397 }
6398 }
6399 request.Request.Method = "POST"
6400 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6401 if err != nil {
6402 return out, metadata, &smithy.SerializationError{Err: err}
6403 }
6404 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6405 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetLoadBalancers")
6406
6407 jsonEncoder := smithyjson.NewEncoder()
6408 if err := awsAwsjson11_serializeOpDocumentGetLoadBalancersInput(input, jsonEncoder.Value); err != nil {
6409 return out, metadata, &smithy.SerializationError{Err: err}
6410 }
6411
6412 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6413 return out, metadata, &smithy.SerializationError{Err: err}
6414 }
6415
6416 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6417 return out, metadata, &smithy.SerializationError{Err: err}
6418 }
6419 in.Request = request
6420
6421 endTimer()
6422 span.End()
6423 return next.HandleSerialize(ctx, in)
6424 }
6425
6426 type awsAwsjson11_serializeOpGetLoadBalancerTlsCertificates struct {
6427 }
6428
6429 func (*awsAwsjson11_serializeOpGetLoadBalancerTlsCertificates) ID() string {
6430 return "OperationSerializer"
6431 }
6432
6433 func (m *awsAwsjson11_serializeOpGetLoadBalancerTlsCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6434 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6435 ) {
6436 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6437 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6438 defer endTimer()
6439 defer span.End()
6440 request, ok := in.Request.(*smithyhttp.Request)
6441 if !ok {
6442 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6443 }
6444
6445 input, ok := in.Parameters.(*GetLoadBalancerTlsCertificatesInput)
6446 _ = input
6447 if !ok {
6448 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6449 }
6450
6451 operationPath := "/"
6452 if len(request.Request.URL.Path) == 0 {
6453 request.Request.URL.Path = operationPath
6454 } else {
6455 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6456 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6457 request.Request.URL.Path += "/"
6458 }
6459 }
6460 request.Request.Method = "POST"
6461 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6462 if err != nil {
6463 return out, metadata, &smithy.SerializationError{Err: err}
6464 }
6465 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6466 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetLoadBalancerTlsCertificates")
6467
6468 jsonEncoder := smithyjson.NewEncoder()
6469 if err := awsAwsjson11_serializeOpDocumentGetLoadBalancerTlsCertificatesInput(input, jsonEncoder.Value); err != nil {
6470 return out, metadata, &smithy.SerializationError{Err: err}
6471 }
6472
6473 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6474 return out, metadata, &smithy.SerializationError{Err: err}
6475 }
6476
6477 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6478 return out, metadata, &smithy.SerializationError{Err: err}
6479 }
6480 in.Request = request
6481
6482 endTimer()
6483 span.End()
6484 return next.HandleSerialize(ctx, in)
6485 }
6486
6487 type awsAwsjson11_serializeOpGetLoadBalancerTlsPolicies struct {
6488 }
6489
6490 func (*awsAwsjson11_serializeOpGetLoadBalancerTlsPolicies) ID() string {
6491 return "OperationSerializer"
6492 }
6493
6494 func (m *awsAwsjson11_serializeOpGetLoadBalancerTlsPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6495 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6496 ) {
6497 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6498 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6499 defer endTimer()
6500 defer span.End()
6501 request, ok := in.Request.(*smithyhttp.Request)
6502 if !ok {
6503 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6504 }
6505
6506 input, ok := in.Parameters.(*GetLoadBalancerTlsPoliciesInput)
6507 _ = input
6508 if !ok {
6509 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6510 }
6511
6512 operationPath := "/"
6513 if len(request.Request.URL.Path) == 0 {
6514 request.Request.URL.Path = operationPath
6515 } else {
6516 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6517 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6518 request.Request.URL.Path += "/"
6519 }
6520 }
6521 request.Request.Method = "POST"
6522 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6523 if err != nil {
6524 return out, metadata, &smithy.SerializationError{Err: err}
6525 }
6526 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6527 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetLoadBalancerTlsPolicies")
6528
6529 jsonEncoder := smithyjson.NewEncoder()
6530 if err := awsAwsjson11_serializeOpDocumentGetLoadBalancerTlsPoliciesInput(input, jsonEncoder.Value); err != nil {
6531 return out, metadata, &smithy.SerializationError{Err: err}
6532 }
6533
6534 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6535 return out, metadata, &smithy.SerializationError{Err: err}
6536 }
6537
6538 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6539 return out, metadata, &smithy.SerializationError{Err: err}
6540 }
6541 in.Request = request
6542
6543 endTimer()
6544 span.End()
6545 return next.HandleSerialize(ctx, in)
6546 }
6547
6548 type awsAwsjson11_serializeOpGetOperation struct {
6549 }
6550
6551 func (*awsAwsjson11_serializeOpGetOperation) ID() string {
6552 return "OperationSerializer"
6553 }
6554
6555 func (m *awsAwsjson11_serializeOpGetOperation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6556 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6557 ) {
6558 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6559 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6560 defer endTimer()
6561 defer span.End()
6562 request, ok := in.Request.(*smithyhttp.Request)
6563 if !ok {
6564 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6565 }
6566
6567 input, ok := in.Parameters.(*GetOperationInput)
6568 _ = input
6569 if !ok {
6570 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6571 }
6572
6573 operationPath := "/"
6574 if len(request.Request.URL.Path) == 0 {
6575 request.Request.URL.Path = operationPath
6576 } else {
6577 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6578 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6579 request.Request.URL.Path += "/"
6580 }
6581 }
6582 request.Request.Method = "POST"
6583 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6584 if err != nil {
6585 return out, metadata, &smithy.SerializationError{Err: err}
6586 }
6587 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6588 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetOperation")
6589
6590 jsonEncoder := smithyjson.NewEncoder()
6591 if err := awsAwsjson11_serializeOpDocumentGetOperationInput(input, jsonEncoder.Value); err != nil {
6592 return out, metadata, &smithy.SerializationError{Err: err}
6593 }
6594
6595 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6596 return out, metadata, &smithy.SerializationError{Err: err}
6597 }
6598
6599 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6600 return out, metadata, &smithy.SerializationError{Err: err}
6601 }
6602 in.Request = request
6603
6604 endTimer()
6605 span.End()
6606 return next.HandleSerialize(ctx, in)
6607 }
6608
6609 type awsAwsjson11_serializeOpGetOperations struct {
6610 }
6611
6612 func (*awsAwsjson11_serializeOpGetOperations) ID() string {
6613 return "OperationSerializer"
6614 }
6615
6616 func (m *awsAwsjson11_serializeOpGetOperations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6617 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6618 ) {
6619 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6620 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6621 defer endTimer()
6622 defer span.End()
6623 request, ok := in.Request.(*smithyhttp.Request)
6624 if !ok {
6625 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6626 }
6627
6628 input, ok := in.Parameters.(*GetOperationsInput)
6629 _ = input
6630 if !ok {
6631 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6632 }
6633
6634 operationPath := "/"
6635 if len(request.Request.URL.Path) == 0 {
6636 request.Request.URL.Path = operationPath
6637 } else {
6638 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6639 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6640 request.Request.URL.Path += "/"
6641 }
6642 }
6643 request.Request.Method = "POST"
6644 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6645 if err != nil {
6646 return out, metadata, &smithy.SerializationError{Err: err}
6647 }
6648 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6649 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetOperations")
6650
6651 jsonEncoder := smithyjson.NewEncoder()
6652 if err := awsAwsjson11_serializeOpDocumentGetOperationsInput(input, jsonEncoder.Value); err != nil {
6653 return out, metadata, &smithy.SerializationError{Err: err}
6654 }
6655
6656 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6657 return out, metadata, &smithy.SerializationError{Err: err}
6658 }
6659
6660 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6661 return out, metadata, &smithy.SerializationError{Err: err}
6662 }
6663 in.Request = request
6664
6665 endTimer()
6666 span.End()
6667 return next.HandleSerialize(ctx, in)
6668 }
6669
6670 type awsAwsjson11_serializeOpGetOperationsForResource struct {
6671 }
6672
6673 func (*awsAwsjson11_serializeOpGetOperationsForResource) ID() string {
6674 return "OperationSerializer"
6675 }
6676
6677 func (m *awsAwsjson11_serializeOpGetOperationsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6678 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6679 ) {
6680 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6681 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6682 defer endTimer()
6683 defer span.End()
6684 request, ok := in.Request.(*smithyhttp.Request)
6685 if !ok {
6686 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6687 }
6688
6689 input, ok := in.Parameters.(*GetOperationsForResourceInput)
6690 _ = input
6691 if !ok {
6692 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6693 }
6694
6695 operationPath := "/"
6696 if len(request.Request.URL.Path) == 0 {
6697 request.Request.URL.Path = operationPath
6698 } else {
6699 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6700 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6701 request.Request.URL.Path += "/"
6702 }
6703 }
6704 request.Request.Method = "POST"
6705 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6706 if err != nil {
6707 return out, metadata, &smithy.SerializationError{Err: err}
6708 }
6709 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6710 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetOperationsForResource")
6711
6712 jsonEncoder := smithyjson.NewEncoder()
6713 if err := awsAwsjson11_serializeOpDocumentGetOperationsForResourceInput(input, jsonEncoder.Value); err != nil {
6714 return out, metadata, &smithy.SerializationError{Err: err}
6715 }
6716
6717 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6718 return out, metadata, &smithy.SerializationError{Err: err}
6719 }
6720
6721 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6722 return out, metadata, &smithy.SerializationError{Err: err}
6723 }
6724 in.Request = request
6725
6726 endTimer()
6727 span.End()
6728 return next.HandleSerialize(ctx, in)
6729 }
6730
6731 type awsAwsjson11_serializeOpGetRegions struct {
6732 }
6733
6734 func (*awsAwsjson11_serializeOpGetRegions) ID() string {
6735 return "OperationSerializer"
6736 }
6737
6738 func (m *awsAwsjson11_serializeOpGetRegions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6739 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6740 ) {
6741 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6742 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6743 defer endTimer()
6744 defer span.End()
6745 request, ok := in.Request.(*smithyhttp.Request)
6746 if !ok {
6747 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6748 }
6749
6750 input, ok := in.Parameters.(*GetRegionsInput)
6751 _ = input
6752 if !ok {
6753 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6754 }
6755
6756 operationPath := "/"
6757 if len(request.Request.URL.Path) == 0 {
6758 request.Request.URL.Path = operationPath
6759 } else {
6760 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6761 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6762 request.Request.URL.Path += "/"
6763 }
6764 }
6765 request.Request.Method = "POST"
6766 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6767 if err != nil {
6768 return out, metadata, &smithy.SerializationError{Err: err}
6769 }
6770 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6771 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRegions")
6772
6773 jsonEncoder := smithyjson.NewEncoder()
6774 if err := awsAwsjson11_serializeOpDocumentGetRegionsInput(input, jsonEncoder.Value); err != nil {
6775 return out, metadata, &smithy.SerializationError{Err: err}
6776 }
6777
6778 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6779 return out, metadata, &smithy.SerializationError{Err: err}
6780 }
6781
6782 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6783 return out, metadata, &smithy.SerializationError{Err: err}
6784 }
6785 in.Request = request
6786
6787 endTimer()
6788 span.End()
6789 return next.HandleSerialize(ctx, in)
6790 }
6791
6792 type awsAwsjson11_serializeOpGetRelationalDatabase struct {
6793 }
6794
6795 func (*awsAwsjson11_serializeOpGetRelationalDatabase) ID() string {
6796 return "OperationSerializer"
6797 }
6798
6799 func (m *awsAwsjson11_serializeOpGetRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6800 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6801 ) {
6802 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6803 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6804 defer endTimer()
6805 defer span.End()
6806 request, ok := in.Request.(*smithyhttp.Request)
6807 if !ok {
6808 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6809 }
6810
6811 input, ok := in.Parameters.(*GetRelationalDatabaseInput)
6812 _ = input
6813 if !ok {
6814 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6815 }
6816
6817 operationPath := "/"
6818 if len(request.Request.URL.Path) == 0 {
6819 request.Request.URL.Path = operationPath
6820 } else {
6821 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6822 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6823 request.Request.URL.Path += "/"
6824 }
6825 }
6826 request.Request.Method = "POST"
6827 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6828 if err != nil {
6829 return out, metadata, &smithy.SerializationError{Err: err}
6830 }
6831 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6832 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabase")
6833
6834 jsonEncoder := smithyjson.NewEncoder()
6835 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
6836 return out, metadata, &smithy.SerializationError{Err: err}
6837 }
6838
6839 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6840 return out, metadata, &smithy.SerializationError{Err: err}
6841 }
6842
6843 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6844 return out, metadata, &smithy.SerializationError{Err: err}
6845 }
6846 in.Request = request
6847
6848 endTimer()
6849 span.End()
6850 return next.HandleSerialize(ctx, in)
6851 }
6852
6853 type awsAwsjson11_serializeOpGetRelationalDatabaseBlueprints struct {
6854 }
6855
6856 func (*awsAwsjson11_serializeOpGetRelationalDatabaseBlueprints) ID() string {
6857 return "OperationSerializer"
6858 }
6859
6860 func (m *awsAwsjson11_serializeOpGetRelationalDatabaseBlueprints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6861 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6862 ) {
6863 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6864 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6865 defer endTimer()
6866 defer span.End()
6867 request, ok := in.Request.(*smithyhttp.Request)
6868 if !ok {
6869 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6870 }
6871
6872 input, ok := in.Parameters.(*GetRelationalDatabaseBlueprintsInput)
6873 _ = input
6874 if !ok {
6875 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6876 }
6877
6878 operationPath := "/"
6879 if len(request.Request.URL.Path) == 0 {
6880 request.Request.URL.Path = operationPath
6881 } else {
6882 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6883 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6884 request.Request.URL.Path += "/"
6885 }
6886 }
6887 request.Request.Method = "POST"
6888 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6889 if err != nil {
6890 return out, metadata, &smithy.SerializationError{Err: err}
6891 }
6892 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6893 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseBlueprints")
6894
6895 jsonEncoder := smithyjson.NewEncoder()
6896 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseBlueprintsInput(input, jsonEncoder.Value); err != nil {
6897 return out, metadata, &smithy.SerializationError{Err: err}
6898 }
6899
6900 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6901 return out, metadata, &smithy.SerializationError{Err: err}
6902 }
6903
6904 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6905 return out, metadata, &smithy.SerializationError{Err: err}
6906 }
6907 in.Request = request
6908
6909 endTimer()
6910 span.End()
6911 return next.HandleSerialize(ctx, in)
6912 }
6913
6914 type awsAwsjson11_serializeOpGetRelationalDatabaseBundles struct {
6915 }
6916
6917 func (*awsAwsjson11_serializeOpGetRelationalDatabaseBundles) ID() string {
6918 return "OperationSerializer"
6919 }
6920
6921 func (m *awsAwsjson11_serializeOpGetRelationalDatabaseBundles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6922 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6923 ) {
6924 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6925 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6926 defer endTimer()
6927 defer span.End()
6928 request, ok := in.Request.(*smithyhttp.Request)
6929 if !ok {
6930 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6931 }
6932
6933 input, ok := in.Parameters.(*GetRelationalDatabaseBundlesInput)
6934 _ = input
6935 if !ok {
6936 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6937 }
6938
6939 operationPath := "/"
6940 if len(request.Request.URL.Path) == 0 {
6941 request.Request.URL.Path = operationPath
6942 } else {
6943 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
6944 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
6945 request.Request.URL.Path += "/"
6946 }
6947 }
6948 request.Request.Method = "POST"
6949 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6950 if err != nil {
6951 return out, metadata, &smithy.SerializationError{Err: err}
6952 }
6953 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6954 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseBundles")
6955
6956 jsonEncoder := smithyjson.NewEncoder()
6957 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseBundlesInput(input, jsonEncoder.Value); err != nil {
6958 return out, metadata, &smithy.SerializationError{Err: err}
6959 }
6960
6961 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6962 return out, metadata, &smithy.SerializationError{Err: err}
6963 }
6964
6965 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6966 return out, metadata, &smithy.SerializationError{Err: err}
6967 }
6968 in.Request = request
6969
6970 endTimer()
6971 span.End()
6972 return next.HandleSerialize(ctx, in)
6973 }
6974
6975 type awsAwsjson11_serializeOpGetRelationalDatabaseEvents struct {
6976 }
6977
6978 func (*awsAwsjson11_serializeOpGetRelationalDatabaseEvents) ID() string {
6979 return "OperationSerializer"
6980 }
6981
6982 func (m *awsAwsjson11_serializeOpGetRelationalDatabaseEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6983 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6984 ) {
6985 _, span := tracing.StartSpan(ctx, "OperationSerializer")
6986 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
6987 defer endTimer()
6988 defer span.End()
6989 request, ok := in.Request.(*smithyhttp.Request)
6990 if !ok {
6991 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6992 }
6993
6994 input, ok := in.Parameters.(*GetRelationalDatabaseEventsInput)
6995 _ = input
6996 if !ok {
6997 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6998 }
6999
7000 operationPath := "/"
7001 if len(request.Request.URL.Path) == 0 {
7002 request.Request.URL.Path = operationPath
7003 } else {
7004 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7005 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7006 request.Request.URL.Path += "/"
7007 }
7008 }
7009 request.Request.Method = "POST"
7010 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7011 if err != nil {
7012 return out, metadata, &smithy.SerializationError{Err: err}
7013 }
7014 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7015 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseEvents")
7016
7017 jsonEncoder := smithyjson.NewEncoder()
7018 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseEventsInput(input, jsonEncoder.Value); err != nil {
7019 return out, metadata, &smithy.SerializationError{Err: err}
7020 }
7021
7022 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7023 return out, metadata, &smithy.SerializationError{Err: err}
7024 }
7025
7026 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7027 return out, metadata, &smithy.SerializationError{Err: err}
7028 }
7029 in.Request = request
7030
7031 endTimer()
7032 span.End()
7033 return next.HandleSerialize(ctx, in)
7034 }
7035
7036 type awsAwsjson11_serializeOpGetRelationalDatabaseLogEvents struct {
7037 }
7038
7039 func (*awsAwsjson11_serializeOpGetRelationalDatabaseLogEvents) ID() string {
7040 return "OperationSerializer"
7041 }
7042
7043 func (m *awsAwsjson11_serializeOpGetRelationalDatabaseLogEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7044 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7045 ) {
7046 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7047 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7048 defer endTimer()
7049 defer span.End()
7050 request, ok := in.Request.(*smithyhttp.Request)
7051 if !ok {
7052 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7053 }
7054
7055 input, ok := in.Parameters.(*GetRelationalDatabaseLogEventsInput)
7056 _ = input
7057 if !ok {
7058 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7059 }
7060
7061 operationPath := "/"
7062 if len(request.Request.URL.Path) == 0 {
7063 request.Request.URL.Path = operationPath
7064 } else {
7065 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7066 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7067 request.Request.URL.Path += "/"
7068 }
7069 }
7070 request.Request.Method = "POST"
7071 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7072 if err != nil {
7073 return out, metadata, &smithy.SerializationError{Err: err}
7074 }
7075 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7076 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseLogEvents")
7077
7078 jsonEncoder := smithyjson.NewEncoder()
7079 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseLogEventsInput(input, jsonEncoder.Value); err != nil {
7080 return out, metadata, &smithy.SerializationError{Err: err}
7081 }
7082
7083 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7084 return out, metadata, &smithy.SerializationError{Err: err}
7085 }
7086
7087 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7088 return out, metadata, &smithy.SerializationError{Err: err}
7089 }
7090 in.Request = request
7091
7092 endTimer()
7093 span.End()
7094 return next.HandleSerialize(ctx, in)
7095 }
7096
7097 type awsAwsjson11_serializeOpGetRelationalDatabaseLogStreams struct {
7098 }
7099
7100 func (*awsAwsjson11_serializeOpGetRelationalDatabaseLogStreams) ID() string {
7101 return "OperationSerializer"
7102 }
7103
7104 func (m *awsAwsjson11_serializeOpGetRelationalDatabaseLogStreams) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7105 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7106 ) {
7107 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7108 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7109 defer endTimer()
7110 defer span.End()
7111 request, ok := in.Request.(*smithyhttp.Request)
7112 if !ok {
7113 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7114 }
7115
7116 input, ok := in.Parameters.(*GetRelationalDatabaseLogStreamsInput)
7117 _ = input
7118 if !ok {
7119 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7120 }
7121
7122 operationPath := "/"
7123 if len(request.Request.URL.Path) == 0 {
7124 request.Request.URL.Path = operationPath
7125 } else {
7126 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7127 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7128 request.Request.URL.Path += "/"
7129 }
7130 }
7131 request.Request.Method = "POST"
7132 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7133 if err != nil {
7134 return out, metadata, &smithy.SerializationError{Err: err}
7135 }
7136 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7137 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseLogStreams")
7138
7139 jsonEncoder := smithyjson.NewEncoder()
7140 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseLogStreamsInput(input, jsonEncoder.Value); err != nil {
7141 return out, metadata, &smithy.SerializationError{Err: err}
7142 }
7143
7144 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7145 return out, metadata, &smithy.SerializationError{Err: err}
7146 }
7147
7148 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7149 return out, metadata, &smithy.SerializationError{Err: err}
7150 }
7151 in.Request = request
7152
7153 endTimer()
7154 span.End()
7155 return next.HandleSerialize(ctx, in)
7156 }
7157
7158 type awsAwsjson11_serializeOpGetRelationalDatabaseMasterUserPassword struct {
7159 }
7160
7161 func (*awsAwsjson11_serializeOpGetRelationalDatabaseMasterUserPassword) ID() string {
7162 return "OperationSerializer"
7163 }
7164
7165 func (m *awsAwsjson11_serializeOpGetRelationalDatabaseMasterUserPassword) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7166 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7167 ) {
7168 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7169 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7170 defer endTimer()
7171 defer span.End()
7172 request, ok := in.Request.(*smithyhttp.Request)
7173 if !ok {
7174 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7175 }
7176
7177 input, ok := in.Parameters.(*GetRelationalDatabaseMasterUserPasswordInput)
7178 _ = input
7179 if !ok {
7180 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7181 }
7182
7183 operationPath := "/"
7184 if len(request.Request.URL.Path) == 0 {
7185 request.Request.URL.Path = operationPath
7186 } else {
7187 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7188 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7189 request.Request.URL.Path += "/"
7190 }
7191 }
7192 request.Request.Method = "POST"
7193 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7194 if err != nil {
7195 return out, metadata, &smithy.SerializationError{Err: err}
7196 }
7197 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7198 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseMasterUserPassword")
7199
7200 jsonEncoder := smithyjson.NewEncoder()
7201 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseMasterUserPasswordInput(input, jsonEncoder.Value); err != nil {
7202 return out, metadata, &smithy.SerializationError{Err: err}
7203 }
7204
7205 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7206 return out, metadata, &smithy.SerializationError{Err: err}
7207 }
7208
7209 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7210 return out, metadata, &smithy.SerializationError{Err: err}
7211 }
7212 in.Request = request
7213
7214 endTimer()
7215 span.End()
7216 return next.HandleSerialize(ctx, in)
7217 }
7218
7219 type awsAwsjson11_serializeOpGetRelationalDatabaseMetricData struct {
7220 }
7221
7222 func (*awsAwsjson11_serializeOpGetRelationalDatabaseMetricData) ID() string {
7223 return "OperationSerializer"
7224 }
7225
7226 func (m *awsAwsjson11_serializeOpGetRelationalDatabaseMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7227 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7228 ) {
7229 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7230 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7231 defer endTimer()
7232 defer span.End()
7233 request, ok := in.Request.(*smithyhttp.Request)
7234 if !ok {
7235 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7236 }
7237
7238 input, ok := in.Parameters.(*GetRelationalDatabaseMetricDataInput)
7239 _ = input
7240 if !ok {
7241 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7242 }
7243
7244 operationPath := "/"
7245 if len(request.Request.URL.Path) == 0 {
7246 request.Request.URL.Path = operationPath
7247 } else {
7248 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7249 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7250 request.Request.URL.Path += "/"
7251 }
7252 }
7253 request.Request.Method = "POST"
7254 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7255 if err != nil {
7256 return out, metadata, &smithy.SerializationError{Err: err}
7257 }
7258 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7259 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseMetricData")
7260
7261 jsonEncoder := smithyjson.NewEncoder()
7262 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseMetricDataInput(input, jsonEncoder.Value); err != nil {
7263 return out, metadata, &smithy.SerializationError{Err: err}
7264 }
7265
7266 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7267 return out, metadata, &smithy.SerializationError{Err: err}
7268 }
7269
7270 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7271 return out, metadata, &smithy.SerializationError{Err: err}
7272 }
7273 in.Request = request
7274
7275 endTimer()
7276 span.End()
7277 return next.HandleSerialize(ctx, in)
7278 }
7279
7280 type awsAwsjson11_serializeOpGetRelationalDatabaseParameters struct {
7281 }
7282
7283 func (*awsAwsjson11_serializeOpGetRelationalDatabaseParameters) ID() string {
7284 return "OperationSerializer"
7285 }
7286
7287 func (m *awsAwsjson11_serializeOpGetRelationalDatabaseParameters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7288 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7289 ) {
7290 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7291 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7292 defer endTimer()
7293 defer span.End()
7294 request, ok := in.Request.(*smithyhttp.Request)
7295 if !ok {
7296 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7297 }
7298
7299 input, ok := in.Parameters.(*GetRelationalDatabaseParametersInput)
7300 _ = input
7301 if !ok {
7302 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7303 }
7304
7305 operationPath := "/"
7306 if len(request.Request.URL.Path) == 0 {
7307 request.Request.URL.Path = operationPath
7308 } else {
7309 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7310 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7311 request.Request.URL.Path += "/"
7312 }
7313 }
7314 request.Request.Method = "POST"
7315 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7316 if err != nil {
7317 return out, metadata, &smithy.SerializationError{Err: err}
7318 }
7319 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7320 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseParameters")
7321
7322 jsonEncoder := smithyjson.NewEncoder()
7323 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseParametersInput(input, jsonEncoder.Value); err != nil {
7324 return out, metadata, &smithy.SerializationError{Err: err}
7325 }
7326
7327 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7328 return out, metadata, &smithy.SerializationError{Err: err}
7329 }
7330
7331 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7332 return out, metadata, &smithy.SerializationError{Err: err}
7333 }
7334 in.Request = request
7335
7336 endTimer()
7337 span.End()
7338 return next.HandleSerialize(ctx, in)
7339 }
7340
7341 type awsAwsjson11_serializeOpGetRelationalDatabases struct {
7342 }
7343
7344 func (*awsAwsjson11_serializeOpGetRelationalDatabases) ID() string {
7345 return "OperationSerializer"
7346 }
7347
7348 func (m *awsAwsjson11_serializeOpGetRelationalDatabases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7349 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7350 ) {
7351 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7352 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7353 defer endTimer()
7354 defer span.End()
7355 request, ok := in.Request.(*smithyhttp.Request)
7356 if !ok {
7357 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7358 }
7359
7360 input, ok := in.Parameters.(*GetRelationalDatabasesInput)
7361 _ = input
7362 if !ok {
7363 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7364 }
7365
7366 operationPath := "/"
7367 if len(request.Request.URL.Path) == 0 {
7368 request.Request.URL.Path = operationPath
7369 } else {
7370 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7371 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7372 request.Request.URL.Path += "/"
7373 }
7374 }
7375 request.Request.Method = "POST"
7376 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7377 if err != nil {
7378 return out, metadata, &smithy.SerializationError{Err: err}
7379 }
7380 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7381 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabases")
7382
7383 jsonEncoder := smithyjson.NewEncoder()
7384 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabasesInput(input, jsonEncoder.Value); err != nil {
7385 return out, metadata, &smithy.SerializationError{Err: err}
7386 }
7387
7388 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7389 return out, metadata, &smithy.SerializationError{Err: err}
7390 }
7391
7392 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7393 return out, metadata, &smithy.SerializationError{Err: err}
7394 }
7395 in.Request = request
7396
7397 endTimer()
7398 span.End()
7399 return next.HandleSerialize(ctx, in)
7400 }
7401
7402 type awsAwsjson11_serializeOpGetRelationalDatabaseSnapshot struct {
7403 }
7404
7405 func (*awsAwsjson11_serializeOpGetRelationalDatabaseSnapshot) ID() string {
7406 return "OperationSerializer"
7407 }
7408
7409 func (m *awsAwsjson11_serializeOpGetRelationalDatabaseSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7410 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7411 ) {
7412 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7413 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7414 defer endTimer()
7415 defer span.End()
7416 request, ok := in.Request.(*smithyhttp.Request)
7417 if !ok {
7418 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7419 }
7420
7421 input, ok := in.Parameters.(*GetRelationalDatabaseSnapshotInput)
7422 _ = input
7423 if !ok {
7424 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7425 }
7426
7427 operationPath := "/"
7428 if len(request.Request.URL.Path) == 0 {
7429 request.Request.URL.Path = operationPath
7430 } else {
7431 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7432 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7433 request.Request.URL.Path += "/"
7434 }
7435 }
7436 request.Request.Method = "POST"
7437 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7438 if err != nil {
7439 return out, metadata, &smithy.SerializationError{Err: err}
7440 }
7441 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7442 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseSnapshot")
7443
7444 jsonEncoder := smithyjson.NewEncoder()
7445 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseSnapshotInput(input, jsonEncoder.Value); err != nil {
7446 return out, metadata, &smithy.SerializationError{Err: err}
7447 }
7448
7449 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7450 return out, metadata, &smithy.SerializationError{Err: err}
7451 }
7452
7453 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7454 return out, metadata, &smithy.SerializationError{Err: err}
7455 }
7456 in.Request = request
7457
7458 endTimer()
7459 span.End()
7460 return next.HandleSerialize(ctx, in)
7461 }
7462
7463 type awsAwsjson11_serializeOpGetRelationalDatabaseSnapshots struct {
7464 }
7465
7466 func (*awsAwsjson11_serializeOpGetRelationalDatabaseSnapshots) ID() string {
7467 return "OperationSerializer"
7468 }
7469
7470 func (m *awsAwsjson11_serializeOpGetRelationalDatabaseSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7471 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7472 ) {
7473 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7474 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7475 defer endTimer()
7476 defer span.End()
7477 request, ok := in.Request.(*smithyhttp.Request)
7478 if !ok {
7479 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7480 }
7481
7482 input, ok := in.Parameters.(*GetRelationalDatabaseSnapshotsInput)
7483 _ = input
7484 if !ok {
7485 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7486 }
7487
7488 operationPath := "/"
7489 if len(request.Request.URL.Path) == 0 {
7490 request.Request.URL.Path = operationPath
7491 } else {
7492 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7493 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7494 request.Request.URL.Path += "/"
7495 }
7496 }
7497 request.Request.Method = "POST"
7498 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7499 if err != nil {
7500 return out, metadata, &smithy.SerializationError{Err: err}
7501 }
7502 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7503 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseSnapshots")
7504
7505 jsonEncoder := smithyjson.NewEncoder()
7506 if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseSnapshotsInput(input, jsonEncoder.Value); err != nil {
7507 return out, metadata, &smithy.SerializationError{Err: err}
7508 }
7509
7510 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7511 return out, metadata, &smithy.SerializationError{Err: err}
7512 }
7513
7514 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7515 return out, metadata, &smithy.SerializationError{Err: err}
7516 }
7517 in.Request = request
7518
7519 endTimer()
7520 span.End()
7521 return next.HandleSerialize(ctx, in)
7522 }
7523
7524 type awsAwsjson11_serializeOpGetSetupHistory struct {
7525 }
7526
7527 func (*awsAwsjson11_serializeOpGetSetupHistory) ID() string {
7528 return "OperationSerializer"
7529 }
7530
7531 func (m *awsAwsjson11_serializeOpGetSetupHistory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7532 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7533 ) {
7534 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7535 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7536 defer endTimer()
7537 defer span.End()
7538 request, ok := in.Request.(*smithyhttp.Request)
7539 if !ok {
7540 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7541 }
7542
7543 input, ok := in.Parameters.(*GetSetupHistoryInput)
7544 _ = input
7545 if !ok {
7546 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7547 }
7548
7549 operationPath := "/"
7550 if len(request.Request.URL.Path) == 0 {
7551 request.Request.URL.Path = operationPath
7552 } else {
7553 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7554 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7555 request.Request.URL.Path += "/"
7556 }
7557 }
7558 request.Request.Method = "POST"
7559 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7560 if err != nil {
7561 return out, metadata, &smithy.SerializationError{Err: err}
7562 }
7563 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7564 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetSetupHistory")
7565
7566 jsonEncoder := smithyjson.NewEncoder()
7567 if err := awsAwsjson11_serializeOpDocumentGetSetupHistoryInput(input, jsonEncoder.Value); err != nil {
7568 return out, metadata, &smithy.SerializationError{Err: err}
7569 }
7570
7571 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7572 return out, metadata, &smithy.SerializationError{Err: err}
7573 }
7574
7575 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7576 return out, metadata, &smithy.SerializationError{Err: err}
7577 }
7578 in.Request = request
7579
7580 endTimer()
7581 span.End()
7582 return next.HandleSerialize(ctx, in)
7583 }
7584
7585 type awsAwsjson11_serializeOpGetStaticIp struct {
7586 }
7587
7588 func (*awsAwsjson11_serializeOpGetStaticIp) ID() string {
7589 return "OperationSerializer"
7590 }
7591
7592 func (m *awsAwsjson11_serializeOpGetStaticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7593 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7594 ) {
7595 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7596 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7597 defer endTimer()
7598 defer span.End()
7599 request, ok := in.Request.(*smithyhttp.Request)
7600 if !ok {
7601 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7602 }
7603
7604 input, ok := in.Parameters.(*GetStaticIpInput)
7605 _ = input
7606 if !ok {
7607 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7608 }
7609
7610 operationPath := "/"
7611 if len(request.Request.URL.Path) == 0 {
7612 request.Request.URL.Path = operationPath
7613 } else {
7614 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7615 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7616 request.Request.URL.Path += "/"
7617 }
7618 }
7619 request.Request.Method = "POST"
7620 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7621 if err != nil {
7622 return out, metadata, &smithy.SerializationError{Err: err}
7623 }
7624 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7625 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetStaticIp")
7626
7627 jsonEncoder := smithyjson.NewEncoder()
7628 if err := awsAwsjson11_serializeOpDocumentGetStaticIpInput(input, jsonEncoder.Value); err != nil {
7629 return out, metadata, &smithy.SerializationError{Err: err}
7630 }
7631
7632 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7633 return out, metadata, &smithy.SerializationError{Err: err}
7634 }
7635
7636 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7637 return out, metadata, &smithy.SerializationError{Err: err}
7638 }
7639 in.Request = request
7640
7641 endTimer()
7642 span.End()
7643 return next.HandleSerialize(ctx, in)
7644 }
7645
7646 type awsAwsjson11_serializeOpGetStaticIps struct {
7647 }
7648
7649 func (*awsAwsjson11_serializeOpGetStaticIps) ID() string {
7650 return "OperationSerializer"
7651 }
7652
7653 func (m *awsAwsjson11_serializeOpGetStaticIps) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7654 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7655 ) {
7656 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7657 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7658 defer endTimer()
7659 defer span.End()
7660 request, ok := in.Request.(*smithyhttp.Request)
7661 if !ok {
7662 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7663 }
7664
7665 input, ok := in.Parameters.(*GetStaticIpsInput)
7666 _ = input
7667 if !ok {
7668 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7669 }
7670
7671 operationPath := "/"
7672 if len(request.Request.URL.Path) == 0 {
7673 request.Request.URL.Path = operationPath
7674 } else {
7675 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7676 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7677 request.Request.URL.Path += "/"
7678 }
7679 }
7680 request.Request.Method = "POST"
7681 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7682 if err != nil {
7683 return out, metadata, &smithy.SerializationError{Err: err}
7684 }
7685 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7686 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetStaticIps")
7687
7688 jsonEncoder := smithyjson.NewEncoder()
7689 if err := awsAwsjson11_serializeOpDocumentGetStaticIpsInput(input, jsonEncoder.Value); err != nil {
7690 return out, metadata, &smithy.SerializationError{Err: err}
7691 }
7692
7693 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7694 return out, metadata, &smithy.SerializationError{Err: err}
7695 }
7696
7697 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7698 return out, metadata, &smithy.SerializationError{Err: err}
7699 }
7700 in.Request = request
7701
7702 endTimer()
7703 span.End()
7704 return next.HandleSerialize(ctx, in)
7705 }
7706
7707 type awsAwsjson11_serializeOpImportKeyPair struct {
7708 }
7709
7710 func (*awsAwsjson11_serializeOpImportKeyPair) ID() string {
7711 return "OperationSerializer"
7712 }
7713
7714 func (m *awsAwsjson11_serializeOpImportKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7715 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7716 ) {
7717 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7718 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7719 defer endTimer()
7720 defer span.End()
7721 request, ok := in.Request.(*smithyhttp.Request)
7722 if !ok {
7723 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7724 }
7725
7726 input, ok := in.Parameters.(*ImportKeyPairInput)
7727 _ = input
7728 if !ok {
7729 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7730 }
7731
7732 operationPath := "/"
7733 if len(request.Request.URL.Path) == 0 {
7734 request.Request.URL.Path = operationPath
7735 } else {
7736 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7737 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7738 request.Request.URL.Path += "/"
7739 }
7740 }
7741 request.Request.Method = "POST"
7742 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7743 if err != nil {
7744 return out, metadata, &smithy.SerializationError{Err: err}
7745 }
7746 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7747 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.ImportKeyPair")
7748
7749 jsonEncoder := smithyjson.NewEncoder()
7750 if err := awsAwsjson11_serializeOpDocumentImportKeyPairInput(input, jsonEncoder.Value); err != nil {
7751 return out, metadata, &smithy.SerializationError{Err: err}
7752 }
7753
7754 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7755 return out, metadata, &smithy.SerializationError{Err: err}
7756 }
7757
7758 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7759 return out, metadata, &smithy.SerializationError{Err: err}
7760 }
7761 in.Request = request
7762
7763 endTimer()
7764 span.End()
7765 return next.HandleSerialize(ctx, in)
7766 }
7767
7768 type awsAwsjson11_serializeOpIsVpcPeered struct {
7769 }
7770
7771 func (*awsAwsjson11_serializeOpIsVpcPeered) ID() string {
7772 return "OperationSerializer"
7773 }
7774
7775 func (m *awsAwsjson11_serializeOpIsVpcPeered) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7776 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7777 ) {
7778 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7779 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7780 defer endTimer()
7781 defer span.End()
7782 request, ok := in.Request.(*smithyhttp.Request)
7783 if !ok {
7784 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7785 }
7786
7787 input, ok := in.Parameters.(*IsVpcPeeredInput)
7788 _ = input
7789 if !ok {
7790 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7791 }
7792
7793 operationPath := "/"
7794 if len(request.Request.URL.Path) == 0 {
7795 request.Request.URL.Path = operationPath
7796 } else {
7797 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7798 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7799 request.Request.URL.Path += "/"
7800 }
7801 }
7802 request.Request.Method = "POST"
7803 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7804 if err != nil {
7805 return out, metadata, &smithy.SerializationError{Err: err}
7806 }
7807 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7808 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.IsVpcPeered")
7809
7810 jsonEncoder := smithyjson.NewEncoder()
7811 if err := awsAwsjson11_serializeOpDocumentIsVpcPeeredInput(input, jsonEncoder.Value); err != nil {
7812 return out, metadata, &smithy.SerializationError{Err: err}
7813 }
7814
7815 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7816 return out, metadata, &smithy.SerializationError{Err: err}
7817 }
7818
7819 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7820 return out, metadata, &smithy.SerializationError{Err: err}
7821 }
7822 in.Request = request
7823
7824 endTimer()
7825 span.End()
7826 return next.HandleSerialize(ctx, in)
7827 }
7828
7829 type awsAwsjson11_serializeOpOpenInstancePublicPorts struct {
7830 }
7831
7832 func (*awsAwsjson11_serializeOpOpenInstancePublicPorts) ID() string {
7833 return "OperationSerializer"
7834 }
7835
7836 func (m *awsAwsjson11_serializeOpOpenInstancePublicPorts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7837 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7838 ) {
7839 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7840 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7841 defer endTimer()
7842 defer span.End()
7843 request, ok := in.Request.(*smithyhttp.Request)
7844 if !ok {
7845 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7846 }
7847
7848 input, ok := in.Parameters.(*OpenInstancePublicPortsInput)
7849 _ = input
7850 if !ok {
7851 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7852 }
7853
7854 operationPath := "/"
7855 if len(request.Request.URL.Path) == 0 {
7856 request.Request.URL.Path = operationPath
7857 } else {
7858 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7859 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7860 request.Request.URL.Path += "/"
7861 }
7862 }
7863 request.Request.Method = "POST"
7864 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7865 if err != nil {
7866 return out, metadata, &smithy.SerializationError{Err: err}
7867 }
7868 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7869 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.OpenInstancePublicPorts")
7870
7871 jsonEncoder := smithyjson.NewEncoder()
7872 if err := awsAwsjson11_serializeOpDocumentOpenInstancePublicPortsInput(input, jsonEncoder.Value); err != nil {
7873 return out, metadata, &smithy.SerializationError{Err: err}
7874 }
7875
7876 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7877 return out, metadata, &smithy.SerializationError{Err: err}
7878 }
7879
7880 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7881 return out, metadata, &smithy.SerializationError{Err: err}
7882 }
7883 in.Request = request
7884
7885 endTimer()
7886 span.End()
7887 return next.HandleSerialize(ctx, in)
7888 }
7889
7890 type awsAwsjson11_serializeOpPeerVpc struct {
7891 }
7892
7893 func (*awsAwsjson11_serializeOpPeerVpc) ID() string {
7894 return "OperationSerializer"
7895 }
7896
7897 func (m *awsAwsjson11_serializeOpPeerVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7898 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7899 ) {
7900 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7901 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7902 defer endTimer()
7903 defer span.End()
7904 request, ok := in.Request.(*smithyhttp.Request)
7905 if !ok {
7906 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7907 }
7908
7909 input, ok := in.Parameters.(*PeerVpcInput)
7910 _ = input
7911 if !ok {
7912 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7913 }
7914
7915 operationPath := "/"
7916 if len(request.Request.URL.Path) == 0 {
7917 request.Request.URL.Path = operationPath
7918 } else {
7919 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7920 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7921 request.Request.URL.Path += "/"
7922 }
7923 }
7924 request.Request.Method = "POST"
7925 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7926 if err != nil {
7927 return out, metadata, &smithy.SerializationError{Err: err}
7928 }
7929 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7930 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.PeerVpc")
7931
7932 jsonEncoder := smithyjson.NewEncoder()
7933 if err := awsAwsjson11_serializeOpDocumentPeerVpcInput(input, jsonEncoder.Value); err != nil {
7934 return out, metadata, &smithy.SerializationError{Err: err}
7935 }
7936
7937 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7938 return out, metadata, &smithy.SerializationError{Err: err}
7939 }
7940
7941 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
7942 return out, metadata, &smithy.SerializationError{Err: err}
7943 }
7944 in.Request = request
7945
7946 endTimer()
7947 span.End()
7948 return next.HandleSerialize(ctx, in)
7949 }
7950
7951 type awsAwsjson11_serializeOpPutAlarm struct {
7952 }
7953
7954 func (*awsAwsjson11_serializeOpPutAlarm) ID() string {
7955 return "OperationSerializer"
7956 }
7957
7958 func (m *awsAwsjson11_serializeOpPutAlarm) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7959 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7960 ) {
7961 _, span := tracing.StartSpan(ctx, "OperationSerializer")
7962 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
7963 defer endTimer()
7964 defer span.End()
7965 request, ok := in.Request.(*smithyhttp.Request)
7966 if !ok {
7967 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7968 }
7969
7970 input, ok := in.Parameters.(*PutAlarmInput)
7971 _ = input
7972 if !ok {
7973 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7974 }
7975
7976 operationPath := "/"
7977 if len(request.Request.URL.Path) == 0 {
7978 request.Request.URL.Path = operationPath
7979 } else {
7980 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
7981 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
7982 request.Request.URL.Path += "/"
7983 }
7984 }
7985 request.Request.Method = "POST"
7986 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7987 if err != nil {
7988 return out, metadata, &smithy.SerializationError{Err: err}
7989 }
7990 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
7991 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.PutAlarm")
7992
7993 jsonEncoder := smithyjson.NewEncoder()
7994 if err := awsAwsjson11_serializeOpDocumentPutAlarmInput(input, jsonEncoder.Value); err != nil {
7995 return out, metadata, &smithy.SerializationError{Err: err}
7996 }
7997
7998 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7999 return out, metadata, &smithy.SerializationError{Err: err}
8000 }
8001
8002 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8003 return out, metadata, &smithy.SerializationError{Err: err}
8004 }
8005 in.Request = request
8006
8007 endTimer()
8008 span.End()
8009 return next.HandleSerialize(ctx, in)
8010 }
8011
8012 type awsAwsjson11_serializeOpPutInstancePublicPorts struct {
8013 }
8014
8015 func (*awsAwsjson11_serializeOpPutInstancePublicPorts) ID() string {
8016 return "OperationSerializer"
8017 }
8018
8019 func (m *awsAwsjson11_serializeOpPutInstancePublicPorts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8020 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8021 ) {
8022 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8023 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8024 defer endTimer()
8025 defer span.End()
8026 request, ok := in.Request.(*smithyhttp.Request)
8027 if !ok {
8028 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8029 }
8030
8031 input, ok := in.Parameters.(*PutInstancePublicPortsInput)
8032 _ = input
8033 if !ok {
8034 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8035 }
8036
8037 operationPath := "/"
8038 if len(request.Request.URL.Path) == 0 {
8039 request.Request.URL.Path = operationPath
8040 } else {
8041 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8042 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8043 request.Request.URL.Path += "/"
8044 }
8045 }
8046 request.Request.Method = "POST"
8047 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8048 if err != nil {
8049 return out, metadata, &smithy.SerializationError{Err: err}
8050 }
8051 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8052 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.PutInstancePublicPorts")
8053
8054 jsonEncoder := smithyjson.NewEncoder()
8055 if err := awsAwsjson11_serializeOpDocumentPutInstancePublicPortsInput(input, jsonEncoder.Value); err != nil {
8056 return out, metadata, &smithy.SerializationError{Err: err}
8057 }
8058
8059 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8060 return out, metadata, &smithy.SerializationError{Err: err}
8061 }
8062
8063 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8064 return out, metadata, &smithy.SerializationError{Err: err}
8065 }
8066 in.Request = request
8067
8068 endTimer()
8069 span.End()
8070 return next.HandleSerialize(ctx, in)
8071 }
8072
8073 type awsAwsjson11_serializeOpRebootInstance struct {
8074 }
8075
8076 func (*awsAwsjson11_serializeOpRebootInstance) ID() string {
8077 return "OperationSerializer"
8078 }
8079
8080 func (m *awsAwsjson11_serializeOpRebootInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8081 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8082 ) {
8083 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8084 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8085 defer endTimer()
8086 defer span.End()
8087 request, ok := in.Request.(*smithyhttp.Request)
8088 if !ok {
8089 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8090 }
8091
8092 input, ok := in.Parameters.(*RebootInstanceInput)
8093 _ = input
8094 if !ok {
8095 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8096 }
8097
8098 operationPath := "/"
8099 if len(request.Request.URL.Path) == 0 {
8100 request.Request.URL.Path = operationPath
8101 } else {
8102 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8103 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8104 request.Request.URL.Path += "/"
8105 }
8106 }
8107 request.Request.Method = "POST"
8108 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8109 if err != nil {
8110 return out, metadata, &smithy.SerializationError{Err: err}
8111 }
8112 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8113 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.RebootInstance")
8114
8115 jsonEncoder := smithyjson.NewEncoder()
8116 if err := awsAwsjson11_serializeOpDocumentRebootInstanceInput(input, jsonEncoder.Value); err != nil {
8117 return out, metadata, &smithy.SerializationError{Err: err}
8118 }
8119
8120 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8121 return out, metadata, &smithy.SerializationError{Err: err}
8122 }
8123
8124 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8125 return out, metadata, &smithy.SerializationError{Err: err}
8126 }
8127 in.Request = request
8128
8129 endTimer()
8130 span.End()
8131 return next.HandleSerialize(ctx, in)
8132 }
8133
8134 type awsAwsjson11_serializeOpRebootRelationalDatabase struct {
8135 }
8136
8137 func (*awsAwsjson11_serializeOpRebootRelationalDatabase) ID() string {
8138 return "OperationSerializer"
8139 }
8140
8141 func (m *awsAwsjson11_serializeOpRebootRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8142 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8143 ) {
8144 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8145 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8146 defer endTimer()
8147 defer span.End()
8148 request, ok := in.Request.(*smithyhttp.Request)
8149 if !ok {
8150 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8151 }
8152
8153 input, ok := in.Parameters.(*RebootRelationalDatabaseInput)
8154 _ = input
8155 if !ok {
8156 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8157 }
8158
8159 operationPath := "/"
8160 if len(request.Request.URL.Path) == 0 {
8161 request.Request.URL.Path = operationPath
8162 } else {
8163 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8164 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8165 request.Request.URL.Path += "/"
8166 }
8167 }
8168 request.Request.Method = "POST"
8169 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8170 if err != nil {
8171 return out, metadata, &smithy.SerializationError{Err: err}
8172 }
8173 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8174 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.RebootRelationalDatabase")
8175
8176 jsonEncoder := smithyjson.NewEncoder()
8177 if err := awsAwsjson11_serializeOpDocumentRebootRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
8178 return out, metadata, &smithy.SerializationError{Err: err}
8179 }
8180
8181 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8182 return out, metadata, &smithy.SerializationError{Err: err}
8183 }
8184
8185 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8186 return out, metadata, &smithy.SerializationError{Err: err}
8187 }
8188 in.Request = request
8189
8190 endTimer()
8191 span.End()
8192 return next.HandleSerialize(ctx, in)
8193 }
8194
8195 type awsAwsjson11_serializeOpRegisterContainerImage struct {
8196 }
8197
8198 func (*awsAwsjson11_serializeOpRegisterContainerImage) ID() string {
8199 return "OperationSerializer"
8200 }
8201
8202 func (m *awsAwsjson11_serializeOpRegisterContainerImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8203 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8204 ) {
8205 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8206 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8207 defer endTimer()
8208 defer span.End()
8209 request, ok := in.Request.(*smithyhttp.Request)
8210 if !ok {
8211 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8212 }
8213
8214 input, ok := in.Parameters.(*RegisterContainerImageInput)
8215 _ = input
8216 if !ok {
8217 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8218 }
8219
8220 operationPath := "/"
8221 if len(request.Request.URL.Path) == 0 {
8222 request.Request.URL.Path = operationPath
8223 } else {
8224 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8225 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8226 request.Request.URL.Path += "/"
8227 }
8228 }
8229 request.Request.Method = "POST"
8230 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8231 if err != nil {
8232 return out, metadata, &smithy.SerializationError{Err: err}
8233 }
8234 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8235 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.RegisterContainerImage")
8236
8237 jsonEncoder := smithyjson.NewEncoder()
8238 if err := awsAwsjson11_serializeOpDocumentRegisterContainerImageInput(input, jsonEncoder.Value); err != nil {
8239 return out, metadata, &smithy.SerializationError{Err: err}
8240 }
8241
8242 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8243 return out, metadata, &smithy.SerializationError{Err: err}
8244 }
8245
8246 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8247 return out, metadata, &smithy.SerializationError{Err: err}
8248 }
8249 in.Request = request
8250
8251 endTimer()
8252 span.End()
8253 return next.HandleSerialize(ctx, in)
8254 }
8255
8256 type awsAwsjson11_serializeOpReleaseStaticIp struct {
8257 }
8258
8259 func (*awsAwsjson11_serializeOpReleaseStaticIp) ID() string {
8260 return "OperationSerializer"
8261 }
8262
8263 func (m *awsAwsjson11_serializeOpReleaseStaticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8264 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8265 ) {
8266 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8267 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8268 defer endTimer()
8269 defer span.End()
8270 request, ok := in.Request.(*smithyhttp.Request)
8271 if !ok {
8272 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8273 }
8274
8275 input, ok := in.Parameters.(*ReleaseStaticIpInput)
8276 _ = input
8277 if !ok {
8278 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8279 }
8280
8281 operationPath := "/"
8282 if len(request.Request.URL.Path) == 0 {
8283 request.Request.URL.Path = operationPath
8284 } else {
8285 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8286 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8287 request.Request.URL.Path += "/"
8288 }
8289 }
8290 request.Request.Method = "POST"
8291 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8292 if err != nil {
8293 return out, metadata, &smithy.SerializationError{Err: err}
8294 }
8295 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8296 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.ReleaseStaticIp")
8297
8298 jsonEncoder := smithyjson.NewEncoder()
8299 if err := awsAwsjson11_serializeOpDocumentReleaseStaticIpInput(input, jsonEncoder.Value); err != nil {
8300 return out, metadata, &smithy.SerializationError{Err: err}
8301 }
8302
8303 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8304 return out, metadata, &smithy.SerializationError{Err: err}
8305 }
8306
8307 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8308 return out, metadata, &smithy.SerializationError{Err: err}
8309 }
8310 in.Request = request
8311
8312 endTimer()
8313 span.End()
8314 return next.HandleSerialize(ctx, in)
8315 }
8316
8317 type awsAwsjson11_serializeOpResetDistributionCache struct {
8318 }
8319
8320 func (*awsAwsjson11_serializeOpResetDistributionCache) ID() string {
8321 return "OperationSerializer"
8322 }
8323
8324 func (m *awsAwsjson11_serializeOpResetDistributionCache) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8325 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8326 ) {
8327 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8328 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8329 defer endTimer()
8330 defer span.End()
8331 request, ok := in.Request.(*smithyhttp.Request)
8332 if !ok {
8333 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8334 }
8335
8336 input, ok := in.Parameters.(*ResetDistributionCacheInput)
8337 _ = input
8338 if !ok {
8339 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8340 }
8341
8342 operationPath := "/"
8343 if len(request.Request.URL.Path) == 0 {
8344 request.Request.URL.Path = operationPath
8345 } else {
8346 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8347 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8348 request.Request.URL.Path += "/"
8349 }
8350 }
8351 request.Request.Method = "POST"
8352 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8353 if err != nil {
8354 return out, metadata, &smithy.SerializationError{Err: err}
8355 }
8356 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8357 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.ResetDistributionCache")
8358
8359 jsonEncoder := smithyjson.NewEncoder()
8360 if err := awsAwsjson11_serializeOpDocumentResetDistributionCacheInput(input, jsonEncoder.Value); err != nil {
8361 return out, metadata, &smithy.SerializationError{Err: err}
8362 }
8363
8364 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8365 return out, metadata, &smithy.SerializationError{Err: err}
8366 }
8367
8368 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8369 return out, metadata, &smithy.SerializationError{Err: err}
8370 }
8371 in.Request = request
8372
8373 endTimer()
8374 span.End()
8375 return next.HandleSerialize(ctx, in)
8376 }
8377
8378 type awsAwsjson11_serializeOpSendContactMethodVerification struct {
8379 }
8380
8381 func (*awsAwsjson11_serializeOpSendContactMethodVerification) ID() string {
8382 return "OperationSerializer"
8383 }
8384
8385 func (m *awsAwsjson11_serializeOpSendContactMethodVerification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8386 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8387 ) {
8388 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8389 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8390 defer endTimer()
8391 defer span.End()
8392 request, ok := in.Request.(*smithyhttp.Request)
8393 if !ok {
8394 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8395 }
8396
8397 input, ok := in.Parameters.(*SendContactMethodVerificationInput)
8398 _ = input
8399 if !ok {
8400 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8401 }
8402
8403 operationPath := "/"
8404 if len(request.Request.URL.Path) == 0 {
8405 request.Request.URL.Path = operationPath
8406 } else {
8407 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8408 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8409 request.Request.URL.Path += "/"
8410 }
8411 }
8412 request.Request.Method = "POST"
8413 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8414 if err != nil {
8415 return out, metadata, &smithy.SerializationError{Err: err}
8416 }
8417 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8418 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.SendContactMethodVerification")
8419
8420 jsonEncoder := smithyjson.NewEncoder()
8421 if err := awsAwsjson11_serializeOpDocumentSendContactMethodVerificationInput(input, jsonEncoder.Value); err != nil {
8422 return out, metadata, &smithy.SerializationError{Err: err}
8423 }
8424
8425 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8426 return out, metadata, &smithy.SerializationError{Err: err}
8427 }
8428
8429 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8430 return out, metadata, &smithy.SerializationError{Err: err}
8431 }
8432 in.Request = request
8433
8434 endTimer()
8435 span.End()
8436 return next.HandleSerialize(ctx, in)
8437 }
8438
8439 type awsAwsjson11_serializeOpSetIpAddressType struct {
8440 }
8441
8442 func (*awsAwsjson11_serializeOpSetIpAddressType) ID() string {
8443 return "OperationSerializer"
8444 }
8445
8446 func (m *awsAwsjson11_serializeOpSetIpAddressType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8447 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8448 ) {
8449 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8450 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8451 defer endTimer()
8452 defer span.End()
8453 request, ok := in.Request.(*smithyhttp.Request)
8454 if !ok {
8455 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8456 }
8457
8458 input, ok := in.Parameters.(*SetIpAddressTypeInput)
8459 _ = input
8460 if !ok {
8461 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8462 }
8463
8464 operationPath := "/"
8465 if len(request.Request.URL.Path) == 0 {
8466 request.Request.URL.Path = operationPath
8467 } else {
8468 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8469 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8470 request.Request.URL.Path += "/"
8471 }
8472 }
8473 request.Request.Method = "POST"
8474 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8475 if err != nil {
8476 return out, metadata, &smithy.SerializationError{Err: err}
8477 }
8478 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8479 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.SetIpAddressType")
8480
8481 jsonEncoder := smithyjson.NewEncoder()
8482 if err := awsAwsjson11_serializeOpDocumentSetIpAddressTypeInput(input, jsonEncoder.Value); err != nil {
8483 return out, metadata, &smithy.SerializationError{Err: err}
8484 }
8485
8486 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8487 return out, metadata, &smithy.SerializationError{Err: err}
8488 }
8489
8490 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8491 return out, metadata, &smithy.SerializationError{Err: err}
8492 }
8493 in.Request = request
8494
8495 endTimer()
8496 span.End()
8497 return next.HandleSerialize(ctx, in)
8498 }
8499
8500 type awsAwsjson11_serializeOpSetResourceAccessForBucket struct {
8501 }
8502
8503 func (*awsAwsjson11_serializeOpSetResourceAccessForBucket) ID() string {
8504 return "OperationSerializer"
8505 }
8506
8507 func (m *awsAwsjson11_serializeOpSetResourceAccessForBucket) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8508 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8509 ) {
8510 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8511 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8512 defer endTimer()
8513 defer span.End()
8514 request, ok := in.Request.(*smithyhttp.Request)
8515 if !ok {
8516 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8517 }
8518
8519 input, ok := in.Parameters.(*SetResourceAccessForBucketInput)
8520 _ = input
8521 if !ok {
8522 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8523 }
8524
8525 operationPath := "/"
8526 if len(request.Request.URL.Path) == 0 {
8527 request.Request.URL.Path = operationPath
8528 } else {
8529 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8530 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8531 request.Request.URL.Path += "/"
8532 }
8533 }
8534 request.Request.Method = "POST"
8535 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8536 if err != nil {
8537 return out, metadata, &smithy.SerializationError{Err: err}
8538 }
8539 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8540 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.SetResourceAccessForBucket")
8541
8542 jsonEncoder := smithyjson.NewEncoder()
8543 if err := awsAwsjson11_serializeOpDocumentSetResourceAccessForBucketInput(input, jsonEncoder.Value); err != nil {
8544 return out, metadata, &smithy.SerializationError{Err: err}
8545 }
8546
8547 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8548 return out, metadata, &smithy.SerializationError{Err: err}
8549 }
8550
8551 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8552 return out, metadata, &smithy.SerializationError{Err: err}
8553 }
8554 in.Request = request
8555
8556 endTimer()
8557 span.End()
8558 return next.HandleSerialize(ctx, in)
8559 }
8560
8561 type awsAwsjson11_serializeOpSetupInstanceHttps struct {
8562 }
8563
8564 func (*awsAwsjson11_serializeOpSetupInstanceHttps) ID() string {
8565 return "OperationSerializer"
8566 }
8567
8568 func (m *awsAwsjson11_serializeOpSetupInstanceHttps) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8569 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8570 ) {
8571 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8572 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8573 defer endTimer()
8574 defer span.End()
8575 request, ok := in.Request.(*smithyhttp.Request)
8576 if !ok {
8577 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8578 }
8579
8580 input, ok := in.Parameters.(*SetupInstanceHttpsInput)
8581 _ = input
8582 if !ok {
8583 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8584 }
8585
8586 operationPath := "/"
8587 if len(request.Request.URL.Path) == 0 {
8588 request.Request.URL.Path = operationPath
8589 } else {
8590 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8591 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8592 request.Request.URL.Path += "/"
8593 }
8594 }
8595 request.Request.Method = "POST"
8596 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8597 if err != nil {
8598 return out, metadata, &smithy.SerializationError{Err: err}
8599 }
8600 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8601 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.SetupInstanceHttps")
8602
8603 jsonEncoder := smithyjson.NewEncoder()
8604 if err := awsAwsjson11_serializeOpDocumentSetupInstanceHttpsInput(input, jsonEncoder.Value); err != nil {
8605 return out, metadata, &smithy.SerializationError{Err: err}
8606 }
8607
8608 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8609 return out, metadata, &smithy.SerializationError{Err: err}
8610 }
8611
8612 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8613 return out, metadata, &smithy.SerializationError{Err: err}
8614 }
8615 in.Request = request
8616
8617 endTimer()
8618 span.End()
8619 return next.HandleSerialize(ctx, in)
8620 }
8621
8622 type awsAwsjson11_serializeOpStartGUISession struct {
8623 }
8624
8625 func (*awsAwsjson11_serializeOpStartGUISession) ID() string {
8626 return "OperationSerializer"
8627 }
8628
8629 func (m *awsAwsjson11_serializeOpStartGUISession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8630 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8631 ) {
8632 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8633 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8634 defer endTimer()
8635 defer span.End()
8636 request, ok := in.Request.(*smithyhttp.Request)
8637 if !ok {
8638 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8639 }
8640
8641 input, ok := in.Parameters.(*StartGUISessionInput)
8642 _ = input
8643 if !ok {
8644 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8645 }
8646
8647 operationPath := "/"
8648 if len(request.Request.URL.Path) == 0 {
8649 request.Request.URL.Path = operationPath
8650 } else {
8651 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8652 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8653 request.Request.URL.Path += "/"
8654 }
8655 }
8656 request.Request.Method = "POST"
8657 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8658 if err != nil {
8659 return out, metadata, &smithy.SerializationError{Err: err}
8660 }
8661 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8662 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.StartGUISession")
8663
8664 jsonEncoder := smithyjson.NewEncoder()
8665 if err := awsAwsjson11_serializeOpDocumentStartGUISessionInput(input, jsonEncoder.Value); err != nil {
8666 return out, metadata, &smithy.SerializationError{Err: err}
8667 }
8668
8669 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8670 return out, metadata, &smithy.SerializationError{Err: err}
8671 }
8672
8673 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8674 return out, metadata, &smithy.SerializationError{Err: err}
8675 }
8676 in.Request = request
8677
8678 endTimer()
8679 span.End()
8680 return next.HandleSerialize(ctx, in)
8681 }
8682
8683 type awsAwsjson11_serializeOpStartInstance struct {
8684 }
8685
8686 func (*awsAwsjson11_serializeOpStartInstance) ID() string {
8687 return "OperationSerializer"
8688 }
8689
8690 func (m *awsAwsjson11_serializeOpStartInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8691 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8692 ) {
8693 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8694 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8695 defer endTimer()
8696 defer span.End()
8697 request, ok := in.Request.(*smithyhttp.Request)
8698 if !ok {
8699 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8700 }
8701
8702 input, ok := in.Parameters.(*StartInstanceInput)
8703 _ = input
8704 if !ok {
8705 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8706 }
8707
8708 operationPath := "/"
8709 if len(request.Request.URL.Path) == 0 {
8710 request.Request.URL.Path = operationPath
8711 } else {
8712 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8713 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8714 request.Request.URL.Path += "/"
8715 }
8716 }
8717 request.Request.Method = "POST"
8718 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8719 if err != nil {
8720 return out, metadata, &smithy.SerializationError{Err: err}
8721 }
8722 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8723 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.StartInstance")
8724
8725 jsonEncoder := smithyjson.NewEncoder()
8726 if err := awsAwsjson11_serializeOpDocumentStartInstanceInput(input, jsonEncoder.Value); err != nil {
8727 return out, metadata, &smithy.SerializationError{Err: err}
8728 }
8729
8730 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8731 return out, metadata, &smithy.SerializationError{Err: err}
8732 }
8733
8734 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8735 return out, metadata, &smithy.SerializationError{Err: err}
8736 }
8737 in.Request = request
8738
8739 endTimer()
8740 span.End()
8741 return next.HandleSerialize(ctx, in)
8742 }
8743
8744 type awsAwsjson11_serializeOpStartRelationalDatabase struct {
8745 }
8746
8747 func (*awsAwsjson11_serializeOpStartRelationalDatabase) ID() string {
8748 return "OperationSerializer"
8749 }
8750
8751 func (m *awsAwsjson11_serializeOpStartRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8752 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8753 ) {
8754 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8755 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8756 defer endTimer()
8757 defer span.End()
8758 request, ok := in.Request.(*smithyhttp.Request)
8759 if !ok {
8760 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8761 }
8762
8763 input, ok := in.Parameters.(*StartRelationalDatabaseInput)
8764 _ = input
8765 if !ok {
8766 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8767 }
8768
8769 operationPath := "/"
8770 if len(request.Request.URL.Path) == 0 {
8771 request.Request.URL.Path = operationPath
8772 } else {
8773 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8774 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8775 request.Request.URL.Path += "/"
8776 }
8777 }
8778 request.Request.Method = "POST"
8779 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8780 if err != nil {
8781 return out, metadata, &smithy.SerializationError{Err: err}
8782 }
8783 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8784 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.StartRelationalDatabase")
8785
8786 jsonEncoder := smithyjson.NewEncoder()
8787 if err := awsAwsjson11_serializeOpDocumentStartRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
8788 return out, metadata, &smithy.SerializationError{Err: err}
8789 }
8790
8791 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8792 return out, metadata, &smithy.SerializationError{Err: err}
8793 }
8794
8795 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8796 return out, metadata, &smithy.SerializationError{Err: err}
8797 }
8798 in.Request = request
8799
8800 endTimer()
8801 span.End()
8802 return next.HandleSerialize(ctx, in)
8803 }
8804
8805 type awsAwsjson11_serializeOpStopGUISession struct {
8806 }
8807
8808 func (*awsAwsjson11_serializeOpStopGUISession) ID() string {
8809 return "OperationSerializer"
8810 }
8811
8812 func (m *awsAwsjson11_serializeOpStopGUISession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8813 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8814 ) {
8815 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8816 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8817 defer endTimer()
8818 defer span.End()
8819 request, ok := in.Request.(*smithyhttp.Request)
8820 if !ok {
8821 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8822 }
8823
8824 input, ok := in.Parameters.(*StopGUISessionInput)
8825 _ = input
8826 if !ok {
8827 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8828 }
8829
8830 operationPath := "/"
8831 if len(request.Request.URL.Path) == 0 {
8832 request.Request.URL.Path = operationPath
8833 } else {
8834 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8835 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8836 request.Request.URL.Path += "/"
8837 }
8838 }
8839 request.Request.Method = "POST"
8840 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8841 if err != nil {
8842 return out, metadata, &smithy.SerializationError{Err: err}
8843 }
8844 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8845 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.StopGUISession")
8846
8847 jsonEncoder := smithyjson.NewEncoder()
8848 if err := awsAwsjson11_serializeOpDocumentStopGUISessionInput(input, jsonEncoder.Value); err != nil {
8849 return out, metadata, &smithy.SerializationError{Err: err}
8850 }
8851
8852 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8853 return out, metadata, &smithy.SerializationError{Err: err}
8854 }
8855
8856 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8857 return out, metadata, &smithy.SerializationError{Err: err}
8858 }
8859 in.Request = request
8860
8861 endTimer()
8862 span.End()
8863 return next.HandleSerialize(ctx, in)
8864 }
8865
8866 type awsAwsjson11_serializeOpStopInstance struct {
8867 }
8868
8869 func (*awsAwsjson11_serializeOpStopInstance) ID() string {
8870 return "OperationSerializer"
8871 }
8872
8873 func (m *awsAwsjson11_serializeOpStopInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8874 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8875 ) {
8876 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8877 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8878 defer endTimer()
8879 defer span.End()
8880 request, ok := in.Request.(*smithyhttp.Request)
8881 if !ok {
8882 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8883 }
8884
8885 input, ok := in.Parameters.(*StopInstanceInput)
8886 _ = input
8887 if !ok {
8888 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8889 }
8890
8891 operationPath := "/"
8892 if len(request.Request.URL.Path) == 0 {
8893 request.Request.URL.Path = operationPath
8894 } else {
8895 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8896 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8897 request.Request.URL.Path += "/"
8898 }
8899 }
8900 request.Request.Method = "POST"
8901 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8902 if err != nil {
8903 return out, metadata, &smithy.SerializationError{Err: err}
8904 }
8905 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8906 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.StopInstance")
8907
8908 jsonEncoder := smithyjson.NewEncoder()
8909 if err := awsAwsjson11_serializeOpDocumentStopInstanceInput(input, jsonEncoder.Value); err != nil {
8910 return out, metadata, &smithy.SerializationError{Err: err}
8911 }
8912
8913 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8914 return out, metadata, &smithy.SerializationError{Err: err}
8915 }
8916
8917 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8918 return out, metadata, &smithy.SerializationError{Err: err}
8919 }
8920 in.Request = request
8921
8922 endTimer()
8923 span.End()
8924 return next.HandleSerialize(ctx, in)
8925 }
8926
8927 type awsAwsjson11_serializeOpStopRelationalDatabase struct {
8928 }
8929
8930 func (*awsAwsjson11_serializeOpStopRelationalDatabase) ID() string {
8931 return "OperationSerializer"
8932 }
8933
8934 func (m *awsAwsjson11_serializeOpStopRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8935 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8936 ) {
8937 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8938 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
8939 defer endTimer()
8940 defer span.End()
8941 request, ok := in.Request.(*smithyhttp.Request)
8942 if !ok {
8943 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8944 }
8945
8946 input, ok := in.Parameters.(*StopRelationalDatabaseInput)
8947 _ = input
8948 if !ok {
8949 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8950 }
8951
8952 operationPath := "/"
8953 if len(request.Request.URL.Path) == 0 {
8954 request.Request.URL.Path = operationPath
8955 } else {
8956 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
8957 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
8958 request.Request.URL.Path += "/"
8959 }
8960 }
8961 request.Request.Method = "POST"
8962 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8963 if err != nil {
8964 return out, metadata, &smithy.SerializationError{Err: err}
8965 }
8966 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
8967 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.StopRelationalDatabase")
8968
8969 jsonEncoder := smithyjson.NewEncoder()
8970 if err := awsAwsjson11_serializeOpDocumentStopRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
8971 return out, metadata, &smithy.SerializationError{Err: err}
8972 }
8973
8974 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8975 return out, metadata, &smithy.SerializationError{Err: err}
8976 }
8977
8978 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
8979 return out, metadata, &smithy.SerializationError{Err: err}
8980 }
8981 in.Request = request
8982
8983 endTimer()
8984 span.End()
8985 return next.HandleSerialize(ctx, in)
8986 }
8987
8988 type awsAwsjson11_serializeOpTagResource struct {
8989 }
8990
8991 func (*awsAwsjson11_serializeOpTagResource) ID() string {
8992 return "OperationSerializer"
8993 }
8994
8995 func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8996 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8997 ) {
8998 _, span := tracing.StartSpan(ctx, "OperationSerializer")
8999 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9000 defer endTimer()
9001 defer span.End()
9002 request, ok := in.Request.(*smithyhttp.Request)
9003 if !ok {
9004 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9005 }
9006
9007 input, ok := in.Parameters.(*TagResourceInput)
9008 _ = input
9009 if !ok {
9010 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9011 }
9012
9013 operationPath := "/"
9014 if len(request.Request.URL.Path) == 0 {
9015 request.Request.URL.Path = operationPath
9016 } else {
9017 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9018 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9019 request.Request.URL.Path += "/"
9020 }
9021 }
9022 request.Request.Method = "POST"
9023 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9024 if err != nil {
9025 return out, metadata, &smithy.SerializationError{Err: err}
9026 }
9027 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9028 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.TagResource")
9029
9030 jsonEncoder := smithyjson.NewEncoder()
9031 if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
9032 return out, metadata, &smithy.SerializationError{Err: err}
9033 }
9034
9035 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9036 return out, metadata, &smithy.SerializationError{Err: err}
9037 }
9038
9039 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9040 return out, metadata, &smithy.SerializationError{Err: err}
9041 }
9042 in.Request = request
9043
9044 endTimer()
9045 span.End()
9046 return next.HandleSerialize(ctx, in)
9047 }
9048
9049 type awsAwsjson11_serializeOpTestAlarm struct {
9050 }
9051
9052 func (*awsAwsjson11_serializeOpTestAlarm) ID() string {
9053 return "OperationSerializer"
9054 }
9055
9056 func (m *awsAwsjson11_serializeOpTestAlarm) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9057 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9058 ) {
9059 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9060 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9061 defer endTimer()
9062 defer span.End()
9063 request, ok := in.Request.(*smithyhttp.Request)
9064 if !ok {
9065 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9066 }
9067
9068 input, ok := in.Parameters.(*TestAlarmInput)
9069 _ = input
9070 if !ok {
9071 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9072 }
9073
9074 operationPath := "/"
9075 if len(request.Request.URL.Path) == 0 {
9076 request.Request.URL.Path = operationPath
9077 } else {
9078 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9079 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9080 request.Request.URL.Path += "/"
9081 }
9082 }
9083 request.Request.Method = "POST"
9084 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9085 if err != nil {
9086 return out, metadata, &smithy.SerializationError{Err: err}
9087 }
9088 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9089 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.TestAlarm")
9090
9091 jsonEncoder := smithyjson.NewEncoder()
9092 if err := awsAwsjson11_serializeOpDocumentTestAlarmInput(input, jsonEncoder.Value); err != nil {
9093 return out, metadata, &smithy.SerializationError{Err: err}
9094 }
9095
9096 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9097 return out, metadata, &smithy.SerializationError{Err: err}
9098 }
9099
9100 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9101 return out, metadata, &smithy.SerializationError{Err: err}
9102 }
9103 in.Request = request
9104
9105 endTimer()
9106 span.End()
9107 return next.HandleSerialize(ctx, in)
9108 }
9109
9110 type awsAwsjson11_serializeOpUnpeerVpc struct {
9111 }
9112
9113 func (*awsAwsjson11_serializeOpUnpeerVpc) ID() string {
9114 return "OperationSerializer"
9115 }
9116
9117 func (m *awsAwsjson11_serializeOpUnpeerVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9118 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9119 ) {
9120 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9121 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9122 defer endTimer()
9123 defer span.End()
9124 request, ok := in.Request.(*smithyhttp.Request)
9125 if !ok {
9126 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9127 }
9128
9129 input, ok := in.Parameters.(*UnpeerVpcInput)
9130 _ = input
9131 if !ok {
9132 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9133 }
9134
9135 operationPath := "/"
9136 if len(request.Request.URL.Path) == 0 {
9137 request.Request.URL.Path = operationPath
9138 } else {
9139 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9140 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9141 request.Request.URL.Path += "/"
9142 }
9143 }
9144 request.Request.Method = "POST"
9145 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9146 if err != nil {
9147 return out, metadata, &smithy.SerializationError{Err: err}
9148 }
9149 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9150 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UnpeerVpc")
9151
9152 jsonEncoder := smithyjson.NewEncoder()
9153 if err := awsAwsjson11_serializeOpDocumentUnpeerVpcInput(input, jsonEncoder.Value); err != nil {
9154 return out, metadata, &smithy.SerializationError{Err: err}
9155 }
9156
9157 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9158 return out, metadata, &smithy.SerializationError{Err: err}
9159 }
9160
9161 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9162 return out, metadata, &smithy.SerializationError{Err: err}
9163 }
9164 in.Request = request
9165
9166 endTimer()
9167 span.End()
9168 return next.HandleSerialize(ctx, in)
9169 }
9170
9171 type awsAwsjson11_serializeOpUntagResource struct {
9172 }
9173
9174 func (*awsAwsjson11_serializeOpUntagResource) ID() string {
9175 return "OperationSerializer"
9176 }
9177
9178 func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9179 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9180 ) {
9181 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9182 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9183 defer endTimer()
9184 defer span.End()
9185 request, ok := in.Request.(*smithyhttp.Request)
9186 if !ok {
9187 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9188 }
9189
9190 input, ok := in.Parameters.(*UntagResourceInput)
9191 _ = input
9192 if !ok {
9193 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9194 }
9195
9196 operationPath := "/"
9197 if len(request.Request.URL.Path) == 0 {
9198 request.Request.URL.Path = operationPath
9199 } else {
9200 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9201 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9202 request.Request.URL.Path += "/"
9203 }
9204 }
9205 request.Request.Method = "POST"
9206 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9207 if err != nil {
9208 return out, metadata, &smithy.SerializationError{Err: err}
9209 }
9210 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9211 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UntagResource")
9212
9213 jsonEncoder := smithyjson.NewEncoder()
9214 if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
9215 return out, metadata, &smithy.SerializationError{Err: err}
9216 }
9217
9218 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9219 return out, metadata, &smithy.SerializationError{Err: err}
9220 }
9221
9222 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9223 return out, metadata, &smithy.SerializationError{Err: err}
9224 }
9225 in.Request = request
9226
9227 endTimer()
9228 span.End()
9229 return next.HandleSerialize(ctx, in)
9230 }
9231
9232 type awsAwsjson11_serializeOpUpdateBucket struct {
9233 }
9234
9235 func (*awsAwsjson11_serializeOpUpdateBucket) ID() string {
9236 return "OperationSerializer"
9237 }
9238
9239 func (m *awsAwsjson11_serializeOpUpdateBucket) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9240 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9241 ) {
9242 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9243 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9244 defer endTimer()
9245 defer span.End()
9246 request, ok := in.Request.(*smithyhttp.Request)
9247 if !ok {
9248 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9249 }
9250
9251 input, ok := in.Parameters.(*UpdateBucketInput)
9252 _ = input
9253 if !ok {
9254 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9255 }
9256
9257 operationPath := "/"
9258 if len(request.Request.URL.Path) == 0 {
9259 request.Request.URL.Path = operationPath
9260 } else {
9261 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9262 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9263 request.Request.URL.Path += "/"
9264 }
9265 }
9266 request.Request.Method = "POST"
9267 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9268 if err != nil {
9269 return out, metadata, &smithy.SerializationError{Err: err}
9270 }
9271 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9272 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateBucket")
9273
9274 jsonEncoder := smithyjson.NewEncoder()
9275 if err := awsAwsjson11_serializeOpDocumentUpdateBucketInput(input, jsonEncoder.Value); err != nil {
9276 return out, metadata, &smithy.SerializationError{Err: err}
9277 }
9278
9279 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9280 return out, metadata, &smithy.SerializationError{Err: err}
9281 }
9282
9283 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9284 return out, metadata, &smithy.SerializationError{Err: err}
9285 }
9286 in.Request = request
9287
9288 endTimer()
9289 span.End()
9290 return next.HandleSerialize(ctx, in)
9291 }
9292
9293 type awsAwsjson11_serializeOpUpdateBucketBundle struct {
9294 }
9295
9296 func (*awsAwsjson11_serializeOpUpdateBucketBundle) ID() string {
9297 return "OperationSerializer"
9298 }
9299
9300 func (m *awsAwsjson11_serializeOpUpdateBucketBundle) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9301 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9302 ) {
9303 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9304 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9305 defer endTimer()
9306 defer span.End()
9307 request, ok := in.Request.(*smithyhttp.Request)
9308 if !ok {
9309 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9310 }
9311
9312 input, ok := in.Parameters.(*UpdateBucketBundleInput)
9313 _ = input
9314 if !ok {
9315 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9316 }
9317
9318 operationPath := "/"
9319 if len(request.Request.URL.Path) == 0 {
9320 request.Request.URL.Path = operationPath
9321 } else {
9322 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9323 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9324 request.Request.URL.Path += "/"
9325 }
9326 }
9327 request.Request.Method = "POST"
9328 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9329 if err != nil {
9330 return out, metadata, &smithy.SerializationError{Err: err}
9331 }
9332 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9333 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateBucketBundle")
9334
9335 jsonEncoder := smithyjson.NewEncoder()
9336 if err := awsAwsjson11_serializeOpDocumentUpdateBucketBundleInput(input, jsonEncoder.Value); err != nil {
9337 return out, metadata, &smithy.SerializationError{Err: err}
9338 }
9339
9340 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9341 return out, metadata, &smithy.SerializationError{Err: err}
9342 }
9343
9344 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9345 return out, metadata, &smithy.SerializationError{Err: err}
9346 }
9347 in.Request = request
9348
9349 endTimer()
9350 span.End()
9351 return next.HandleSerialize(ctx, in)
9352 }
9353
9354 type awsAwsjson11_serializeOpUpdateContainerService struct {
9355 }
9356
9357 func (*awsAwsjson11_serializeOpUpdateContainerService) ID() string {
9358 return "OperationSerializer"
9359 }
9360
9361 func (m *awsAwsjson11_serializeOpUpdateContainerService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9362 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9363 ) {
9364 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9365 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9366 defer endTimer()
9367 defer span.End()
9368 request, ok := in.Request.(*smithyhttp.Request)
9369 if !ok {
9370 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9371 }
9372
9373 input, ok := in.Parameters.(*UpdateContainerServiceInput)
9374 _ = input
9375 if !ok {
9376 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9377 }
9378
9379 operationPath := "/"
9380 if len(request.Request.URL.Path) == 0 {
9381 request.Request.URL.Path = operationPath
9382 } else {
9383 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9384 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9385 request.Request.URL.Path += "/"
9386 }
9387 }
9388 request.Request.Method = "POST"
9389 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9390 if err != nil {
9391 return out, metadata, &smithy.SerializationError{Err: err}
9392 }
9393 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9394 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateContainerService")
9395
9396 jsonEncoder := smithyjson.NewEncoder()
9397 if err := awsAwsjson11_serializeOpDocumentUpdateContainerServiceInput(input, jsonEncoder.Value); err != nil {
9398 return out, metadata, &smithy.SerializationError{Err: err}
9399 }
9400
9401 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9402 return out, metadata, &smithy.SerializationError{Err: err}
9403 }
9404
9405 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9406 return out, metadata, &smithy.SerializationError{Err: err}
9407 }
9408 in.Request = request
9409
9410 endTimer()
9411 span.End()
9412 return next.HandleSerialize(ctx, in)
9413 }
9414
9415 type awsAwsjson11_serializeOpUpdateDistribution struct {
9416 }
9417
9418 func (*awsAwsjson11_serializeOpUpdateDistribution) ID() string {
9419 return "OperationSerializer"
9420 }
9421
9422 func (m *awsAwsjson11_serializeOpUpdateDistribution) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9423 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9424 ) {
9425 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9426 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9427 defer endTimer()
9428 defer span.End()
9429 request, ok := in.Request.(*smithyhttp.Request)
9430 if !ok {
9431 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9432 }
9433
9434 input, ok := in.Parameters.(*UpdateDistributionInput)
9435 _ = input
9436 if !ok {
9437 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9438 }
9439
9440 operationPath := "/"
9441 if len(request.Request.URL.Path) == 0 {
9442 request.Request.URL.Path = operationPath
9443 } else {
9444 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9445 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9446 request.Request.URL.Path += "/"
9447 }
9448 }
9449 request.Request.Method = "POST"
9450 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9451 if err != nil {
9452 return out, metadata, &smithy.SerializationError{Err: err}
9453 }
9454 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9455 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateDistribution")
9456
9457 jsonEncoder := smithyjson.NewEncoder()
9458 if err := awsAwsjson11_serializeOpDocumentUpdateDistributionInput(input, jsonEncoder.Value); err != nil {
9459 return out, metadata, &smithy.SerializationError{Err: err}
9460 }
9461
9462 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9463 return out, metadata, &smithy.SerializationError{Err: err}
9464 }
9465
9466 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9467 return out, metadata, &smithy.SerializationError{Err: err}
9468 }
9469 in.Request = request
9470
9471 endTimer()
9472 span.End()
9473 return next.HandleSerialize(ctx, in)
9474 }
9475
9476 type awsAwsjson11_serializeOpUpdateDistributionBundle struct {
9477 }
9478
9479 func (*awsAwsjson11_serializeOpUpdateDistributionBundle) ID() string {
9480 return "OperationSerializer"
9481 }
9482
9483 func (m *awsAwsjson11_serializeOpUpdateDistributionBundle) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9484 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9485 ) {
9486 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9487 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9488 defer endTimer()
9489 defer span.End()
9490 request, ok := in.Request.(*smithyhttp.Request)
9491 if !ok {
9492 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9493 }
9494
9495 input, ok := in.Parameters.(*UpdateDistributionBundleInput)
9496 _ = input
9497 if !ok {
9498 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9499 }
9500
9501 operationPath := "/"
9502 if len(request.Request.URL.Path) == 0 {
9503 request.Request.URL.Path = operationPath
9504 } else {
9505 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9506 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9507 request.Request.URL.Path += "/"
9508 }
9509 }
9510 request.Request.Method = "POST"
9511 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9512 if err != nil {
9513 return out, metadata, &smithy.SerializationError{Err: err}
9514 }
9515 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9516 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateDistributionBundle")
9517
9518 jsonEncoder := smithyjson.NewEncoder()
9519 if err := awsAwsjson11_serializeOpDocumentUpdateDistributionBundleInput(input, jsonEncoder.Value); err != nil {
9520 return out, metadata, &smithy.SerializationError{Err: err}
9521 }
9522
9523 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9524 return out, metadata, &smithy.SerializationError{Err: err}
9525 }
9526
9527 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9528 return out, metadata, &smithy.SerializationError{Err: err}
9529 }
9530 in.Request = request
9531
9532 endTimer()
9533 span.End()
9534 return next.HandleSerialize(ctx, in)
9535 }
9536
9537 type awsAwsjson11_serializeOpUpdateDomainEntry struct {
9538 }
9539
9540 func (*awsAwsjson11_serializeOpUpdateDomainEntry) ID() string {
9541 return "OperationSerializer"
9542 }
9543
9544 func (m *awsAwsjson11_serializeOpUpdateDomainEntry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9545 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9546 ) {
9547 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9548 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9549 defer endTimer()
9550 defer span.End()
9551 request, ok := in.Request.(*smithyhttp.Request)
9552 if !ok {
9553 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9554 }
9555
9556 input, ok := in.Parameters.(*UpdateDomainEntryInput)
9557 _ = input
9558 if !ok {
9559 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9560 }
9561
9562 operationPath := "/"
9563 if len(request.Request.URL.Path) == 0 {
9564 request.Request.URL.Path = operationPath
9565 } else {
9566 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9567 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9568 request.Request.URL.Path += "/"
9569 }
9570 }
9571 request.Request.Method = "POST"
9572 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9573 if err != nil {
9574 return out, metadata, &smithy.SerializationError{Err: err}
9575 }
9576 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9577 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateDomainEntry")
9578
9579 jsonEncoder := smithyjson.NewEncoder()
9580 if err := awsAwsjson11_serializeOpDocumentUpdateDomainEntryInput(input, jsonEncoder.Value); err != nil {
9581 return out, metadata, &smithy.SerializationError{Err: err}
9582 }
9583
9584 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9585 return out, metadata, &smithy.SerializationError{Err: err}
9586 }
9587
9588 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9589 return out, metadata, &smithy.SerializationError{Err: err}
9590 }
9591 in.Request = request
9592
9593 endTimer()
9594 span.End()
9595 return next.HandleSerialize(ctx, in)
9596 }
9597
9598 type awsAwsjson11_serializeOpUpdateInstanceMetadataOptions struct {
9599 }
9600
9601 func (*awsAwsjson11_serializeOpUpdateInstanceMetadataOptions) ID() string {
9602 return "OperationSerializer"
9603 }
9604
9605 func (m *awsAwsjson11_serializeOpUpdateInstanceMetadataOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9606 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9607 ) {
9608 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9609 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9610 defer endTimer()
9611 defer span.End()
9612 request, ok := in.Request.(*smithyhttp.Request)
9613 if !ok {
9614 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9615 }
9616
9617 input, ok := in.Parameters.(*UpdateInstanceMetadataOptionsInput)
9618 _ = input
9619 if !ok {
9620 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9621 }
9622
9623 operationPath := "/"
9624 if len(request.Request.URL.Path) == 0 {
9625 request.Request.URL.Path = operationPath
9626 } else {
9627 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9628 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9629 request.Request.URL.Path += "/"
9630 }
9631 }
9632 request.Request.Method = "POST"
9633 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9634 if err != nil {
9635 return out, metadata, &smithy.SerializationError{Err: err}
9636 }
9637 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9638 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateInstanceMetadataOptions")
9639
9640 jsonEncoder := smithyjson.NewEncoder()
9641 if err := awsAwsjson11_serializeOpDocumentUpdateInstanceMetadataOptionsInput(input, jsonEncoder.Value); err != nil {
9642 return out, metadata, &smithy.SerializationError{Err: err}
9643 }
9644
9645 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9646 return out, metadata, &smithy.SerializationError{Err: err}
9647 }
9648
9649 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9650 return out, metadata, &smithy.SerializationError{Err: err}
9651 }
9652 in.Request = request
9653
9654 endTimer()
9655 span.End()
9656 return next.HandleSerialize(ctx, in)
9657 }
9658
9659 type awsAwsjson11_serializeOpUpdateLoadBalancerAttribute struct {
9660 }
9661
9662 func (*awsAwsjson11_serializeOpUpdateLoadBalancerAttribute) ID() string {
9663 return "OperationSerializer"
9664 }
9665
9666 func (m *awsAwsjson11_serializeOpUpdateLoadBalancerAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9667 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9668 ) {
9669 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9670 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9671 defer endTimer()
9672 defer span.End()
9673 request, ok := in.Request.(*smithyhttp.Request)
9674 if !ok {
9675 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9676 }
9677
9678 input, ok := in.Parameters.(*UpdateLoadBalancerAttributeInput)
9679 _ = input
9680 if !ok {
9681 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9682 }
9683
9684 operationPath := "/"
9685 if len(request.Request.URL.Path) == 0 {
9686 request.Request.URL.Path = operationPath
9687 } else {
9688 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9689 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9690 request.Request.URL.Path += "/"
9691 }
9692 }
9693 request.Request.Method = "POST"
9694 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9695 if err != nil {
9696 return out, metadata, &smithy.SerializationError{Err: err}
9697 }
9698 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9699 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateLoadBalancerAttribute")
9700
9701 jsonEncoder := smithyjson.NewEncoder()
9702 if err := awsAwsjson11_serializeOpDocumentUpdateLoadBalancerAttributeInput(input, jsonEncoder.Value); err != nil {
9703 return out, metadata, &smithy.SerializationError{Err: err}
9704 }
9705
9706 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9707 return out, metadata, &smithy.SerializationError{Err: err}
9708 }
9709
9710 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9711 return out, metadata, &smithy.SerializationError{Err: err}
9712 }
9713 in.Request = request
9714
9715 endTimer()
9716 span.End()
9717 return next.HandleSerialize(ctx, in)
9718 }
9719
9720 type awsAwsjson11_serializeOpUpdateRelationalDatabase struct {
9721 }
9722
9723 func (*awsAwsjson11_serializeOpUpdateRelationalDatabase) ID() string {
9724 return "OperationSerializer"
9725 }
9726
9727 func (m *awsAwsjson11_serializeOpUpdateRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9728 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9729 ) {
9730 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9731 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9732 defer endTimer()
9733 defer span.End()
9734 request, ok := in.Request.(*smithyhttp.Request)
9735 if !ok {
9736 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9737 }
9738
9739 input, ok := in.Parameters.(*UpdateRelationalDatabaseInput)
9740 _ = input
9741 if !ok {
9742 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9743 }
9744
9745 operationPath := "/"
9746 if len(request.Request.URL.Path) == 0 {
9747 request.Request.URL.Path = operationPath
9748 } else {
9749 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9750 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9751 request.Request.URL.Path += "/"
9752 }
9753 }
9754 request.Request.Method = "POST"
9755 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9756 if err != nil {
9757 return out, metadata, &smithy.SerializationError{Err: err}
9758 }
9759 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9760 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateRelationalDatabase")
9761
9762 jsonEncoder := smithyjson.NewEncoder()
9763 if err := awsAwsjson11_serializeOpDocumentUpdateRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
9764 return out, metadata, &smithy.SerializationError{Err: err}
9765 }
9766
9767 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9768 return out, metadata, &smithy.SerializationError{Err: err}
9769 }
9770
9771 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9772 return out, metadata, &smithy.SerializationError{Err: err}
9773 }
9774 in.Request = request
9775
9776 endTimer()
9777 span.End()
9778 return next.HandleSerialize(ctx, in)
9779 }
9780
9781 type awsAwsjson11_serializeOpUpdateRelationalDatabaseParameters struct {
9782 }
9783
9784 func (*awsAwsjson11_serializeOpUpdateRelationalDatabaseParameters) ID() string {
9785 return "OperationSerializer"
9786 }
9787
9788 func (m *awsAwsjson11_serializeOpUpdateRelationalDatabaseParameters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9789 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9790 ) {
9791 _, span := tracing.StartSpan(ctx, "OperationSerializer")
9792 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
9793 defer endTimer()
9794 defer span.End()
9795 request, ok := in.Request.(*smithyhttp.Request)
9796 if !ok {
9797 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9798 }
9799
9800 input, ok := in.Parameters.(*UpdateRelationalDatabaseParametersInput)
9801 _ = input
9802 if !ok {
9803 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9804 }
9805
9806 operationPath := "/"
9807 if len(request.Request.URL.Path) == 0 {
9808 request.Request.URL.Path = operationPath
9809 } else {
9810 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
9811 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
9812 request.Request.URL.Path += "/"
9813 }
9814 }
9815 request.Request.Method = "POST"
9816 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9817 if err != nil {
9818 return out, metadata, &smithy.SerializationError{Err: err}
9819 }
9820 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
9821 httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateRelationalDatabaseParameters")
9822
9823 jsonEncoder := smithyjson.NewEncoder()
9824 if err := awsAwsjson11_serializeOpDocumentUpdateRelationalDatabaseParametersInput(input, jsonEncoder.Value); err != nil {
9825 return out, metadata, &smithy.SerializationError{Err: err}
9826 }
9827
9828 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9829 return out, metadata, &smithy.SerializationError{Err: err}
9830 }
9831
9832 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
9833 return out, metadata, &smithy.SerializationError{Err: err}
9834 }
9835 in.Request = request
9836
9837 endTimer()
9838 span.End()
9839 return next.HandleSerialize(ctx, in)
9840 }
9841 func awsAwsjson11_serializeDocumentAccessRules(v *types.AccessRules, value smithyjson.Value) error {
9842 object := value.Object()
9843 defer object.Close()
9844
9845 if v.AllowPublicOverrides != nil {
9846 ok := object.Key("allowPublicOverrides")
9847 ok.Boolean(*v.AllowPublicOverrides)
9848 }
9849
9850 if len(v.GetObject) > 0 {
9851 ok := object.Key("getObject")
9852 ok.String(string(v.GetObject))
9853 }
9854
9855 return nil
9856 }
9857
9858 func awsAwsjson11_serializeDocumentAddOnRequest(v *types.AddOnRequest, value smithyjson.Value) error {
9859 object := value.Object()
9860 defer object.Close()
9861
9862 if len(v.AddOnType) > 0 {
9863 ok := object.Key("addOnType")
9864 ok.String(string(v.AddOnType))
9865 }
9866
9867 if v.AutoSnapshotAddOnRequest != nil {
9868 ok := object.Key("autoSnapshotAddOnRequest")
9869 if err := awsAwsjson11_serializeDocumentAutoSnapshotAddOnRequest(v.AutoSnapshotAddOnRequest, ok); err != nil {
9870 return err
9871 }
9872 }
9873
9874 if v.StopInstanceOnIdleRequest != nil {
9875 ok := object.Key("stopInstanceOnIdleRequest")
9876 if err := awsAwsjson11_serializeDocumentStopInstanceOnIdleRequest(v.StopInstanceOnIdleRequest, ok); err != nil {
9877 return err
9878 }
9879 }
9880
9881 return nil
9882 }
9883
9884 func awsAwsjson11_serializeDocumentAddOnRequestList(v []types.AddOnRequest, value smithyjson.Value) error {
9885 array := value.Array()
9886 defer array.Close()
9887
9888 for i := range v {
9889 av := array.Value()
9890 if err := awsAwsjson11_serializeDocumentAddOnRequest(&v[i], av); err != nil {
9891 return err
9892 }
9893 }
9894 return nil
9895 }
9896
9897 func awsAwsjson11_serializeDocumentAttachedDiskMap(v map[string][]types.DiskMap, value smithyjson.Value) error {
9898 object := value.Object()
9899 defer object.Close()
9900
9901 for key := range v {
9902 om := object.Key(key)
9903 if vv := v[key]; vv == nil {
9904 continue
9905 }
9906 if err := awsAwsjson11_serializeDocumentDiskMapList(v[key], om); err != nil {
9907 return err
9908 }
9909 }
9910 return nil
9911 }
9912
9913 func awsAwsjson11_serializeDocumentAutoSnapshotAddOnRequest(v *types.AutoSnapshotAddOnRequest, value smithyjson.Value) error {
9914 object := value.Object()
9915 defer object.Close()
9916
9917 if v.SnapshotTimeOfDay != nil {
9918 ok := object.Key("snapshotTimeOfDay")
9919 ok.String(*v.SnapshotTimeOfDay)
9920 }
9921
9922 return nil
9923 }
9924
9925 func awsAwsjson11_serializeDocumentBucketAccessLogConfig(v *types.BucketAccessLogConfig, value smithyjson.Value) error {
9926 object := value.Object()
9927 defer object.Close()
9928
9929 if v.Destination != nil {
9930 ok := object.Key("destination")
9931 ok.String(*v.Destination)
9932 }
9933
9934 if v.Enabled != nil {
9935 ok := object.Key("enabled")
9936 ok.Boolean(*v.Enabled)
9937 }
9938
9939 if v.Prefix != nil {
9940 ok := object.Key("prefix")
9941 ok.String(*v.Prefix)
9942 }
9943
9944 return nil
9945 }
9946
9947 func awsAwsjson11_serializeDocumentBucketCorsAllowedHeaders(v []string, value smithyjson.Value) error {
9948 array := value.Array()
9949 defer array.Close()
9950
9951 for i := range v {
9952 av := array.Value()
9953 av.String(v[i])
9954 }
9955 return nil
9956 }
9957
9958 func awsAwsjson11_serializeDocumentBucketCorsAllowedMethods(v []string, value smithyjson.Value) error {
9959 array := value.Array()
9960 defer array.Close()
9961
9962 for i := range v {
9963 av := array.Value()
9964 av.String(v[i])
9965 }
9966 return nil
9967 }
9968
9969 func awsAwsjson11_serializeDocumentBucketCorsAllowedOrigins(v []string, value smithyjson.Value) error {
9970 array := value.Array()
9971 defer array.Close()
9972
9973 for i := range v {
9974 av := array.Value()
9975 av.String(v[i])
9976 }
9977 return nil
9978 }
9979
9980 func awsAwsjson11_serializeDocumentBucketCorsConfig(v *types.BucketCorsConfig, value smithyjson.Value) error {
9981 object := value.Object()
9982 defer object.Close()
9983
9984 if v.Rules != nil {
9985 ok := object.Key("rules")
9986 if err := awsAwsjson11_serializeDocumentBucketCorsRules(v.Rules, ok); err != nil {
9987 return err
9988 }
9989 }
9990
9991 return nil
9992 }
9993
9994 func awsAwsjson11_serializeDocumentBucketCorsExposeHeaders(v []string, value smithyjson.Value) error {
9995 array := value.Array()
9996 defer array.Close()
9997
9998 for i := range v {
9999 av := array.Value()
10000 av.String(v[i])
10001 }
10002 return nil
10003 }
10004
10005 func awsAwsjson11_serializeDocumentBucketCorsRule(v *types.BucketCorsRule, value smithyjson.Value) error {
10006 object := value.Object()
10007 defer object.Close()
10008
10009 if v.AllowedHeaders != nil {
10010 ok := object.Key("allowedHeaders")
10011 if err := awsAwsjson11_serializeDocumentBucketCorsAllowedHeaders(v.AllowedHeaders, ok); err != nil {
10012 return err
10013 }
10014 }
10015
10016 if v.AllowedMethods != nil {
10017 ok := object.Key("allowedMethods")
10018 if err := awsAwsjson11_serializeDocumentBucketCorsAllowedMethods(v.AllowedMethods, ok); err != nil {
10019 return err
10020 }
10021 }
10022
10023 if v.AllowedOrigins != nil {
10024 ok := object.Key("allowedOrigins")
10025 if err := awsAwsjson11_serializeDocumentBucketCorsAllowedOrigins(v.AllowedOrigins, ok); err != nil {
10026 return err
10027 }
10028 }
10029
10030 if v.ExposeHeaders != nil {
10031 ok := object.Key("exposeHeaders")
10032 if err := awsAwsjson11_serializeDocumentBucketCorsExposeHeaders(v.ExposeHeaders, ok); err != nil {
10033 return err
10034 }
10035 }
10036
10037 if v.Id != nil {
10038 ok := object.Key("id")
10039 ok.String(*v.Id)
10040 }
10041
10042 if v.MaxAgeSeconds != nil {
10043 ok := object.Key("maxAgeSeconds")
10044 ok.Integer(*v.MaxAgeSeconds)
10045 }
10046
10047 return nil
10048 }
10049
10050 func awsAwsjson11_serializeDocumentBucketCorsRules(v []types.BucketCorsRule, value smithyjson.Value) error {
10051 array := value.Array()
10052 defer array.Close()
10053
10054 for i := range v {
10055 av := array.Value()
10056 if err := awsAwsjson11_serializeDocumentBucketCorsRule(&v[i], av); err != nil {
10057 return err
10058 }
10059 }
10060 return nil
10061 }
10062
10063 func awsAwsjson11_serializeDocumentCacheBehavior(v *types.CacheBehavior, value smithyjson.Value) error {
10064 object := value.Object()
10065 defer object.Close()
10066
10067 if len(v.Behavior) > 0 {
10068 ok := object.Key("behavior")
10069 ok.String(string(v.Behavior))
10070 }
10071
10072 return nil
10073 }
10074
10075 func awsAwsjson11_serializeDocumentCacheBehaviorList(v []types.CacheBehaviorPerPath, value smithyjson.Value) error {
10076 array := value.Array()
10077 defer array.Close()
10078
10079 for i := range v {
10080 av := array.Value()
10081 if err := awsAwsjson11_serializeDocumentCacheBehaviorPerPath(&v[i], av); err != nil {
10082 return err
10083 }
10084 }
10085 return nil
10086 }
10087
10088 func awsAwsjson11_serializeDocumentCacheBehaviorPerPath(v *types.CacheBehaviorPerPath, value smithyjson.Value) error {
10089 object := value.Object()
10090 defer object.Close()
10091
10092 if len(v.Behavior) > 0 {
10093 ok := object.Key("behavior")
10094 ok.String(string(v.Behavior))
10095 }
10096
10097 if v.Path != nil {
10098 ok := object.Key("path")
10099 ok.String(*v.Path)
10100 }
10101
10102 return nil
10103 }
10104
10105 func awsAwsjson11_serializeDocumentCacheSettings(v *types.CacheSettings, value smithyjson.Value) error {
10106 object := value.Object()
10107 defer object.Close()
10108
10109 if v.AllowedHTTPMethods != nil {
10110 ok := object.Key("allowedHTTPMethods")
10111 ok.String(*v.AllowedHTTPMethods)
10112 }
10113
10114 if v.CachedHTTPMethods != nil {
10115 ok := object.Key("cachedHTTPMethods")
10116 ok.String(*v.CachedHTTPMethods)
10117 }
10118
10119 if v.DefaultTTL != nil {
10120 ok := object.Key("defaultTTL")
10121 ok.Long(*v.DefaultTTL)
10122 }
10123
10124 if v.ForwardedCookies != nil {
10125 ok := object.Key("forwardedCookies")
10126 if err := awsAwsjson11_serializeDocumentCookieObject(v.ForwardedCookies, ok); err != nil {
10127 return err
10128 }
10129 }
10130
10131 if v.ForwardedHeaders != nil {
10132 ok := object.Key("forwardedHeaders")
10133 if err := awsAwsjson11_serializeDocumentHeaderObject(v.ForwardedHeaders, ok); err != nil {
10134 return err
10135 }
10136 }
10137
10138 if v.ForwardedQueryStrings != nil {
10139 ok := object.Key("forwardedQueryStrings")
10140 if err := awsAwsjson11_serializeDocumentQueryStringObject(v.ForwardedQueryStrings, ok); err != nil {
10141 return err
10142 }
10143 }
10144
10145 if v.MaximumTTL != nil {
10146 ok := object.Key("maximumTTL")
10147 ok.Long(*v.MaximumTTL)
10148 }
10149
10150 if v.MinimumTTL != nil {
10151 ok := object.Key("minimumTTL")
10152 ok.Long(*v.MinimumTTL)
10153 }
10154
10155 return nil
10156 }
10157
10158 func awsAwsjson11_serializeDocumentCertificateStatusList(v []types.CertificateStatus, value smithyjson.Value) error {
10159 array := value.Array()
10160 defer array.Close()
10161
10162 for i := range v {
10163 av := array.Value()
10164 av.String(string(v[i]))
10165 }
10166 return nil
10167 }
10168
10169 func awsAwsjson11_serializeDocumentContactProtocolsList(v []types.ContactProtocol, value smithyjson.Value) error {
10170 array := value.Array()
10171 defer array.Close()
10172
10173 for i := range v {
10174 av := array.Value()
10175 av.String(string(v[i]))
10176 }
10177 return nil
10178 }
10179
10180 func awsAwsjson11_serializeDocumentContainer(v *types.Container, value smithyjson.Value) error {
10181 object := value.Object()
10182 defer object.Close()
10183
10184 if v.Command != nil {
10185 ok := object.Key("command")
10186 if err := awsAwsjson11_serializeDocumentStringList(v.Command, ok); err != nil {
10187 return err
10188 }
10189 }
10190
10191 if v.Environment != nil {
10192 ok := object.Key("environment")
10193 if err := awsAwsjson11_serializeDocumentEnvironment(v.Environment, ok); err != nil {
10194 return err
10195 }
10196 }
10197
10198 if v.Image != nil {
10199 ok := object.Key("image")
10200 ok.String(*v.Image)
10201 }
10202
10203 if v.Ports != nil {
10204 ok := object.Key("ports")
10205 if err := awsAwsjson11_serializeDocumentPortMap(v.Ports, ok); err != nil {
10206 return err
10207 }
10208 }
10209
10210 return nil
10211 }
10212
10213 func awsAwsjson11_serializeDocumentContainerMap(v map[string]types.Container, value smithyjson.Value) error {
10214 object := value.Object()
10215 defer object.Close()
10216
10217 for key := range v {
10218 om := object.Key(key)
10219 mapVar := v[key]
10220 if err := awsAwsjson11_serializeDocumentContainer(&mapVar, om); err != nil {
10221 return err
10222 }
10223 }
10224 return nil
10225 }
10226
10227 func awsAwsjson11_serializeDocumentContainerServiceDeploymentRequest(v *types.ContainerServiceDeploymentRequest, value smithyjson.Value) error {
10228 object := value.Object()
10229 defer object.Close()
10230
10231 if v.Containers != nil {
10232 ok := object.Key("containers")
10233 if err := awsAwsjson11_serializeDocumentContainerMap(v.Containers, ok); err != nil {
10234 return err
10235 }
10236 }
10237
10238 if v.PublicEndpoint != nil {
10239 ok := object.Key("publicEndpoint")
10240 if err := awsAwsjson11_serializeDocumentEndpointRequest(v.PublicEndpoint, ok); err != nil {
10241 return err
10242 }
10243 }
10244
10245 return nil
10246 }
10247
10248 func awsAwsjson11_serializeDocumentContainerServiceECRImagePullerRoleRequest(v *types.ContainerServiceECRImagePullerRoleRequest, value smithyjson.Value) error {
10249 object := value.Object()
10250 defer object.Close()
10251
10252 if v.IsActive != nil {
10253 ok := object.Key("isActive")
10254 ok.Boolean(*v.IsActive)
10255 }
10256
10257 return nil
10258 }
10259
10260 func awsAwsjson11_serializeDocumentContainerServiceHealthCheckConfig(v *types.ContainerServiceHealthCheckConfig, value smithyjson.Value) error {
10261 object := value.Object()
10262 defer object.Close()
10263
10264 if v.HealthyThreshold != nil {
10265 ok := object.Key("healthyThreshold")
10266 ok.Integer(*v.HealthyThreshold)
10267 }
10268
10269 if v.IntervalSeconds != nil {
10270 ok := object.Key("intervalSeconds")
10271 ok.Integer(*v.IntervalSeconds)
10272 }
10273
10274 if v.Path != nil {
10275 ok := object.Key("path")
10276 ok.String(*v.Path)
10277 }
10278
10279 if v.SuccessCodes != nil {
10280 ok := object.Key("successCodes")
10281 ok.String(*v.SuccessCodes)
10282 }
10283
10284 if v.TimeoutSeconds != nil {
10285 ok := object.Key("timeoutSeconds")
10286 ok.Integer(*v.TimeoutSeconds)
10287 }
10288
10289 if v.UnhealthyThreshold != nil {
10290 ok := object.Key("unhealthyThreshold")
10291 ok.Integer(*v.UnhealthyThreshold)
10292 }
10293
10294 return nil
10295 }
10296
10297 func awsAwsjson11_serializeDocumentContainerServicePublicDomains(v map[string][]string, value smithyjson.Value) error {
10298 object := value.Object()
10299 defer object.Close()
10300
10301 for key := range v {
10302 om := object.Key(key)
10303 if vv := v[key]; vv == nil {
10304 continue
10305 }
10306 if err := awsAwsjson11_serializeDocumentContainerServicePublicDomainsList(v[key], om); err != nil {
10307 return err
10308 }
10309 }
10310 return nil
10311 }
10312
10313 func awsAwsjson11_serializeDocumentContainerServicePublicDomainsList(v []string, value smithyjson.Value) error {
10314 array := value.Array()
10315 defer array.Close()
10316
10317 for i := range v {
10318 av := array.Value()
10319 av.String(v[i])
10320 }
10321 return nil
10322 }
10323
10324 func awsAwsjson11_serializeDocumentCookieObject(v *types.CookieObject, value smithyjson.Value) error {
10325 object := value.Object()
10326 defer object.Close()
10327
10328 if v.CookiesAllowList != nil {
10329 ok := object.Key("cookiesAllowList")
10330 if err := awsAwsjson11_serializeDocumentStringList(v.CookiesAllowList, ok); err != nil {
10331 return err
10332 }
10333 }
10334
10335 if len(v.Option) > 0 {
10336 ok := object.Key("option")
10337 ok.String(string(v.Option))
10338 }
10339
10340 return nil
10341 }
10342
10343 func awsAwsjson11_serializeDocumentDiskMap(v *types.DiskMap, value smithyjson.Value) error {
10344 object := value.Object()
10345 defer object.Close()
10346
10347 if v.NewDiskName != nil {
10348 ok := object.Key("newDiskName")
10349 ok.String(*v.NewDiskName)
10350 }
10351
10352 if v.OriginalDiskPath != nil {
10353 ok := object.Key("originalDiskPath")
10354 ok.String(*v.OriginalDiskPath)
10355 }
10356
10357 return nil
10358 }
10359
10360 func awsAwsjson11_serializeDocumentDiskMapList(v []types.DiskMap, value smithyjson.Value) error {
10361 array := value.Array()
10362 defer array.Close()
10363
10364 for i := range v {
10365 av := array.Value()
10366 if err := awsAwsjson11_serializeDocumentDiskMap(&v[i], av); err != nil {
10367 return err
10368 }
10369 }
10370 return nil
10371 }
10372
10373 func awsAwsjson11_serializeDocumentDomainEntry(v *types.DomainEntry, value smithyjson.Value) error {
10374 object := value.Object()
10375 defer object.Close()
10376
10377 if v.Id != nil {
10378 ok := object.Key("id")
10379 ok.String(*v.Id)
10380 }
10381
10382 if v.IsAlias != nil {
10383 ok := object.Key("isAlias")
10384 ok.Boolean(*v.IsAlias)
10385 }
10386
10387 if v.Name != nil {
10388 ok := object.Key("name")
10389 ok.String(*v.Name)
10390 }
10391
10392 if v.Options != nil {
10393 ok := object.Key("options")
10394 if err := awsAwsjson11_serializeDocumentDomainEntryOptions(v.Options, ok); err != nil {
10395 return err
10396 }
10397 }
10398
10399 if v.Target != nil {
10400 ok := object.Key("target")
10401 ok.String(*v.Target)
10402 }
10403
10404 if v.Type != nil {
10405 ok := object.Key("type")
10406 ok.String(*v.Type)
10407 }
10408
10409 return nil
10410 }
10411
10412 func awsAwsjson11_serializeDocumentDomainEntryOptions(v map[string]string, value smithyjson.Value) error {
10413 object := value.Object()
10414 defer object.Close()
10415
10416 for key := range v {
10417 om := object.Key(key)
10418 om.String(v[key])
10419 }
10420 return nil
10421 }
10422
10423 func awsAwsjson11_serializeDocumentDomainNameList(v []string, value smithyjson.Value) error {
10424 array := value.Array()
10425 defer array.Close()
10426
10427 for i := range v {
10428 av := array.Value()
10429 av.String(v[i])
10430 }
10431 return nil
10432 }
10433
10434 func awsAwsjson11_serializeDocumentEndpointRequest(v *types.EndpointRequest, value smithyjson.Value) error {
10435 object := value.Object()
10436 defer object.Close()
10437
10438 if v.ContainerName != nil {
10439 ok := object.Key("containerName")
10440 ok.String(*v.ContainerName)
10441 }
10442
10443 if v.ContainerPort != nil {
10444 ok := object.Key("containerPort")
10445 ok.Integer(*v.ContainerPort)
10446 }
10447
10448 if v.HealthCheck != nil {
10449 ok := object.Key("healthCheck")
10450 if err := awsAwsjson11_serializeDocumentContainerServiceHealthCheckConfig(v.HealthCheck, ok); err != nil {
10451 return err
10452 }
10453 }
10454
10455 return nil
10456 }
10457
10458 func awsAwsjson11_serializeDocumentEnvironment(v map[string]string, value smithyjson.Value) error {
10459 object := value.Object()
10460 defer object.Close()
10461
10462 for key := range v {
10463 om := object.Key(key)
10464 om.String(v[key])
10465 }
10466 return nil
10467 }
10468
10469 func awsAwsjson11_serializeDocumentHeaderForwardList(v []types.HeaderEnum, value smithyjson.Value) error {
10470 array := value.Array()
10471 defer array.Close()
10472
10473 for i := range v {
10474 av := array.Value()
10475 av.String(string(v[i]))
10476 }
10477 return nil
10478 }
10479
10480 func awsAwsjson11_serializeDocumentHeaderObject(v *types.HeaderObject, value smithyjson.Value) error {
10481 object := value.Object()
10482 defer object.Close()
10483
10484 if v.HeadersAllowList != nil {
10485 ok := object.Key("headersAllowList")
10486 if err := awsAwsjson11_serializeDocumentHeaderForwardList(v.HeadersAllowList, ok); err != nil {
10487 return err
10488 }
10489 }
10490
10491 if len(v.Option) > 0 {
10492 ok := object.Key("option")
10493 ok.String(string(v.Option))
10494 }
10495
10496 return nil
10497 }
10498
10499 func awsAwsjson11_serializeDocumentInputOrigin(v *types.InputOrigin, value smithyjson.Value) error {
10500 object := value.Object()
10501 defer object.Close()
10502
10503 if v.Name != nil {
10504 ok := object.Key("name")
10505 ok.String(*v.Name)
10506 }
10507
10508 if len(v.ProtocolPolicy) > 0 {
10509 ok := object.Key("protocolPolicy")
10510 ok.String(string(v.ProtocolPolicy))
10511 }
10512
10513 if len(v.RegionName) > 0 {
10514 ok := object.Key("regionName")
10515 ok.String(string(v.RegionName))
10516 }
10517
10518 if v.ResponseTimeout != nil {
10519 ok := object.Key("responseTimeout")
10520 ok.Integer(*v.ResponseTimeout)
10521 }
10522
10523 return nil
10524 }
10525
10526 func awsAwsjson11_serializeDocumentInstanceEntry(v *types.InstanceEntry, value smithyjson.Value) error {
10527 object := value.Object()
10528 defer object.Close()
10529
10530 if v.AvailabilityZone != nil {
10531 ok := object.Key("availabilityZone")
10532 ok.String(*v.AvailabilityZone)
10533 }
10534
10535 if v.InstanceType != nil {
10536 ok := object.Key("instanceType")
10537 ok.String(*v.InstanceType)
10538 }
10539
10540 if len(v.PortInfoSource) > 0 {
10541 ok := object.Key("portInfoSource")
10542 ok.String(string(v.PortInfoSource))
10543 }
10544
10545 if v.SourceName != nil {
10546 ok := object.Key("sourceName")
10547 ok.String(*v.SourceName)
10548 }
10549
10550 if v.UserData != nil {
10551 ok := object.Key("userData")
10552 ok.String(*v.UserData)
10553 }
10554
10555 return nil
10556 }
10557
10558 func awsAwsjson11_serializeDocumentInstanceEntryList(v []types.InstanceEntry, value smithyjson.Value) error {
10559 array := value.Array()
10560 defer array.Close()
10561
10562 for i := range v {
10563 av := array.Value()
10564 if err := awsAwsjson11_serializeDocumentInstanceEntry(&v[i], av); err != nil {
10565 return err
10566 }
10567 }
10568 return nil
10569 }
10570
10571 func awsAwsjson11_serializeDocumentMetricStatisticList(v []types.MetricStatistic, value smithyjson.Value) error {
10572 array := value.Array()
10573 defer array.Close()
10574
10575 for i := range v {
10576 av := array.Value()
10577 av.String(string(v[i]))
10578 }
10579 return nil
10580 }
10581
10582 func awsAwsjson11_serializeDocumentNotificationTriggerList(v []types.AlarmState, value smithyjson.Value) error {
10583 array := value.Array()
10584 defer array.Close()
10585
10586 for i := range v {
10587 av := array.Value()
10588 av.String(string(v[i]))
10589 }
10590 return nil
10591 }
10592
10593 func awsAwsjson11_serializeDocumentPartnerIdList(v []string, value smithyjson.Value) error {
10594 array := value.Array()
10595 defer array.Close()
10596
10597 for i := range v {
10598 av := array.Value()
10599 av.String(v[i])
10600 }
10601 return nil
10602 }
10603
10604 func awsAwsjson11_serializeDocumentPortInfo(v *types.PortInfo, value smithyjson.Value) error {
10605 object := value.Object()
10606 defer object.Close()
10607
10608 if v.CidrListAliases != nil {
10609 ok := object.Key("cidrListAliases")
10610 if err := awsAwsjson11_serializeDocumentStringList(v.CidrListAliases, ok); err != nil {
10611 return err
10612 }
10613 }
10614
10615 if v.Cidrs != nil {
10616 ok := object.Key("cidrs")
10617 if err := awsAwsjson11_serializeDocumentStringList(v.Cidrs, ok); err != nil {
10618 return err
10619 }
10620 }
10621
10622 if v.FromPort != 0 {
10623 ok := object.Key("fromPort")
10624 ok.Integer(v.FromPort)
10625 }
10626
10627 if v.Ipv6Cidrs != nil {
10628 ok := object.Key("ipv6Cidrs")
10629 if err := awsAwsjson11_serializeDocumentStringList(v.Ipv6Cidrs, ok); err != nil {
10630 return err
10631 }
10632 }
10633
10634 if len(v.Protocol) > 0 {
10635 ok := object.Key("protocol")
10636 ok.String(string(v.Protocol))
10637 }
10638
10639 if v.ToPort != 0 {
10640 ok := object.Key("toPort")
10641 ok.Integer(v.ToPort)
10642 }
10643
10644 return nil
10645 }
10646
10647 func awsAwsjson11_serializeDocumentPortInfoList(v []types.PortInfo, value smithyjson.Value) error {
10648 array := value.Array()
10649 defer array.Close()
10650
10651 for i := range v {
10652 av := array.Value()
10653 if err := awsAwsjson11_serializeDocumentPortInfo(&v[i], av); err != nil {
10654 return err
10655 }
10656 }
10657 return nil
10658 }
10659
10660 func awsAwsjson11_serializeDocumentPortMap(v map[string]types.ContainerServiceProtocol, value smithyjson.Value) error {
10661 object := value.Object()
10662 defer object.Close()
10663
10664 for key := range v {
10665 om := object.Key(key)
10666 om.String(string(v[key]))
10667 }
10668 return nil
10669 }
10670
10671 func awsAwsjson11_serializeDocumentPrivateRegistryAccessRequest(v *types.PrivateRegistryAccessRequest, value smithyjson.Value) error {
10672 object := value.Object()
10673 defer object.Close()
10674
10675 if v.EcrImagePullerRole != nil {
10676 ok := object.Key("ecrImagePullerRole")
10677 if err := awsAwsjson11_serializeDocumentContainerServiceECRImagePullerRoleRequest(v.EcrImagePullerRole, ok); err != nil {
10678 return err
10679 }
10680 }
10681
10682 return nil
10683 }
10684
10685 func awsAwsjson11_serializeDocumentQueryStringObject(v *types.QueryStringObject, value smithyjson.Value) error {
10686 object := value.Object()
10687 defer object.Close()
10688
10689 if v.Option != nil {
10690 ok := object.Key("option")
10691 ok.Boolean(*v.Option)
10692 }
10693
10694 if v.QueryStringsAllowList != nil {
10695 ok := object.Key("queryStringsAllowList")
10696 if err := awsAwsjson11_serializeDocumentStringList(v.QueryStringsAllowList, ok); err != nil {
10697 return err
10698 }
10699 }
10700
10701 return nil
10702 }
10703
10704 func awsAwsjson11_serializeDocumentRelationalDatabaseParameter(v *types.RelationalDatabaseParameter, value smithyjson.Value) error {
10705 object := value.Object()
10706 defer object.Close()
10707
10708 if v.AllowedValues != nil {
10709 ok := object.Key("allowedValues")
10710 ok.String(*v.AllowedValues)
10711 }
10712
10713 if v.ApplyMethod != nil {
10714 ok := object.Key("applyMethod")
10715 ok.String(*v.ApplyMethod)
10716 }
10717
10718 if v.ApplyType != nil {
10719 ok := object.Key("applyType")
10720 ok.String(*v.ApplyType)
10721 }
10722
10723 if v.DataType != nil {
10724 ok := object.Key("dataType")
10725 ok.String(*v.DataType)
10726 }
10727
10728 if v.Description != nil {
10729 ok := object.Key("description")
10730 ok.String(*v.Description)
10731 }
10732
10733 if v.IsModifiable != nil {
10734 ok := object.Key("isModifiable")
10735 ok.Boolean(*v.IsModifiable)
10736 }
10737
10738 if v.ParameterName != nil {
10739 ok := object.Key("parameterName")
10740 ok.String(*v.ParameterName)
10741 }
10742
10743 if v.ParameterValue != nil {
10744 ok := object.Key("parameterValue")
10745 ok.String(*v.ParameterValue)
10746 }
10747
10748 return nil
10749 }
10750
10751 func awsAwsjson11_serializeDocumentRelationalDatabaseParameterList(v []types.RelationalDatabaseParameter, value smithyjson.Value) error {
10752 array := value.Array()
10753 defer array.Close()
10754
10755 for i := range v {
10756 av := array.Value()
10757 if err := awsAwsjson11_serializeDocumentRelationalDatabaseParameter(&v[i], av); err != nil {
10758 return err
10759 }
10760 }
10761 return nil
10762 }
10763
10764 func awsAwsjson11_serializeDocumentResourceNameList(v []string, value smithyjson.Value) error {
10765 array := value.Array()
10766 defer array.Close()
10767
10768 for i := range v {
10769 av := array.Value()
10770 av.String(v[i])
10771 }
10772 return nil
10773 }
10774
10775 func awsAwsjson11_serializeDocumentSetupDomainNameList(v []string, value smithyjson.Value) error {
10776 array := value.Array()
10777 defer array.Close()
10778
10779 for i := range v {
10780 av := array.Value()
10781 av.String(v[i])
10782 }
10783 return nil
10784 }
10785
10786 func awsAwsjson11_serializeDocumentStopInstanceOnIdleRequest(v *types.StopInstanceOnIdleRequest, value smithyjson.Value) error {
10787 object := value.Object()
10788 defer object.Close()
10789
10790 if v.Duration != nil {
10791 ok := object.Key("duration")
10792 ok.String(*v.Duration)
10793 }
10794
10795 if v.Threshold != nil {
10796 ok := object.Key("threshold")
10797 ok.String(*v.Threshold)
10798 }
10799
10800 return nil
10801 }
10802
10803 func awsAwsjson11_serializeDocumentStringList(v []string, value smithyjson.Value) error {
10804 array := value.Array()
10805 defer array.Close()
10806
10807 for i := range v {
10808 av := array.Value()
10809 av.String(v[i])
10810 }
10811 return nil
10812 }
10813
10814 func awsAwsjson11_serializeDocumentSubjectAlternativeNameList(v []string, value smithyjson.Value) error {
10815 array := value.Array()
10816 defer array.Close()
10817
10818 for i := range v {
10819 av := array.Value()
10820 av.String(v[i])
10821 }
10822 return nil
10823 }
10824
10825 func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
10826 object := value.Object()
10827 defer object.Close()
10828
10829 if v.Key != nil {
10830 ok := object.Key("key")
10831 ok.String(*v.Key)
10832 }
10833
10834 if v.Value != nil {
10835 ok := object.Key("value")
10836 ok.String(*v.Value)
10837 }
10838
10839 return nil
10840 }
10841
10842 func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
10843 array := value.Array()
10844 defer array.Close()
10845
10846 for i := range v {
10847 av := array.Value()
10848 av.String(v[i])
10849 }
10850 return nil
10851 }
10852
10853 func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
10854 array := value.Array()
10855 defer array.Close()
10856
10857 for i := range v {
10858 av := array.Value()
10859 if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
10860 return err
10861 }
10862 }
10863 return nil
10864 }
10865
10866 func awsAwsjson11_serializeOpDocumentAllocateStaticIpInput(v *AllocateStaticIpInput, value smithyjson.Value) error {
10867 object := value.Object()
10868 defer object.Close()
10869
10870 if v.StaticIpName != nil {
10871 ok := object.Key("staticIpName")
10872 ok.String(*v.StaticIpName)
10873 }
10874
10875 return nil
10876 }
10877
10878 func awsAwsjson11_serializeOpDocumentAttachCertificateToDistributionInput(v *AttachCertificateToDistributionInput, value smithyjson.Value) error {
10879 object := value.Object()
10880 defer object.Close()
10881
10882 if v.CertificateName != nil {
10883 ok := object.Key("certificateName")
10884 ok.String(*v.CertificateName)
10885 }
10886
10887 if v.DistributionName != nil {
10888 ok := object.Key("distributionName")
10889 ok.String(*v.DistributionName)
10890 }
10891
10892 return nil
10893 }
10894
10895 func awsAwsjson11_serializeOpDocumentAttachDiskInput(v *AttachDiskInput, value smithyjson.Value) error {
10896 object := value.Object()
10897 defer object.Close()
10898
10899 if v.AutoMounting != nil {
10900 ok := object.Key("autoMounting")
10901 ok.Boolean(*v.AutoMounting)
10902 }
10903
10904 if v.DiskName != nil {
10905 ok := object.Key("diskName")
10906 ok.String(*v.DiskName)
10907 }
10908
10909 if v.DiskPath != nil {
10910 ok := object.Key("diskPath")
10911 ok.String(*v.DiskPath)
10912 }
10913
10914 if v.InstanceName != nil {
10915 ok := object.Key("instanceName")
10916 ok.String(*v.InstanceName)
10917 }
10918
10919 return nil
10920 }
10921
10922 func awsAwsjson11_serializeOpDocumentAttachInstancesToLoadBalancerInput(v *AttachInstancesToLoadBalancerInput, value smithyjson.Value) error {
10923 object := value.Object()
10924 defer object.Close()
10925
10926 if v.InstanceNames != nil {
10927 ok := object.Key("instanceNames")
10928 if err := awsAwsjson11_serializeDocumentResourceNameList(v.InstanceNames, ok); err != nil {
10929 return err
10930 }
10931 }
10932
10933 if v.LoadBalancerName != nil {
10934 ok := object.Key("loadBalancerName")
10935 ok.String(*v.LoadBalancerName)
10936 }
10937
10938 return nil
10939 }
10940
10941 func awsAwsjson11_serializeOpDocumentAttachLoadBalancerTlsCertificateInput(v *AttachLoadBalancerTlsCertificateInput, value smithyjson.Value) error {
10942 object := value.Object()
10943 defer object.Close()
10944
10945 if v.CertificateName != nil {
10946 ok := object.Key("certificateName")
10947 ok.String(*v.CertificateName)
10948 }
10949
10950 if v.LoadBalancerName != nil {
10951 ok := object.Key("loadBalancerName")
10952 ok.String(*v.LoadBalancerName)
10953 }
10954
10955 return nil
10956 }
10957
10958 func awsAwsjson11_serializeOpDocumentAttachStaticIpInput(v *AttachStaticIpInput, value smithyjson.Value) error {
10959 object := value.Object()
10960 defer object.Close()
10961
10962 if v.InstanceName != nil {
10963 ok := object.Key("instanceName")
10964 ok.String(*v.InstanceName)
10965 }
10966
10967 if v.StaticIpName != nil {
10968 ok := object.Key("staticIpName")
10969 ok.String(*v.StaticIpName)
10970 }
10971
10972 return nil
10973 }
10974
10975 func awsAwsjson11_serializeOpDocumentCloseInstancePublicPortsInput(v *CloseInstancePublicPortsInput, value smithyjson.Value) error {
10976 object := value.Object()
10977 defer object.Close()
10978
10979 if v.InstanceName != nil {
10980 ok := object.Key("instanceName")
10981 ok.String(*v.InstanceName)
10982 }
10983
10984 if v.PortInfo != nil {
10985 ok := object.Key("portInfo")
10986 if err := awsAwsjson11_serializeDocumentPortInfo(v.PortInfo, ok); err != nil {
10987 return err
10988 }
10989 }
10990
10991 return nil
10992 }
10993
10994 func awsAwsjson11_serializeOpDocumentCopySnapshotInput(v *CopySnapshotInput, value smithyjson.Value) error {
10995 object := value.Object()
10996 defer object.Close()
10997
10998 if v.RestoreDate != nil {
10999 ok := object.Key("restoreDate")
11000 ok.String(*v.RestoreDate)
11001 }
11002
11003 if len(v.SourceRegion) > 0 {
11004 ok := object.Key("sourceRegion")
11005 ok.String(string(v.SourceRegion))
11006 }
11007
11008 if v.SourceResourceName != nil {
11009 ok := object.Key("sourceResourceName")
11010 ok.String(*v.SourceResourceName)
11011 }
11012
11013 if v.SourceSnapshotName != nil {
11014 ok := object.Key("sourceSnapshotName")
11015 ok.String(*v.SourceSnapshotName)
11016 }
11017
11018 if v.TargetSnapshotName != nil {
11019 ok := object.Key("targetSnapshotName")
11020 ok.String(*v.TargetSnapshotName)
11021 }
11022
11023 if v.UseLatestRestorableAutoSnapshot != nil {
11024 ok := object.Key("useLatestRestorableAutoSnapshot")
11025 ok.Boolean(*v.UseLatestRestorableAutoSnapshot)
11026 }
11027
11028 return nil
11029 }
11030
11031 func awsAwsjson11_serializeOpDocumentCreateBucketAccessKeyInput(v *CreateBucketAccessKeyInput, value smithyjson.Value) error {
11032 object := value.Object()
11033 defer object.Close()
11034
11035 if v.BucketName != nil {
11036 ok := object.Key("bucketName")
11037 ok.String(*v.BucketName)
11038 }
11039
11040 return nil
11041 }
11042
11043 func awsAwsjson11_serializeOpDocumentCreateBucketInput(v *CreateBucketInput, value smithyjson.Value) error {
11044 object := value.Object()
11045 defer object.Close()
11046
11047 if v.BucketName != nil {
11048 ok := object.Key("bucketName")
11049 ok.String(*v.BucketName)
11050 }
11051
11052 if v.BundleId != nil {
11053 ok := object.Key("bundleId")
11054 ok.String(*v.BundleId)
11055 }
11056
11057 if v.EnableObjectVersioning != nil {
11058 ok := object.Key("enableObjectVersioning")
11059 ok.Boolean(*v.EnableObjectVersioning)
11060 }
11061
11062 if v.Tags != nil {
11063 ok := object.Key("tags")
11064 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11065 return err
11066 }
11067 }
11068
11069 return nil
11070 }
11071
11072 func awsAwsjson11_serializeOpDocumentCreateCertificateInput(v *CreateCertificateInput, value smithyjson.Value) error {
11073 object := value.Object()
11074 defer object.Close()
11075
11076 if v.CertificateName != nil {
11077 ok := object.Key("certificateName")
11078 ok.String(*v.CertificateName)
11079 }
11080
11081 if v.DomainName != nil {
11082 ok := object.Key("domainName")
11083 ok.String(*v.DomainName)
11084 }
11085
11086 if v.SubjectAlternativeNames != nil {
11087 ok := object.Key("subjectAlternativeNames")
11088 if err := awsAwsjson11_serializeDocumentSubjectAlternativeNameList(v.SubjectAlternativeNames, ok); err != nil {
11089 return err
11090 }
11091 }
11092
11093 if v.Tags != nil {
11094 ok := object.Key("tags")
11095 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11096 return err
11097 }
11098 }
11099
11100 return nil
11101 }
11102
11103 func awsAwsjson11_serializeOpDocumentCreateCloudFormationStackInput(v *CreateCloudFormationStackInput, value smithyjson.Value) error {
11104 object := value.Object()
11105 defer object.Close()
11106
11107 if v.Instances != nil {
11108 ok := object.Key("instances")
11109 if err := awsAwsjson11_serializeDocumentInstanceEntryList(v.Instances, ok); err != nil {
11110 return err
11111 }
11112 }
11113
11114 return nil
11115 }
11116
11117 func awsAwsjson11_serializeOpDocumentCreateContactMethodInput(v *CreateContactMethodInput, value smithyjson.Value) error {
11118 object := value.Object()
11119 defer object.Close()
11120
11121 if v.ContactEndpoint != nil {
11122 ok := object.Key("contactEndpoint")
11123 ok.String(*v.ContactEndpoint)
11124 }
11125
11126 if len(v.Protocol) > 0 {
11127 ok := object.Key("protocol")
11128 ok.String(string(v.Protocol))
11129 }
11130
11131 return nil
11132 }
11133
11134 func awsAwsjson11_serializeOpDocumentCreateContainerServiceDeploymentInput(v *CreateContainerServiceDeploymentInput, value smithyjson.Value) error {
11135 object := value.Object()
11136 defer object.Close()
11137
11138 if v.Containers != nil {
11139 ok := object.Key("containers")
11140 if err := awsAwsjson11_serializeDocumentContainerMap(v.Containers, ok); err != nil {
11141 return err
11142 }
11143 }
11144
11145 if v.PublicEndpoint != nil {
11146 ok := object.Key("publicEndpoint")
11147 if err := awsAwsjson11_serializeDocumentEndpointRequest(v.PublicEndpoint, ok); err != nil {
11148 return err
11149 }
11150 }
11151
11152 if v.ServiceName != nil {
11153 ok := object.Key("serviceName")
11154 ok.String(*v.ServiceName)
11155 }
11156
11157 return nil
11158 }
11159
11160 func awsAwsjson11_serializeOpDocumentCreateContainerServiceInput(v *CreateContainerServiceInput, value smithyjson.Value) error {
11161 object := value.Object()
11162 defer object.Close()
11163
11164 if v.Deployment != nil {
11165 ok := object.Key("deployment")
11166 if err := awsAwsjson11_serializeDocumentContainerServiceDeploymentRequest(v.Deployment, ok); err != nil {
11167 return err
11168 }
11169 }
11170
11171 if len(v.Power) > 0 {
11172 ok := object.Key("power")
11173 ok.String(string(v.Power))
11174 }
11175
11176 if v.PrivateRegistryAccess != nil {
11177 ok := object.Key("privateRegistryAccess")
11178 if err := awsAwsjson11_serializeDocumentPrivateRegistryAccessRequest(v.PrivateRegistryAccess, ok); err != nil {
11179 return err
11180 }
11181 }
11182
11183 if v.PublicDomainNames != nil {
11184 ok := object.Key("publicDomainNames")
11185 if err := awsAwsjson11_serializeDocumentContainerServicePublicDomains(v.PublicDomainNames, ok); err != nil {
11186 return err
11187 }
11188 }
11189
11190 if v.Scale != nil {
11191 ok := object.Key("scale")
11192 ok.Integer(*v.Scale)
11193 }
11194
11195 if v.ServiceName != nil {
11196 ok := object.Key("serviceName")
11197 ok.String(*v.ServiceName)
11198 }
11199
11200 if v.Tags != nil {
11201 ok := object.Key("tags")
11202 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11203 return err
11204 }
11205 }
11206
11207 return nil
11208 }
11209
11210 func awsAwsjson11_serializeOpDocumentCreateContainerServiceRegistryLoginInput(v *CreateContainerServiceRegistryLoginInput, value smithyjson.Value) error {
11211 object := value.Object()
11212 defer object.Close()
11213
11214 return nil
11215 }
11216
11217 func awsAwsjson11_serializeOpDocumentCreateDiskFromSnapshotInput(v *CreateDiskFromSnapshotInput, value smithyjson.Value) error {
11218 object := value.Object()
11219 defer object.Close()
11220
11221 if v.AddOns != nil {
11222 ok := object.Key("addOns")
11223 if err := awsAwsjson11_serializeDocumentAddOnRequestList(v.AddOns, ok); err != nil {
11224 return err
11225 }
11226 }
11227
11228 if v.AvailabilityZone != nil {
11229 ok := object.Key("availabilityZone")
11230 ok.String(*v.AvailabilityZone)
11231 }
11232
11233 if v.DiskName != nil {
11234 ok := object.Key("diskName")
11235 ok.String(*v.DiskName)
11236 }
11237
11238 if v.DiskSnapshotName != nil {
11239 ok := object.Key("diskSnapshotName")
11240 ok.String(*v.DiskSnapshotName)
11241 }
11242
11243 if v.RestoreDate != nil {
11244 ok := object.Key("restoreDate")
11245 ok.String(*v.RestoreDate)
11246 }
11247
11248 if v.SizeInGb != nil {
11249 ok := object.Key("sizeInGb")
11250 ok.Integer(*v.SizeInGb)
11251 }
11252
11253 if v.SourceDiskName != nil {
11254 ok := object.Key("sourceDiskName")
11255 ok.String(*v.SourceDiskName)
11256 }
11257
11258 if v.Tags != nil {
11259 ok := object.Key("tags")
11260 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11261 return err
11262 }
11263 }
11264
11265 if v.UseLatestRestorableAutoSnapshot != nil {
11266 ok := object.Key("useLatestRestorableAutoSnapshot")
11267 ok.Boolean(*v.UseLatestRestorableAutoSnapshot)
11268 }
11269
11270 return nil
11271 }
11272
11273 func awsAwsjson11_serializeOpDocumentCreateDiskInput(v *CreateDiskInput, value smithyjson.Value) error {
11274 object := value.Object()
11275 defer object.Close()
11276
11277 if v.AddOns != nil {
11278 ok := object.Key("addOns")
11279 if err := awsAwsjson11_serializeDocumentAddOnRequestList(v.AddOns, ok); err != nil {
11280 return err
11281 }
11282 }
11283
11284 if v.AvailabilityZone != nil {
11285 ok := object.Key("availabilityZone")
11286 ok.String(*v.AvailabilityZone)
11287 }
11288
11289 if v.DiskName != nil {
11290 ok := object.Key("diskName")
11291 ok.String(*v.DiskName)
11292 }
11293
11294 if v.SizeInGb != nil {
11295 ok := object.Key("sizeInGb")
11296 ok.Integer(*v.SizeInGb)
11297 }
11298
11299 if v.Tags != nil {
11300 ok := object.Key("tags")
11301 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11302 return err
11303 }
11304 }
11305
11306 return nil
11307 }
11308
11309 func awsAwsjson11_serializeOpDocumentCreateDiskSnapshotInput(v *CreateDiskSnapshotInput, value smithyjson.Value) error {
11310 object := value.Object()
11311 defer object.Close()
11312
11313 if v.DiskName != nil {
11314 ok := object.Key("diskName")
11315 ok.String(*v.DiskName)
11316 }
11317
11318 if v.DiskSnapshotName != nil {
11319 ok := object.Key("diskSnapshotName")
11320 ok.String(*v.DiskSnapshotName)
11321 }
11322
11323 if v.InstanceName != nil {
11324 ok := object.Key("instanceName")
11325 ok.String(*v.InstanceName)
11326 }
11327
11328 if v.Tags != nil {
11329 ok := object.Key("tags")
11330 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11331 return err
11332 }
11333 }
11334
11335 return nil
11336 }
11337
11338 func awsAwsjson11_serializeOpDocumentCreateDistributionInput(v *CreateDistributionInput, value smithyjson.Value) error {
11339 object := value.Object()
11340 defer object.Close()
11341
11342 if v.BundleId != nil {
11343 ok := object.Key("bundleId")
11344 ok.String(*v.BundleId)
11345 }
11346
11347 if v.CacheBehaviors != nil {
11348 ok := object.Key("cacheBehaviors")
11349 if err := awsAwsjson11_serializeDocumentCacheBehaviorList(v.CacheBehaviors, ok); err != nil {
11350 return err
11351 }
11352 }
11353
11354 if v.CacheBehaviorSettings != nil {
11355 ok := object.Key("cacheBehaviorSettings")
11356 if err := awsAwsjson11_serializeDocumentCacheSettings(v.CacheBehaviorSettings, ok); err != nil {
11357 return err
11358 }
11359 }
11360
11361 if v.CertificateName != nil {
11362 ok := object.Key("certificateName")
11363 ok.String(*v.CertificateName)
11364 }
11365
11366 if v.DefaultCacheBehavior != nil {
11367 ok := object.Key("defaultCacheBehavior")
11368 if err := awsAwsjson11_serializeDocumentCacheBehavior(v.DefaultCacheBehavior, ok); err != nil {
11369 return err
11370 }
11371 }
11372
11373 if v.DistributionName != nil {
11374 ok := object.Key("distributionName")
11375 ok.String(*v.DistributionName)
11376 }
11377
11378 if len(v.IpAddressType) > 0 {
11379 ok := object.Key("ipAddressType")
11380 ok.String(string(v.IpAddressType))
11381 }
11382
11383 if v.Origin != nil {
11384 ok := object.Key("origin")
11385 if err := awsAwsjson11_serializeDocumentInputOrigin(v.Origin, ok); err != nil {
11386 return err
11387 }
11388 }
11389
11390 if v.Tags != nil {
11391 ok := object.Key("tags")
11392 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11393 return err
11394 }
11395 }
11396
11397 if len(v.ViewerMinimumTlsProtocolVersion) > 0 {
11398 ok := object.Key("viewerMinimumTlsProtocolVersion")
11399 ok.String(string(v.ViewerMinimumTlsProtocolVersion))
11400 }
11401
11402 return nil
11403 }
11404
11405 func awsAwsjson11_serializeOpDocumentCreateDomainEntryInput(v *CreateDomainEntryInput, value smithyjson.Value) error {
11406 object := value.Object()
11407 defer object.Close()
11408
11409 if v.DomainEntry != nil {
11410 ok := object.Key("domainEntry")
11411 if err := awsAwsjson11_serializeDocumentDomainEntry(v.DomainEntry, ok); err != nil {
11412 return err
11413 }
11414 }
11415
11416 if v.DomainName != nil {
11417 ok := object.Key("domainName")
11418 ok.String(*v.DomainName)
11419 }
11420
11421 return nil
11422 }
11423
11424 func awsAwsjson11_serializeOpDocumentCreateDomainInput(v *CreateDomainInput, value smithyjson.Value) error {
11425 object := value.Object()
11426 defer object.Close()
11427
11428 if v.DomainName != nil {
11429 ok := object.Key("domainName")
11430 ok.String(*v.DomainName)
11431 }
11432
11433 if v.Tags != nil {
11434 ok := object.Key("tags")
11435 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11436 return err
11437 }
11438 }
11439
11440 return nil
11441 }
11442
11443 func awsAwsjson11_serializeOpDocumentCreateGUISessionAccessDetailsInput(v *CreateGUISessionAccessDetailsInput, value smithyjson.Value) error {
11444 object := value.Object()
11445 defer object.Close()
11446
11447 if v.ResourceName != nil {
11448 ok := object.Key("resourceName")
11449 ok.String(*v.ResourceName)
11450 }
11451
11452 return nil
11453 }
11454
11455 func awsAwsjson11_serializeOpDocumentCreateInstancesFromSnapshotInput(v *CreateInstancesFromSnapshotInput, value smithyjson.Value) error {
11456 object := value.Object()
11457 defer object.Close()
11458
11459 if v.AddOns != nil {
11460 ok := object.Key("addOns")
11461 if err := awsAwsjson11_serializeDocumentAddOnRequestList(v.AddOns, ok); err != nil {
11462 return err
11463 }
11464 }
11465
11466 if v.AttachedDiskMapping != nil {
11467 ok := object.Key("attachedDiskMapping")
11468 if err := awsAwsjson11_serializeDocumentAttachedDiskMap(v.AttachedDiskMapping, ok); err != nil {
11469 return err
11470 }
11471 }
11472
11473 if v.AvailabilityZone != nil {
11474 ok := object.Key("availabilityZone")
11475 ok.String(*v.AvailabilityZone)
11476 }
11477
11478 if v.BundleId != nil {
11479 ok := object.Key("bundleId")
11480 ok.String(*v.BundleId)
11481 }
11482
11483 if v.InstanceNames != nil {
11484 ok := object.Key("instanceNames")
11485 if err := awsAwsjson11_serializeDocumentStringList(v.InstanceNames, ok); err != nil {
11486 return err
11487 }
11488 }
11489
11490 if v.InstanceSnapshotName != nil {
11491 ok := object.Key("instanceSnapshotName")
11492 ok.String(*v.InstanceSnapshotName)
11493 }
11494
11495 if len(v.IpAddressType) > 0 {
11496 ok := object.Key("ipAddressType")
11497 ok.String(string(v.IpAddressType))
11498 }
11499
11500 if v.KeyPairName != nil {
11501 ok := object.Key("keyPairName")
11502 ok.String(*v.KeyPairName)
11503 }
11504
11505 if v.RestoreDate != nil {
11506 ok := object.Key("restoreDate")
11507 ok.String(*v.RestoreDate)
11508 }
11509
11510 if v.SourceInstanceName != nil {
11511 ok := object.Key("sourceInstanceName")
11512 ok.String(*v.SourceInstanceName)
11513 }
11514
11515 if v.Tags != nil {
11516 ok := object.Key("tags")
11517 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11518 return err
11519 }
11520 }
11521
11522 if v.UseLatestRestorableAutoSnapshot != nil {
11523 ok := object.Key("useLatestRestorableAutoSnapshot")
11524 ok.Boolean(*v.UseLatestRestorableAutoSnapshot)
11525 }
11526
11527 if v.UserData != nil {
11528 ok := object.Key("userData")
11529 ok.String(*v.UserData)
11530 }
11531
11532 return nil
11533 }
11534
11535 func awsAwsjson11_serializeOpDocumentCreateInstancesInput(v *CreateInstancesInput, value smithyjson.Value) error {
11536 object := value.Object()
11537 defer object.Close()
11538
11539 if v.AddOns != nil {
11540 ok := object.Key("addOns")
11541 if err := awsAwsjson11_serializeDocumentAddOnRequestList(v.AddOns, ok); err != nil {
11542 return err
11543 }
11544 }
11545
11546 if v.AvailabilityZone != nil {
11547 ok := object.Key("availabilityZone")
11548 ok.String(*v.AvailabilityZone)
11549 }
11550
11551 if v.BlueprintId != nil {
11552 ok := object.Key("blueprintId")
11553 ok.String(*v.BlueprintId)
11554 }
11555
11556 if v.BundleId != nil {
11557 ok := object.Key("bundleId")
11558 ok.String(*v.BundleId)
11559 }
11560
11561 if v.CustomImageName != nil {
11562 ok := object.Key("customImageName")
11563 ok.String(*v.CustomImageName)
11564 }
11565
11566 if v.InstanceNames != nil {
11567 ok := object.Key("instanceNames")
11568 if err := awsAwsjson11_serializeDocumentStringList(v.InstanceNames, ok); err != nil {
11569 return err
11570 }
11571 }
11572
11573 if len(v.IpAddressType) > 0 {
11574 ok := object.Key("ipAddressType")
11575 ok.String(string(v.IpAddressType))
11576 }
11577
11578 if v.KeyPairName != nil {
11579 ok := object.Key("keyPairName")
11580 ok.String(*v.KeyPairName)
11581 }
11582
11583 if v.Tags != nil {
11584 ok := object.Key("tags")
11585 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11586 return err
11587 }
11588 }
11589
11590 if v.UserData != nil {
11591 ok := object.Key("userData")
11592 ok.String(*v.UserData)
11593 }
11594
11595 return nil
11596 }
11597
11598 func awsAwsjson11_serializeOpDocumentCreateInstanceSnapshotInput(v *CreateInstanceSnapshotInput, value smithyjson.Value) error {
11599 object := value.Object()
11600 defer object.Close()
11601
11602 if v.InstanceName != nil {
11603 ok := object.Key("instanceName")
11604 ok.String(*v.InstanceName)
11605 }
11606
11607 if v.InstanceSnapshotName != nil {
11608 ok := object.Key("instanceSnapshotName")
11609 ok.String(*v.InstanceSnapshotName)
11610 }
11611
11612 if v.Tags != nil {
11613 ok := object.Key("tags")
11614 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11615 return err
11616 }
11617 }
11618
11619 return nil
11620 }
11621
11622 func awsAwsjson11_serializeOpDocumentCreateKeyPairInput(v *CreateKeyPairInput, value smithyjson.Value) error {
11623 object := value.Object()
11624 defer object.Close()
11625
11626 if v.KeyPairName != nil {
11627 ok := object.Key("keyPairName")
11628 ok.String(*v.KeyPairName)
11629 }
11630
11631 if v.Tags != nil {
11632 ok := object.Key("tags")
11633 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11634 return err
11635 }
11636 }
11637
11638 return nil
11639 }
11640
11641 func awsAwsjson11_serializeOpDocumentCreateLoadBalancerInput(v *CreateLoadBalancerInput, value smithyjson.Value) error {
11642 object := value.Object()
11643 defer object.Close()
11644
11645 if v.CertificateAlternativeNames != nil {
11646 ok := object.Key("certificateAlternativeNames")
11647 if err := awsAwsjson11_serializeDocumentDomainNameList(v.CertificateAlternativeNames, ok); err != nil {
11648 return err
11649 }
11650 }
11651
11652 if v.CertificateDomainName != nil {
11653 ok := object.Key("certificateDomainName")
11654 ok.String(*v.CertificateDomainName)
11655 }
11656
11657 if v.CertificateName != nil {
11658 ok := object.Key("certificateName")
11659 ok.String(*v.CertificateName)
11660 }
11661
11662 if v.HealthCheckPath != nil {
11663 ok := object.Key("healthCheckPath")
11664 ok.String(*v.HealthCheckPath)
11665 }
11666
11667 {
11668 ok := object.Key("instancePort")
11669 ok.Integer(v.InstancePort)
11670 }
11671
11672 if len(v.IpAddressType) > 0 {
11673 ok := object.Key("ipAddressType")
11674 ok.String(string(v.IpAddressType))
11675 }
11676
11677 if v.LoadBalancerName != nil {
11678 ok := object.Key("loadBalancerName")
11679 ok.String(*v.LoadBalancerName)
11680 }
11681
11682 if v.Tags != nil {
11683 ok := object.Key("tags")
11684 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11685 return err
11686 }
11687 }
11688
11689 if v.TlsPolicyName != nil {
11690 ok := object.Key("tlsPolicyName")
11691 ok.String(*v.TlsPolicyName)
11692 }
11693
11694 return nil
11695 }
11696
11697 func awsAwsjson11_serializeOpDocumentCreateLoadBalancerTlsCertificateInput(v *CreateLoadBalancerTlsCertificateInput, value smithyjson.Value) error {
11698 object := value.Object()
11699 defer object.Close()
11700
11701 if v.CertificateAlternativeNames != nil {
11702 ok := object.Key("certificateAlternativeNames")
11703 if err := awsAwsjson11_serializeDocumentDomainNameList(v.CertificateAlternativeNames, ok); err != nil {
11704 return err
11705 }
11706 }
11707
11708 if v.CertificateDomainName != nil {
11709 ok := object.Key("certificateDomainName")
11710 ok.String(*v.CertificateDomainName)
11711 }
11712
11713 if v.CertificateName != nil {
11714 ok := object.Key("certificateName")
11715 ok.String(*v.CertificateName)
11716 }
11717
11718 if v.LoadBalancerName != nil {
11719 ok := object.Key("loadBalancerName")
11720 ok.String(*v.LoadBalancerName)
11721 }
11722
11723 if v.Tags != nil {
11724 ok := object.Key("tags")
11725 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11726 return err
11727 }
11728 }
11729
11730 return nil
11731 }
11732
11733 func awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseFromSnapshotInput(v *CreateRelationalDatabaseFromSnapshotInput, value smithyjson.Value) error {
11734 object := value.Object()
11735 defer object.Close()
11736
11737 if v.AvailabilityZone != nil {
11738 ok := object.Key("availabilityZone")
11739 ok.String(*v.AvailabilityZone)
11740 }
11741
11742 if v.PubliclyAccessible != nil {
11743 ok := object.Key("publiclyAccessible")
11744 ok.Boolean(*v.PubliclyAccessible)
11745 }
11746
11747 if v.RelationalDatabaseBundleId != nil {
11748 ok := object.Key("relationalDatabaseBundleId")
11749 ok.String(*v.RelationalDatabaseBundleId)
11750 }
11751
11752 if v.RelationalDatabaseName != nil {
11753 ok := object.Key("relationalDatabaseName")
11754 ok.String(*v.RelationalDatabaseName)
11755 }
11756
11757 if v.RelationalDatabaseSnapshotName != nil {
11758 ok := object.Key("relationalDatabaseSnapshotName")
11759 ok.String(*v.RelationalDatabaseSnapshotName)
11760 }
11761
11762 if v.RestoreTime != nil {
11763 ok := object.Key("restoreTime")
11764 ok.Double(smithytime.FormatEpochSeconds(*v.RestoreTime))
11765 }
11766
11767 if v.SourceRelationalDatabaseName != nil {
11768 ok := object.Key("sourceRelationalDatabaseName")
11769 ok.String(*v.SourceRelationalDatabaseName)
11770 }
11771
11772 if v.Tags != nil {
11773 ok := object.Key("tags")
11774 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11775 return err
11776 }
11777 }
11778
11779 if v.UseLatestRestorableTime != nil {
11780 ok := object.Key("useLatestRestorableTime")
11781 ok.Boolean(*v.UseLatestRestorableTime)
11782 }
11783
11784 return nil
11785 }
11786
11787 func awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseInput(v *CreateRelationalDatabaseInput, value smithyjson.Value) error {
11788 object := value.Object()
11789 defer object.Close()
11790
11791 if v.AvailabilityZone != nil {
11792 ok := object.Key("availabilityZone")
11793 ok.String(*v.AvailabilityZone)
11794 }
11795
11796 if v.MasterDatabaseName != nil {
11797 ok := object.Key("masterDatabaseName")
11798 ok.String(*v.MasterDatabaseName)
11799 }
11800
11801 if v.MasterUsername != nil {
11802 ok := object.Key("masterUsername")
11803 ok.String(*v.MasterUsername)
11804 }
11805
11806 if v.MasterUserPassword != nil {
11807 ok := object.Key("masterUserPassword")
11808 ok.String(*v.MasterUserPassword)
11809 }
11810
11811 if v.PreferredBackupWindow != nil {
11812 ok := object.Key("preferredBackupWindow")
11813 ok.String(*v.PreferredBackupWindow)
11814 }
11815
11816 if v.PreferredMaintenanceWindow != nil {
11817 ok := object.Key("preferredMaintenanceWindow")
11818 ok.String(*v.PreferredMaintenanceWindow)
11819 }
11820
11821 if v.PubliclyAccessible != nil {
11822 ok := object.Key("publiclyAccessible")
11823 ok.Boolean(*v.PubliclyAccessible)
11824 }
11825
11826 if v.RelationalDatabaseBlueprintId != nil {
11827 ok := object.Key("relationalDatabaseBlueprintId")
11828 ok.String(*v.RelationalDatabaseBlueprintId)
11829 }
11830
11831 if v.RelationalDatabaseBundleId != nil {
11832 ok := object.Key("relationalDatabaseBundleId")
11833 ok.String(*v.RelationalDatabaseBundleId)
11834 }
11835
11836 if v.RelationalDatabaseName != nil {
11837 ok := object.Key("relationalDatabaseName")
11838 ok.String(*v.RelationalDatabaseName)
11839 }
11840
11841 if v.Tags != nil {
11842 ok := object.Key("tags")
11843 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11844 return err
11845 }
11846 }
11847
11848 return nil
11849 }
11850
11851 func awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseSnapshotInput(v *CreateRelationalDatabaseSnapshotInput, value smithyjson.Value) error {
11852 object := value.Object()
11853 defer object.Close()
11854
11855 if v.RelationalDatabaseName != nil {
11856 ok := object.Key("relationalDatabaseName")
11857 ok.String(*v.RelationalDatabaseName)
11858 }
11859
11860 if v.RelationalDatabaseSnapshotName != nil {
11861 ok := object.Key("relationalDatabaseSnapshotName")
11862 ok.String(*v.RelationalDatabaseSnapshotName)
11863 }
11864
11865 if v.Tags != nil {
11866 ok := object.Key("tags")
11867 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
11868 return err
11869 }
11870 }
11871
11872 return nil
11873 }
11874
11875 func awsAwsjson11_serializeOpDocumentDeleteAlarmInput(v *DeleteAlarmInput, value smithyjson.Value) error {
11876 object := value.Object()
11877 defer object.Close()
11878
11879 if v.AlarmName != nil {
11880 ok := object.Key("alarmName")
11881 ok.String(*v.AlarmName)
11882 }
11883
11884 return nil
11885 }
11886
11887 func awsAwsjson11_serializeOpDocumentDeleteAutoSnapshotInput(v *DeleteAutoSnapshotInput, value smithyjson.Value) error {
11888 object := value.Object()
11889 defer object.Close()
11890
11891 if v.Date != nil {
11892 ok := object.Key("date")
11893 ok.String(*v.Date)
11894 }
11895
11896 if v.ResourceName != nil {
11897 ok := object.Key("resourceName")
11898 ok.String(*v.ResourceName)
11899 }
11900
11901 return nil
11902 }
11903
11904 func awsAwsjson11_serializeOpDocumentDeleteBucketAccessKeyInput(v *DeleteBucketAccessKeyInput, value smithyjson.Value) error {
11905 object := value.Object()
11906 defer object.Close()
11907
11908 if v.AccessKeyId != nil {
11909 ok := object.Key("accessKeyId")
11910 ok.String(*v.AccessKeyId)
11911 }
11912
11913 if v.BucketName != nil {
11914 ok := object.Key("bucketName")
11915 ok.String(*v.BucketName)
11916 }
11917
11918 return nil
11919 }
11920
11921 func awsAwsjson11_serializeOpDocumentDeleteBucketInput(v *DeleteBucketInput, value smithyjson.Value) error {
11922 object := value.Object()
11923 defer object.Close()
11924
11925 if v.BucketName != nil {
11926 ok := object.Key("bucketName")
11927 ok.String(*v.BucketName)
11928 }
11929
11930 if v.ForceDelete != nil {
11931 ok := object.Key("forceDelete")
11932 ok.Boolean(*v.ForceDelete)
11933 }
11934
11935 return nil
11936 }
11937
11938 func awsAwsjson11_serializeOpDocumentDeleteCertificateInput(v *DeleteCertificateInput, value smithyjson.Value) error {
11939 object := value.Object()
11940 defer object.Close()
11941
11942 if v.CertificateName != nil {
11943 ok := object.Key("certificateName")
11944 ok.String(*v.CertificateName)
11945 }
11946
11947 return nil
11948 }
11949
11950 func awsAwsjson11_serializeOpDocumentDeleteContactMethodInput(v *DeleteContactMethodInput, value smithyjson.Value) error {
11951 object := value.Object()
11952 defer object.Close()
11953
11954 if len(v.Protocol) > 0 {
11955 ok := object.Key("protocol")
11956 ok.String(string(v.Protocol))
11957 }
11958
11959 return nil
11960 }
11961
11962 func awsAwsjson11_serializeOpDocumentDeleteContainerImageInput(v *DeleteContainerImageInput, value smithyjson.Value) error {
11963 object := value.Object()
11964 defer object.Close()
11965
11966 if v.Image != nil {
11967 ok := object.Key("image")
11968 ok.String(*v.Image)
11969 }
11970
11971 if v.ServiceName != nil {
11972 ok := object.Key("serviceName")
11973 ok.String(*v.ServiceName)
11974 }
11975
11976 return nil
11977 }
11978
11979 func awsAwsjson11_serializeOpDocumentDeleteContainerServiceInput(v *DeleteContainerServiceInput, value smithyjson.Value) error {
11980 object := value.Object()
11981 defer object.Close()
11982
11983 if v.ServiceName != nil {
11984 ok := object.Key("serviceName")
11985 ok.String(*v.ServiceName)
11986 }
11987
11988 return nil
11989 }
11990
11991 func awsAwsjson11_serializeOpDocumentDeleteDiskInput(v *DeleteDiskInput, value smithyjson.Value) error {
11992 object := value.Object()
11993 defer object.Close()
11994
11995 if v.DiskName != nil {
11996 ok := object.Key("diskName")
11997 ok.String(*v.DiskName)
11998 }
11999
12000 if v.ForceDeleteAddOns != nil {
12001 ok := object.Key("forceDeleteAddOns")
12002 ok.Boolean(*v.ForceDeleteAddOns)
12003 }
12004
12005 return nil
12006 }
12007
12008 func awsAwsjson11_serializeOpDocumentDeleteDiskSnapshotInput(v *DeleteDiskSnapshotInput, value smithyjson.Value) error {
12009 object := value.Object()
12010 defer object.Close()
12011
12012 if v.DiskSnapshotName != nil {
12013 ok := object.Key("diskSnapshotName")
12014 ok.String(*v.DiskSnapshotName)
12015 }
12016
12017 return nil
12018 }
12019
12020 func awsAwsjson11_serializeOpDocumentDeleteDistributionInput(v *DeleteDistributionInput, value smithyjson.Value) error {
12021 object := value.Object()
12022 defer object.Close()
12023
12024 if v.DistributionName != nil {
12025 ok := object.Key("distributionName")
12026 ok.String(*v.DistributionName)
12027 }
12028
12029 return nil
12030 }
12031
12032 func awsAwsjson11_serializeOpDocumentDeleteDomainEntryInput(v *DeleteDomainEntryInput, value smithyjson.Value) error {
12033 object := value.Object()
12034 defer object.Close()
12035
12036 if v.DomainEntry != nil {
12037 ok := object.Key("domainEntry")
12038 if err := awsAwsjson11_serializeDocumentDomainEntry(v.DomainEntry, ok); err != nil {
12039 return err
12040 }
12041 }
12042
12043 if v.DomainName != nil {
12044 ok := object.Key("domainName")
12045 ok.String(*v.DomainName)
12046 }
12047
12048 return nil
12049 }
12050
12051 func awsAwsjson11_serializeOpDocumentDeleteDomainInput(v *DeleteDomainInput, value smithyjson.Value) error {
12052 object := value.Object()
12053 defer object.Close()
12054
12055 if v.DomainName != nil {
12056 ok := object.Key("domainName")
12057 ok.String(*v.DomainName)
12058 }
12059
12060 return nil
12061 }
12062
12063 func awsAwsjson11_serializeOpDocumentDeleteInstanceInput(v *DeleteInstanceInput, value smithyjson.Value) error {
12064 object := value.Object()
12065 defer object.Close()
12066
12067 if v.ForceDeleteAddOns != nil {
12068 ok := object.Key("forceDeleteAddOns")
12069 ok.Boolean(*v.ForceDeleteAddOns)
12070 }
12071
12072 if v.InstanceName != nil {
12073 ok := object.Key("instanceName")
12074 ok.String(*v.InstanceName)
12075 }
12076
12077 return nil
12078 }
12079
12080 func awsAwsjson11_serializeOpDocumentDeleteInstanceSnapshotInput(v *DeleteInstanceSnapshotInput, value smithyjson.Value) error {
12081 object := value.Object()
12082 defer object.Close()
12083
12084 if v.InstanceSnapshotName != nil {
12085 ok := object.Key("instanceSnapshotName")
12086 ok.String(*v.InstanceSnapshotName)
12087 }
12088
12089 return nil
12090 }
12091
12092 func awsAwsjson11_serializeOpDocumentDeleteKeyPairInput(v *DeleteKeyPairInput, value smithyjson.Value) error {
12093 object := value.Object()
12094 defer object.Close()
12095
12096 if v.ExpectedFingerprint != nil {
12097 ok := object.Key("expectedFingerprint")
12098 ok.String(*v.ExpectedFingerprint)
12099 }
12100
12101 if v.KeyPairName != nil {
12102 ok := object.Key("keyPairName")
12103 ok.String(*v.KeyPairName)
12104 }
12105
12106 return nil
12107 }
12108
12109 func awsAwsjson11_serializeOpDocumentDeleteKnownHostKeysInput(v *DeleteKnownHostKeysInput, value smithyjson.Value) error {
12110 object := value.Object()
12111 defer object.Close()
12112
12113 if v.InstanceName != nil {
12114 ok := object.Key("instanceName")
12115 ok.String(*v.InstanceName)
12116 }
12117
12118 return nil
12119 }
12120
12121 func awsAwsjson11_serializeOpDocumentDeleteLoadBalancerInput(v *DeleteLoadBalancerInput, value smithyjson.Value) error {
12122 object := value.Object()
12123 defer object.Close()
12124
12125 if v.LoadBalancerName != nil {
12126 ok := object.Key("loadBalancerName")
12127 ok.String(*v.LoadBalancerName)
12128 }
12129
12130 return nil
12131 }
12132
12133 func awsAwsjson11_serializeOpDocumentDeleteLoadBalancerTlsCertificateInput(v *DeleteLoadBalancerTlsCertificateInput, value smithyjson.Value) error {
12134 object := value.Object()
12135 defer object.Close()
12136
12137 if v.CertificateName != nil {
12138 ok := object.Key("certificateName")
12139 ok.String(*v.CertificateName)
12140 }
12141
12142 if v.Force != nil {
12143 ok := object.Key("force")
12144 ok.Boolean(*v.Force)
12145 }
12146
12147 if v.LoadBalancerName != nil {
12148 ok := object.Key("loadBalancerName")
12149 ok.String(*v.LoadBalancerName)
12150 }
12151
12152 return nil
12153 }
12154
12155 func awsAwsjson11_serializeOpDocumentDeleteRelationalDatabaseInput(v *DeleteRelationalDatabaseInput, value smithyjson.Value) error {
12156 object := value.Object()
12157 defer object.Close()
12158
12159 if v.FinalRelationalDatabaseSnapshotName != nil {
12160 ok := object.Key("finalRelationalDatabaseSnapshotName")
12161 ok.String(*v.FinalRelationalDatabaseSnapshotName)
12162 }
12163
12164 if v.RelationalDatabaseName != nil {
12165 ok := object.Key("relationalDatabaseName")
12166 ok.String(*v.RelationalDatabaseName)
12167 }
12168
12169 if v.SkipFinalSnapshot != nil {
12170 ok := object.Key("skipFinalSnapshot")
12171 ok.Boolean(*v.SkipFinalSnapshot)
12172 }
12173
12174 return nil
12175 }
12176
12177 func awsAwsjson11_serializeOpDocumentDeleteRelationalDatabaseSnapshotInput(v *DeleteRelationalDatabaseSnapshotInput, value smithyjson.Value) error {
12178 object := value.Object()
12179 defer object.Close()
12180
12181 if v.RelationalDatabaseSnapshotName != nil {
12182 ok := object.Key("relationalDatabaseSnapshotName")
12183 ok.String(*v.RelationalDatabaseSnapshotName)
12184 }
12185
12186 return nil
12187 }
12188
12189 func awsAwsjson11_serializeOpDocumentDetachCertificateFromDistributionInput(v *DetachCertificateFromDistributionInput, value smithyjson.Value) error {
12190 object := value.Object()
12191 defer object.Close()
12192
12193 if v.DistributionName != nil {
12194 ok := object.Key("distributionName")
12195 ok.String(*v.DistributionName)
12196 }
12197
12198 return nil
12199 }
12200
12201 func awsAwsjson11_serializeOpDocumentDetachDiskInput(v *DetachDiskInput, value smithyjson.Value) error {
12202 object := value.Object()
12203 defer object.Close()
12204
12205 if v.DiskName != nil {
12206 ok := object.Key("diskName")
12207 ok.String(*v.DiskName)
12208 }
12209
12210 return nil
12211 }
12212
12213 func awsAwsjson11_serializeOpDocumentDetachInstancesFromLoadBalancerInput(v *DetachInstancesFromLoadBalancerInput, value smithyjson.Value) error {
12214 object := value.Object()
12215 defer object.Close()
12216
12217 if v.InstanceNames != nil {
12218 ok := object.Key("instanceNames")
12219 if err := awsAwsjson11_serializeDocumentResourceNameList(v.InstanceNames, ok); err != nil {
12220 return err
12221 }
12222 }
12223
12224 if v.LoadBalancerName != nil {
12225 ok := object.Key("loadBalancerName")
12226 ok.String(*v.LoadBalancerName)
12227 }
12228
12229 return nil
12230 }
12231
12232 func awsAwsjson11_serializeOpDocumentDetachStaticIpInput(v *DetachStaticIpInput, value smithyjson.Value) error {
12233 object := value.Object()
12234 defer object.Close()
12235
12236 if v.StaticIpName != nil {
12237 ok := object.Key("staticIpName")
12238 ok.String(*v.StaticIpName)
12239 }
12240
12241 return nil
12242 }
12243
12244 func awsAwsjson11_serializeOpDocumentDisableAddOnInput(v *DisableAddOnInput, value smithyjson.Value) error {
12245 object := value.Object()
12246 defer object.Close()
12247
12248 if len(v.AddOnType) > 0 {
12249 ok := object.Key("addOnType")
12250 ok.String(string(v.AddOnType))
12251 }
12252
12253 if v.ResourceName != nil {
12254 ok := object.Key("resourceName")
12255 ok.String(*v.ResourceName)
12256 }
12257
12258 return nil
12259 }
12260
12261 func awsAwsjson11_serializeOpDocumentDownloadDefaultKeyPairInput(v *DownloadDefaultKeyPairInput, value smithyjson.Value) error {
12262 object := value.Object()
12263 defer object.Close()
12264
12265 return nil
12266 }
12267
12268 func awsAwsjson11_serializeOpDocumentEnableAddOnInput(v *EnableAddOnInput, value smithyjson.Value) error {
12269 object := value.Object()
12270 defer object.Close()
12271
12272 if v.AddOnRequest != nil {
12273 ok := object.Key("addOnRequest")
12274 if err := awsAwsjson11_serializeDocumentAddOnRequest(v.AddOnRequest, ok); err != nil {
12275 return err
12276 }
12277 }
12278
12279 if v.ResourceName != nil {
12280 ok := object.Key("resourceName")
12281 ok.String(*v.ResourceName)
12282 }
12283
12284 return nil
12285 }
12286
12287 func awsAwsjson11_serializeOpDocumentExportSnapshotInput(v *ExportSnapshotInput, value smithyjson.Value) error {
12288 object := value.Object()
12289 defer object.Close()
12290
12291 if v.SourceSnapshotName != nil {
12292 ok := object.Key("sourceSnapshotName")
12293 ok.String(*v.SourceSnapshotName)
12294 }
12295
12296 return nil
12297 }
12298
12299 func awsAwsjson11_serializeOpDocumentGetActiveNamesInput(v *GetActiveNamesInput, value smithyjson.Value) error {
12300 object := value.Object()
12301 defer object.Close()
12302
12303 if v.PageToken != nil {
12304 ok := object.Key("pageToken")
12305 ok.String(*v.PageToken)
12306 }
12307
12308 return nil
12309 }
12310
12311 func awsAwsjson11_serializeOpDocumentGetAlarmsInput(v *GetAlarmsInput, value smithyjson.Value) error {
12312 object := value.Object()
12313 defer object.Close()
12314
12315 if v.AlarmName != nil {
12316 ok := object.Key("alarmName")
12317 ok.String(*v.AlarmName)
12318 }
12319
12320 if v.MonitoredResourceName != nil {
12321 ok := object.Key("monitoredResourceName")
12322 ok.String(*v.MonitoredResourceName)
12323 }
12324
12325 if v.PageToken != nil {
12326 ok := object.Key("pageToken")
12327 ok.String(*v.PageToken)
12328 }
12329
12330 return nil
12331 }
12332
12333 func awsAwsjson11_serializeOpDocumentGetAutoSnapshotsInput(v *GetAutoSnapshotsInput, value smithyjson.Value) error {
12334 object := value.Object()
12335 defer object.Close()
12336
12337 if v.ResourceName != nil {
12338 ok := object.Key("resourceName")
12339 ok.String(*v.ResourceName)
12340 }
12341
12342 return nil
12343 }
12344
12345 func awsAwsjson11_serializeOpDocumentGetBlueprintsInput(v *GetBlueprintsInput, value smithyjson.Value) error {
12346 object := value.Object()
12347 defer object.Close()
12348
12349 if len(v.AppCategory) > 0 {
12350 ok := object.Key("appCategory")
12351 ok.String(string(v.AppCategory))
12352 }
12353
12354 if v.IncludeInactive != nil {
12355 ok := object.Key("includeInactive")
12356 ok.Boolean(*v.IncludeInactive)
12357 }
12358
12359 if v.PageToken != nil {
12360 ok := object.Key("pageToken")
12361 ok.String(*v.PageToken)
12362 }
12363
12364 return nil
12365 }
12366
12367 func awsAwsjson11_serializeOpDocumentGetBucketAccessKeysInput(v *GetBucketAccessKeysInput, value smithyjson.Value) error {
12368 object := value.Object()
12369 defer object.Close()
12370
12371 if v.BucketName != nil {
12372 ok := object.Key("bucketName")
12373 ok.String(*v.BucketName)
12374 }
12375
12376 return nil
12377 }
12378
12379 func awsAwsjson11_serializeOpDocumentGetBucketBundlesInput(v *GetBucketBundlesInput, value smithyjson.Value) error {
12380 object := value.Object()
12381 defer object.Close()
12382
12383 if v.IncludeInactive != nil {
12384 ok := object.Key("includeInactive")
12385 ok.Boolean(*v.IncludeInactive)
12386 }
12387
12388 return nil
12389 }
12390
12391 func awsAwsjson11_serializeOpDocumentGetBucketMetricDataInput(v *GetBucketMetricDataInput, value smithyjson.Value) error {
12392 object := value.Object()
12393 defer object.Close()
12394
12395 if v.BucketName != nil {
12396 ok := object.Key("bucketName")
12397 ok.String(*v.BucketName)
12398 }
12399
12400 if v.EndTime != nil {
12401 ok := object.Key("endTime")
12402 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
12403 }
12404
12405 if len(v.MetricName) > 0 {
12406 ok := object.Key("metricName")
12407 ok.String(string(v.MetricName))
12408 }
12409
12410 if v.Period != nil {
12411 ok := object.Key("period")
12412 ok.Integer(*v.Period)
12413 }
12414
12415 if v.StartTime != nil {
12416 ok := object.Key("startTime")
12417 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
12418 }
12419
12420 if v.Statistics != nil {
12421 ok := object.Key("statistics")
12422 if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
12423 return err
12424 }
12425 }
12426
12427 if len(v.Unit) > 0 {
12428 ok := object.Key("unit")
12429 ok.String(string(v.Unit))
12430 }
12431
12432 return nil
12433 }
12434
12435 func awsAwsjson11_serializeOpDocumentGetBucketsInput(v *GetBucketsInput, value smithyjson.Value) error {
12436 object := value.Object()
12437 defer object.Close()
12438
12439 if v.BucketName != nil {
12440 ok := object.Key("bucketName")
12441 ok.String(*v.BucketName)
12442 }
12443
12444 if v.IncludeConnectedResources != nil {
12445 ok := object.Key("includeConnectedResources")
12446 ok.Boolean(*v.IncludeConnectedResources)
12447 }
12448
12449 if v.IncludeCors != nil {
12450 ok := object.Key("includeCors")
12451 ok.Boolean(*v.IncludeCors)
12452 }
12453
12454 if v.PageToken != nil {
12455 ok := object.Key("pageToken")
12456 ok.String(*v.PageToken)
12457 }
12458
12459 return nil
12460 }
12461
12462 func awsAwsjson11_serializeOpDocumentGetBundlesInput(v *GetBundlesInput, value smithyjson.Value) error {
12463 object := value.Object()
12464 defer object.Close()
12465
12466 if len(v.AppCategory) > 0 {
12467 ok := object.Key("appCategory")
12468 ok.String(string(v.AppCategory))
12469 }
12470
12471 if v.IncludeInactive != nil {
12472 ok := object.Key("includeInactive")
12473 ok.Boolean(*v.IncludeInactive)
12474 }
12475
12476 if v.PageToken != nil {
12477 ok := object.Key("pageToken")
12478 ok.String(*v.PageToken)
12479 }
12480
12481 return nil
12482 }
12483
12484 func awsAwsjson11_serializeOpDocumentGetCertificatesInput(v *GetCertificatesInput, value smithyjson.Value) error {
12485 object := value.Object()
12486 defer object.Close()
12487
12488 if v.CertificateName != nil {
12489 ok := object.Key("certificateName")
12490 ok.String(*v.CertificateName)
12491 }
12492
12493 if v.CertificateStatuses != nil {
12494 ok := object.Key("certificateStatuses")
12495 if err := awsAwsjson11_serializeDocumentCertificateStatusList(v.CertificateStatuses, ok); err != nil {
12496 return err
12497 }
12498 }
12499
12500 if v.IncludeCertificateDetails {
12501 ok := object.Key("includeCertificateDetails")
12502 ok.Boolean(v.IncludeCertificateDetails)
12503 }
12504
12505 if v.PageToken != nil {
12506 ok := object.Key("pageToken")
12507 ok.String(*v.PageToken)
12508 }
12509
12510 return nil
12511 }
12512
12513 func awsAwsjson11_serializeOpDocumentGetCloudFormationStackRecordsInput(v *GetCloudFormationStackRecordsInput, value smithyjson.Value) error {
12514 object := value.Object()
12515 defer object.Close()
12516
12517 if v.PageToken != nil {
12518 ok := object.Key("pageToken")
12519 ok.String(*v.PageToken)
12520 }
12521
12522 return nil
12523 }
12524
12525 func awsAwsjson11_serializeOpDocumentGetContactMethodsInput(v *GetContactMethodsInput, value smithyjson.Value) error {
12526 object := value.Object()
12527 defer object.Close()
12528
12529 if v.Protocols != nil {
12530 ok := object.Key("protocols")
12531 if err := awsAwsjson11_serializeDocumentContactProtocolsList(v.Protocols, ok); err != nil {
12532 return err
12533 }
12534 }
12535
12536 return nil
12537 }
12538
12539 func awsAwsjson11_serializeOpDocumentGetContainerAPIMetadataInput(v *GetContainerAPIMetadataInput, value smithyjson.Value) error {
12540 object := value.Object()
12541 defer object.Close()
12542
12543 return nil
12544 }
12545
12546 func awsAwsjson11_serializeOpDocumentGetContainerImagesInput(v *GetContainerImagesInput, value smithyjson.Value) error {
12547 object := value.Object()
12548 defer object.Close()
12549
12550 if v.ServiceName != nil {
12551 ok := object.Key("serviceName")
12552 ok.String(*v.ServiceName)
12553 }
12554
12555 return nil
12556 }
12557
12558 func awsAwsjson11_serializeOpDocumentGetContainerLogInput(v *GetContainerLogInput, value smithyjson.Value) error {
12559 object := value.Object()
12560 defer object.Close()
12561
12562 if v.ContainerName != nil {
12563 ok := object.Key("containerName")
12564 ok.String(*v.ContainerName)
12565 }
12566
12567 if v.EndTime != nil {
12568 ok := object.Key("endTime")
12569 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
12570 }
12571
12572 if v.FilterPattern != nil {
12573 ok := object.Key("filterPattern")
12574 ok.String(*v.FilterPattern)
12575 }
12576
12577 if v.PageToken != nil {
12578 ok := object.Key("pageToken")
12579 ok.String(*v.PageToken)
12580 }
12581
12582 if v.ServiceName != nil {
12583 ok := object.Key("serviceName")
12584 ok.String(*v.ServiceName)
12585 }
12586
12587 if v.StartTime != nil {
12588 ok := object.Key("startTime")
12589 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
12590 }
12591
12592 return nil
12593 }
12594
12595 func awsAwsjson11_serializeOpDocumentGetContainerServiceDeploymentsInput(v *GetContainerServiceDeploymentsInput, value smithyjson.Value) error {
12596 object := value.Object()
12597 defer object.Close()
12598
12599 if v.ServiceName != nil {
12600 ok := object.Key("serviceName")
12601 ok.String(*v.ServiceName)
12602 }
12603
12604 return nil
12605 }
12606
12607 func awsAwsjson11_serializeOpDocumentGetContainerServiceMetricDataInput(v *GetContainerServiceMetricDataInput, value smithyjson.Value) error {
12608 object := value.Object()
12609 defer object.Close()
12610
12611 if v.EndTime != nil {
12612 ok := object.Key("endTime")
12613 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
12614 }
12615
12616 if len(v.MetricName) > 0 {
12617 ok := object.Key("metricName")
12618 ok.String(string(v.MetricName))
12619 }
12620
12621 if v.Period != nil {
12622 ok := object.Key("period")
12623 ok.Integer(*v.Period)
12624 }
12625
12626 if v.ServiceName != nil {
12627 ok := object.Key("serviceName")
12628 ok.String(*v.ServiceName)
12629 }
12630
12631 if v.StartTime != nil {
12632 ok := object.Key("startTime")
12633 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
12634 }
12635
12636 if v.Statistics != nil {
12637 ok := object.Key("statistics")
12638 if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
12639 return err
12640 }
12641 }
12642
12643 return nil
12644 }
12645
12646 func awsAwsjson11_serializeOpDocumentGetContainerServicePowersInput(v *GetContainerServicePowersInput, value smithyjson.Value) error {
12647 object := value.Object()
12648 defer object.Close()
12649
12650 return nil
12651 }
12652
12653 func awsAwsjson11_serializeOpDocumentGetContainerServicesInput(v *GetContainerServicesInput, value smithyjson.Value) error {
12654 object := value.Object()
12655 defer object.Close()
12656
12657 if v.ServiceName != nil {
12658 ok := object.Key("serviceName")
12659 ok.String(*v.ServiceName)
12660 }
12661
12662 return nil
12663 }
12664
12665 func awsAwsjson11_serializeOpDocumentGetCostEstimateInput(v *GetCostEstimateInput, value smithyjson.Value) error {
12666 object := value.Object()
12667 defer object.Close()
12668
12669 if v.EndTime != nil {
12670 ok := object.Key("endTime")
12671 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
12672 }
12673
12674 if v.ResourceName != nil {
12675 ok := object.Key("resourceName")
12676 ok.String(*v.ResourceName)
12677 }
12678
12679 if v.StartTime != nil {
12680 ok := object.Key("startTime")
12681 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
12682 }
12683
12684 return nil
12685 }
12686
12687 func awsAwsjson11_serializeOpDocumentGetDiskInput(v *GetDiskInput, value smithyjson.Value) error {
12688 object := value.Object()
12689 defer object.Close()
12690
12691 if v.DiskName != nil {
12692 ok := object.Key("diskName")
12693 ok.String(*v.DiskName)
12694 }
12695
12696 return nil
12697 }
12698
12699 func awsAwsjson11_serializeOpDocumentGetDisksInput(v *GetDisksInput, value smithyjson.Value) error {
12700 object := value.Object()
12701 defer object.Close()
12702
12703 if v.PageToken != nil {
12704 ok := object.Key("pageToken")
12705 ok.String(*v.PageToken)
12706 }
12707
12708 return nil
12709 }
12710
12711 func awsAwsjson11_serializeOpDocumentGetDiskSnapshotInput(v *GetDiskSnapshotInput, value smithyjson.Value) error {
12712 object := value.Object()
12713 defer object.Close()
12714
12715 if v.DiskSnapshotName != nil {
12716 ok := object.Key("diskSnapshotName")
12717 ok.String(*v.DiskSnapshotName)
12718 }
12719
12720 return nil
12721 }
12722
12723 func awsAwsjson11_serializeOpDocumentGetDiskSnapshotsInput(v *GetDiskSnapshotsInput, value smithyjson.Value) error {
12724 object := value.Object()
12725 defer object.Close()
12726
12727 if v.PageToken != nil {
12728 ok := object.Key("pageToken")
12729 ok.String(*v.PageToken)
12730 }
12731
12732 return nil
12733 }
12734
12735 func awsAwsjson11_serializeOpDocumentGetDistributionBundlesInput(v *GetDistributionBundlesInput, value smithyjson.Value) error {
12736 object := value.Object()
12737 defer object.Close()
12738
12739 return nil
12740 }
12741
12742 func awsAwsjson11_serializeOpDocumentGetDistributionLatestCacheResetInput(v *GetDistributionLatestCacheResetInput, value smithyjson.Value) error {
12743 object := value.Object()
12744 defer object.Close()
12745
12746 if v.DistributionName != nil {
12747 ok := object.Key("distributionName")
12748 ok.String(*v.DistributionName)
12749 }
12750
12751 return nil
12752 }
12753
12754 func awsAwsjson11_serializeOpDocumentGetDistributionMetricDataInput(v *GetDistributionMetricDataInput, value smithyjson.Value) error {
12755 object := value.Object()
12756 defer object.Close()
12757
12758 if v.DistributionName != nil {
12759 ok := object.Key("distributionName")
12760 ok.String(*v.DistributionName)
12761 }
12762
12763 if v.EndTime != nil {
12764 ok := object.Key("endTime")
12765 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
12766 }
12767
12768 if len(v.MetricName) > 0 {
12769 ok := object.Key("metricName")
12770 ok.String(string(v.MetricName))
12771 }
12772
12773 if v.Period != nil {
12774 ok := object.Key("period")
12775 ok.Integer(*v.Period)
12776 }
12777
12778 if v.StartTime != nil {
12779 ok := object.Key("startTime")
12780 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
12781 }
12782
12783 if v.Statistics != nil {
12784 ok := object.Key("statistics")
12785 if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
12786 return err
12787 }
12788 }
12789
12790 if len(v.Unit) > 0 {
12791 ok := object.Key("unit")
12792 ok.String(string(v.Unit))
12793 }
12794
12795 return nil
12796 }
12797
12798 func awsAwsjson11_serializeOpDocumentGetDistributionsInput(v *GetDistributionsInput, value smithyjson.Value) error {
12799 object := value.Object()
12800 defer object.Close()
12801
12802 if v.DistributionName != nil {
12803 ok := object.Key("distributionName")
12804 ok.String(*v.DistributionName)
12805 }
12806
12807 if v.PageToken != nil {
12808 ok := object.Key("pageToken")
12809 ok.String(*v.PageToken)
12810 }
12811
12812 return nil
12813 }
12814
12815 func awsAwsjson11_serializeOpDocumentGetDomainInput(v *GetDomainInput, value smithyjson.Value) error {
12816 object := value.Object()
12817 defer object.Close()
12818
12819 if v.DomainName != nil {
12820 ok := object.Key("domainName")
12821 ok.String(*v.DomainName)
12822 }
12823
12824 return nil
12825 }
12826
12827 func awsAwsjson11_serializeOpDocumentGetDomainsInput(v *GetDomainsInput, value smithyjson.Value) error {
12828 object := value.Object()
12829 defer object.Close()
12830
12831 if v.PageToken != nil {
12832 ok := object.Key("pageToken")
12833 ok.String(*v.PageToken)
12834 }
12835
12836 return nil
12837 }
12838
12839 func awsAwsjson11_serializeOpDocumentGetExportSnapshotRecordsInput(v *GetExportSnapshotRecordsInput, value smithyjson.Value) error {
12840 object := value.Object()
12841 defer object.Close()
12842
12843 if v.PageToken != nil {
12844 ok := object.Key("pageToken")
12845 ok.String(*v.PageToken)
12846 }
12847
12848 return nil
12849 }
12850
12851 func awsAwsjson11_serializeOpDocumentGetInstanceAccessDetailsInput(v *GetInstanceAccessDetailsInput, value smithyjson.Value) error {
12852 object := value.Object()
12853 defer object.Close()
12854
12855 if v.InstanceName != nil {
12856 ok := object.Key("instanceName")
12857 ok.String(*v.InstanceName)
12858 }
12859
12860 if len(v.Protocol) > 0 {
12861 ok := object.Key("protocol")
12862 ok.String(string(v.Protocol))
12863 }
12864
12865 return nil
12866 }
12867
12868 func awsAwsjson11_serializeOpDocumentGetInstanceInput(v *GetInstanceInput, value smithyjson.Value) error {
12869 object := value.Object()
12870 defer object.Close()
12871
12872 if v.InstanceName != nil {
12873 ok := object.Key("instanceName")
12874 ok.String(*v.InstanceName)
12875 }
12876
12877 return nil
12878 }
12879
12880 func awsAwsjson11_serializeOpDocumentGetInstanceMetricDataInput(v *GetInstanceMetricDataInput, value smithyjson.Value) error {
12881 object := value.Object()
12882 defer object.Close()
12883
12884 if v.EndTime != nil {
12885 ok := object.Key("endTime")
12886 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
12887 }
12888
12889 if v.InstanceName != nil {
12890 ok := object.Key("instanceName")
12891 ok.String(*v.InstanceName)
12892 }
12893
12894 if len(v.MetricName) > 0 {
12895 ok := object.Key("metricName")
12896 ok.String(string(v.MetricName))
12897 }
12898
12899 if v.Period != nil {
12900 ok := object.Key("period")
12901 ok.Integer(*v.Period)
12902 }
12903
12904 if v.StartTime != nil {
12905 ok := object.Key("startTime")
12906 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
12907 }
12908
12909 if v.Statistics != nil {
12910 ok := object.Key("statistics")
12911 if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
12912 return err
12913 }
12914 }
12915
12916 if len(v.Unit) > 0 {
12917 ok := object.Key("unit")
12918 ok.String(string(v.Unit))
12919 }
12920
12921 return nil
12922 }
12923
12924 func awsAwsjson11_serializeOpDocumentGetInstancePortStatesInput(v *GetInstancePortStatesInput, value smithyjson.Value) error {
12925 object := value.Object()
12926 defer object.Close()
12927
12928 if v.InstanceName != nil {
12929 ok := object.Key("instanceName")
12930 ok.String(*v.InstanceName)
12931 }
12932
12933 return nil
12934 }
12935
12936 func awsAwsjson11_serializeOpDocumentGetInstancesInput(v *GetInstancesInput, value smithyjson.Value) error {
12937 object := value.Object()
12938 defer object.Close()
12939
12940 if v.PageToken != nil {
12941 ok := object.Key("pageToken")
12942 ok.String(*v.PageToken)
12943 }
12944
12945 return nil
12946 }
12947
12948 func awsAwsjson11_serializeOpDocumentGetInstanceSnapshotInput(v *GetInstanceSnapshotInput, value smithyjson.Value) error {
12949 object := value.Object()
12950 defer object.Close()
12951
12952 if v.InstanceSnapshotName != nil {
12953 ok := object.Key("instanceSnapshotName")
12954 ok.String(*v.InstanceSnapshotName)
12955 }
12956
12957 return nil
12958 }
12959
12960 func awsAwsjson11_serializeOpDocumentGetInstanceSnapshotsInput(v *GetInstanceSnapshotsInput, value smithyjson.Value) error {
12961 object := value.Object()
12962 defer object.Close()
12963
12964 if v.PageToken != nil {
12965 ok := object.Key("pageToken")
12966 ok.String(*v.PageToken)
12967 }
12968
12969 return nil
12970 }
12971
12972 func awsAwsjson11_serializeOpDocumentGetInstanceStateInput(v *GetInstanceStateInput, value smithyjson.Value) error {
12973 object := value.Object()
12974 defer object.Close()
12975
12976 if v.InstanceName != nil {
12977 ok := object.Key("instanceName")
12978 ok.String(*v.InstanceName)
12979 }
12980
12981 return nil
12982 }
12983
12984 func awsAwsjson11_serializeOpDocumentGetKeyPairInput(v *GetKeyPairInput, value smithyjson.Value) error {
12985 object := value.Object()
12986 defer object.Close()
12987
12988 if v.KeyPairName != nil {
12989 ok := object.Key("keyPairName")
12990 ok.String(*v.KeyPairName)
12991 }
12992
12993 return nil
12994 }
12995
12996 func awsAwsjson11_serializeOpDocumentGetKeyPairsInput(v *GetKeyPairsInput, value smithyjson.Value) error {
12997 object := value.Object()
12998 defer object.Close()
12999
13000 if v.IncludeDefaultKeyPair != nil {
13001 ok := object.Key("includeDefaultKeyPair")
13002 ok.Boolean(*v.IncludeDefaultKeyPair)
13003 }
13004
13005 if v.PageToken != nil {
13006 ok := object.Key("pageToken")
13007 ok.String(*v.PageToken)
13008 }
13009
13010 return nil
13011 }
13012
13013 func awsAwsjson11_serializeOpDocumentGetLoadBalancerInput(v *GetLoadBalancerInput, value smithyjson.Value) error {
13014 object := value.Object()
13015 defer object.Close()
13016
13017 if v.LoadBalancerName != nil {
13018 ok := object.Key("loadBalancerName")
13019 ok.String(*v.LoadBalancerName)
13020 }
13021
13022 return nil
13023 }
13024
13025 func awsAwsjson11_serializeOpDocumentGetLoadBalancerMetricDataInput(v *GetLoadBalancerMetricDataInput, value smithyjson.Value) error {
13026 object := value.Object()
13027 defer object.Close()
13028
13029 if v.EndTime != nil {
13030 ok := object.Key("endTime")
13031 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
13032 }
13033
13034 if v.LoadBalancerName != nil {
13035 ok := object.Key("loadBalancerName")
13036 ok.String(*v.LoadBalancerName)
13037 }
13038
13039 if len(v.MetricName) > 0 {
13040 ok := object.Key("metricName")
13041 ok.String(string(v.MetricName))
13042 }
13043
13044 if v.Period != nil {
13045 ok := object.Key("period")
13046 ok.Integer(*v.Period)
13047 }
13048
13049 if v.StartTime != nil {
13050 ok := object.Key("startTime")
13051 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
13052 }
13053
13054 if v.Statistics != nil {
13055 ok := object.Key("statistics")
13056 if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
13057 return err
13058 }
13059 }
13060
13061 if len(v.Unit) > 0 {
13062 ok := object.Key("unit")
13063 ok.String(string(v.Unit))
13064 }
13065
13066 return nil
13067 }
13068
13069 func awsAwsjson11_serializeOpDocumentGetLoadBalancersInput(v *GetLoadBalancersInput, value smithyjson.Value) error {
13070 object := value.Object()
13071 defer object.Close()
13072
13073 if v.PageToken != nil {
13074 ok := object.Key("pageToken")
13075 ok.String(*v.PageToken)
13076 }
13077
13078 return nil
13079 }
13080
13081 func awsAwsjson11_serializeOpDocumentGetLoadBalancerTlsCertificatesInput(v *GetLoadBalancerTlsCertificatesInput, value smithyjson.Value) error {
13082 object := value.Object()
13083 defer object.Close()
13084
13085 if v.LoadBalancerName != nil {
13086 ok := object.Key("loadBalancerName")
13087 ok.String(*v.LoadBalancerName)
13088 }
13089
13090 return nil
13091 }
13092
13093 func awsAwsjson11_serializeOpDocumentGetLoadBalancerTlsPoliciesInput(v *GetLoadBalancerTlsPoliciesInput, value smithyjson.Value) error {
13094 object := value.Object()
13095 defer object.Close()
13096
13097 if v.PageToken != nil {
13098 ok := object.Key("pageToken")
13099 ok.String(*v.PageToken)
13100 }
13101
13102 return nil
13103 }
13104
13105 func awsAwsjson11_serializeOpDocumentGetOperationInput(v *GetOperationInput, value smithyjson.Value) error {
13106 object := value.Object()
13107 defer object.Close()
13108
13109 if v.OperationId != nil {
13110 ok := object.Key("operationId")
13111 ok.String(*v.OperationId)
13112 }
13113
13114 return nil
13115 }
13116
13117 func awsAwsjson11_serializeOpDocumentGetOperationsForResourceInput(v *GetOperationsForResourceInput, value smithyjson.Value) error {
13118 object := value.Object()
13119 defer object.Close()
13120
13121 if v.PageToken != nil {
13122 ok := object.Key("pageToken")
13123 ok.String(*v.PageToken)
13124 }
13125
13126 if v.ResourceName != nil {
13127 ok := object.Key("resourceName")
13128 ok.String(*v.ResourceName)
13129 }
13130
13131 return nil
13132 }
13133
13134 func awsAwsjson11_serializeOpDocumentGetOperationsInput(v *GetOperationsInput, value smithyjson.Value) error {
13135 object := value.Object()
13136 defer object.Close()
13137
13138 if v.PageToken != nil {
13139 ok := object.Key("pageToken")
13140 ok.String(*v.PageToken)
13141 }
13142
13143 return nil
13144 }
13145
13146 func awsAwsjson11_serializeOpDocumentGetRegionsInput(v *GetRegionsInput, value smithyjson.Value) error {
13147 object := value.Object()
13148 defer object.Close()
13149
13150 if v.IncludeAvailabilityZones != nil {
13151 ok := object.Key("includeAvailabilityZones")
13152 ok.Boolean(*v.IncludeAvailabilityZones)
13153 }
13154
13155 if v.IncludeRelationalDatabaseAvailabilityZones != nil {
13156 ok := object.Key("includeRelationalDatabaseAvailabilityZones")
13157 ok.Boolean(*v.IncludeRelationalDatabaseAvailabilityZones)
13158 }
13159
13160 return nil
13161 }
13162
13163 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseBlueprintsInput(v *GetRelationalDatabaseBlueprintsInput, value smithyjson.Value) error {
13164 object := value.Object()
13165 defer object.Close()
13166
13167 if v.PageToken != nil {
13168 ok := object.Key("pageToken")
13169 ok.String(*v.PageToken)
13170 }
13171
13172 return nil
13173 }
13174
13175 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseBundlesInput(v *GetRelationalDatabaseBundlesInput, value smithyjson.Value) error {
13176 object := value.Object()
13177 defer object.Close()
13178
13179 if v.IncludeInactive != nil {
13180 ok := object.Key("includeInactive")
13181 ok.Boolean(*v.IncludeInactive)
13182 }
13183
13184 if v.PageToken != nil {
13185 ok := object.Key("pageToken")
13186 ok.String(*v.PageToken)
13187 }
13188
13189 return nil
13190 }
13191
13192 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseEventsInput(v *GetRelationalDatabaseEventsInput, value smithyjson.Value) error {
13193 object := value.Object()
13194 defer object.Close()
13195
13196 if v.DurationInMinutes != nil {
13197 ok := object.Key("durationInMinutes")
13198 ok.Integer(*v.DurationInMinutes)
13199 }
13200
13201 if v.PageToken != nil {
13202 ok := object.Key("pageToken")
13203 ok.String(*v.PageToken)
13204 }
13205
13206 if v.RelationalDatabaseName != nil {
13207 ok := object.Key("relationalDatabaseName")
13208 ok.String(*v.RelationalDatabaseName)
13209 }
13210
13211 return nil
13212 }
13213
13214 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseInput(v *GetRelationalDatabaseInput, value smithyjson.Value) error {
13215 object := value.Object()
13216 defer object.Close()
13217
13218 if v.RelationalDatabaseName != nil {
13219 ok := object.Key("relationalDatabaseName")
13220 ok.String(*v.RelationalDatabaseName)
13221 }
13222
13223 return nil
13224 }
13225
13226 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseLogEventsInput(v *GetRelationalDatabaseLogEventsInput, value smithyjson.Value) error {
13227 object := value.Object()
13228 defer object.Close()
13229
13230 if v.EndTime != nil {
13231 ok := object.Key("endTime")
13232 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
13233 }
13234
13235 if v.LogStreamName != nil {
13236 ok := object.Key("logStreamName")
13237 ok.String(*v.LogStreamName)
13238 }
13239
13240 if v.PageToken != nil {
13241 ok := object.Key("pageToken")
13242 ok.String(*v.PageToken)
13243 }
13244
13245 if v.RelationalDatabaseName != nil {
13246 ok := object.Key("relationalDatabaseName")
13247 ok.String(*v.RelationalDatabaseName)
13248 }
13249
13250 if v.StartFromHead != nil {
13251 ok := object.Key("startFromHead")
13252 ok.Boolean(*v.StartFromHead)
13253 }
13254
13255 if v.StartTime != nil {
13256 ok := object.Key("startTime")
13257 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
13258 }
13259
13260 return nil
13261 }
13262
13263 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseLogStreamsInput(v *GetRelationalDatabaseLogStreamsInput, value smithyjson.Value) error {
13264 object := value.Object()
13265 defer object.Close()
13266
13267 if v.RelationalDatabaseName != nil {
13268 ok := object.Key("relationalDatabaseName")
13269 ok.String(*v.RelationalDatabaseName)
13270 }
13271
13272 return nil
13273 }
13274
13275 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseMasterUserPasswordInput(v *GetRelationalDatabaseMasterUserPasswordInput, value smithyjson.Value) error {
13276 object := value.Object()
13277 defer object.Close()
13278
13279 if len(v.PasswordVersion) > 0 {
13280 ok := object.Key("passwordVersion")
13281 ok.String(string(v.PasswordVersion))
13282 }
13283
13284 if v.RelationalDatabaseName != nil {
13285 ok := object.Key("relationalDatabaseName")
13286 ok.String(*v.RelationalDatabaseName)
13287 }
13288
13289 return nil
13290 }
13291
13292 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseMetricDataInput(v *GetRelationalDatabaseMetricDataInput, value smithyjson.Value) error {
13293 object := value.Object()
13294 defer object.Close()
13295
13296 if v.EndTime != nil {
13297 ok := object.Key("endTime")
13298 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
13299 }
13300
13301 if len(v.MetricName) > 0 {
13302 ok := object.Key("metricName")
13303 ok.String(string(v.MetricName))
13304 }
13305
13306 if v.Period != nil {
13307 ok := object.Key("period")
13308 ok.Integer(*v.Period)
13309 }
13310
13311 if v.RelationalDatabaseName != nil {
13312 ok := object.Key("relationalDatabaseName")
13313 ok.String(*v.RelationalDatabaseName)
13314 }
13315
13316 if v.StartTime != nil {
13317 ok := object.Key("startTime")
13318 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
13319 }
13320
13321 if v.Statistics != nil {
13322 ok := object.Key("statistics")
13323 if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
13324 return err
13325 }
13326 }
13327
13328 if len(v.Unit) > 0 {
13329 ok := object.Key("unit")
13330 ok.String(string(v.Unit))
13331 }
13332
13333 return nil
13334 }
13335
13336 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseParametersInput(v *GetRelationalDatabaseParametersInput, value smithyjson.Value) error {
13337 object := value.Object()
13338 defer object.Close()
13339
13340 if v.PageToken != nil {
13341 ok := object.Key("pageToken")
13342 ok.String(*v.PageToken)
13343 }
13344
13345 if v.RelationalDatabaseName != nil {
13346 ok := object.Key("relationalDatabaseName")
13347 ok.String(*v.RelationalDatabaseName)
13348 }
13349
13350 return nil
13351 }
13352
13353 func awsAwsjson11_serializeOpDocumentGetRelationalDatabasesInput(v *GetRelationalDatabasesInput, value smithyjson.Value) error {
13354 object := value.Object()
13355 defer object.Close()
13356
13357 if v.PageToken != nil {
13358 ok := object.Key("pageToken")
13359 ok.String(*v.PageToken)
13360 }
13361
13362 return nil
13363 }
13364
13365 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseSnapshotInput(v *GetRelationalDatabaseSnapshotInput, value smithyjson.Value) error {
13366 object := value.Object()
13367 defer object.Close()
13368
13369 if v.RelationalDatabaseSnapshotName != nil {
13370 ok := object.Key("relationalDatabaseSnapshotName")
13371 ok.String(*v.RelationalDatabaseSnapshotName)
13372 }
13373
13374 return nil
13375 }
13376
13377 func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseSnapshotsInput(v *GetRelationalDatabaseSnapshotsInput, value smithyjson.Value) error {
13378 object := value.Object()
13379 defer object.Close()
13380
13381 if v.PageToken != nil {
13382 ok := object.Key("pageToken")
13383 ok.String(*v.PageToken)
13384 }
13385
13386 return nil
13387 }
13388
13389 func awsAwsjson11_serializeOpDocumentGetSetupHistoryInput(v *GetSetupHistoryInput, value smithyjson.Value) error {
13390 object := value.Object()
13391 defer object.Close()
13392
13393 if v.PageToken != nil {
13394 ok := object.Key("pageToken")
13395 ok.String(*v.PageToken)
13396 }
13397
13398 if v.ResourceName != nil {
13399 ok := object.Key("resourceName")
13400 ok.String(*v.ResourceName)
13401 }
13402
13403 return nil
13404 }
13405
13406 func awsAwsjson11_serializeOpDocumentGetStaticIpInput(v *GetStaticIpInput, value smithyjson.Value) error {
13407 object := value.Object()
13408 defer object.Close()
13409
13410 if v.StaticIpName != nil {
13411 ok := object.Key("staticIpName")
13412 ok.String(*v.StaticIpName)
13413 }
13414
13415 return nil
13416 }
13417
13418 func awsAwsjson11_serializeOpDocumentGetStaticIpsInput(v *GetStaticIpsInput, value smithyjson.Value) error {
13419 object := value.Object()
13420 defer object.Close()
13421
13422 if v.PageToken != nil {
13423 ok := object.Key("pageToken")
13424 ok.String(*v.PageToken)
13425 }
13426
13427 return nil
13428 }
13429
13430 func awsAwsjson11_serializeOpDocumentImportKeyPairInput(v *ImportKeyPairInput, value smithyjson.Value) error {
13431 object := value.Object()
13432 defer object.Close()
13433
13434 if v.KeyPairName != nil {
13435 ok := object.Key("keyPairName")
13436 ok.String(*v.KeyPairName)
13437 }
13438
13439 if v.PublicKeyBase64 != nil {
13440 ok := object.Key("publicKeyBase64")
13441 ok.String(*v.PublicKeyBase64)
13442 }
13443
13444 return nil
13445 }
13446
13447 func awsAwsjson11_serializeOpDocumentIsVpcPeeredInput(v *IsVpcPeeredInput, value smithyjson.Value) error {
13448 object := value.Object()
13449 defer object.Close()
13450
13451 return nil
13452 }
13453
13454 func awsAwsjson11_serializeOpDocumentOpenInstancePublicPortsInput(v *OpenInstancePublicPortsInput, value smithyjson.Value) error {
13455 object := value.Object()
13456 defer object.Close()
13457
13458 if v.InstanceName != nil {
13459 ok := object.Key("instanceName")
13460 ok.String(*v.InstanceName)
13461 }
13462
13463 if v.PortInfo != nil {
13464 ok := object.Key("portInfo")
13465 if err := awsAwsjson11_serializeDocumentPortInfo(v.PortInfo, ok); err != nil {
13466 return err
13467 }
13468 }
13469
13470 return nil
13471 }
13472
13473 func awsAwsjson11_serializeOpDocumentPeerVpcInput(v *PeerVpcInput, value smithyjson.Value) error {
13474 object := value.Object()
13475 defer object.Close()
13476
13477 return nil
13478 }
13479
13480 func awsAwsjson11_serializeOpDocumentPutAlarmInput(v *PutAlarmInput, value smithyjson.Value) error {
13481 object := value.Object()
13482 defer object.Close()
13483
13484 if v.AlarmName != nil {
13485 ok := object.Key("alarmName")
13486 ok.String(*v.AlarmName)
13487 }
13488
13489 if len(v.ComparisonOperator) > 0 {
13490 ok := object.Key("comparisonOperator")
13491 ok.String(string(v.ComparisonOperator))
13492 }
13493
13494 if v.ContactProtocols != nil {
13495 ok := object.Key("contactProtocols")
13496 if err := awsAwsjson11_serializeDocumentContactProtocolsList(v.ContactProtocols, ok); err != nil {
13497 return err
13498 }
13499 }
13500
13501 if v.DatapointsToAlarm != nil {
13502 ok := object.Key("datapointsToAlarm")
13503 ok.Integer(*v.DatapointsToAlarm)
13504 }
13505
13506 if v.EvaluationPeriods != nil {
13507 ok := object.Key("evaluationPeriods")
13508 ok.Integer(*v.EvaluationPeriods)
13509 }
13510
13511 if len(v.MetricName) > 0 {
13512 ok := object.Key("metricName")
13513 ok.String(string(v.MetricName))
13514 }
13515
13516 if v.MonitoredResourceName != nil {
13517 ok := object.Key("monitoredResourceName")
13518 ok.String(*v.MonitoredResourceName)
13519 }
13520
13521 if v.NotificationEnabled != nil {
13522 ok := object.Key("notificationEnabled")
13523 ok.Boolean(*v.NotificationEnabled)
13524 }
13525
13526 if v.NotificationTriggers != nil {
13527 ok := object.Key("notificationTriggers")
13528 if err := awsAwsjson11_serializeDocumentNotificationTriggerList(v.NotificationTriggers, ok); err != nil {
13529 return err
13530 }
13531 }
13532
13533 if v.Threshold != nil {
13534 ok := object.Key("threshold")
13535 switch {
13536 case math.IsNaN(*v.Threshold):
13537 ok.String("NaN")
13538
13539 case math.IsInf(*v.Threshold, 1):
13540 ok.String("Infinity")
13541
13542 case math.IsInf(*v.Threshold, -1):
13543 ok.String("-Infinity")
13544
13545 default:
13546 ok.Double(*v.Threshold)
13547
13548 }
13549 }
13550
13551 if len(v.TreatMissingData) > 0 {
13552 ok := object.Key("treatMissingData")
13553 ok.String(string(v.TreatMissingData))
13554 }
13555
13556 return nil
13557 }
13558
13559 func awsAwsjson11_serializeOpDocumentPutInstancePublicPortsInput(v *PutInstancePublicPortsInput, value smithyjson.Value) error {
13560 object := value.Object()
13561 defer object.Close()
13562
13563 if v.InstanceName != nil {
13564 ok := object.Key("instanceName")
13565 ok.String(*v.InstanceName)
13566 }
13567
13568 if v.PortInfos != nil {
13569 ok := object.Key("portInfos")
13570 if err := awsAwsjson11_serializeDocumentPortInfoList(v.PortInfos, ok); err != nil {
13571 return err
13572 }
13573 }
13574
13575 return nil
13576 }
13577
13578 func awsAwsjson11_serializeOpDocumentRebootInstanceInput(v *RebootInstanceInput, value smithyjson.Value) error {
13579 object := value.Object()
13580 defer object.Close()
13581
13582 if v.InstanceName != nil {
13583 ok := object.Key("instanceName")
13584 ok.String(*v.InstanceName)
13585 }
13586
13587 return nil
13588 }
13589
13590 func awsAwsjson11_serializeOpDocumentRebootRelationalDatabaseInput(v *RebootRelationalDatabaseInput, value smithyjson.Value) error {
13591 object := value.Object()
13592 defer object.Close()
13593
13594 if v.RelationalDatabaseName != nil {
13595 ok := object.Key("relationalDatabaseName")
13596 ok.String(*v.RelationalDatabaseName)
13597 }
13598
13599 return nil
13600 }
13601
13602 func awsAwsjson11_serializeOpDocumentRegisterContainerImageInput(v *RegisterContainerImageInput, value smithyjson.Value) error {
13603 object := value.Object()
13604 defer object.Close()
13605
13606 if v.Digest != nil {
13607 ok := object.Key("digest")
13608 ok.String(*v.Digest)
13609 }
13610
13611 if v.Label != nil {
13612 ok := object.Key("label")
13613 ok.String(*v.Label)
13614 }
13615
13616 if v.ServiceName != nil {
13617 ok := object.Key("serviceName")
13618 ok.String(*v.ServiceName)
13619 }
13620
13621 return nil
13622 }
13623
13624 func awsAwsjson11_serializeOpDocumentReleaseStaticIpInput(v *ReleaseStaticIpInput, value smithyjson.Value) error {
13625 object := value.Object()
13626 defer object.Close()
13627
13628 if v.StaticIpName != nil {
13629 ok := object.Key("staticIpName")
13630 ok.String(*v.StaticIpName)
13631 }
13632
13633 return nil
13634 }
13635
13636 func awsAwsjson11_serializeOpDocumentResetDistributionCacheInput(v *ResetDistributionCacheInput, value smithyjson.Value) error {
13637 object := value.Object()
13638 defer object.Close()
13639
13640 if v.DistributionName != nil {
13641 ok := object.Key("distributionName")
13642 ok.String(*v.DistributionName)
13643 }
13644
13645 return nil
13646 }
13647
13648 func awsAwsjson11_serializeOpDocumentSendContactMethodVerificationInput(v *SendContactMethodVerificationInput, value smithyjson.Value) error {
13649 object := value.Object()
13650 defer object.Close()
13651
13652 if len(v.Protocol) > 0 {
13653 ok := object.Key("protocol")
13654 ok.String(string(v.Protocol))
13655 }
13656
13657 return nil
13658 }
13659
13660 func awsAwsjson11_serializeOpDocumentSetIpAddressTypeInput(v *SetIpAddressTypeInput, value smithyjson.Value) error {
13661 object := value.Object()
13662 defer object.Close()
13663
13664 if v.AcceptBundleUpdate != nil {
13665 ok := object.Key("acceptBundleUpdate")
13666 ok.Boolean(*v.AcceptBundleUpdate)
13667 }
13668
13669 if len(v.IpAddressType) > 0 {
13670 ok := object.Key("ipAddressType")
13671 ok.String(string(v.IpAddressType))
13672 }
13673
13674 if v.ResourceName != nil {
13675 ok := object.Key("resourceName")
13676 ok.String(*v.ResourceName)
13677 }
13678
13679 if len(v.ResourceType) > 0 {
13680 ok := object.Key("resourceType")
13681 ok.String(string(v.ResourceType))
13682 }
13683
13684 return nil
13685 }
13686
13687 func awsAwsjson11_serializeOpDocumentSetResourceAccessForBucketInput(v *SetResourceAccessForBucketInput, value smithyjson.Value) error {
13688 object := value.Object()
13689 defer object.Close()
13690
13691 if len(v.Access) > 0 {
13692 ok := object.Key("access")
13693 ok.String(string(v.Access))
13694 }
13695
13696 if v.BucketName != nil {
13697 ok := object.Key("bucketName")
13698 ok.String(*v.BucketName)
13699 }
13700
13701 if v.ResourceName != nil {
13702 ok := object.Key("resourceName")
13703 ok.String(*v.ResourceName)
13704 }
13705
13706 return nil
13707 }
13708
13709 func awsAwsjson11_serializeOpDocumentSetupInstanceHttpsInput(v *SetupInstanceHttpsInput, value smithyjson.Value) error {
13710 object := value.Object()
13711 defer object.Close()
13712
13713 if len(v.CertificateProvider) > 0 {
13714 ok := object.Key("certificateProvider")
13715 ok.String(string(v.CertificateProvider))
13716 }
13717
13718 if v.DomainNames != nil {
13719 ok := object.Key("domainNames")
13720 if err := awsAwsjson11_serializeDocumentSetupDomainNameList(v.DomainNames, ok); err != nil {
13721 return err
13722 }
13723 }
13724
13725 if v.EmailAddress != nil {
13726 ok := object.Key("emailAddress")
13727 ok.String(*v.EmailAddress)
13728 }
13729
13730 if v.InstanceName != nil {
13731 ok := object.Key("instanceName")
13732 ok.String(*v.InstanceName)
13733 }
13734
13735 return nil
13736 }
13737
13738 func awsAwsjson11_serializeOpDocumentStartGUISessionInput(v *StartGUISessionInput, value smithyjson.Value) error {
13739 object := value.Object()
13740 defer object.Close()
13741
13742 if v.ResourceName != nil {
13743 ok := object.Key("resourceName")
13744 ok.String(*v.ResourceName)
13745 }
13746
13747 return nil
13748 }
13749
13750 func awsAwsjson11_serializeOpDocumentStartInstanceInput(v *StartInstanceInput, value smithyjson.Value) error {
13751 object := value.Object()
13752 defer object.Close()
13753
13754 if v.InstanceName != nil {
13755 ok := object.Key("instanceName")
13756 ok.String(*v.InstanceName)
13757 }
13758
13759 return nil
13760 }
13761
13762 func awsAwsjson11_serializeOpDocumentStartRelationalDatabaseInput(v *StartRelationalDatabaseInput, value smithyjson.Value) error {
13763 object := value.Object()
13764 defer object.Close()
13765
13766 if v.RelationalDatabaseName != nil {
13767 ok := object.Key("relationalDatabaseName")
13768 ok.String(*v.RelationalDatabaseName)
13769 }
13770
13771 return nil
13772 }
13773
13774 func awsAwsjson11_serializeOpDocumentStopGUISessionInput(v *StopGUISessionInput, value smithyjson.Value) error {
13775 object := value.Object()
13776 defer object.Close()
13777
13778 if v.ResourceName != nil {
13779 ok := object.Key("resourceName")
13780 ok.String(*v.ResourceName)
13781 }
13782
13783 return nil
13784 }
13785
13786 func awsAwsjson11_serializeOpDocumentStopInstanceInput(v *StopInstanceInput, value smithyjson.Value) error {
13787 object := value.Object()
13788 defer object.Close()
13789
13790 if v.Force != nil {
13791 ok := object.Key("force")
13792 ok.Boolean(*v.Force)
13793 }
13794
13795 if v.InstanceName != nil {
13796 ok := object.Key("instanceName")
13797 ok.String(*v.InstanceName)
13798 }
13799
13800 return nil
13801 }
13802
13803 func awsAwsjson11_serializeOpDocumentStopRelationalDatabaseInput(v *StopRelationalDatabaseInput, value smithyjson.Value) error {
13804 object := value.Object()
13805 defer object.Close()
13806
13807 if v.RelationalDatabaseName != nil {
13808 ok := object.Key("relationalDatabaseName")
13809 ok.String(*v.RelationalDatabaseName)
13810 }
13811
13812 if v.RelationalDatabaseSnapshotName != nil {
13813 ok := object.Key("relationalDatabaseSnapshotName")
13814 ok.String(*v.RelationalDatabaseSnapshotName)
13815 }
13816
13817 return nil
13818 }
13819
13820 func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
13821 object := value.Object()
13822 defer object.Close()
13823
13824 if v.ResourceArn != nil {
13825 ok := object.Key("resourceArn")
13826 ok.String(*v.ResourceArn)
13827 }
13828
13829 if v.ResourceName != nil {
13830 ok := object.Key("resourceName")
13831 ok.String(*v.ResourceName)
13832 }
13833
13834 if v.Tags != nil {
13835 ok := object.Key("tags")
13836 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
13837 return err
13838 }
13839 }
13840
13841 return nil
13842 }
13843
13844 func awsAwsjson11_serializeOpDocumentTestAlarmInput(v *TestAlarmInput, value smithyjson.Value) error {
13845 object := value.Object()
13846 defer object.Close()
13847
13848 if v.AlarmName != nil {
13849 ok := object.Key("alarmName")
13850 ok.String(*v.AlarmName)
13851 }
13852
13853 if len(v.State) > 0 {
13854 ok := object.Key("state")
13855 ok.String(string(v.State))
13856 }
13857
13858 return nil
13859 }
13860
13861 func awsAwsjson11_serializeOpDocumentUnpeerVpcInput(v *UnpeerVpcInput, value smithyjson.Value) error {
13862 object := value.Object()
13863 defer object.Close()
13864
13865 return nil
13866 }
13867
13868 func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
13869 object := value.Object()
13870 defer object.Close()
13871
13872 if v.ResourceArn != nil {
13873 ok := object.Key("resourceArn")
13874 ok.String(*v.ResourceArn)
13875 }
13876
13877 if v.ResourceName != nil {
13878 ok := object.Key("resourceName")
13879 ok.String(*v.ResourceName)
13880 }
13881
13882 if v.TagKeys != nil {
13883 ok := object.Key("tagKeys")
13884 if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
13885 return err
13886 }
13887 }
13888
13889 return nil
13890 }
13891
13892 func awsAwsjson11_serializeOpDocumentUpdateBucketBundleInput(v *UpdateBucketBundleInput, value smithyjson.Value) error {
13893 object := value.Object()
13894 defer object.Close()
13895
13896 if v.BucketName != nil {
13897 ok := object.Key("bucketName")
13898 ok.String(*v.BucketName)
13899 }
13900
13901 if v.BundleId != nil {
13902 ok := object.Key("bundleId")
13903 ok.String(*v.BundleId)
13904 }
13905
13906 return nil
13907 }
13908
13909 func awsAwsjson11_serializeOpDocumentUpdateBucketInput(v *UpdateBucketInput, value smithyjson.Value) error {
13910 object := value.Object()
13911 defer object.Close()
13912
13913 if v.AccessLogConfig != nil {
13914 ok := object.Key("accessLogConfig")
13915 if err := awsAwsjson11_serializeDocumentBucketAccessLogConfig(v.AccessLogConfig, ok); err != nil {
13916 return err
13917 }
13918 }
13919
13920 if v.AccessRules != nil {
13921 ok := object.Key("accessRules")
13922 if err := awsAwsjson11_serializeDocumentAccessRules(v.AccessRules, ok); err != nil {
13923 return err
13924 }
13925 }
13926
13927 if v.BucketName != nil {
13928 ok := object.Key("bucketName")
13929 ok.String(*v.BucketName)
13930 }
13931
13932 if v.Cors != nil {
13933 ok := object.Key("cors")
13934 if err := awsAwsjson11_serializeDocumentBucketCorsConfig(v.Cors, ok); err != nil {
13935 return err
13936 }
13937 }
13938
13939 if v.ReadonlyAccessAccounts != nil {
13940 ok := object.Key("readonlyAccessAccounts")
13941 if err := awsAwsjson11_serializeDocumentPartnerIdList(v.ReadonlyAccessAccounts, ok); err != nil {
13942 return err
13943 }
13944 }
13945
13946 if v.Versioning != nil {
13947 ok := object.Key("versioning")
13948 ok.String(*v.Versioning)
13949 }
13950
13951 return nil
13952 }
13953
13954 func awsAwsjson11_serializeOpDocumentUpdateContainerServiceInput(v *UpdateContainerServiceInput, value smithyjson.Value) error {
13955 object := value.Object()
13956 defer object.Close()
13957
13958 if v.IsDisabled != nil {
13959 ok := object.Key("isDisabled")
13960 ok.Boolean(*v.IsDisabled)
13961 }
13962
13963 if len(v.Power) > 0 {
13964 ok := object.Key("power")
13965 ok.String(string(v.Power))
13966 }
13967
13968 if v.PrivateRegistryAccess != nil {
13969 ok := object.Key("privateRegistryAccess")
13970 if err := awsAwsjson11_serializeDocumentPrivateRegistryAccessRequest(v.PrivateRegistryAccess, ok); err != nil {
13971 return err
13972 }
13973 }
13974
13975 if v.PublicDomainNames != nil {
13976 ok := object.Key("publicDomainNames")
13977 if err := awsAwsjson11_serializeDocumentContainerServicePublicDomains(v.PublicDomainNames, ok); err != nil {
13978 return err
13979 }
13980 }
13981
13982 if v.Scale != nil {
13983 ok := object.Key("scale")
13984 ok.Integer(*v.Scale)
13985 }
13986
13987 if v.ServiceName != nil {
13988 ok := object.Key("serviceName")
13989 ok.String(*v.ServiceName)
13990 }
13991
13992 return nil
13993 }
13994
13995 func awsAwsjson11_serializeOpDocumentUpdateDistributionBundleInput(v *UpdateDistributionBundleInput, value smithyjson.Value) error {
13996 object := value.Object()
13997 defer object.Close()
13998
13999 if v.BundleId != nil {
14000 ok := object.Key("bundleId")
14001 ok.String(*v.BundleId)
14002 }
14003
14004 if v.DistributionName != nil {
14005 ok := object.Key("distributionName")
14006 ok.String(*v.DistributionName)
14007 }
14008
14009 return nil
14010 }
14011
14012 func awsAwsjson11_serializeOpDocumentUpdateDistributionInput(v *UpdateDistributionInput, value smithyjson.Value) error {
14013 object := value.Object()
14014 defer object.Close()
14015
14016 if v.CacheBehaviors != nil {
14017 ok := object.Key("cacheBehaviors")
14018 if err := awsAwsjson11_serializeDocumentCacheBehaviorList(v.CacheBehaviors, ok); err != nil {
14019 return err
14020 }
14021 }
14022
14023 if v.CacheBehaviorSettings != nil {
14024 ok := object.Key("cacheBehaviorSettings")
14025 if err := awsAwsjson11_serializeDocumentCacheSettings(v.CacheBehaviorSettings, ok); err != nil {
14026 return err
14027 }
14028 }
14029
14030 if v.CertificateName != nil {
14031 ok := object.Key("certificateName")
14032 ok.String(*v.CertificateName)
14033 }
14034
14035 if v.DefaultCacheBehavior != nil {
14036 ok := object.Key("defaultCacheBehavior")
14037 if err := awsAwsjson11_serializeDocumentCacheBehavior(v.DefaultCacheBehavior, ok); err != nil {
14038 return err
14039 }
14040 }
14041
14042 if v.DistributionName != nil {
14043 ok := object.Key("distributionName")
14044 ok.String(*v.DistributionName)
14045 }
14046
14047 if v.IsEnabled != nil {
14048 ok := object.Key("isEnabled")
14049 ok.Boolean(*v.IsEnabled)
14050 }
14051
14052 if v.Origin != nil {
14053 ok := object.Key("origin")
14054 if err := awsAwsjson11_serializeDocumentInputOrigin(v.Origin, ok); err != nil {
14055 return err
14056 }
14057 }
14058
14059 if v.UseDefaultCertificate != nil {
14060 ok := object.Key("useDefaultCertificate")
14061 ok.Boolean(*v.UseDefaultCertificate)
14062 }
14063
14064 if len(v.ViewerMinimumTlsProtocolVersion) > 0 {
14065 ok := object.Key("viewerMinimumTlsProtocolVersion")
14066 ok.String(string(v.ViewerMinimumTlsProtocolVersion))
14067 }
14068
14069 return nil
14070 }
14071
14072 func awsAwsjson11_serializeOpDocumentUpdateDomainEntryInput(v *UpdateDomainEntryInput, value smithyjson.Value) error {
14073 object := value.Object()
14074 defer object.Close()
14075
14076 if v.DomainEntry != nil {
14077 ok := object.Key("domainEntry")
14078 if err := awsAwsjson11_serializeDocumentDomainEntry(v.DomainEntry, ok); err != nil {
14079 return err
14080 }
14081 }
14082
14083 if v.DomainName != nil {
14084 ok := object.Key("domainName")
14085 ok.String(*v.DomainName)
14086 }
14087
14088 return nil
14089 }
14090
14091 func awsAwsjson11_serializeOpDocumentUpdateInstanceMetadataOptionsInput(v *UpdateInstanceMetadataOptionsInput, value smithyjson.Value) error {
14092 object := value.Object()
14093 defer object.Close()
14094
14095 if len(v.HttpEndpoint) > 0 {
14096 ok := object.Key("httpEndpoint")
14097 ok.String(string(v.HttpEndpoint))
14098 }
14099
14100 if len(v.HttpProtocolIpv6) > 0 {
14101 ok := object.Key("httpProtocolIpv6")
14102 ok.String(string(v.HttpProtocolIpv6))
14103 }
14104
14105 if v.HttpPutResponseHopLimit != nil {
14106 ok := object.Key("httpPutResponseHopLimit")
14107 ok.Integer(*v.HttpPutResponseHopLimit)
14108 }
14109
14110 if len(v.HttpTokens) > 0 {
14111 ok := object.Key("httpTokens")
14112 ok.String(string(v.HttpTokens))
14113 }
14114
14115 if v.InstanceName != nil {
14116 ok := object.Key("instanceName")
14117 ok.String(*v.InstanceName)
14118 }
14119
14120 return nil
14121 }
14122
14123 func awsAwsjson11_serializeOpDocumentUpdateLoadBalancerAttributeInput(v *UpdateLoadBalancerAttributeInput, value smithyjson.Value) error {
14124 object := value.Object()
14125 defer object.Close()
14126
14127 if len(v.AttributeName) > 0 {
14128 ok := object.Key("attributeName")
14129 ok.String(string(v.AttributeName))
14130 }
14131
14132 if v.AttributeValue != nil {
14133 ok := object.Key("attributeValue")
14134 ok.String(*v.AttributeValue)
14135 }
14136
14137 if v.LoadBalancerName != nil {
14138 ok := object.Key("loadBalancerName")
14139 ok.String(*v.LoadBalancerName)
14140 }
14141
14142 return nil
14143 }
14144
14145 func awsAwsjson11_serializeOpDocumentUpdateRelationalDatabaseInput(v *UpdateRelationalDatabaseInput, value smithyjson.Value) error {
14146 object := value.Object()
14147 defer object.Close()
14148
14149 if v.ApplyImmediately != nil {
14150 ok := object.Key("applyImmediately")
14151 ok.Boolean(*v.ApplyImmediately)
14152 }
14153
14154 if v.CaCertificateIdentifier != nil {
14155 ok := object.Key("caCertificateIdentifier")
14156 ok.String(*v.CaCertificateIdentifier)
14157 }
14158
14159 if v.DisableBackupRetention != nil {
14160 ok := object.Key("disableBackupRetention")
14161 ok.Boolean(*v.DisableBackupRetention)
14162 }
14163
14164 if v.EnableBackupRetention != nil {
14165 ok := object.Key("enableBackupRetention")
14166 ok.Boolean(*v.EnableBackupRetention)
14167 }
14168
14169 if v.MasterUserPassword != nil {
14170 ok := object.Key("masterUserPassword")
14171 ok.String(*v.MasterUserPassword)
14172 }
14173
14174 if v.PreferredBackupWindow != nil {
14175 ok := object.Key("preferredBackupWindow")
14176 ok.String(*v.PreferredBackupWindow)
14177 }
14178
14179 if v.PreferredMaintenanceWindow != nil {
14180 ok := object.Key("preferredMaintenanceWindow")
14181 ok.String(*v.PreferredMaintenanceWindow)
14182 }
14183
14184 if v.PubliclyAccessible != nil {
14185 ok := object.Key("publiclyAccessible")
14186 ok.Boolean(*v.PubliclyAccessible)
14187 }
14188
14189 if v.RelationalDatabaseBlueprintId != nil {
14190 ok := object.Key("relationalDatabaseBlueprintId")
14191 ok.String(*v.RelationalDatabaseBlueprintId)
14192 }
14193
14194 if v.RelationalDatabaseName != nil {
14195 ok := object.Key("relationalDatabaseName")
14196 ok.String(*v.RelationalDatabaseName)
14197 }
14198
14199 if v.RotateMasterUserPassword != nil {
14200 ok := object.Key("rotateMasterUserPassword")
14201 ok.Boolean(*v.RotateMasterUserPassword)
14202 }
14203
14204 return nil
14205 }
14206
14207 func awsAwsjson11_serializeOpDocumentUpdateRelationalDatabaseParametersInput(v *UpdateRelationalDatabaseParametersInput, value smithyjson.Value) error {
14208 object := value.Object()
14209 defer object.Close()
14210
14211 if v.Parameters != nil {
14212 ok := object.Key("parameters")
14213 if err := awsAwsjson11_serializeDocumentRelationalDatabaseParameterList(v.Parameters, ok); err != nil {
14214 return err
14215 }
14216 }
14217
14218 if v.RelationalDatabaseName != nil {
14219 ok := object.Key("relationalDatabaseName")
14220 ok.String(*v.RelationalDatabaseName)
14221 }
14222
14223 return nil
14224 }
14225