1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package lightsail
4
5import (
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	smithyhttp "github.com/aws/smithy-go/transport/http"
16)
17
18type awsAwsjson11_serializeOpAllocateStaticIp struct {
19}
20
21func (*awsAwsjson11_serializeOpAllocateStaticIp) ID() string {
22	return "OperationSerializer"
23}
24
25func (m *awsAwsjson11_serializeOpAllocateStaticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
26	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
27) {
28	request, ok := in.Request.(*smithyhttp.Request)
29	if !ok {
30		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
31	}
32
33	input, ok := in.Parameters.(*AllocateStaticIpInput)
34	_ = input
35	if !ok {
36		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
37	}
38
39	request.Request.URL.Path = "/"
40	request.Request.Method = "POST"
41	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
42	if err != nil {
43		return out, metadata, &smithy.SerializationError{Err: err}
44	}
45	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
46	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AllocateStaticIp")
47
48	jsonEncoder := smithyjson.NewEncoder()
49	if err := awsAwsjson11_serializeOpDocumentAllocateStaticIpInput(input, jsonEncoder.Value); err != nil {
50		return out, metadata, &smithy.SerializationError{Err: err}
51	}
52
53	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
54		return out, metadata, &smithy.SerializationError{Err: err}
55	}
56
57	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
58		return out, metadata, &smithy.SerializationError{Err: err}
59	}
60	in.Request = request
61
62	return next.HandleSerialize(ctx, in)
63}
64
65type awsAwsjson11_serializeOpAttachCertificateToDistribution struct {
66}
67
68func (*awsAwsjson11_serializeOpAttachCertificateToDistribution) ID() string {
69	return "OperationSerializer"
70}
71
72func (m *awsAwsjson11_serializeOpAttachCertificateToDistribution) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
73	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
74) {
75	request, ok := in.Request.(*smithyhttp.Request)
76	if !ok {
77		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
78	}
79
80	input, ok := in.Parameters.(*AttachCertificateToDistributionInput)
81	_ = input
82	if !ok {
83		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
84	}
85
86	request.Request.URL.Path = "/"
87	request.Request.Method = "POST"
88	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
89	if err != nil {
90		return out, metadata, &smithy.SerializationError{Err: err}
91	}
92	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
93	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AttachCertificateToDistribution")
94
95	jsonEncoder := smithyjson.NewEncoder()
96	if err := awsAwsjson11_serializeOpDocumentAttachCertificateToDistributionInput(input, jsonEncoder.Value); err != nil {
97		return out, metadata, &smithy.SerializationError{Err: err}
98	}
99
100	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
101		return out, metadata, &smithy.SerializationError{Err: err}
102	}
103
104	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
105		return out, metadata, &smithy.SerializationError{Err: err}
106	}
107	in.Request = request
108
109	return next.HandleSerialize(ctx, in)
110}
111
112type awsAwsjson11_serializeOpAttachDisk struct {
113}
114
115func (*awsAwsjson11_serializeOpAttachDisk) ID() string {
116	return "OperationSerializer"
117}
118
119func (m *awsAwsjson11_serializeOpAttachDisk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
120	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
121) {
122	request, ok := in.Request.(*smithyhttp.Request)
123	if !ok {
124		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
125	}
126
127	input, ok := in.Parameters.(*AttachDiskInput)
128	_ = input
129	if !ok {
130		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
131	}
132
133	request.Request.URL.Path = "/"
134	request.Request.Method = "POST"
135	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
136	if err != nil {
137		return out, metadata, &smithy.SerializationError{Err: err}
138	}
139	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
140	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AttachDisk")
141
142	jsonEncoder := smithyjson.NewEncoder()
143	if err := awsAwsjson11_serializeOpDocumentAttachDiskInput(input, jsonEncoder.Value); err != nil {
144		return out, metadata, &smithy.SerializationError{Err: err}
145	}
146
147	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
148		return out, metadata, &smithy.SerializationError{Err: err}
149	}
150
151	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
152		return out, metadata, &smithy.SerializationError{Err: err}
153	}
154	in.Request = request
155
156	return next.HandleSerialize(ctx, in)
157}
158
159type awsAwsjson11_serializeOpAttachInstancesToLoadBalancer struct {
160}
161
162func (*awsAwsjson11_serializeOpAttachInstancesToLoadBalancer) ID() string {
163	return "OperationSerializer"
164}
165
166func (m *awsAwsjson11_serializeOpAttachInstancesToLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
167	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
168) {
169	request, ok := in.Request.(*smithyhttp.Request)
170	if !ok {
171		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
172	}
173
174	input, ok := in.Parameters.(*AttachInstancesToLoadBalancerInput)
175	_ = input
176	if !ok {
177		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
178	}
179
180	request.Request.URL.Path = "/"
181	request.Request.Method = "POST"
182	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
183	if err != nil {
184		return out, metadata, &smithy.SerializationError{Err: err}
185	}
186	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
187	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AttachInstancesToLoadBalancer")
188
189	jsonEncoder := smithyjson.NewEncoder()
190	if err := awsAwsjson11_serializeOpDocumentAttachInstancesToLoadBalancerInput(input, jsonEncoder.Value); err != nil {
191		return out, metadata, &smithy.SerializationError{Err: err}
192	}
193
194	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
195		return out, metadata, &smithy.SerializationError{Err: err}
196	}
197
198	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
199		return out, metadata, &smithy.SerializationError{Err: err}
200	}
201	in.Request = request
202
203	return next.HandleSerialize(ctx, in)
204}
205
206type awsAwsjson11_serializeOpAttachLoadBalancerTlsCertificate struct {
207}
208
209func (*awsAwsjson11_serializeOpAttachLoadBalancerTlsCertificate) ID() string {
210	return "OperationSerializer"
211}
212
213func (m *awsAwsjson11_serializeOpAttachLoadBalancerTlsCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
214	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
215) {
216	request, ok := in.Request.(*smithyhttp.Request)
217	if !ok {
218		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
219	}
220
221	input, ok := in.Parameters.(*AttachLoadBalancerTlsCertificateInput)
222	_ = input
223	if !ok {
224		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
225	}
226
227	request.Request.URL.Path = "/"
228	request.Request.Method = "POST"
229	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
230	if err != nil {
231		return out, metadata, &smithy.SerializationError{Err: err}
232	}
233	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
234	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AttachLoadBalancerTlsCertificate")
235
236	jsonEncoder := smithyjson.NewEncoder()
237	if err := awsAwsjson11_serializeOpDocumentAttachLoadBalancerTlsCertificateInput(input, jsonEncoder.Value); err != nil {
238		return out, metadata, &smithy.SerializationError{Err: err}
239	}
240
241	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
242		return out, metadata, &smithy.SerializationError{Err: err}
243	}
244
245	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
246		return out, metadata, &smithy.SerializationError{Err: err}
247	}
248	in.Request = request
249
250	return next.HandleSerialize(ctx, in)
251}
252
253type awsAwsjson11_serializeOpAttachStaticIp struct {
254}
255
256func (*awsAwsjson11_serializeOpAttachStaticIp) ID() string {
257	return "OperationSerializer"
258}
259
260func (m *awsAwsjson11_serializeOpAttachStaticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
261	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
262) {
263	request, ok := in.Request.(*smithyhttp.Request)
264	if !ok {
265		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
266	}
267
268	input, ok := in.Parameters.(*AttachStaticIpInput)
269	_ = input
270	if !ok {
271		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
272	}
273
274	request.Request.URL.Path = "/"
275	request.Request.Method = "POST"
276	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
277	if err != nil {
278		return out, metadata, &smithy.SerializationError{Err: err}
279	}
280	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
281	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.AttachStaticIp")
282
283	jsonEncoder := smithyjson.NewEncoder()
284	if err := awsAwsjson11_serializeOpDocumentAttachStaticIpInput(input, jsonEncoder.Value); err != nil {
285		return out, metadata, &smithy.SerializationError{Err: err}
286	}
287
288	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
289		return out, metadata, &smithy.SerializationError{Err: err}
290	}
291
292	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
293		return out, metadata, &smithy.SerializationError{Err: err}
294	}
295	in.Request = request
296
297	return next.HandleSerialize(ctx, in)
298}
299
300type awsAwsjson11_serializeOpCloseInstancePublicPorts struct {
301}
302
303func (*awsAwsjson11_serializeOpCloseInstancePublicPorts) ID() string {
304	return "OperationSerializer"
305}
306
307func (m *awsAwsjson11_serializeOpCloseInstancePublicPorts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
308	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
309) {
310	request, ok := in.Request.(*smithyhttp.Request)
311	if !ok {
312		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
313	}
314
315	input, ok := in.Parameters.(*CloseInstancePublicPortsInput)
316	_ = input
317	if !ok {
318		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
319	}
320
321	request.Request.URL.Path = "/"
322	request.Request.Method = "POST"
323	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
324	if err != nil {
325		return out, metadata, &smithy.SerializationError{Err: err}
326	}
327	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
328	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CloseInstancePublicPorts")
329
330	jsonEncoder := smithyjson.NewEncoder()
331	if err := awsAwsjson11_serializeOpDocumentCloseInstancePublicPortsInput(input, jsonEncoder.Value); err != nil {
332		return out, metadata, &smithy.SerializationError{Err: err}
333	}
334
335	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
336		return out, metadata, &smithy.SerializationError{Err: err}
337	}
338
339	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
340		return out, metadata, &smithy.SerializationError{Err: err}
341	}
342	in.Request = request
343
344	return next.HandleSerialize(ctx, in)
345}
346
347type awsAwsjson11_serializeOpCopySnapshot struct {
348}
349
350func (*awsAwsjson11_serializeOpCopySnapshot) ID() string {
351	return "OperationSerializer"
352}
353
354func (m *awsAwsjson11_serializeOpCopySnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
355	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
356) {
357	request, ok := in.Request.(*smithyhttp.Request)
358	if !ok {
359		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
360	}
361
362	input, ok := in.Parameters.(*CopySnapshotInput)
363	_ = input
364	if !ok {
365		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
366	}
367
368	request.Request.URL.Path = "/"
369	request.Request.Method = "POST"
370	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
371	if err != nil {
372		return out, metadata, &smithy.SerializationError{Err: err}
373	}
374	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
375	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CopySnapshot")
376
377	jsonEncoder := smithyjson.NewEncoder()
378	if err := awsAwsjson11_serializeOpDocumentCopySnapshotInput(input, jsonEncoder.Value); err != nil {
379		return out, metadata, &smithy.SerializationError{Err: err}
380	}
381
382	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
383		return out, metadata, &smithy.SerializationError{Err: err}
384	}
385
386	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
387		return out, metadata, &smithy.SerializationError{Err: err}
388	}
389	in.Request = request
390
391	return next.HandleSerialize(ctx, in)
392}
393
394type awsAwsjson11_serializeOpCreateCertificate struct {
395}
396
397func (*awsAwsjson11_serializeOpCreateCertificate) ID() string {
398	return "OperationSerializer"
399}
400
401func (m *awsAwsjson11_serializeOpCreateCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
402	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
403) {
404	request, ok := in.Request.(*smithyhttp.Request)
405	if !ok {
406		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
407	}
408
409	input, ok := in.Parameters.(*CreateCertificateInput)
410	_ = input
411	if !ok {
412		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
413	}
414
415	request.Request.URL.Path = "/"
416	request.Request.Method = "POST"
417	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
418	if err != nil {
419		return out, metadata, &smithy.SerializationError{Err: err}
420	}
421	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
422	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateCertificate")
423
424	jsonEncoder := smithyjson.NewEncoder()
425	if err := awsAwsjson11_serializeOpDocumentCreateCertificateInput(input, jsonEncoder.Value); err != nil {
426		return out, metadata, &smithy.SerializationError{Err: err}
427	}
428
429	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
430		return out, metadata, &smithy.SerializationError{Err: err}
431	}
432
433	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
434		return out, metadata, &smithy.SerializationError{Err: err}
435	}
436	in.Request = request
437
438	return next.HandleSerialize(ctx, in)
439}
440
441type awsAwsjson11_serializeOpCreateCloudFormationStack struct {
442}
443
444func (*awsAwsjson11_serializeOpCreateCloudFormationStack) ID() string {
445	return "OperationSerializer"
446}
447
448func (m *awsAwsjson11_serializeOpCreateCloudFormationStack) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
449	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
450) {
451	request, ok := in.Request.(*smithyhttp.Request)
452	if !ok {
453		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
454	}
455
456	input, ok := in.Parameters.(*CreateCloudFormationStackInput)
457	_ = input
458	if !ok {
459		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
460	}
461
462	request.Request.URL.Path = "/"
463	request.Request.Method = "POST"
464	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
465	if err != nil {
466		return out, metadata, &smithy.SerializationError{Err: err}
467	}
468	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
469	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateCloudFormationStack")
470
471	jsonEncoder := smithyjson.NewEncoder()
472	if err := awsAwsjson11_serializeOpDocumentCreateCloudFormationStackInput(input, jsonEncoder.Value); err != nil {
473		return out, metadata, &smithy.SerializationError{Err: err}
474	}
475
476	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
477		return out, metadata, &smithy.SerializationError{Err: err}
478	}
479
480	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
481		return out, metadata, &smithy.SerializationError{Err: err}
482	}
483	in.Request = request
484
485	return next.HandleSerialize(ctx, in)
486}
487
488type awsAwsjson11_serializeOpCreateContactMethod struct {
489}
490
491func (*awsAwsjson11_serializeOpCreateContactMethod) ID() string {
492	return "OperationSerializer"
493}
494
495func (m *awsAwsjson11_serializeOpCreateContactMethod) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
496	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
497) {
498	request, ok := in.Request.(*smithyhttp.Request)
499	if !ok {
500		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
501	}
502
503	input, ok := in.Parameters.(*CreateContactMethodInput)
504	_ = input
505	if !ok {
506		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
507	}
508
509	request.Request.URL.Path = "/"
510	request.Request.Method = "POST"
511	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
512	if err != nil {
513		return out, metadata, &smithy.SerializationError{Err: err}
514	}
515	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
516	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateContactMethod")
517
518	jsonEncoder := smithyjson.NewEncoder()
519	if err := awsAwsjson11_serializeOpDocumentCreateContactMethodInput(input, jsonEncoder.Value); err != nil {
520		return out, metadata, &smithy.SerializationError{Err: err}
521	}
522
523	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
524		return out, metadata, &smithy.SerializationError{Err: err}
525	}
526
527	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
528		return out, metadata, &smithy.SerializationError{Err: err}
529	}
530	in.Request = request
531
532	return next.HandleSerialize(ctx, in)
533}
534
535type awsAwsjson11_serializeOpCreateContainerService struct {
536}
537
538func (*awsAwsjson11_serializeOpCreateContainerService) ID() string {
539	return "OperationSerializer"
540}
541
542func (m *awsAwsjson11_serializeOpCreateContainerService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
543	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
544) {
545	request, ok := in.Request.(*smithyhttp.Request)
546	if !ok {
547		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
548	}
549
550	input, ok := in.Parameters.(*CreateContainerServiceInput)
551	_ = input
552	if !ok {
553		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
554	}
555
556	request.Request.URL.Path = "/"
557	request.Request.Method = "POST"
558	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
559	if err != nil {
560		return out, metadata, &smithy.SerializationError{Err: err}
561	}
562	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
563	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateContainerService")
564
565	jsonEncoder := smithyjson.NewEncoder()
566	if err := awsAwsjson11_serializeOpDocumentCreateContainerServiceInput(input, jsonEncoder.Value); err != nil {
567		return out, metadata, &smithy.SerializationError{Err: err}
568	}
569
570	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
571		return out, metadata, &smithy.SerializationError{Err: err}
572	}
573
574	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
575		return out, metadata, &smithy.SerializationError{Err: err}
576	}
577	in.Request = request
578
579	return next.HandleSerialize(ctx, in)
580}
581
582type awsAwsjson11_serializeOpCreateContainerServiceDeployment struct {
583}
584
585func (*awsAwsjson11_serializeOpCreateContainerServiceDeployment) ID() string {
586	return "OperationSerializer"
587}
588
589func (m *awsAwsjson11_serializeOpCreateContainerServiceDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
590	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
591) {
592	request, ok := in.Request.(*smithyhttp.Request)
593	if !ok {
594		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
595	}
596
597	input, ok := in.Parameters.(*CreateContainerServiceDeploymentInput)
598	_ = input
599	if !ok {
600		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
601	}
602
603	request.Request.URL.Path = "/"
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.CreateContainerServiceDeployment")
611
612	jsonEncoder := smithyjson.NewEncoder()
613	if err := awsAwsjson11_serializeOpDocumentCreateContainerServiceDeploymentInput(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	return next.HandleSerialize(ctx, in)
627}
628
629type awsAwsjson11_serializeOpCreateContainerServiceRegistryLogin struct {
630}
631
632func (*awsAwsjson11_serializeOpCreateContainerServiceRegistryLogin) ID() string {
633	return "OperationSerializer"
634}
635
636func (m *awsAwsjson11_serializeOpCreateContainerServiceRegistryLogin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
637	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
638) {
639	request, ok := in.Request.(*smithyhttp.Request)
640	if !ok {
641		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
642	}
643
644	input, ok := in.Parameters.(*CreateContainerServiceRegistryLoginInput)
645	_ = input
646	if !ok {
647		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
648	}
649
650	request.Request.URL.Path = "/"
651	request.Request.Method = "POST"
652	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
653	if err != nil {
654		return out, metadata, &smithy.SerializationError{Err: err}
655	}
656	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
657	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateContainerServiceRegistryLogin")
658
659	jsonEncoder := smithyjson.NewEncoder()
660	if err := awsAwsjson11_serializeOpDocumentCreateContainerServiceRegistryLoginInput(input, jsonEncoder.Value); err != nil {
661		return out, metadata, &smithy.SerializationError{Err: err}
662	}
663
664	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
665		return out, metadata, &smithy.SerializationError{Err: err}
666	}
667
668	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
669		return out, metadata, &smithy.SerializationError{Err: err}
670	}
671	in.Request = request
672
673	return next.HandleSerialize(ctx, in)
674}
675
676type awsAwsjson11_serializeOpCreateDisk struct {
677}
678
679func (*awsAwsjson11_serializeOpCreateDisk) ID() string {
680	return "OperationSerializer"
681}
682
683func (m *awsAwsjson11_serializeOpCreateDisk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
684	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
685) {
686	request, ok := in.Request.(*smithyhttp.Request)
687	if !ok {
688		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
689	}
690
691	input, ok := in.Parameters.(*CreateDiskInput)
692	_ = input
693	if !ok {
694		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
695	}
696
697	request.Request.URL.Path = "/"
698	request.Request.Method = "POST"
699	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
700	if err != nil {
701		return out, metadata, &smithy.SerializationError{Err: err}
702	}
703	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
704	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDisk")
705
706	jsonEncoder := smithyjson.NewEncoder()
707	if err := awsAwsjson11_serializeOpDocumentCreateDiskInput(input, jsonEncoder.Value); err != nil {
708		return out, metadata, &smithy.SerializationError{Err: err}
709	}
710
711	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
712		return out, metadata, &smithy.SerializationError{Err: err}
713	}
714
715	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
716		return out, metadata, &smithy.SerializationError{Err: err}
717	}
718	in.Request = request
719
720	return next.HandleSerialize(ctx, in)
721}
722
723type awsAwsjson11_serializeOpCreateDiskFromSnapshot struct {
724}
725
726func (*awsAwsjson11_serializeOpCreateDiskFromSnapshot) ID() string {
727	return "OperationSerializer"
728}
729
730func (m *awsAwsjson11_serializeOpCreateDiskFromSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
731	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
732) {
733	request, ok := in.Request.(*smithyhttp.Request)
734	if !ok {
735		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
736	}
737
738	input, ok := in.Parameters.(*CreateDiskFromSnapshotInput)
739	_ = input
740	if !ok {
741		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
742	}
743
744	request.Request.URL.Path = "/"
745	request.Request.Method = "POST"
746	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
747	if err != nil {
748		return out, metadata, &smithy.SerializationError{Err: err}
749	}
750	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
751	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDiskFromSnapshot")
752
753	jsonEncoder := smithyjson.NewEncoder()
754	if err := awsAwsjson11_serializeOpDocumentCreateDiskFromSnapshotInput(input, jsonEncoder.Value); err != nil {
755		return out, metadata, &smithy.SerializationError{Err: err}
756	}
757
758	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
759		return out, metadata, &smithy.SerializationError{Err: err}
760	}
761
762	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
763		return out, metadata, &smithy.SerializationError{Err: err}
764	}
765	in.Request = request
766
767	return next.HandleSerialize(ctx, in)
768}
769
770type awsAwsjson11_serializeOpCreateDiskSnapshot struct {
771}
772
773func (*awsAwsjson11_serializeOpCreateDiskSnapshot) ID() string {
774	return "OperationSerializer"
775}
776
777func (m *awsAwsjson11_serializeOpCreateDiskSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
778	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
779) {
780	request, ok := in.Request.(*smithyhttp.Request)
781	if !ok {
782		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
783	}
784
785	input, ok := in.Parameters.(*CreateDiskSnapshotInput)
786	_ = input
787	if !ok {
788		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
789	}
790
791	request.Request.URL.Path = "/"
792	request.Request.Method = "POST"
793	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
794	if err != nil {
795		return out, metadata, &smithy.SerializationError{Err: err}
796	}
797	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
798	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDiskSnapshot")
799
800	jsonEncoder := smithyjson.NewEncoder()
801	if err := awsAwsjson11_serializeOpDocumentCreateDiskSnapshotInput(input, jsonEncoder.Value); err != nil {
802		return out, metadata, &smithy.SerializationError{Err: err}
803	}
804
805	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
806		return out, metadata, &smithy.SerializationError{Err: err}
807	}
808
809	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
810		return out, metadata, &smithy.SerializationError{Err: err}
811	}
812	in.Request = request
813
814	return next.HandleSerialize(ctx, in)
815}
816
817type awsAwsjson11_serializeOpCreateDistribution struct {
818}
819
820func (*awsAwsjson11_serializeOpCreateDistribution) ID() string {
821	return "OperationSerializer"
822}
823
824func (m *awsAwsjson11_serializeOpCreateDistribution) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
825	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
826) {
827	request, ok := in.Request.(*smithyhttp.Request)
828	if !ok {
829		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
830	}
831
832	input, ok := in.Parameters.(*CreateDistributionInput)
833	_ = input
834	if !ok {
835		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
836	}
837
838	request.Request.URL.Path = "/"
839	request.Request.Method = "POST"
840	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
841	if err != nil {
842		return out, metadata, &smithy.SerializationError{Err: err}
843	}
844	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
845	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDistribution")
846
847	jsonEncoder := smithyjson.NewEncoder()
848	if err := awsAwsjson11_serializeOpDocumentCreateDistributionInput(input, jsonEncoder.Value); err != nil {
849		return out, metadata, &smithy.SerializationError{Err: err}
850	}
851
852	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
853		return out, metadata, &smithy.SerializationError{Err: err}
854	}
855
856	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
857		return out, metadata, &smithy.SerializationError{Err: err}
858	}
859	in.Request = request
860
861	return next.HandleSerialize(ctx, in)
862}
863
864type awsAwsjson11_serializeOpCreateDomain struct {
865}
866
867func (*awsAwsjson11_serializeOpCreateDomain) ID() string {
868	return "OperationSerializer"
869}
870
871func (m *awsAwsjson11_serializeOpCreateDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
872	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
873) {
874	request, ok := in.Request.(*smithyhttp.Request)
875	if !ok {
876		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
877	}
878
879	input, ok := in.Parameters.(*CreateDomainInput)
880	_ = input
881	if !ok {
882		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
883	}
884
885	request.Request.URL.Path = "/"
886	request.Request.Method = "POST"
887	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
888	if err != nil {
889		return out, metadata, &smithy.SerializationError{Err: err}
890	}
891	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
892	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDomain")
893
894	jsonEncoder := smithyjson.NewEncoder()
895	if err := awsAwsjson11_serializeOpDocumentCreateDomainInput(input, jsonEncoder.Value); err != nil {
896		return out, metadata, &smithy.SerializationError{Err: err}
897	}
898
899	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
900		return out, metadata, &smithy.SerializationError{Err: err}
901	}
902
903	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
904		return out, metadata, &smithy.SerializationError{Err: err}
905	}
906	in.Request = request
907
908	return next.HandleSerialize(ctx, in)
909}
910
911type awsAwsjson11_serializeOpCreateDomainEntry struct {
912}
913
914func (*awsAwsjson11_serializeOpCreateDomainEntry) ID() string {
915	return "OperationSerializer"
916}
917
918func (m *awsAwsjson11_serializeOpCreateDomainEntry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
919	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
920) {
921	request, ok := in.Request.(*smithyhttp.Request)
922	if !ok {
923		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
924	}
925
926	input, ok := in.Parameters.(*CreateDomainEntryInput)
927	_ = input
928	if !ok {
929		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
930	}
931
932	request.Request.URL.Path = "/"
933	request.Request.Method = "POST"
934	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
935	if err != nil {
936		return out, metadata, &smithy.SerializationError{Err: err}
937	}
938	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
939	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateDomainEntry")
940
941	jsonEncoder := smithyjson.NewEncoder()
942	if err := awsAwsjson11_serializeOpDocumentCreateDomainEntryInput(input, jsonEncoder.Value); err != nil {
943		return out, metadata, &smithy.SerializationError{Err: err}
944	}
945
946	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
947		return out, metadata, &smithy.SerializationError{Err: err}
948	}
949
950	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
951		return out, metadata, &smithy.SerializationError{Err: err}
952	}
953	in.Request = request
954
955	return next.HandleSerialize(ctx, in)
956}
957
958type awsAwsjson11_serializeOpCreateInstances struct {
959}
960
961func (*awsAwsjson11_serializeOpCreateInstances) ID() string {
962	return "OperationSerializer"
963}
964
965func (m *awsAwsjson11_serializeOpCreateInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
966	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
967) {
968	request, ok := in.Request.(*smithyhttp.Request)
969	if !ok {
970		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
971	}
972
973	input, ok := in.Parameters.(*CreateInstancesInput)
974	_ = input
975	if !ok {
976		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
977	}
978
979	request.Request.URL.Path = "/"
980	request.Request.Method = "POST"
981	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
982	if err != nil {
983		return out, metadata, &smithy.SerializationError{Err: err}
984	}
985	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
986	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateInstances")
987
988	jsonEncoder := smithyjson.NewEncoder()
989	if err := awsAwsjson11_serializeOpDocumentCreateInstancesInput(input, jsonEncoder.Value); err != nil {
990		return out, metadata, &smithy.SerializationError{Err: err}
991	}
992
993	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
994		return out, metadata, &smithy.SerializationError{Err: err}
995	}
996
997	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
998		return out, metadata, &smithy.SerializationError{Err: err}
999	}
1000	in.Request = request
1001
1002	return next.HandleSerialize(ctx, in)
1003}
1004
1005type awsAwsjson11_serializeOpCreateInstancesFromSnapshot struct {
1006}
1007
1008func (*awsAwsjson11_serializeOpCreateInstancesFromSnapshot) ID() string {
1009	return "OperationSerializer"
1010}
1011
1012func (m *awsAwsjson11_serializeOpCreateInstancesFromSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1013	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1014) {
1015	request, ok := in.Request.(*smithyhttp.Request)
1016	if !ok {
1017		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1018	}
1019
1020	input, ok := in.Parameters.(*CreateInstancesFromSnapshotInput)
1021	_ = input
1022	if !ok {
1023		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1024	}
1025
1026	request.Request.URL.Path = "/"
1027	request.Request.Method = "POST"
1028	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1029	if err != nil {
1030		return out, metadata, &smithy.SerializationError{Err: err}
1031	}
1032	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1033	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateInstancesFromSnapshot")
1034
1035	jsonEncoder := smithyjson.NewEncoder()
1036	if err := awsAwsjson11_serializeOpDocumentCreateInstancesFromSnapshotInput(input, jsonEncoder.Value); err != nil {
1037		return out, metadata, &smithy.SerializationError{Err: err}
1038	}
1039
1040	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1041		return out, metadata, &smithy.SerializationError{Err: err}
1042	}
1043
1044	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1045		return out, metadata, &smithy.SerializationError{Err: err}
1046	}
1047	in.Request = request
1048
1049	return next.HandleSerialize(ctx, in)
1050}
1051
1052type awsAwsjson11_serializeOpCreateInstanceSnapshot struct {
1053}
1054
1055func (*awsAwsjson11_serializeOpCreateInstanceSnapshot) ID() string {
1056	return "OperationSerializer"
1057}
1058
1059func (m *awsAwsjson11_serializeOpCreateInstanceSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1060	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1061) {
1062	request, ok := in.Request.(*smithyhttp.Request)
1063	if !ok {
1064		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1065	}
1066
1067	input, ok := in.Parameters.(*CreateInstanceSnapshotInput)
1068	_ = input
1069	if !ok {
1070		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1071	}
1072
1073	request.Request.URL.Path = "/"
1074	request.Request.Method = "POST"
1075	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1076	if err != nil {
1077		return out, metadata, &smithy.SerializationError{Err: err}
1078	}
1079	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1080	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateInstanceSnapshot")
1081
1082	jsonEncoder := smithyjson.NewEncoder()
1083	if err := awsAwsjson11_serializeOpDocumentCreateInstanceSnapshotInput(input, jsonEncoder.Value); err != nil {
1084		return out, metadata, &smithy.SerializationError{Err: err}
1085	}
1086
1087	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1088		return out, metadata, &smithy.SerializationError{Err: err}
1089	}
1090
1091	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1092		return out, metadata, &smithy.SerializationError{Err: err}
1093	}
1094	in.Request = request
1095
1096	return next.HandleSerialize(ctx, in)
1097}
1098
1099type awsAwsjson11_serializeOpCreateKeyPair struct {
1100}
1101
1102func (*awsAwsjson11_serializeOpCreateKeyPair) ID() string {
1103	return "OperationSerializer"
1104}
1105
1106func (m *awsAwsjson11_serializeOpCreateKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1107	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1108) {
1109	request, ok := in.Request.(*smithyhttp.Request)
1110	if !ok {
1111		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1112	}
1113
1114	input, ok := in.Parameters.(*CreateKeyPairInput)
1115	_ = input
1116	if !ok {
1117		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1118	}
1119
1120	request.Request.URL.Path = "/"
1121	request.Request.Method = "POST"
1122	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1123	if err != nil {
1124		return out, metadata, &smithy.SerializationError{Err: err}
1125	}
1126	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1127	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateKeyPair")
1128
1129	jsonEncoder := smithyjson.NewEncoder()
1130	if err := awsAwsjson11_serializeOpDocumentCreateKeyPairInput(input, jsonEncoder.Value); err != nil {
1131		return out, metadata, &smithy.SerializationError{Err: err}
1132	}
1133
1134	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1135		return out, metadata, &smithy.SerializationError{Err: err}
1136	}
1137
1138	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1139		return out, metadata, &smithy.SerializationError{Err: err}
1140	}
1141	in.Request = request
1142
1143	return next.HandleSerialize(ctx, in)
1144}
1145
1146type awsAwsjson11_serializeOpCreateLoadBalancer struct {
1147}
1148
1149func (*awsAwsjson11_serializeOpCreateLoadBalancer) ID() string {
1150	return "OperationSerializer"
1151}
1152
1153func (m *awsAwsjson11_serializeOpCreateLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1154	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1155) {
1156	request, ok := in.Request.(*smithyhttp.Request)
1157	if !ok {
1158		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1159	}
1160
1161	input, ok := in.Parameters.(*CreateLoadBalancerInput)
1162	_ = input
1163	if !ok {
1164		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1165	}
1166
1167	request.Request.URL.Path = "/"
1168	request.Request.Method = "POST"
1169	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1170	if err != nil {
1171		return out, metadata, &smithy.SerializationError{Err: err}
1172	}
1173	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1174	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateLoadBalancer")
1175
1176	jsonEncoder := smithyjson.NewEncoder()
1177	if err := awsAwsjson11_serializeOpDocumentCreateLoadBalancerInput(input, jsonEncoder.Value); err != nil {
1178		return out, metadata, &smithy.SerializationError{Err: err}
1179	}
1180
1181	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1182		return out, metadata, &smithy.SerializationError{Err: err}
1183	}
1184
1185	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1186		return out, metadata, &smithy.SerializationError{Err: err}
1187	}
1188	in.Request = request
1189
1190	return next.HandleSerialize(ctx, in)
1191}
1192
1193type awsAwsjson11_serializeOpCreateLoadBalancerTlsCertificate struct {
1194}
1195
1196func (*awsAwsjson11_serializeOpCreateLoadBalancerTlsCertificate) ID() string {
1197	return "OperationSerializer"
1198}
1199
1200func (m *awsAwsjson11_serializeOpCreateLoadBalancerTlsCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1201	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	request, ok := in.Request.(*smithyhttp.Request)
1204	if !ok {
1205		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1206	}
1207
1208	input, ok := in.Parameters.(*CreateLoadBalancerTlsCertificateInput)
1209	_ = input
1210	if !ok {
1211		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1212	}
1213
1214	request.Request.URL.Path = "/"
1215	request.Request.Method = "POST"
1216	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1217	if err != nil {
1218		return out, metadata, &smithy.SerializationError{Err: err}
1219	}
1220	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1221	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateLoadBalancerTlsCertificate")
1222
1223	jsonEncoder := smithyjson.NewEncoder()
1224	if err := awsAwsjson11_serializeOpDocumentCreateLoadBalancerTlsCertificateInput(input, jsonEncoder.Value); err != nil {
1225		return out, metadata, &smithy.SerializationError{Err: err}
1226	}
1227
1228	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1229		return out, metadata, &smithy.SerializationError{Err: err}
1230	}
1231
1232	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1233		return out, metadata, &smithy.SerializationError{Err: err}
1234	}
1235	in.Request = request
1236
1237	return next.HandleSerialize(ctx, in)
1238}
1239
1240type awsAwsjson11_serializeOpCreateRelationalDatabase struct {
1241}
1242
1243func (*awsAwsjson11_serializeOpCreateRelationalDatabase) ID() string {
1244	return "OperationSerializer"
1245}
1246
1247func (m *awsAwsjson11_serializeOpCreateRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1248	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1249) {
1250	request, ok := in.Request.(*smithyhttp.Request)
1251	if !ok {
1252		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1253	}
1254
1255	input, ok := in.Parameters.(*CreateRelationalDatabaseInput)
1256	_ = input
1257	if !ok {
1258		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1259	}
1260
1261	request.Request.URL.Path = "/"
1262	request.Request.Method = "POST"
1263	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1264	if err != nil {
1265		return out, metadata, &smithy.SerializationError{Err: err}
1266	}
1267	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1268	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateRelationalDatabase")
1269
1270	jsonEncoder := smithyjson.NewEncoder()
1271	if err := awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
1272		return out, metadata, &smithy.SerializationError{Err: err}
1273	}
1274
1275	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1276		return out, metadata, &smithy.SerializationError{Err: err}
1277	}
1278
1279	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1280		return out, metadata, &smithy.SerializationError{Err: err}
1281	}
1282	in.Request = request
1283
1284	return next.HandleSerialize(ctx, in)
1285}
1286
1287type awsAwsjson11_serializeOpCreateRelationalDatabaseFromSnapshot struct {
1288}
1289
1290func (*awsAwsjson11_serializeOpCreateRelationalDatabaseFromSnapshot) ID() string {
1291	return "OperationSerializer"
1292}
1293
1294func (m *awsAwsjson11_serializeOpCreateRelationalDatabaseFromSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1295	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1296) {
1297	request, ok := in.Request.(*smithyhttp.Request)
1298	if !ok {
1299		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1300	}
1301
1302	input, ok := in.Parameters.(*CreateRelationalDatabaseFromSnapshotInput)
1303	_ = input
1304	if !ok {
1305		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1306	}
1307
1308	request.Request.URL.Path = "/"
1309	request.Request.Method = "POST"
1310	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1311	if err != nil {
1312		return out, metadata, &smithy.SerializationError{Err: err}
1313	}
1314	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1315	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateRelationalDatabaseFromSnapshot")
1316
1317	jsonEncoder := smithyjson.NewEncoder()
1318	if err := awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseFromSnapshotInput(input, jsonEncoder.Value); err != nil {
1319		return out, metadata, &smithy.SerializationError{Err: err}
1320	}
1321
1322	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1323		return out, metadata, &smithy.SerializationError{Err: err}
1324	}
1325
1326	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1327		return out, metadata, &smithy.SerializationError{Err: err}
1328	}
1329	in.Request = request
1330
1331	return next.HandleSerialize(ctx, in)
1332}
1333
1334type awsAwsjson11_serializeOpCreateRelationalDatabaseSnapshot struct {
1335}
1336
1337func (*awsAwsjson11_serializeOpCreateRelationalDatabaseSnapshot) ID() string {
1338	return "OperationSerializer"
1339}
1340
1341func (m *awsAwsjson11_serializeOpCreateRelationalDatabaseSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1342	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1343) {
1344	request, ok := in.Request.(*smithyhttp.Request)
1345	if !ok {
1346		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1347	}
1348
1349	input, ok := in.Parameters.(*CreateRelationalDatabaseSnapshotInput)
1350	_ = input
1351	if !ok {
1352		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1353	}
1354
1355	request.Request.URL.Path = "/"
1356	request.Request.Method = "POST"
1357	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1358	if err != nil {
1359		return out, metadata, &smithy.SerializationError{Err: err}
1360	}
1361	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1362	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.CreateRelationalDatabaseSnapshot")
1363
1364	jsonEncoder := smithyjson.NewEncoder()
1365	if err := awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseSnapshotInput(input, jsonEncoder.Value); err != nil {
1366		return out, metadata, &smithy.SerializationError{Err: err}
1367	}
1368
1369	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1370		return out, metadata, &smithy.SerializationError{Err: err}
1371	}
1372
1373	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1374		return out, metadata, &smithy.SerializationError{Err: err}
1375	}
1376	in.Request = request
1377
1378	return next.HandleSerialize(ctx, in)
1379}
1380
1381type awsAwsjson11_serializeOpDeleteAlarm struct {
1382}
1383
1384func (*awsAwsjson11_serializeOpDeleteAlarm) ID() string {
1385	return "OperationSerializer"
1386}
1387
1388func (m *awsAwsjson11_serializeOpDeleteAlarm) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1389	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1390) {
1391	request, ok := in.Request.(*smithyhttp.Request)
1392	if !ok {
1393		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1394	}
1395
1396	input, ok := in.Parameters.(*DeleteAlarmInput)
1397	_ = input
1398	if !ok {
1399		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1400	}
1401
1402	request.Request.URL.Path = "/"
1403	request.Request.Method = "POST"
1404	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1405	if err != nil {
1406		return out, metadata, &smithy.SerializationError{Err: err}
1407	}
1408	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1409	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteAlarm")
1410
1411	jsonEncoder := smithyjson.NewEncoder()
1412	if err := awsAwsjson11_serializeOpDocumentDeleteAlarmInput(input, jsonEncoder.Value); err != nil {
1413		return out, metadata, &smithy.SerializationError{Err: err}
1414	}
1415
1416	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1417		return out, metadata, &smithy.SerializationError{Err: err}
1418	}
1419
1420	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1421		return out, metadata, &smithy.SerializationError{Err: err}
1422	}
1423	in.Request = request
1424
1425	return next.HandleSerialize(ctx, in)
1426}
1427
1428type awsAwsjson11_serializeOpDeleteAutoSnapshot struct {
1429}
1430
1431func (*awsAwsjson11_serializeOpDeleteAutoSnapshot) ID() string {
1432	return "OperationSerializer"
1433}
1434
1435func (m *awsAwsjson11_serializeOpDeleteAutoSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1436	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1437) {
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.(*DeleteAutoSnapshotInput)
1444	_ = input
1445	if !ok {
1446		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1447	}
1448
1449	request.Request.URL.Path = "/"
1450	request.Request.Method = "POST"
1451	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1452	if err != nil {
1453		return out, metadata, &smithy.SerializationError{Err: err}
1454	}
1455	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1456	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteAutoSnapshot")
1457
1458	jsonEncoder := smithyjson.NewEncoder()
1459	if err := awsAwsjson11_serializeOpDocumentDeleteAutoSnapshotInput(input, jsonEncoder.Value); err != nil {
1460		return out, metadata, &smithy.SerializationError{Err: err}
1461	}
1462
1463	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1464		return out, metadata, &smithy.SerializationError{Err: err}
1465	}
1466
1467	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1468		return out, metadata, &smithy.SerializationError{Err: err}
1469	}
1470	in.Request = request
1471
1472	return next.HandleSerialize(ctx, in)
1473}
1474
1475type awsAwsjson11_serializeOpDeleteCertificate struct {
1476}
1477
1478func (*awsAwsjson11_serializeOpDeleteCertificate) ID() string {
1479	return "OperationSerializer"
1480}
1481
1482func (m *awsAwsjson11_serializeOpDeleteCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1483	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1484) {
1485	request, ok := in.Request.(*smithyhttp.Request)
1486	if !ok {
1487		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1488	}
1489
1490	input, ok := in.Parameters.(*DeleteCertificateInput)
1491	_ = input
1492	if !ok {
1493		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1494	}
1495
1496	request.Request.URL.Path = "/"
1497	request.Request.Method = "POST"
1498	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1499	if err != nil {
1500		return out, metadata, &smithy.SerializationError{Err: err}
1501	}
1502	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1503	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteCertificate")
1504
1505	jsonEncoder := smithyjson.NewEncoder()
1506	if err := awsAwsjson11_serializeOpDocumentDeleteCertificateInput(input, jsonEncoder.Value); err != nil {
1507		return out, metadata, &smithy.SerializationError{Err: err}
1508	}
1509
1510	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1511		return out, metadata, &smithy.SerializationError{Err: err}
1512	}
1513
1514	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1515		return out, metadata, &smithy.SerializationError{Err: err}
1516	}
1517	in.Request = request
1518
1519	return next.HandleSerialize(ctx, in)
1520}
1521
1522type awsAwsjson11_serializeOpDeleteContactMethod struct {
1523}
1524
1525func (*awsAwsjson11_serializeOpDeleteContactMethod) ID() string {
1526	return "OperationSerializer"
1527}
1528
1529func (m *awsAwsjson11_serializeOpDeleteContactMethod) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1530	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1531) {
1532	request, ok := in.Request.(*smithyhttp.Request)
1533	if !ok {
1534		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1535	}
1536
1537	input, ok := in.Parameters.(*DeleteContactMethodInput)
1538	_ = input
1539	if !ok {
1540		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1541	}
1542
1543	request.Request.URL.Path = "/"
1544	request.Request.Method = "POST"
1545	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1546	if err != nil {
1547		return out, metadata, &smithy.SerializationError{Err: err}
1548	}
1549	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1550	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteContactMethod")
1551
1552	jsonEncoder := smithyjson.NewEncoder()
1553	if err := awsAwsjson11_serializeOpDocumentDeleteContactMethodInput(input, jsonEncoder.Value); err != nil {
1554		return out, metadata, &smithy.SerializationError{Err: err}
1555	}
1556
1557	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1558		return out, metadata, &smithy.SerializationError{Err: err}
1559	}
1560
1561	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1562		return out, metadata, &smithy.SerializationError{Err: err}
1563	}
1564	in.Request = request
1565
1566	return next.HandleSerialize(ctx, in)
1567}
1568
1569type awsAwsjson11_serializeOpDeleteContainerImage struct {
1570}
1571
1572func (*awsAwsjson11_serializeOpDeleteContainerImage) ID() string {
1573	return "OperationSerializer"
1574}
1575
1576func (m *awsAwsjson11_serializeOpDeleteContainerImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1577	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1578) {
1579	request, ok := in.Request.(*smithyhttp.Request)
1580	if !ok {
1581		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1582	}
1583
1584	input, ok := in.Parameters.(*DeleteContainerImageInput)
1585	_ = input
1586	if !ok {
1587		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1588	}
1589
1590	request.Request.URL.Path = "/"
1591	request.Request.Method = "POST"
1592	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1593	if err != nil {
1594		return out, metadata, &smithy.SerializationError{Err: err}
1595	}
1596	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1597	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteContainerImage")
1598
1599	jsonEncoder := smithyjson.NewEncoder()
1600	if err := awsAwsjson11_serializeOpDocumentDeleteContainerImageInput(input, jsonEncoder.Value); err != nil {
1601		return out, metadata, &smithy.SerializationError{Err: err}
1602	}
1603
1604	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1605		return out, metadata, &smithy.SerializationError{Err: err}
1606	}
1607
1608	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1609		return out, metadata, &smithy.SerializationError{Err: err}
1610	}
1611	in.Request = request
1612
1613	return next.HandleSerialize(ctx, in)
1614}
1615
1616type awsAwsjson11_serializeOpDeleteContainerService struct {
1617}
1618
1619func (*awsAwsjson11_serializeOpDeleteContainerService) ID() string {
1620	return "OperationSerializer"
1621}
1622
1623func (m *awsAwsjson11_serializeOpDeleteContainerService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1624	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1625) {
1626	request, ok := in.Request.(*smithyhttp.Request)
1627	if !ok {
1628		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1629	}
1630
1631	input, ok := in.Parameters.(*DeleteContainerServiceInput)
1632	_ = input
1633	if !ok {
1634		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1635	}
1636
1637	request.Request.URL.Path = "/"
1638	request.Request.Method = "POST"
1639	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1640	if err != nil {
1641		return out, metadata, &smithy.SerializationError{Err: err}
1642	}
1643	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1644	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteContainerService")
1645
1646	jsonEncoder := smithyjson.NewEncoder()
1647	if err := awsAwsjson11_serializeOpDocumentDeleteContainerServiceInput(input, jsonEncoder.Value); err != nil {
1648		return out, metadata, &smithy.SerializationError{Err: err}
1649	}
1650
1651	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1652		return out, metadata, &smithy.SerializationError{Err: err}
1653	}
1654
1655	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1656		return out, metadata, &smithy.SerializationError{Err: err}
1657	}
1658	in.Request = request
1659
1660	return next.HandleSerialize(ctx, in)
1661}
1662
1663type awsAwsjson11_serializeOpDeleteDisk struct {
1664}
1665
1666func (*awsAwsjson11_serializeOpDeleteDisk) ID() string {
1667	return "OperationSerializer"
1668}
1669
1670func (m *awsAwsjson11_serializeOpDeleteDisk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1671	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1672) {
1673	request, ok := in.Request.(*smithyhttp.Request)
1674	if !ok {
1675		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1676	}
1677
1678	input, ok := in.Parameters.(*DeleteDiskInput)
1679	_ = input
1680	if !ok {
1681		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1682	}
1683
1684	request.Request.URL.Path = "/"
1685	request.Request.Method = "POST"
1686	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1687	if err != nil {
1688		return out, metadata, &smithy.SerializationError{Err: err}
1689	}
1690	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1691	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteDisk")
1692
1693	jsonEncoder := smithyjson.NewEncoder()
1694	if err := awsAwsjson11_serializeOpDocumentDeleteDiskInput(input, jsonEncoder.Value); err != nil {
1695		return out, metadata, &smithy.SerializationError{Err: err}
1696	}
1697
1698	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1699		return out, metadata, &smithy.SerializationError{Err: err}
1700	}
1701
1702	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1703		return out, metadata, &smithy.SerializationError{Err: err}
1704	}
1705	in.Request = request
1706
1707	return next.HandleSerialize(ctx, in)
1708}
1709
1710type awsAwsjson11_serializeOpDeleteDiskSnapshot struct {
1711}
1712
1713func (*awsAwsjson11_serializeOpDeleteDiskSnapshot) ID() string {
1714	return "OperationSerializer"
1715}
1716
1717func (m *awsAwsjson11_serializeOpDeleteDiskSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1718	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1719) {
1720	request, ok := in.Request.(*smithyhttp.Request)
1721	if !ok {
1722		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1723	}
1724
1725	input, ok := in.Parameters.(*DeleteDiskSnapshotInput)
1726	_ = input
1727	if !ok {
1728		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1729	}
1730
1731	request.Request.URL.Path = "/"
1732	request.Request.Method = "POST"
1733	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1734	if err != nil {
1735		return out, metadata, &smithy.SerializationError{Err: err}
1736	}
1737	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1738	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteDiskSnapshot")
1739
1740	jsonEncoder := smithyjson.NewEncoder()
1741	if err := awsAwsjson11_serializeOpDocumentDeleteDiskSnapshotInput(input, jsonEncoder.Value); err != nil {
1742		return out, metadata, &smithy.SerializationError{Err: err}
1743	}
1744
1745	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1746		return out, metadata, &smithy.SerializationError{Err: err}
1747	}
1748
1749	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1750		return out, metadata, &smithy.SerializationError{Err: err}
1751	}
1752	in.Request = request
1753
1754	return next.HandleSerialize(ctx, in)
1755}
1756
1757type awsAwsjson11_serializeOpDeleteDistribution struct {
1758}
1759
1760func (*awsAwsjson11_serializeOpDeleteDistribution) ID() string {
1761	return "OperationSerializer"
1762}
1763
1764func (m *awsAwsjson11_serializeOpDeleteDistribution) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1765	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1766) {
1767	request, ok := in.Request.(*smithyhttp.Request)
1768	if !ok {
1769		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1770	}
1771
1772	input, ok := in.Parameters.(*DeleteDistributionInput)
1773	_ = input
1774	if !ok {
1775		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1776	}
1777
1778	request.Request.URL.Path = "/"
1779	request.Request.Method = "POST"
1780	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1781	if err != nil {
1782		return out, metadata, &smithy.SerializationError{Err: err}
1783	}
1784	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1785	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteDistribution")
1786
1787	jsonEncoder := smithyjson.NewEncoder()
1788	if err := awsAwsjson11_serializeOpDocumentDeleteDistributionInput(input, jsonEncoder.Value); err != nil {
1789		return out, metadata, &smithy.SerializationError{Err: err}
1790	}
1791
1792	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1793		return out, metadata, &smithy.SerializationError{Err: err}
1794	}
1795
1796	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1797		return out, metadata, &smithy.SerializationError{Err: err}
1798	}
1799	in.Request = request
1800
1801	return next.HandleSerialize(ctx, in)
1802}
1803
1804type awsAwsjson11_serializeOpDeleteDomain struct {
1805}
1806
1807func (*awsAwsjson11_serializeOpDeleteDomain) ID() string {
1808	return "OperationSerializer"
1809}
1810
1811func (m *awsAwsjson11_serializeOpDeleteDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1812	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1813) {
1814	request, ok := in.Request.(*smithyhttp.Request)
1815	if !ok {
1816		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1817	}
1818
1819	input, ok := in.Parameters.(*DeleteDomainInput)
1820	_ = input
1821	if !ok {
1822		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1823	}
1824
1825	request.Request.URL.Path = "/"
1826	request.Request.Method = "POST"
1827	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1828	if err != nil {
1829		return out, metadata, &smithy.SerializationError{Err: err}
1830	}
1831	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1832	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteDomain")
1833
1834	jsonEncoder := smithyjson.NewEncoder()
1835	if err := awsAwsjson11_serializeOpDocumentDeleteDomainInput(input, jsonEncoder.Value); err != nil {
1836		return out, metadata, &smithy.SerializationError{Err: err}
1837	}
1838
1839	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1840		return out, metadata, &smithy.SerializationError{Err: err}
1841	}
1842
1843	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1844		return out, metadata, &smithy.SerializationError{Err: err}
1845	}
1846	in.Request = request
1847
1848	return next.HandleSerialize(ctx, in)
1849}
1850
1851type awsAwsjson11_serializeOpDeleteDomainEntry struct {
1852}
1853
1854func (*awsAwsjson11_serializeOpDeleteDomainEntry) ID() string {
1855	return "OperationSerializer"
1856}
1857
1858func (m *awsAwsjson11_serializeOpDeleteDomainEntry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1859	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1860) {
1861	request, ok := in.Request.(*smithyhttp.Request)
1862	if !ok {
1863		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1864	}
1865
1866	input, ok := in.Parameters.(*DeleteDomainEntryInput)
1867	_ = input
1868	if !ok {
1869		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1870	}
1871
1872	request.Request.URL.Path = "/"
1873	request.Request.Method = "POST"
1874	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1875	if err != nil {
1876		return out, metadata, &smithy.SerializationError{Err: err}
1877	}
1878	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1879	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteDomainEntry")
1880
1881	jsonEncoder := smithyjson.NewEncoder()
1882	if err := awsAwsjson11_serializeOpDocumentDeleteDomainEntryInput(input, jsonEncoder.Value); err != nil {
1883		return out, metadata, &smithy.SerializationError{Err: err}
1884	}
1885
1886	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1887		return out, metadata, &smithy.SerializationError{Err: err}
1888	}
1889
1890	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1891		return out, metadata, &smithy.SerializationError{Err: err}
1892	}
1893	in.Request = request
1894
1895	return next.HandleSerialize(ctx, in)
1896}
1897
1898type awsAwsjson11_serializeOpDeleteInstance struct {
1899}
1900
1901func (*awsAwsjson11_serializeOpDeleteInstance) ID() string {
1902	return "OperationSerializer"
1903}
1904
1905func (m *awsAwsjson11_serializeOpDeleteInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1906	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1907) {
1908	request, ok := in.Request.(*smithyhttp.Request)
1909	if !ok {
1910		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1911	}
1912
1913	input, ok := in.Parameters.(*DeleteInstanceInput)
1914	_ = input
1915	if !ok {
1916		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1917	}
1918
1919	request.Request.URL.Path = "/"
1920	request.Request.Method = "POST"
1921	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1922	if err != nil {
1923		return out, metadata, &smithy.SerializationError{Err: err}
1924	}
1925	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1926	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteInstance")
1927
1928	jsonEncoder := smithyjson.NewEncoder()
1929	if err := awsAwsjson11_serializeOpDocumentDeleteInstanceInput(input, jsonEncoder.Value); err != nil {
1930		return out, metadata, &smithy.SerializationError{Err: err}
1931	}
1932
1933	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1934		return out, metadata, &smithy.SerializationError{Err: err}
1935	}
1936
1937	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1938		return out, metadata, &smithy.SerializationError{Err: err}
1939	}
1940	in.Request = request
1941
1942	return next.HandleSerialize(ctx, in)
1943}
1944
1945type awsAwsjson11_serializeOpDeleteInstanceSnapshot struct {
1946}
1947
1948func (*awsAwsjson11_serializeOpDeleteInstanceSnapshot) ID() string {
1949	return "OperationSerializer"
1950}
1951
1952func (m *awsAwsjson11_serializeOpDeleteInstanceSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1953	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1954) {
1955	request, ok := in.Request.(*smithyhttp.Request)
1956	if !ok {
1957		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1958	}
1959
1960	input, ok := in.Parameters.(*DeleteInstanceSnapshotInput)
1961	_ = input
1962	if !ok {
1963		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1964	}
1965
1966	request.Request.URL.Path = "/"
1967	request.Request.Method = "POST"
1968	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1969	if err != nil {
1970		return out, metadata, &smithy.SerializationError{Err: err}
1971	}
1972	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1973	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteInstanceSnapshot")
1974
1975	jsonEncoder := smithyjson.NewEncoder()
1976	if err := awsAwsjson11_serializeOpDocumentDeleteInstanceSnapshotInput(input, jsonEncoder.Value); err != nil {
1977		return out, metadata, &smithy.SerializationError{Err: err}
1978	}
1979
1980	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1981		return out, metadata, &smithy.SerializationError{Err: err}
1982	}
1983
1984	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1985		return out, metadata, &smithy.SerializationError{Err: err}
1986	}
1987	in.Request = request
1988
1989	return next.HandleSerialize(ctx, in)
1990}
1991
1992type awsAwsjson11_serializeOpDeleteKeyPair struct {
1993}
1994
1995func (*awsAwsjson11_serializeOpDeleteKeyPair) ID() string {
1996	return "OperationSerializer"
1997}
1998
1999func (m *awsAwsjson11_serializeOpDeleteKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2000	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2001) {
2002	request, ok := in.Request.(*smithyhttp.Request)
2003	if !ok {
2004		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2005	}
2006
2007	input, ok := in.Parameters.(*DeleteKeyPairInput)
2008	_ = input
2009	if !ok {
2010		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2011	}
2012
2013	request.Request.URL.Path = "/"
2014	request.Request.Method = "POST"
2015	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2016	if err != nil {
2017		return out, metadata, &smithy.SerializationError{Err: err}
2018	}
2019	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2020	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteKeyPair")
2021
2022	jsonEncoder := smithyjson.NewEncoder()
2023	if err := awsAwsjson11_serializeOpDocumentDeleteKeyPairInput(input, jsonEncoder.Value); err != nil {
2024		return out, metadata, &smithy.SerializationError{Err: err}
2025	}
2026
2027	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2028		return out, metadata, &smithy.SerializationError{Err: err}
2029	}
2030
2031	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2032		return out, metadata, &smithy.SerializationError{Err: err}
2033	}
2034	in.Request = request
2035
2036	return next.HandleSerialize(ctx, in)
2037}
2038
2039type awsAwsjson11_serializeOpDeleteKnownHostKeys struct {
2040}
2041
2042func (*awsAwsjson11_serializeOpDeleteKnownHostKeys) ID() string {
2043	return "OperationSerializer"
2044}
2045
2046func (m *awsAwsjson11_serializeOpDeleteKnownHostKeys) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2047	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2048) {
2049	request, ok := in.Request.(*smithyhttp.Request)
2050	if !ok {
2051		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2052	}
2053
2054	input, ok := in.Parameters.(*DeleteKnownHostKeysInput)
2055	_ = input
2056	if !ok {
2057		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2058	}
2059
2060	request.Request.URL.Path = "/"
2061	request.Request.Method = "POST"
2062	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2063	if err != nil {
2064		return out, metadata, &smithy.SerializationError{Err: err}
2065	}
2066	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2067	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteKnownHostKeys")
2068
2069	jsonEncoder := smithyjson.NewEncoder()
2070	if err := awsAwsjson11_serializeOpDocumentDeleteKnownHostKeysInput(input, jsonEncoder.Value); err != nil {
2071		return out, metadata, &smithy.SerializationError{Err: err}
2072	}
2073
2074	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2075		return out, metadata, &smithy.SerializationError{Err: err}
2076	}
2077
2078	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2079		return out, metadata, &smithy.SerializationError{Err: err}
2080	}
2081	in.Request = request
2082
2083	return next.HandleSerialize(ctx, in)
2084}
2085
2086type awsAwsjson11_serializeOpDeleteLoadBalancer struct {
2087}
2088
2089func (*awsAwsjson11_serializeOpDeleteLoadBalancer) ID() string {
2090	return "OperationSerializer"
2091}
2092
2093func (m *awsAwsjson11_serializeOpDeleteLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2094	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2095) {
2096	request, ok := in.Request.(*smithyhttp.Request)
2097	if !ok {
2098		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2099	}
2100
2101	input, ok := in.Parameters.(*DeleteLoadBalancerInput)
2102	_ = input
2103	if !ok {
2104		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2105	}
2106
2107	request.Request.URL.Path = "/"
2108	request.Request.Method = "POST"
2109	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2110	if err != nil {
2111		return out, metadata, &smithy.SerializationError{Err: err}
2112	}
2113	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2114	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteLoadBalancer")
2115
2116	jsonEncoder := smithyjson.NewEncoder()
2117	if err := awsAwsjson11_serializeOpDocumentDeleteLoadBalancerInput(input, jsonEncoder.Value); err != nil {
2118		return out, metadata, &smithy.SerializationError{Err: err}
2119	}
2120
2121	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2122		return out, metadata, &smithy.SerializationError{Err: err}
2123	}
2124
2125	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2126		return out, metadata, &smithy.SerializationError{Err: err}
2127	}
2128	in.Request = request
2129
2130	return next.HandleSerialize(ctx, in)
2131}
2132
2133type awsAwsjson11_serializeOpDeleteLoadBalancerTlsCertificate struct {
2134}
2135
2136func (*awsAwsjson11_serializeOpDeleteLoadBalancerTlsCertificate) ID() string {
2137	return "OperationSerializer"
2138}
2139
2140func (m *awsAwsjson11_serializeOpDeleteLoadBalancerTlsCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2141	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2142) {
2143	request, ok := in.Request.(*smithyhttp.Request)
2144	if !ok {
2145		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2146	}
2147
2148	input, ok := in.Parameters.(*DeleteLoadBalancerTlsCertificateInput)
2149	_ = input
2150	if !ok {
2151		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2152	}
2153
2154	request.Request.URL.Path = "/"
2155	request.Request.Method = "POST"
2156	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2157	if err != nil {
2158		return out, metadata, &smithy.SerializationError{Err: err}
2159	}
2160	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2161	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteLoadBalancerTlsCertificate")
2162
2163	jsonEncoder := smithyjson.NewEncoder()
2164	if err := awsAwsjson11_serializeOpDocumentDeleteLoadBalancerTlsCertificateInput(input, jsonEncoder.Value); err != nil {
2165		return out, metadata, &smithy.SerializationError{Err: err}
2166	}
2167
2168	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2169		return out, metadata, &smithy.SerializationError{Err: err}
2170	}
2171
2172	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2173		return out, metadata, &smithy.SerializationError{Err: err}
2174	}
2175	in.Request = request
2176
2177	return next.HandleSerialize(ctx, in)
2178}
2179
2180type awsAwsjson11_serializeOpDeleteRelationalDatabase struct {
2181}
2182
2183func (*awsAwsjson11_serializeOpDeleteRelationalDatabase) ID() string {
2184	return "OperationSerializer"
2185}
2186
2187func (m *awsAwsjson11_serializeOpDeleteRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2188	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2189) {
2190	request, ok := in.Request.(*smithyhttp.Request)
2191	if !ok {
2192		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2193	}
2194
2195	input, ok := in.Parameters.(*DeleteRelationalDatabaseInput)
2196	_ = input
2197	if !ok {
2198		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2199	}
2200
2201	request.Request.URL.Path = "/"
2202	request.Request.Method = "POST"
2203	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2204	if err != nil {
2205		return out, metadata, &smithy.SerializationError{Err: err}
2206	}
2207	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2208	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteRelationalDatabase")
2209
2210	jsonEncoder := smithyjson.NewEncoder()
2211	if err := awsAwsjson11_serializeOpDocumentDeleteRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
2212		return out, metadata, &smithy.SerializationError{Err: err}
2213	}
2214
2215	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2216		return out, metadata, &smithy.SerializationError{Err: err}
2217	}
2218
2219	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2220		return out, metadata, &smithy.SerializationError{Err: err}
2221	}
2222	in.Request = request
2223
2224	return next.HandleSerialize(ctx, in)
2225}
2226
2227type awsAwsjson11_serializeOpDeleteRelationalDatabaseSnapshot struct {
2228}
2229
2230func (*awsAwsjson11_serializeOpDeleteRelationalDatabaseSnapshot) ID() string {
2231	return "OperationSerializer"
2232}
2233
2234func (m *awsAwsjson11_serializeOpDeleteRelationalDatabaseSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2235	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2236) {
2237	request, ok := in.Request.(*smithyhttp.Request)
2238	if !ok {
2239		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2240	}
2241
2242	input, ok := in.Parameters.(*DeleteRelationalDatabaseSnapshotInput)
2243	_ = input
2244	if !ok {
2245		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2246	}
2247
2248	request.Request.URL.Path = "/"
2249	request.Request.Method = "POST"
2250	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2251	if err != nil {
2252		return out, metadata, &smithy.SerializationError{Err: err}
2253	}
2254	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2255	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DeleteRelationalDatabaseSnapshot")
2256
2257	jsonEncoder := smithyjson.NewEncoder()
2258	if err := awsAwsjson11_serializeOpDocumentDeleteRelationalDatabaseSnapshotInput(input, jsonEncoder.Value); err != nil {
2259		return out, metadata, &smithy.SerializationError{Err: err}
2260	}
2261
2262	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2263		return out, metadata, &smithy.SerializationError{Err: err}
2264	}
2265
2266	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2267		return out, metadata, &smithy.SerializationError{Err: err}
2268	}
2269	in.Request = request
2270
2271	return next.HandleSerialize(ctx, in)
2272}
2273
2274type awsAwsjson11_serializeOpDetachCertificateFromDistribution struct {
2275}
2276
2277func (*awsAwsjson11_serializeOpDetachCertificateFromDistribution) ID() string {
2278	return "OperationSerializer"
2279}
2280
2281func (m *awsAwsjson11_serializeOpDetachCertificateFromDistribution) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2282	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2283) {
2284	request, ok := in.Request.(*smithyhttp.Request)
2285	if !ok {
2286		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2287	}
2288
2289	input, ok := in.Parameters.(*DetachCertificateFromDistributionInput)
2290	_ = input
2291	if !ok {
2292		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2293	}
2294
2295	request.Request.URL.Path = "/"
2296	request.Request.Method = "POST"
2297	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2298	if err != nil {
2299		return out, metadata, &smithy.SerializationError{Err: err}
2300	}
2301	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2302	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DetachCertificateFromDistribution")
2303
2304	jsonEncoder := smithyjson.NewEncoder()
2305	if err := awsAwsjson11_serializeOpDocumentDetachCertificateFromDistributionInput(input, jsonEncoder.Value); err != nil {
2306		return out, metadata, &smithy.SerializationError{Err: err}
2307	}
2308
2309	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2310		return out, metadata, &smithy.SerializationError{Err: err}
2311	}
2312
2313	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2314		return out, metadata, &smithy.SerializationError{Err: err}
2315	}
2316	in.Request = request
2317
2318	return next.HandleSerialize(ctx, in)
2319}
2320
2321type awsAwsjson11_serializeOpDetachDisk struct {
2322}
2323
2324func (*awsAwsjson11_serializeOpDetachDisk) ID() string {
2325	return "OperationSerializer"
2326}
2327
2328func (m *awsAwsjson11_serializeOpDetachDisk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2329	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2330) {
2331	request, ok := in.Request.(*smithyhttp.Request)
2332	if !ok {
2333		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2334	}
2335
2336	input, ok := in.Parameters.(*DetachDiskInput)
2337	_ = input
2338	if !ok {
2339		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2340	}
2341
2342	request.Request.URL.Path = "/"
2343	request.Request.Method = "POST"
2344	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2345	if err != nil {
2346		return out, metadata, &smithy.SerializationError{Err: err}
2347	}
2348	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2349	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DetachDisk")
2350
2351	jsonEncoder := smithyjson.NewEncoder()
2352	if err := awsAwsjson11_serializeOpDocumentDetachDiskInput(input, jsonEncoder.Value); err != nil {
2353		return out, metadata, &smithy.SerializationError{Err: err}
2354	}
2355
2356	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2357		return out, metadata, &smithy.SerializationError{Err: err}
2358	}
2359
2360	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2361		return out, metadata, &smithy.SerializationError{Err: err}
2362	}
2363	in.Request = request
2364
2365	return next.HandleSerialize(ctx, in)
2366}
2367
2368type awsAwsjson11_serializeOpDetachInstancesFromLoadBalancer struct {
2369}
2370
2371func (*awsAwsjson11_serializeOpDetachInstancesFromLoadBalancer) ID() string {
2372	return "OperationSerializer"
2373}
2374
2375func (m *awsAwsjson11_serializeOpDetachInstancesFromLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2376	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2377) {
2378	request, ok := in.Request.(*smithyhttp.Request)
2379	if !ok {
2380		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2381	}
2382
2383	input, ok := in.Parameters.(*DetachInstancesFromLoadBalancerInput)
2384	_ = input
2385	if !ok {
2386		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2387	}
2388
2389	request.Request.URL.Path = "/"
2390	request.Request.Method = "POST"
2391	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2392	if err != nil {
2393		return out, metadata, &smithy.SerializationError{Err: err}
2394	}
2395	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2396	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DetachInstancesFromLoadBalancer")
2397
2398	jsonEncoder := smithyjson.NewEncoder()
2399	if err := awsAwsjson11_serializeOpDocumentDetachInstancesFromLoadBalancerInput(input, jsonEncoder.Value); err != nil {
2400		return out, metadata, &smithy.SerializationError{Err: err}
2401	}
2402
2403	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2404		return out, metadata, &smithy.SerializationError{Err: err}
2405	}
2406
2407	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2408		return out, metadata, &smithy.SerializationError{Err: err}
2409	}
2410	in.Request = request
2411
2412	return next.HandleSerialize(ctx, in)
2413}
2414
2415type awsAwsjson11_serializeOpDetachStaticIp struct {
2416}
2417
2418func (*awsAwsjson11_serializeOpDetachStaticIp) ID() string {
2419	return "OperationSerializer"
2420}
2421
2422func (m *awsAwsjson11_serializeOpDetachStaticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2423	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2424) {
2425	request, ok := in.Request.(*smithyhttp.Request)
2426	if !ok {
2427		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2428	}
2429
2430	input, ok := in.Parameters.(*DetachStaticIpInput)
2431	_ = input
2432	if !ok {
2433		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2434	}
2435
2436	request.Request.URL.Path = "/"
2437	request.Request.Method = "POST"
2438	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2439	if err != nil {
2440		return out, metadata, &smithy.SerializationError{Err: err}
2441	}
2442	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2443	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DetachStaticIp")
2444
2445	jsonEncoder := smithyjson.NewEncoder()
2446	if err := awsAwsjson11_serializeOpDocumentDetachStaticIpInput(input, jsonEncoder.Value); err != nil {
2447		return out, metadata, &smithy.SerializationError{Err: err}
2448	}
2449
2450	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2451		return out, metadata, &smithy.SerializationError{Err: err}
2452	}
2453
2454	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2455		return out, metadata, &smithy.SerializationError{Err: err}
2456	}
2457	in.Request = request
2458
2459	return next.HandleSerialize(ctx, in)
2460}
2461
2462type awsAwsjson11_serializeOpDisableAddOn struct {
2463}
2464
2465func (*awsAwsjson11_serializeOpDisableAddOn) ID() string {
2466	return "OperationSerializer"
2467}
2468
2469func (m *awsAwsjson11_serializeOpDisableAddOn) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2470	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2471) {
2472	request, ok := in.Request.(*smithyhttp.Request)
2473	if !ok {
2474		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2475	}
2476
2477	input, ok := in.Parameters.(*DisableAddOnInput)
2478	_ = input
2479	if !ok {
2480		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2481	}
2482
2483	request.Request.URL.Path = "/"
2484	request.Request.Method = "POST"
2485	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2486	if err != nil {
2487		return out, metadata, &smithy.SerializationError{Err: err}
2488	}
2489	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2490	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DisableAddOn")
2491
2492	jsonEncoder := smithyjson.NewEncoder()
2493	if err := awsAwsjson11_serializeOpDocumentDisableAddOnInput(input, jsonEncoder.Value); err != nil {
2494		return out, metadata, &smithy.SerializationError{Err: err}
2495	}
2496
2497	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2498		return out, metadata, &smithy.SerializationError{Err: err}
2499	}
2500
2501	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2502		return out, metadata, &smithy.SerializationError{Err: err}
2503	}
2504	in.Request = request
2505
2506	return next.HandleSerialize(ctx, in)
2507}
2508
2509type awsAwsjson11_serializeOpDownloadDefaultKeyPair struct {
2510}
2511
2512func (*awsAwsjson11_serializeOpDownloadDefaultKeyPair) ID() string {
2513	return "OperationSerializer"
2514}
2515
2516func (m *awsAwsjson11_serializeOpDownloadDefaultKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2517	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2518) {
2519	request, ok := in.Request.(*smithyhttp.Request)
2520	if !ok {
2521		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2522	}
2523
2524	input, ok := in.Parameters.(*DownloadDefaultKeyPairInput)
2525	_ = input
2526	if !ok {
2527		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2528	}
2529
2530	request.Request.URL.Path = "/"
2531	request.Request.Method = "POST"
2532	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2533	if err != nil {
2534		return out, metadata, &smithy.SerializationError{Err: err}
2535	}
2536	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2537	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.DownloadDefaultKeyPair")
2538
2539	jsonEncoder := smithyjson.NewEncoder()
2540	if err := awsAwsjson11_serializeOpDocumentDownloadDefaultKeyPairInput(input, jsonEncoder.Value); err != nil {
2541		return out, metadata, &smithy.SerializationError{Err: err}
2542	}
2543
2544	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2545		return out, metadata, &smithy.SerializationError{Err: err}
2546	}
2547
2548	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2549		return out, metadata, &smithy.SerializationError{Err: err}
2550	}
2551	in.Request = request
2552
2553	return next.HandleSerialize(ctx, in)
2554}
2555
2556type awsAwsjson11_serializeOpEnableAddOn struct {
2557}
2558
2559func (*awsAwsjson11_serializeOpEnableAddOn) ID() string {
2560	return "OperationSerializer"
2561}
2562
2563func (m *awsAwsjson11_serializeOpEnableAddOn) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2564	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2565) {
2566	request, ok := in.Request.(*smithyhttp.Request)
2567	if !ok {
2568		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2569	}
2570
2571	input, ok := in.Parameters.(*EnableAddOnInput)
2572	_ = input
2573	if !ok {
2574		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2575	}
2576
2577	request.Request.URL.Path = "/"
2578	request.Request.Method = "POST"
2579	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2580	if err != nil {
2581		return out, metadata, &smithy.SerializationError{Err: err}
2582	}
2583	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2584	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.EnableAddOn")
2585
2586	jsonEncoder := smithyjson.NewEncoder()
2587	if err := awsAwsjson11_serializeOpDocumentEnableAddOnInput(input, jsonEncoder.Value); err != nil {
2588		return out, metadata, &smithy.SerializationError{Err: err}
2589	}
2590
2591	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2592		return out, metadata, &smithy.SerializationError{Err: err}
2593	}
2594
2595	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2596		return out, metadata, &smithy.SerializationError{Err: err}
2597	}
2598	in.Request = request
2599
2600	return next.HandleSerialize(ctx, in)
2601}
2602
2603type awsAwsjson11_serializeOpExportSnapshot struct {
2604}
2605
2606func (*awsAwsjson11_serializeOpExportSnapshot) ID() string {
2607	return "OperationSerializer"
2608}
2609
2610func (m *awsAwsjson11_serializeOpExportSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2611	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2612) {
2613	request, ok := in.Request.(*smithyhttp.Request)
2614	if !ok {
2615		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2616	}
2617
2618	input, ok := in.Parameters.(*ExportSnapshotInput)
2619	_ = input
2620	if !ok {
2621		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2622	}
2623
2624	request.Request.URL.Path = "/"
2625	request.Request.Method = "POST"
2626	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2627	if err != nil {
2628		return out, metadata, &smithy.SerializationError{Err: err}
2629	}
2630	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2631	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.ExportSnapshot")
2632
2633	jsonEncoder := smithyjson.NewEncoder()
2634	if err := awsAwsjson11_serializeOpDocumentExportSnapshotInput(input, jsonEncoder.Value); err != nil {
2635		return out, metadata, &smithy.SerializationError{Err: err}
2636	}
2637
2638	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2639		return out, metadata, &smithy.SerializationError{Err: err}
2640	}
2641
2642	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2643		return out, metadata, &smithy.SerializationError{Err: err}
2644	}
2645	in.Request = request
2646
2647	return next.HandleSerialize(ctx, in)
2648}
2649
2650type awsAwsjson11_serializeOpGetActiveNames struct {
2651}
2652
2653func (*awsAwsjson11_serializeOpGetActiveNames) ID() string {
2654	return "OperationSerializer"
2655}
2656
2657func (m *awsAwsjson11_serializeOpGetActiveNames) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2658	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2659) {
2660	request, ok := in.Request.(*smithyhttp.Request)
2661	if !ok {
2662		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2663	}
2664
2665	input, ok := in.Parameters.(*GetActiveNamesInput)
2666	_ = input
2667	if !ok {
2668		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2669	}
2670
2671	request.Request.URL.Path = "/"
2672	request.Request.Method = "POST"
2673	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2674	if err != nil {
2675		return out, metadata, &smithy.SerializationError{Err: err}
2676	}
2677	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2678	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetActiveNames")
2679
2680	jsonEncoder := smithyjson.NewEncoder()
2681	if err := awsAwsjson11_serializeOpDocumentGetActiveNamesInput(input, jsonEncoder.Value); err != nil {
2682		return out, metadata, &smithy.SerializationError{Err: err}
2683	}
2684
2685	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2686		return out, metadata, &smithy.SerializationError{Err: err}
2687	}
2688
2689	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2690		return out, metadata, &smithy.SerializationError{Err: err}
2691	}
2692	in.Request = request
2693
2694	return next.HandleSerialize(ctx, in)
2695}
2696
2697type awsAwsjson11_serializeOpGetAlarms struct {
2698}
2699
2700func (*awsAwsjson11_serializeOpGetAlarms) ID() string {
2701	return "OperationSerializer"
2702}
2703
2704func (m *awsAwsjson11_serializeOpGetAlarms) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2705	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2706) {
2707	request, ok := in.Request.(*smithyhttp.Request)
2708	if !ok {
2709		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2710	}
2711
2712	input, ok := in.Parameters.(*GetAlarmsInput)
2713	_ = input
2714	if !ok {
2715		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2716	}
2717
2718	request.Request.URL.Path = "/"
2719	request.Request.Method = "POST"
2720	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2721	if err != nil {
2722		return out, metadata, &smithy.SerializationError{Err: err}
2723	}
2724	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2725	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetAlarms")
2726
2727	jsonEncoder := smithyjson.NewEncoder()
2728	if err := awsAwsjson11_serializeOpDocumentGetAlarmsInput(input, jsonEncoder.Value); err != nil {
2729		return out, metadata, &smithy.SerializationError{Err: err}
2730	}
2731
2732	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2733		return out, metadata, &smithy.SerializationError{Err: err}
2734	}
2735
2736	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2737		return out, metadata, &smithy.SerializationError{Err: err}
2738	}
2739	in.Request = request
2740
2741	return next.HandleSerialize(ctx, in)
2742}
2743
2744type awsAwsjson11_serializeOpGetAutoSnapshots struct {
2745}
2746
2747func (*awsAwsjson11_serializeOpGetAutoSnapshots) ID() string {
2748	return "OperationSerializer"
2749}
2750
2751func (m *awsAwsjson11_serializeOpGetAutoSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2752	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2753) {
2754	request, ok := in.Request.(*smithyhttp.Request)
2755	if !ok {
2756		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2757	}
2758
2759	input, ok := in.Parameters.(*GetAutoSnapshotsInput)
2760	_ = input
2761	if !ok {
2762		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2763	}
2764
2765	request.Request.URL.Path = "/"
2766	request.Request.Method = "POST"
2767	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2768	if err != nil {
2769		return out, metadata, &smithy.SerializationError{Err: err}
2770	}
2771	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2772	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetAutoSnapshots")
2773
2774	jsonEncoder := smithyjson.NewEncoder()
2775	if err := awsAwsjson11_serializeOpDocumentGetAutoSnapshotsInput(input, jsonEncoder.Value); err != nil {
2776		return out, metadata, &smithy.SerializationError{Err: err}
2777	}
2778
2779	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2780		return out, metadata, &smithy.SerializationError{Err: err}
2781	}
2782
2783	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2784		return out, metadata, &smithy.SerializationError{Err: err}
2785	}
2786	in.Request = request
2787
2788	return next.HandleSerialize(ctx, in)
2789}
2790
2791type awsAwsjson11_serializeOpGetBlueprints struct {
2792}
2793
2794func (*awsAwsjson11_serializeOpGetBlueprints) ID() string {
2795	return "OperationSerializer"
2796}
2797
2798func (m *awsAwsjson11_serializeOpGetBlueprints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2799	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2800) {
2801	request, ok := in.Request.(*smithyhttp.Request)
2802	if !ok {
2803		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2804	}
2805
2806	input, ok := in.Parameters.(*GetBlueprintsInput)
2807	_ = input
2808	if !ok {
2809		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2810	}
2811
2812	request.Request.URL.Path = "/"
2813	request.Request.Method = "POST"
2814	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2815	if err != nil {
2816		return out, metadata, &smithy.SerializationError{Err: err}
2817	}
2818	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2819	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetBlueprints")
2820
2821	jsonEncoder := smithyjson.NewEncoder()
2822	if err := awsAwsjson11_serializeOpDocumentGetBlueprintsInput(input, jsonEncoder.Value); err != nil {
2823		return out, metadata, &smithy.SerializationError{Err: err}
2824	}
2825
2826	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2827		return out, metadata, &smithy.SerializationError{Err: err}
2828	}
2829
2830	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2831		return out, metadata, &smithy.SerializationError{Err: err}
2832	}
2833	in.Request = request
2834
2835	return next.HandleSerialize(ctx, in)
2836}
2837
2838type awsAwsjson11_serializeOpGetBundles struct {
2839}
2840
2841func (*awsAwsjson11_serializeOpGetBundles) ID() string {
2842	return "OperationSerializer"
2843}
2844
2845func (m *awsAwsjson11_serializeOpGetBundles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2846	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2847) {
2848	request, ok := in.Request.(*smithyhttp.Request)
2849	if !ok {
2850		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2851	}
2852
2853	input, ok := in.Parameters.(*GetBundlesInput)
2854	_ = input
2855	if !ok {
2856		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2857	}
2858
2859	request.Request.URL.Path = "/"
2860	request.Request.Method = "POST"
2861	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2862	if err != nil {
2863		return out, metadata, &smithy.SerializationError{Err: err}
2864	}
2865	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2866	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetBundles")
2867
2868	jsonEncoder := smithyjson.NewEncoder()
2869	if err := awsAwsjson11_serializeOpDocumentGetBundlesInput(input, jsonEncoder.Value); err != nil {
2870		return out, metadata, &smithy.SerializationError{Err: err}
2871	}
2872
2873	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2874		return out, metadata, &smithy.SerializationError{Err: err}
2875	}
2876
2877	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2878		return out, metadata, &smithy.SerializationError{Err: err}
2879	}
2880	in.Request = request
2881
2882	return next.HandleSerialize(ctx, in)
2883}
2884
2885type awsAwsjson11_serializeOpGetCertificates struct {
2886}
2887
2888func (*awsAwsjson11_serializeOpGetCertificates) ID() string {
2889	return "OperationSerializer"
2890}
2891
2892func (m *awsAwsjson11_serializeOpGetCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2893	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2894) {
2895	request, ok := in.Request.(*smithyhttp.Request)
2896	if !ok {
2897		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2898	}
2899
2900	input, ok := in.Parameters.(*GetCertificatesInput)
2901	_ = input
2902	if !ok {
2903		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2904	}
2905
2906	request.Request.URL.Path = "/"
2907	request.Request.Method = "POST"
2908	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2909	if err != nil {
2910		return out, metadata, &smithy.SerializationError{Err: err}
2911	}
2912	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2913	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetCertificates")
2914
2915	jsonEncoder := smithyjson.NewEncoder()
2916	if err := awsAwsjson11_serializeOpDocumentGetCertificatesInput(input, jsonEncoder.Value); err != nil {
2917		return out, metadata, &smithy.SerializationError{Err: err}
2918	}
2919
2920	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2921		return out, metadata, &smithy.SerializationError{Err: err}
2922	}
2923
2924	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2925		return out, metadata, &smithy.SerializationError{Err: err}
2926	}
2927	in.Request = request
2928
2929	return next.HandleSerialize(ctx, in)
2930}
2931
2932type awsAwsjson11_serializeOpGetCloudFormationStackRecords struct {
2933}
2934
2935func (*awsAwsjson11_serializeOpGetCloudFormationStackRecords) ID() string {
2936	return "OperationSerializer"
2937}
2938
2939func (m *awsAwsjson11_serializeOpGetCloudFormationStackRecords) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2940	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2941) {
2942	request, ok := in.Request.(*smithyhttp.Request)
2943	if !ok {
2944		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2945	}
2946
2947	input, ok := in.Parameters.(*GetCloudFormationStackRecordsInput)
2948	_ = input
2949	if !ok {
2950		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2951	}
2952
2953	request.Request.URL.Path = "/"
2954	request.Request.Method = "POST"
2955	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2956	if err != nil {
2957		return out, metadata, &smithy.SerializationError{Err: err}
2958	}
2959	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2960	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetCloudFormationStackRecords")
2961
2962	jsonEncoder := smithyjson.NewEncoder()
2963	if err := awsAwsjson11_serializeOpDocumentGetCloudFormationStackRecordsInput(input, jsonEncoder.Value); err != nil {
2964		return out, metadata, &smithy.SerializationError{Err: err}
2965	}
2966
2967	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2968		return out, metadata, &smithy.SerializationError{Err: err}
2969	}
2970
2971	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2972		return out, metadata, &smithy.SerializationError{Err: err}
2973	}
2974	in.Request = request
2975
2976	return next.HandleSerialize(ctx, in)
2977}
2978
2979type awsAwsjson11_serializeOpGetContactMethods struct {
2980}
2981
2982func (*awsAwsjson11_serializeOpGetContactMethods) ID() string {
2983	return "OperationSerializer"
2984}
2985
2986func (m *awsAwsjson11_serializeOpGetContactMethods) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2987	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2988) {
2989	request, ok := in.Request.(*smithyhttp.Request)
2990	if !ok {
2991		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2992	}
2993
2994	input, ok := in.Parameters.(*GetContactMethodsInput)
2995	_ = input
2996	if !ok {
2997		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2998	}
2999
3000	request.Request.URL.Path = "/"
3001	request.Request.Method = "POST"
3002	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3003	if err != nil {
3004		return out, metadata, &smithy.SerializationError{Err: err}
3005	}
3006	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3007	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContactMethods")
3008
3009	jsonEncoder := smithyjson.NewEncoder()
3010	if err := awsAwsjson11_serializeOpDocumentGetContactMethodsInput(input, jsonEncoder.Value); err != nil {
3011		return out, metadata, &smithy.SerializationError{Err: err}
3012	}
3013
3014	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3015		return out, metadata, &smithy.SerializationError{Err: err}
3016	}
3017
3018	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3019		return out, metadata, &smithy.SerializationError{Err: err}
3020	}
3021	in.Request = request
3022
3023	return next.HandleSerialize(ctx, in)
3024}
3025
3026type awsAwsjson11_serializeOpGetContainerAPIMetadata struct {
3027}
3028
3029func (*awsAwsjson11_serializeOpGetContainerAPIMetadata) ID() string {
3030	return "OperationSerializer"
3031}
3032
3033func (m *awsAwsjson11_serializeOpGetContainerAPIMetadata) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3034	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3035) {
3036	request, ok := in.Request.(*smithyhttp.Request)
3037	if !ok {
3038		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3039	}
3040
3041	input, ok := in.Parameters.(*GetContainerAPIMetadataInput)
3042	_ = input
3043	if !ok {
3044		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3045	}
3046
3047	request.Request.URL.Path = "/"
3048	request.Request.Method = "POST"
3049	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3050	if err != nil {
3051		return out, metadata, &smithy.SerializationError{Err: err}
3052	}
3053	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3054	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerAPIMetadata")
3055
3056	jsonEncoder := smithyjson.NewEncoder()
3057	if err := awsAwsjson11_serializeOpDocumentGetContainerAPIMetadataInput(input, jsonEncoder.Value); err != nil {
3058		return out, metadata, &smithy.SerializationError{Err: err}
3059	}
3060
3061	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3062		return out, metadata, &smithy.SerializationError{Err: err}
3063	}
3064
3065	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3066		return out, metadata, &smithy.SerializationError{Err: err}
3067	}
3068	in.Request = request
3069
3070	return next.HandleSerialize(ctx, in)
3071}
3072
3073type awsAwsjson11_serializeOpGetContainerImages struct {
3074}
3075
3076func (*awsAwsjson11_serializeOpGetContainerImages) ID() string {
3077	return "OperationSerializer"
3078}
3079
3080func (m *awsAwsjson11_serializeOpGetContainerImages) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3081	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3082) {
3083	request, ok := in.Request.(*smithyhttp.Request)
3084	if !ok {
3085		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3086	}
3087
3088	input, ok := in.Parameters.(*GetContainerImagesInput)
3089	_ = input
3090	if !ok {
3091		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3092	}
3093
3094	request.Request.URL.Path = "/"
3095	request.Request.Method = "POST"
3096	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3097	if err != nil {
3098		return out, metadata, &smithy.SerializationError{Err: err}
3099	}
3100	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3101	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerImages")
3102
3103	jsonEncoder := smithyjson.NewEncoder()
3104	if err := awsAwsjson11_serializeOpDocumentGetContainerImagesInput(input, jsonEncoder.Value); err != nil {
3105		return out, metadata, &smithy.SerializationError{Err: err}
3106	}
3107
3108	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3109		return out, metadata, &smithy.SerializationError{Err: err}
3110	}
3111
3112	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3113		return out, metadata, &smithy.SerializationError{Err: err}
3114	}
3115	in.Request = request
3116
3117	return next.HandleSerialize(ctx, in)
3118}
3119
3120type awsAwsjson11_serializeOpGetContainerLog struct {
3121}
3122
3123func (*awsAwsjson11_serializeOpGetContainerLog) ID() string {
3124	return "OperationSerializer"
3125}
3126
3127func (m *awsAwsjson11_serializeOpGetContainerLog) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3128	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3129) {
3130	request, ok := in.Request.(*smithyhttp.Request)
3131	if !ok {
3132		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3133	}
3134
3135	input, ok := in.Parameters.(*GetContainerLogInput)
3136	_ = input
3137	if !ok {
3138		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3139	}
3140
3141	request.Request.URL.Path = "/"
3142	request.Request.Method = "POST"
3143	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3144	if err != nil {
3145		return out, metadata, &smithy.SerializationError{Err: err}
3146	}
3147	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3148	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerLog")
3149
3150	jsonEncoder := smithyjson.NewEncoder()
3151	if err := awsAwsjson11_serializeOpDocumentGetContainerLogInput(input, jsonEncoder.Value); err != nil {
3152		return out, metadata, &smithy.SerializationError{Err: err}
3153	}
3154
3155	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3156		return out, metadata, &smithy.SerializationError{Err: err}
3157	}
3158
3159	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3160		return out, metadata, &smithy.SerializationError{Err: err}
3161	}
3162	in.Request = request
3163
3164	return next.HandleSerialize(ctx, in)
3165}
3166
3167type awsAwsjson11_serializeOpGetContainerServiceDeployments struct {
3168}
3169
3170func (*awsAwsjson11_serializeOpGetContainerServiceDeployments) ID() string {
3171	return "OperationSerializer"
3172}
3173
3174func (m *awsAwsjson11_serializeOpGetContainerServiceDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3175	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3176) {
3177	request, ok := in.Request.(*smithyhttp.Request)
3178	if !ok {
3179		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3180	}
3181
3182	input, ok := in.Parameters.(*GetContainerServiceDeploymentsInput)
3183	_ = input
3184	if !ok {
3185		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3186	}
3187
3188	request.Request.URL.Path = "/"
3189	request.Request.Method = "POST"
3190	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3191	if err != nil {
3192		return out, metadata, &smithy.SerializationError{Err: err}
3193	}
3194	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3195	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerServiceDeployments")
3196
3197	jsonEncoder := smithyjson.NewEncoder()
3198	if err := awsAwsjson11_serializeOpDocumentGetContainerServiceDeploymentsInput(input, jsonEncoder.Value); err != nil {
3199		return out, metadata, &smithy.SerializationError{Err: err}
3200	}
3201
3202	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3203		return out, metadata, &smithy.SerializationError{Err: err}
3204	}
3205
3206	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3207		return out, metadata, &smithy.SerializationError{Err: err}
3208	}
3209	in.Request = request
3210
3211	return next.HandleSerialize(ctx, in)
3212}
3213
3214type awsAwsjson11_serializeOpGetContainerServiceMetricData struct {
3215}
3216
3217func (*awsAwsjson11_serializeOpGetContainerServiceMetricData) ID() string {
3218	return "OperationSerializer"
3219}
3220
3221func (m *awsAwsjson11_serializeOpGetContainerServiceMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3222	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3223) {
3224	request, ok := in.Request.(*smithyhttp.Request)
3225	if !ok {
3226		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3227	}
3228
3229	input, ok := in.Parameters.(*GetContainerServiceMetricDataInput)
3230	_ = input
3231	if !ok {
3232		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3233	}
3234
3235	request.Request.URL.Path = "/"
3236	request.Request.Method = "POST"
3237	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3238	if err != nil {
3239		return out, metadata, &smithy.SerializationError{Err: err}
3240	}
3241	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3242	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerServiceMetricData")
3243
3244	jsonEncoder := smithyjson.NewEncoder()
3245	if err := awsAwsjson11_serializeOpDocumentGetContainerServiceMetricDataInput(input, jsonEncoder.Value); err != nil {
3246		return out, metadata, &smithy.SerializationError{Err: err}
3247	}
3248
3249	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3250		return out, metadata, &smithy.SerializationError{Err: err}
3251	}
3252
3253	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3254		return out, metadata, &smithy.SerializationError{Err: err}
3255	}
3256	in.Request = request
3257
3258	return next.HandleSerialize(ctx, in)
3259}
3260
3261type awsAwsjson11_serializeOpGetContainerServicePowers struct {
3262}
3263
3264func (*awsAwsjson11_serializeOpGetContainerServicePowers) ID() string {
3265	return "OperationSerializer"
3266}
3267
3268func (m *awsAwsjson11_serializeOpGetContainerServicePowers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3269	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3270) {
3271	request, ok := in.Request.(*smithyhttp.Request)
3272	if !ok {
3273		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3274	}
3275
3276	input, ok := in.Parameters.(*GetContainerServicePowersInput)
3277	_ = input
3278	if !ok {
3279		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3280	}
3281
3282	request.Request.URL.Path = "/"
3283	request.Request.Method = "POST"
3284	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3285	if err != nil {
3286		return out, metadata, &smithy.SerializationError{Err: err}
3287	}
3288	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3289	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerServicePowers")
3290
3291	jsonEncoder := smithyjson.NewEncoder()
3292	if err := awsAwsjson11_serializeOpDocumentGetContainerServicePowersInput(input, jsonEncoder.Value); err != nil {
3293		return out, metadata, &smithy.SerializationError{Err: err}
3294	}
3295
3296	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3297		return out, metadata, &smithy.SerializationError{Err: err}
3298	}
3299
3300	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3301		return out, metadata, &smithy.SerializationError{Err: err}
3302	}
3303	in.Request = request
3304
3305	return next.HandleSerialize(ctx, in)
3306}
3307
3308type awsAwsjson11_serializeOpGetContainerServices struct {
3309}
3310
3311func (*awsAwsjson11_serializeOpGetContainerServices) ID() string {
3312	return "OperationSerializer"
3313}
3314
3315func (m *awsAwsjson11_serializeOpGetContainerServices) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3316	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3317) {
3318	request, ok := in.Request.(*smithyhttp.Request)
3319	if !ok {
3320		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3321	}
3322
3323	input, ok := in.Parameters.(*GetContainerServicesInput)
3324	_ = input
3325	if !ok {
3326		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3327	}
3328
3329	request.Request.URL.Path = "/"
3330	request.Request.Method = "POST"
3331	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3332	if err != nil {
3333		return out, metadata, &smithy.SerializationError{Err: err}
3334	}
3335	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3336	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetContainerServices")
3337
3338	jsonEncoder := smithyjson.NewEncoder()
3339	if err := awsAwsjson11_serializeOpDocumentGetContainerServicesInput(input, jsonEncoder.Value); err != nil {
3340		return out, metadata, &smithy.SerializationError{Err: err}
3341	}
3342
3343	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3344		return out, metadata, &smithy.SerializationError{Err: err}
3345	}
3346
3347	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3348		return out, metadata, &smithy.SerializationError{Err: err}
3349	}
3350	in.Request = request
3351
3352	return next.HandleSerialize(ctx, in)
3353}
3354
3355type awsAwsjson11_serializeOpGetDisk struct {
3356}
3357
3358func (*awsAwsjson11_serializeOpGetDisk) ID() string {
3359	return "OperationSerializer"
3360}
3361
3362func (m *awsAwsjson11_serializeOpGetDisk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3363	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3364) {
3365	request, ok := in.Request.(*smithyhttp.Request)
3366	if !ok {
3367		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3368	}
3369
3370	input, ok := in.Parameters.(*GetDiskInput)
3371	_ = input
3372	if !ok {
3373		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3374	}
3375
3376	request.Request.URL.Path = "/"
3377	request.Request.Method = "POST"
3378	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3379	if err != nil {
3380		return out, metadata, &smithy.SerializationError{Err: err}
3381	}
3382	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3383	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDisk")
3384
3385	jsonEncoder := smithyjson.NewEncoder()
3386	if err := awsAwsjson11_serializeOpDocumentGetDiskInput(input, jsonEncoder.Value); err != nil {
3387		return out, metadata, &smithy.SerializationError{Err: err}
3388	}
3389
3390	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3391		return out, metadata, &smithy.SerializationError{Err: err}
3392	}
3393
3394	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3395		return out, metadata, &smithy.SerializationError{Err: err}
3396	}
3397	in.Request = request
3398
3399	return next.HandleSerialize(ctx, in)
3400}
3401
3402type awsAwsjson11_serializeOpGetDisks struct {
3403}
3404
3405func (*awsAwsjson11_serializeOpGetDisks) ID() string {
3406	return "OperationSerializer"
3407}
3408
3409func (m *awsAwsjson11_serializeOpGetDisks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3410	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3411) {
3412	request, ok := in.Request.(*smithyhttp.Request)
3413	if !ok {
3414		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3415	}
3416
3417	input, ok := in.Parameters.(*GetDisksInput)
3418	_ = input
3419	if !ok {
3420		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3421	}
3422
3423	request.Request.URL.Path = "/"
3424	request.Request.Method = "POST"
3425	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3426	if err != nil {
3427		return out, metadata, &smithy.SerializationError{Err: err}
3428	}
3429	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3430	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDisks")
3431
3432	jsonEncoder := smithyjson.NewEncoder()
3433	if err := awsAwsjson11_serializeOpDocumentGetDisksInput(input, jsonEncoder.Value); err != nil {
3434		return out, metadata, &smithy.SerializationError{Err: err}
3435	}
3436
3437	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3438		return out, metadata, &smithy.SerializationError{Err: err}
3439	}
3440
3441	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3442		return out, metadata, &smithy.SerializationError{Err: err}
3443	}
3444	in.Request = request
3445
3446	return next.HandleSerialize(ctx, in)
3447}
3448
3449type awsAwsjson11_serializeOpGetDiskSnapshot struct {
3450}
3451
3452func (*awsAwsjson11_serializeOpGetDiskSnapshot) ID() string {
3453	return "OperationSerializer"
3454}
3455
3456func (m *awsAwsjson11_serializeOpGetDiskSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3457	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3458) {
3459	request, ok := in.Request.(*smithyhttp.Request)
3460	if !ok {
3461		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3462	}
3463
3464	input, ok := in.Parameters.(*GetDiskSnapshotInput)
3465	_ = input
3466	if !ok {
3467		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3468	}
3469
3470	request.Request.URL.Path = "/"
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.GetDiskSnapshot")
3478
3479	jsonEncoder := smithyjson.NewEncoder()
3480	if err := awsAwsjson11_serializeOpDocumentGetDiskSnapshotInput(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	return next.HandleSerialize(ctx, in)
3494}
3495
3496type awsAwsjson11_serializeOpGetDiskSnapshots struct {
3497}
3498
3499func (*awsAwsjson11_serializeOpGetDiskSnapshots) ID() string {
3500	return "OperationSerializer"
3501}
3502
3503func (m *awsAwsjson11_serializeOpGetDiskSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3504	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3505) {
3506	request, ok := in.Request.(*smithyhttp.Request)
3507	if !ok {
3508		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3509	}
3510
3511	input, ok := in.Parameters.(*GetDiskSnapshotsInput)
3512	_ = input
3513	if !ok {
3514		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3515	}
3516
3517	request.Request.URL.Path = "/"
3518	request.Request.Method = "POST"
3519	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3520	if err != nil {
3521		return out, metadata, &smithy.SerializationError{Err: err}
3522	}
3523	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3524	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDiskSnapshots")
3525
3526	jsonEncoder := smithyjson.NewEncoder()
3527	if err := awsAwsjson11_serializeOpDocumentGetDiskSnapshotsInput(input, jsonEncoder.Value); err != nil {
3528		return out, metadata, &smithy.SerializationError{Err: err}
3529	}
3530
3531	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3532		return out, metadata, &smithy.SerializationError{Err: err}
3533	}
3534
3535	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3536		return out, metadata, &smithy.SerializationError{Err: err}
3537	}
3538	in.Request = request
3539
3540	return next.HandleSerialize(ctx, in)
3541}
3542
3543type awsAwsjson11_serializeOpGetDistributionBundles struct {
3544}
3545
3546func (*awsAwsjson11_serializeOpGetDistributionBundles) ID() string {
3547	return "OperationSerializer"
3548}
3549
3550func (m *awsAwsjson11_serializeOpGetDistributionBundles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3551	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3552) {
3553	request, ok := in.Request.(*smithyhttp.Request)
3554	if !ok {
3555		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3556	}
3557
3558	input, ok := in.Parameters.(*GetDistributionBundlesInput)
3559	_ = input
3560	if !ok {
3561		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3562	}
3563
3564	request.Request.URL.Path = "/"
3565	request.Request.Method = "POST"
3566	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3567	if err != nil {
3568		return out, metadata, &smithy.SerializationError{Err: err}
3569	}
3570	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3571	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDistributionBundles")
3572
3573	jsonEncoder := smithyjson.NewEncoder()
3574	if err := awsAwsjson11_serializeOpDocumentGetDistributionBundlesInput(input, jsonEncoder.Value); err != nil {
3575		return out, metadata, &smithy.SerializationError{Err: err}
3576	}
3577
3578	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3579		return out, metadata, &smithy.SerializationError{Err: err}
3580	}
3581
3582	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3583		return out, metadata, &smithy.SerializationError{Err: err}
3584	}
3585	in.Request = request
3586
3587	return next.HandleSerialize(ctx, in)
3588}
3589
3590type awsAwsjson11_serializeOpGetDistributionLatestCacheReset struct {
3591}
3592
3593func (*awsAwsjson11_serializeOpGetDistributionLatestCacheReset) ID() string {
3594	return "OperationSerializer"
3595}
3596
3597func (m *awsAwsjson11_serializeOpGetDistributionLatestCacheReset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3598	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3599) {
3600	request, ok := in.Request.(*smithyhttp.Request)
3601	if !ok {
3602		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3603	}
3604
3605	input, ok := in.Parameters.(*GetDistributionLatestCacheResetInput)
3606	_ = input
3607	if !ok {
3608		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3609	}
3610
3611	request.Request.URL.Path = "/"
3612	request.Request.Method = "POST"
3613	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3614	if err != nil {
3615		return out, metadata, &smithy.SerializationError{Err: err}
3616	}
3617	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3618	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDistributionLatestCacheReset")
3619
3620	jsonEncoder := smithyjson.NewEncoder()
3621	if err := awsAwsjson11_serializeOpDocumentGetDistributionLatestCacheResetInput(input, jsonEncoder.Value); err != nil {
3622		return out, metadata, &smithy.SerializationError{Err: err}
3623	}
3624
3625	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3626		return out, metadata, &smithy.SerializationError{Err: err}
3627	}
3628
3629	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3630		return out, metadata, &smithy.SerializationError{Err: err}
3631	}
3632	in.Request = request
3633
3634	return next.HandleSerialize(ctx, in)
3635}
3636
3637type awsAwsjson11_serializeOpGetDistributionMetricData struct {
3638}
3639
3640func (*awsAwsjson11_serializeOpGetDistributionMetricData) ID() string {
3641	return "OperationSerializer"
3642}
3643
3644func (m *awsAwsjson11_serializeOpGetDistributionMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3645	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3646) {
3647	request, ok := in.Request.(*smithyhttp.Request)
3648	if !ok {
3649		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3650	}
3651
3652	input, ok := in.Parameters.(*GetDistributionMetricDataInput)
3653	_ = input
3654	if !ok {
3655		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3656	}
3657
3658	request.Request.URL.Path = "/"
3659	request.Request.Method = "POST"
3660	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3661	if err != nil {
3662		return out, metadata, &smithy.SerializationError{Err: err}
3663	}
3664	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3665	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDistributionMetricData")
3666
3667	jsonEncoder := smithyjson.NewEncoder()
3668	if err := awsAwsjson11_serializeOpDocumentGetDistributionMetricDataInput(input, jsonEncoder.Value); err != nil {
3669		return out, metadata, &smithy.SerializationError{Err: err}
3670	}
3671
3672	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3673		return out, metadata, &smithy.SerializationError{Err: err}
3674	}
3675
3676	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3677		return out, metadata, &smithy.SerializationError{Err: err}
3678	}
3679	in.Request = request
3680
3681	return next.HandleSerialize(ctx, in)
3682}
3683
3684type awsAwsjson11_serializeOpGetDistributions struct {
3685}
3686
3687func (*awsAwsjson11_serializeOpGetDistributions) ID() string {
3688	return "OperationSerializer"
3689}
3690
3691func (m *awsAwsjson11_serializeOpGetDistributions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3692	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3693) {
3694	request, ok := in.Request.(*smithyhttp.Request)
3695	if !ok {
3696		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3697	}
3698
3699	input, ok := in.Parameters.(*GetDistributionsInput)
3700	_ = input
3701	if !ok {
3702		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3703	}
3704
3705	request.Request.URL.Path = "/"
3706	request.Request.Method = "POST"
3707	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3708	if err != nil {
3709		return out, metadata, &smithy.SerializationError{Err: err}
3710	}
3711	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3712	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDistributions")
3713
3714	jsonEncoder := smithyjson.NewEncoder()
3715	if err := awsAwsjson11_serializeOpDocumentGetDistributionsInput(input, jsonEncoder.Value); err != nil {
3716		return out, metadata, &smithy.SerializationError{Err: err}
3717	}
3718
3719	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3720		return out, metadata, &smithy.SerializationError{Err: err}
3721	}
3722
3723	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3724		return out, metadata, &smithy.SerializationError{Err: err}
3725	}
3726	in.Request = request
3727
3728	return next.HandleSerialize(ctx, in)
3729}
3730
3731type awsAwsjson11_serializeOpGetDomain struct {
3732}
3733
3734func (*awsAwsjson11_serializeOpGetDomain) ID() string {
3735	return "OperationSerializer"
3736}
3737
3738func (m *awsAwsjson11_serializeOpGetDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3739	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3740) {
3741	request, ok := in.Request.(*smithyhttp.Request)
3742	if !ok {
3743		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3744	}
3745
3746	input, ok := in.Parameters.(*GetDomainInput)
3747	_ = input
3748	if !ok {
3749		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3750	}
3751
3752	request.Request.URL.Path = "/"
3753	request.Request.Method = "POST"
3754	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3755	if err != nil {
3756		return out, metadata, &smithy.SerializationError{Err: err}
3757	}
3758	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3759	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDomain")
3760
3761	jsonEncoder := smithyjson.NewEncoder()
3762	if err := awsAwsjson11_serializeOpDocumentGetDomainInput(input, jsonEncoder.Value); err != nil {
3763		return out, metadata, &smithy.SerializationError{Err: err}
3764	}
3765
3766	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3767		return out, metadata, &smithy.SerializationError{Err: err}
3768	}
3769
3770	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3771		return out, metadata, &smithy.SerializationError{Err: err}
3772	}
3773	in.Request = request
3774
3775	return next.HandleSerialize(ctx, in)
3776}
3777
3778type awsAwsjson11_serializeOpGetDomains struct {
3779}
3780
3781func (*awsAwsjson11_serializeOpGetDomains) ID() string {
3782	return "OperationSerializer"
3783}
3784
3785func (m *awsAwsjson11_serializeOpGetDomains) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3786	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3787) {
3788	request, ok := in.Request.(*smithyhttp.Request)
3789	if !ok {
3790		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3791	}
3792
3793	input, ok := in.Parameters.(*GetDomainsInput)
3794	_ = input
3795	if !ok {
3796		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3797	}
3798
3799	request.Request.URL.Path = "/"
3800	request.Request.Method = "POST"
3801	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3802	if err != nil {
3803		return out, metadata, &smithy.SerializationError{Err: err}
3804	}
3805	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3806	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetDomains")
3807
3808	jsonEncoder := smithyjson.NewEncoder()
3809	if err := awsAwsjson11_serializeOpDocumentGetDomainsInput(input, jsonEncoder.Value); err != nil {
3810		return out, metadata, &smithy.SerializationError{Err: err}
3811	}
3812
3813	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3814		return out, metadata, &smithy.SerializationError{Err: err}
3815	}
3816
3817	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3818		return out, metadata, &smithy.SerializationError{Err: err}
3819	}
3820	in.Request = request
3821
3822	return next.HandleSerialize(ctx, in)
3823}
3824
3825type awsAwsjson11_serializeOpGetExportSnapshotRecords struct {
3826}
3827
3828func (*awsAwsjson11_serializeOpGetExportSnapshotRecords) ID() string {
3829	return "OperationSerializer"
3830}
3831
3832func (m *awsAwsjson11_serializeOpGetExportSnapshotRecords) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3833	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3834) {
3835	request, ok := in.Request.(*smithyhttp.Request)
3836	if !ok {
3837		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3838	}
3839
3840	input, ok := in.Parameters.(*GetExportSnapshotRecordsInput)
3841	_ = input
3842	if !ok {
3843		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3844	}
3845
3846	request.Request.URL.Path = "/"
3847	request.Request.Method = "POST"
3848	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3849	if err != nil {
3850		return out, metadata, &smithy.SerializationError{Err: err}
3851	}
3852	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3853	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetExportSnapshotRecords")
3854
3855	jsonEncoder := smithyjson.NewEncoder()
3856	if err := awsAwsjson11_serializeOpDocumentGetExportSnapshotRecordsInput(input, jsonEncoder.Value); err != nil {
3857		return out, metadata, &smithy.SerializationError{Err: err}
3858	}
3859
3860	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3861		return out, metadata, &smithy.SerializationError{Err: err}
3862	}
3863
3864	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3865		return out, metadata, &smithy.SerializationError{Err: err}
3866	}
3867	in.Request = request
3868
3869	return next.HandleSerialize(ctx, in)
3870}
3871
3872type awsAwsjson11_serializeOpGetInstance struct {
3873}
3874
3875func (*awsAwsjson11_serializeOpGetInstance) ID() string {
3876	return "OperationSerializer"
3877}
3878
3879func (m *awsAwsjson11_serializeOpGetInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3880	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3881) {
3882	request, ok := in.Request.(*smithyhttp.Request)
3883	if !ok {
3884		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3885	}
3886
3887	input, ok := in.Parameters.(*GetInstanceInput)
3888	_ = input
3889	if !ok {
3890		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3891	}
3892
3893	request.Request.URL.Path = "/"
3894	request.Request.Method = "POST"
3895	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3896	if err != nil {
3897		return out, metadata, &smithy.SerializationError{Err: err}
3898	}
3899	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3900	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstance")
3901
3902	jsonEncoder := smithyjson.NewEncoder()
3903	if err := awsAwsjson11_serializeOpDocumentGetInstanceInput(input, jsonEncoder.Value); err != nil {
3904		return out, metadata, &smithy.SerializationError{Err: err}
3905	}
3906
3907	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3908		return out, metadata, &smithy.SerializationError{Err: err}
3909	}
3910
3911	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3912		return out, metadata, &smithy.SerializationError{Err: err}
3913	}
3914	in.Request = request
3915
3916	return next.HandleSerialize(ctx, in)
3917}
3918
3919type awsAwsjson11_serializeOpGetInstanceAccessDetails struct {
3920}
3921
3922func (*awsAwsjson11_serializeOpGetInstanceAccessDetails) ID() string {
3923	return "OperationSerializer"
3924}
3925
3926func (m *awsAwsjson11_serializeOpGetInstanceAccessDetails) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3927	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3928) {
3929	request, ok := in.Request.(*smithyhttp.Request)
3930	if !ok {
3931		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3932	}
3933
3934	input, ok := in.Parameters.(*GetInstanceAccessDetailsInput)
3935	_ = input
3936	if !ok {
3937		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3938	}
3939
3940	request.Request.URL.Path = "/"
3941	request.Request.Method = "POST"
3942	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3943	if err != nil {
3944		return out, metadata, &smithy.SerializationError{Err: err}
3945	}
3946	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3947	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstanceAccessDetails")
3948
3949	jsonEncoder := smithyjson.NewEncoder()
3950	if err := awsAwsjson11_serializeOpDocumentGetInstanceAccessDetailsInput(input, jsonEncoder.Value); err != nil {
3951		return out, metadata, &smithy.SerializationError{Err: err}
3952	}
3953
3954	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3955		return out, metadata, &smithy.SerializationError{Err: err}
3956	}
3957
3958	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3959		return out, metadata, &smithy.SerializationError{Err: err}
3960	}
3961	in.Request = request
3962
3963	return next.HandleSerialize(ctx, in)
3964}
3965
3966type awsAwsjson11_serializeOpGetInstanceMetricData struct {
3967}
3968
3969func (*awsAwsjson11_serializeOpGetInstanceMetricData) ID() string {
3970	return "OperationSerializer"
3971}
3972
3973func (m *awsAwsjson11_serializeOpGetInstanceMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3974	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3975) {
3976	request, ok := in.Request.(*smithyhttp.Request)
3977	if !ok {
3978		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3979	}
3980
3981	input, ok := in.Parameters.(*GetInstanceMetricDataInput)
3982	_ = input
3983	if !ok {
3984		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3985	}
3986
3987	request.Request.URL.Path = "/"
3988	request.Request.Method = "POST"
3989	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3990	if err != nil {
3991		return out, metadata, &smithy.SerializationError{Err: err}
3992	}
3993	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3994	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstanceMetricData")
3995
3996	jsonEncoder := smithyjson.NewEncoder()
3997	if err := awsAwsjson11_serializeOpDocumentGetInstanceMetricDataInput(input, jsonEncoder.Value); err != nil {
3998		return out, metadata, &smithy.SerializationError{Err: err}
3999	}
4000
4001	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4002		return out, metadata, &smithy.SerializationError{Err: err}
4003	}
4004
4005	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4006		return out, metadata, &smithy.SerializationError{Err: err}
4007	}
4008	in.Request = request
4009
4010	return next.HandleSerialize(ctx, in)
4011}
4012
4013type awsAwsjson11_serializeOpGetInstancePortStates struct {
4014}
4015
4016func (*awsAwsjson11_serializeOpGetInstancePortStates) ID() string {
4017	return "OperationSerializer"
4018}
4019
4020func (m *awsAwsjson11_serializeOpGetInstancePortStates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4021	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4022) {
4023	request, ok := in.Request.(*smithyhttp.Request)
4024	if !ok {
4025		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4026	}
4027
4028	input, ok := in.Parameters.(*GetInstancePortStatesInput)
4029	_ = input
4030	if !ok {
4031		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4032	}
4033
4034	request.Request.URL.Path = "/"
4035	request.Request.Method = "POST"
4036	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4037	if err != nil {
4038		return out, metadata, &smithy.SerializationError{Err: err}
4039	}
4040	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4041	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstancePortStates")
4042
4043	jsonEncoder := smithyjson.NewEncoder()
4044	if err := awsAwsjson11_serializeOpDocumentGetInstancePortStatesInput(input, jsonEncoder.Value); err != nil {
4045		return out, metadata, &smithy.SerializationError{Err: err}
4046	}
4047
4048	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4049		return out, metadata, &smithy.SerializationError{Err: err}
4050	}
4051
4052	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4053		return out, metadata, &smithy.SerializationError{Err: err}
4054	}
4055	in.Request = request
4056
4057	return next.HandleSerialize(ctx, in)
4058}
4059
4060type awsAwsjson11_serializeOpGetInstances struct {
4061}
4062
4063func (*awsAwsjson11_serializeOpGetInstances) ID() string {
4064	return "OperationSerializer"
4065}
4066
4067func (m *awsAwsjson11_serializeOpGetInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4068	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4069) {
4070	request, ok := in.Request.(*smithyhttp.Request)
4071	if !ok {
4072		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4073	}
4074
4075	input, ok := in.Parameters.(*GetInstancesInput)
4076	_ = input
4077	if !ok {
4078		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4079	}
4080
4081	request.Request.URL.Path = "/"
4082	request.Request.Method = "POST"
4083	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4084	if err != nil {
4085		return out, metadata, &smithy.SerializationError{Err: err}
4086	}
4087	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4088	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstances")
4089
4090	jsonEncoder := smithyjson.NewEncoder()
4091	if err := awsAwsjson11_serializeOpDocumentGetInstancesInput(input, jsonEncoder.Value); err != nil {
4092		return out, metadata, &smithy.SerializationError{Err: err}
4093	}
4094
4095	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4096		return out, metadata, &smithy.SerializationError{Err: err}
4097	}
4098
4099	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4100		return out, metadata, &smithy.SerializationError{Err: err}
4101	}
4102	in.Request = request
4103
4104	return next.HandleSerialize(ctx, in)
4105}
4106
4107type awsAwsjson11_serializeOpGetInstanceSnapshot struct {
4108}
4109
4110func (*awsAwsjson11_serializeOpGetInstanceSnapshot) ID() string {
4111	return "OperationSerializer"
4112}
4113
4114func (m *awsAwsjson11_serializeOpGetInstanceSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4115	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4116) {
4117	request, ok := in.Request.(*smithyhttp.Request)
4118	if !ok {
4119		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4120	}
4121
4122	input, ok := in.Parameters.(*GetInstanceSnapshotInput)
4123	_ = input
4124	if !ok {
4125		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4126	}
4127
4128	request.Request.URL.Path = "/"
4129	request.Request.Method = "POST"
4130	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4131	if err != nil {
4132		return out, metadata, &smithy.SerializationError{Err: err}
4133	}
4134	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4135	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstanceSnapshot")
4136
4137	jsonEncoder := smithyjson.NewEncoder()
4138	if err := awsAwsjson11_serializeOpDocumentGetInstanceSnapshotInput(input, jsonEncoder.Value); err != nil {
4139		return out, metadata, &smithy.SerializationError{Err: err}
4140	}
4141
4142	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4143		return out, metadata, &smithy.SerializationError{Err: err}
4144	}
4145
4146	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4147		return out, metadata, &smithy.SerializationError{Err: err}
4148	}
4149	in.Request = request
4150
4151	return next.HandleSerialize(ctx, in)
4152}
4153
4154type awsAwsjson11_serializeOpGetInstanceSnapshots struct {
4155}
4156
4157func (*awsAwsjson11_serializeOpGetInstanceSnapshots) ID() string {
4158	return "OperationSerializer"
4159}
4160
4161func (m *awsAwsjson11_serializeOpGetInstanceSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4162	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4163) {
4164	request, ok := in.Request.(*smithyhttp.Request)
4165	if !ok {
4166		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4167	}
4168
4169	input, ok := in.Parameters.(*GetInstanceSnapshotsInput)
4170	_ = input
4171	if !ok {
4172		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4173	}
4174
4175	request.Request.URL.Path = "/"
4176	request.Request.Method = "POST"
4177	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4178	if err != nil {
4179		return out, metadata, &smithy.SerializationError{Err: err}
4180	}
4181	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4182	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstanceSnapshots")
4183
4184	jsonEncoder := smithyjson.NewEncoder()
4185	if err := awsAwsjson11_serializeOpDocumentGetInstanceSnapshotsInput(input, jsonEncoder.Value); err != nil {
4186		return out, metadata, &smithy.SerializationError{Err: err}
4187	}
4188
4189	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4190		return out, metadata, &smithy.SerializationError{Err: err}
4191	}
4192
4193	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4194		return out, metadata, &smithy.SerializationError{Err: err}
4195	}
4196	in.Request = request
4197
4198	return next.HandleSerialize(ctx, in)
4199}
4200
4201type awsAwsjson11_serializeOpGetInstanceState struct {
4202}
4203
4204func (*awsAwsjson11_serializeOpGetInstanceState) ID() string {
4205	return "OperationSerializer"
4206}
4207
4208func (m *awsAwsjson11_serializeOpGetInstanceState) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4209	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4210) {
4211	request, ok := in.Request.(*smithyhttp.Request)
4212	if !ok {
4213		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4214	}
4215
4216	input, ok := in.Parameters.(*GetInstanceStateInput)
4217	_ = input
4218	if !ok {
4219		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4220	}
4221
4222	request.Request.URL.Path = "/"
4223	request.Request.Method = "POST"
4224	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4225	if err != nil {
4226		return out, metadata, &smithy.SerializationError{Err: err}
4227	}
4228	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4229	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetInstanceState")
4230
4231	jsonEncoder := smithyjson.NewEncoder()
4232	if err := awsAwsjson11_serializeOpDocumentGetInstanceStateInput(input, jsonEncoder.Value); err != nil {
4233		return out, metadata, &smithy.SerializationError{Err: err}
4234	}
4235
4236	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4237		return out, metadata, &smithy.SerializationError{Err: err}
4238	}
4239
4240	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4241		return out, metadata, &smithy.SerializationError{Err: err}
4242	}
4243	in.Request = request
4244
4245	return next.HandleSerialize(ctx, in)
4246}
4247
4248type awsAwsjson11_serializeOpGetKeyPair struct {
4249}
4250
4251func (*awsAwsjson11_serializeOpGetKeyPair) ID() string {
4252	return "OperationSerializer"
4253}
4254
4255func (m *awsAwsjson11_serializeOpGetKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4256	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4257) {
4258	request, ok := in.Request.(*smithyhttp.Request)
4259	if !ok {
4260		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4261	}
4262
4263	input, ok := in.Parameters.(*GetKeyPairInput)
4264	_ = input
4265	if !ok {
4266		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4267	}
4268
4269	request.Request.URL.Path = "/"
4270	request.Request.Method = "POST"
4271	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4272	if err != nil {
4273		return out, metadata, &smithy.SerializationError{Err: err}
4274	}
4275	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4276	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetKeyPair")
4277
4278	jsonEncoder := smithyjson.NewEncoder()
4279	if err := awsAwsjson11_serializeOpDocumentGetKeyPairInput(input, jsonEncoder.Value); err != nil {
4280		return out, metadata, &smithy.SerializationError{Err: err}
4281	}
4282
4283	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4284		return out, metadata, &smithy.SerializationError{Err: err}
4285	}
4286
4287	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4288		return out, metadata, &smithy.SerializationError{Err: err}
4289	}
4290	in.Request = request
4291
4292	return next.HandleSerialize(ctx, in)
4293}
4294
4295type awsAwsjson11_serializeOpGetKeyPairs struct {
4296}
4297
4298func (*awsAwsjson11_serializeOpGetKeyPairs) ID() string {
4299	return "OperationSerializer"
4300}
4301
4302func (m *awsAwsjson11_serializeOpGetKeyPairs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4303	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4304) {
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.(*GetKeyPairsInput)
4311	_ = input
4312	if !ok {
4313		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4314	}
4315
4316	request.Request.URL.Path = "/"
4317	request.Request.Method = "POST"
4318	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4319	if err != nil {
4320		return out, metadata, &smithy.SerializationError{Err: err}
4321	}
4322	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4323	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetKeyPairs")
4324
4325	jsonEncoder := smithyjson.NewEncoder()
4326	if err := awsAwsjson11_serializeOpDocumentGetKeyPairsInput(input, jsonEncoder.Value); err != nil {
4327		return out, metadata, &smithy.SerializationError{Err: err}
4328	}
4329
4330	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4331		return out, metadata, &smithy.SerializationError{Err: err}
4332	}
4333
4334	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4335		return out, metadata, &smithy.SerializationError{Err: err}
4336	}
4337	in.Request = request
4338
4339	return next.HandleSerialize(ctx, in)
4340}
4341
4342type awsAwsjson11_serializeOpGetLoadBalancer struct {
4343}
4344
4345func (*awsAwsjson11_serializeOpGetLoadBalancer) ID() string {
4346	return "OperationSerializer"
4347}
4348
4349func (m *awsAwsjson11_serializeOpGetLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4350	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4351) {
4352	request, ok := in.Request.(*smithyhttp.Request)
4353	if !ok {
4354		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4355	}
4356
4357	input, ok := in.Parameters.(*GetLoadBalancerInput)
4358	_ = input
4359	if !ok {
4360		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4361	}
4362
4363	request.Request.URL.Path = "/"
4364	request.Request.Method = "POST"
4365	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4366	if err != nil {
4367		return out, metadata, &smithy.SerializationError{Err: err}
4368	}
4369	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4370	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetLoadBalancer")
4371
4372	jsonEncoder := smithyjson.NewEncoder()
4373	if err := awsAwsjson11_serializeOpDocumentGetLoadBalancerInput(input, jsonEncoder.Value); err != nil {
4374		return out, metadata, &smithy.SerializationError{Err: err}
4375	}
4376
4377	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4378		return out, metadata, &smithy.SerializationError{Err: err}
4379	}
4380
4381	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4382		return out, metadata, &smithy.SerializationError{Err: err}
4383	}
4384	in.Request = request
4385
4386	return next.HandleSerialize(ctx, in)
4387}
4388
4389type awsAwsjson11_serializeOpGetLoadBalancerMetricData struct {
4390}
4391
4392func (*awsAwsjson11_serializeOpGetLoadBalancerMetricData) ID() string {
4393	return "OperationSerializer"
4394}
4395
4396func (m *awsAwsjson11_serializeOpGetLoadBalancerMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4397	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4398) {
4399	request, ok := in.Request.(*smithyhttp.Request)
4400	if !ok {
4401		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4402	}
4403
4404	input, ok := in.Parameters.(*GetLoadBalancerMetricDataInput)
4405	_ = input
4406	if !ok {
4407		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4408	}
4409
4410	request.Request.URL.Path = "/"
4411	request.Request.Method = "POST"
4412	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4413	if err != nil {
4414		return out, metadata, &smithy.SerializationError{Err: err}
4415	}
4416	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4417	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetLoadBalancerMetricData")
4418
4419	jsonEncoder := smithyjson.NewEncoder()
4420	if err := awsAwsjson11_serializeOpDocumentGetLoadBalancerMetricDataInput(input, jsonEncoder.Value); err != nil {
4421		return out, metadata, &smithy.SerializationError{Err: err}
4422	}
4423
4424	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4425		return out, metadata, &smithy.SerializationError{Err: err}
4426	}
4427
4428	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4429		return out, metadata, &smithy.SerializationError{Err: err}
4430	}
4431	in.Request = request
4432
4433	return next.HandleSerialize(ctx, in)
4434}
4435
4436type awsAwsjson11_serializeOpGetLoadBalancers struct {
4437}
4438
4439func (*awsAwsjson11_serializeOpGetLoadBalancers) ID() string {
4440	return "OperationSerializer"
4441}
4442
4443func (m *awsAwsjson11_serializeOpGetLoadBalancers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4444	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4445) {
4446	request, ok := in.Request.(*smithyhttp.Request)
4447	if !ok {
4448		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4449	}
4450
4451	input, ok := in.Parameters.(*GetLoadBalancersInput)
4452	_ = input
4453	if !ok {
4454		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4455	}
4456
4457	request.Request.URL.Path = "/"
4458	request.Request.Method = "POST"
4459	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4460	if err != nil {
4461		return out, metadata, &smithy.SerializationError{Err: err}
4462	}
4463	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4464	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetLoadBalancers")
4465
4466	jsonEncoder := smithyjson.NewEncoder()
4467	if err := awsAwsjson11_serializeOpDocumentGetLoadBalancersInput(input, jsonEncoder.Value); err != nil {
4468		return out, metadata, &smithy.SerializationError{Err: err}
4469	}
4470
4471	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4472		return out, metadata, &smithy.SerializationError{Err: err}
4473	}
4474
4475	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4476		return out, metadata, &smithy.SerializationError{Err: err}
4477	}
4478	in.Request = request
4479
4480	return next.HandleSerialize(ctx, in)
4481}
4482
4483type awsAwsjson11_serializeOpGetLoadBalancerTlsCertificates struct {
4484}
4485
4486func (*awsAwsjson11_serializeOpGetLoadBalancerTlsCertificates) ID() string {
4487	return "OperationSerializer"
4488}
4489
4490func (m *awsAwsjson11_serializeOpGetLoadBalancerTlsCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4491	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4492) {
4493	request, ok := in.Request.(*smithyhttp.Request)
4494	if !ok {
4495		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4496	}
4497
4498	input, ok := in.Parameters.(*GetLoadBalancerTlsCertificatesInput)
4499	_ = input
4500	if !ok {
4501		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4502	}
4503
4504	request.Request.URL.Path = "/"
4505	request.Request.Method = "POST"
4506	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4507	if err != nil {
4508		return out, metadata, &smithy.SerializationError{Err: err}
4509	}
4510	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4511	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetLoadBalancerTlsCertificates")
4512
4513	jsonEncoder := smithyjson.NewEncoder()
4514	if err := awsAwsjson11_serializeOpDocumentGetLoadBalancerTlsCertificatesInput(input, jsonEncoder.Value); err != nil {
4515		return out, metadata, &smithy.SerializationError{Err: err}
4516	}
4517
4518	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4519		return out, metadata, &smithy.SerializationError{Err: err}
4520	}
4521
4522	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4523		return out, metadata, &smithy.SerializationError{Err: err}
4524	}
4525	in.Request = request
4526
4527	return next.HandleSerialize(ctx, in)
4528}
4529
4530type awsAwsjson11_serializeOpGetOperation struct {
4531}
4532
4533func (*awsAwsjson11_serializeOpGetOperation) ID() string {
4534	return "OperationSerializer"
4535}
4536
4537func (m *awsAwsjson11_serializeOpGetOperation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4538	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4539) {
4540	request, ok := in.Request.(*smithyhttp.Request)
4541	if !ok {
4542		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4543	}
4544
4545	input, ok := in.Parameters.(*GetOperationInput)
4546	_ = input
4547	if !ok {
4548		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4549	}
4550
4551	request.Request.URL.Path = "/"
4552	request.Request.Method = "POST"
4553	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4554	if err != nil {
4555		return out, metadata, &smithy.SerializationError{Err: err}
4556	}
4557	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4558	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetOperation")
4559
4560	jsonEncoder := smithyjson.NewEncoder()
4561	if err := awsAwsjson11_serializeOpDocumentGetOperationInput(input, jsonEncoder.Value); err != nil {
4562		return out, metadata, &smithy.SerializationError{Err: err}
4563	}
4564
4565	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4566		return out, metadata, &smithy.SerializationError{Err: err}
4567	}
4568
4569	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4570		return out, metadata, &smithy.SerializationError{Err: err}
4571	}
4572	in.Request = request
4573
4574	return next.HandleSerialize(ctx, in)
4575}
4576
4577type awsAwsjson11_serializeOpGetOperations struct {
4578}
4579
4580func (*awsAwsjson11_serializeOpGetOperations) ID() string {
4581	return "OperationSerializer"
4582}
4583
4584func (m *awsAwsjson11_serializeOpGetOperations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4585	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4586) {
4587	request, ok := in.Request.(*smithyhttp.Request)
4588	if !ok {
4589		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4590	}
4591
4592	input, ok := in.Parameters.(*GetOperationsInput)
4593	_ = input
4594	if !ok {
4595		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4596	}
4597
4598	request.Request.URL.Path = "/"
4599	request.Request.Method = "POST"
4600	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4601	if err != nil {
4602		return out, metadata, &smithy.SerializationError{Err: err}
4603	}
4604	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4605	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetOperations")
4606
4607	jsonEncoder := smithyjson.NewEncoder()
4608	if err := awsAwsjson11_serializeOpDocumentGetOperationsInput(input, jsonEncoder.Value); err != nil {
4609		return out, metadata, &smithy.SerializationError{Err: err}
4610	}
4611
4612	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4613		return out, metadata, &smithy.SerializationError{Err: err}
4614	}
4615
4616	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4617		return out, metadata, &smithy.SerializationError{Err: err}
4618	}
4619	in.Request = request
4620
4621	return next.HandleSerialize(ctx, in)
4622}
4623
4624type awsAwsjson11_serializeOpGetOperationsForResource struct {
4625}
4626
4627func (*awsAwsjson11_serializeOpGetOperationsForResource) ID() string {
4628	return "OperationSerializer"
4629}
4630
4631func (m *awsAwsjson11_serializeOpGetOperationsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4632	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4633) {
4634	request, ok := in.Request.(*smithyhttp.Request)
4635	if !ok {
4636		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4637	}
4638
4639	input, ok := in.Parameters.(*GetOperationsForResourceInput)
4640	_ = input
4641	if !ok {
4642		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4643	}
4644
4645	request.Request.URL.Path = "/"
4646	request.Request.Method = "POST"
4647	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4648	if err != nil {
4649		return out, metadata, &smithy.SerializationError{Err: err}
4650	}
4651	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4652	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetOperationsForResource")
4653
4654	jsonEncoder := smithyjson.NewEncoder()
4655	if err := awsAwsjson11_serializeOpDocumentGetOperationsForResourceInput(input, jsonEncoder.Value); err != nil {
4656		return out, metadata, &smithy.SerializationError{Err: err}
4657	}
4658
4659	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4660		return out, metadata, &smithy.SerializationError{Err: err}
4661	}
4662
4663	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4664		return out, metadata, &smithy.SerializationError{Err: err}
4665	}
4666	in.Request = request
4667
4668	return next.HandleSerialize(ctx, in)
4669}
4670
4671type awsAwsjson11_serializeOpGetRegions struct {
4672}
4673
4674func (*awsAwsjson11_serializeOpGetRegions) ID() string {
4675	return "OperationSerializer"
4676}
4677
4678func (m *awsAwsjson11_serializeOpGetRegions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4679	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4680) {
4681	request, ok := in.Request.(*smithyhttp.Request)
4682	if !ok {
4683		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4684	}
4685
4686	input, ok := in.Parameters.(*GetRegionsInput)
4687	_ = input
4688	if !ok {
4689		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4690	}
4691
4692	request.Request.URL.Path = "/"
4693	request.Request.Method = "POST"
4694	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4695	if err != nil {
4696		return out, metadata, &smithy.SerializationError{Err: err}
4697	}
4698	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4699	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRegions")
4700
4701	jsonEncoder := smithyjson.NewEncoder()
4702	if err := awsAwsjson11_serializeOpDocumentGetRegionsInput(input, jsonEncoder.Value); err != nil {
4703		return out, metadata, &smithy.SerializationError{Err: err}
4704	}
4705
4706	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4707		return out, metadata, &smithy.SerializationError{Err: err}
4708	}
4709
4710	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4711		return out, metadata, &smithy.SerializationError{Err: err}
4712	}
4713	in.Request = request
4714
4715	return next.HandleSerialize(ctx, in)
4716}
4717
4718type awsAwsjson11_serializeOpGetRelationalDatabase struct {
4719}
4720
4721func (*awsAwsjson11_serializeOpGetRelationalDatabase) ID() string {
4722	return "OperationSerializer"
4723}
4724
4725func (m *awsAwsjson11_serializeOpGetRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4726	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4727) {
4728	request, ok := in.Request.(*smithyhttp.Request)
4729	if !ok {
4730		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4731	}
4732
4733	input, ok := in.Parameters.(*GetRelationalDatabaseInput)
4734	_ = input
4735	if !ok {
4736		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4737	}
4738
4739	request.Request.URL.Path = "/"
4740	request.Request.Method = "POST"
4741	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4742	if err != nil {
4743		return out, metadata, &smithy.SerializationError{Err: err}
4744	}
4745	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4746	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabase")
4747
4748	jsonEncoder := smithyjson.NewEncoder()
4749	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
4750		return out, metadata, &smithy.SerializationError{Err: err}
4751	}
4752
4753	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4754		return out, metadata, &smithy.SerializationError{Err: err}
4755	}
4756
4757	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4758		return out, metadata, &smithy.SerializationError{Err: err}
4759	}
4760	in.Request = request
4761
4762	return next.HandleSerialize(ctx, in)
4763}
4764
4765type awsAwsjson11_serializeOpGetRelationalDatabaseBlueprints struct {
4766}
4767
4768func (*awsAwsjson11_serializeOpGetRelationalDatabaseBlueprints) ID() string {
4769	return "OperationSerializer"
4770}
4771
4772func (m *awsAwsjson11_serializeOpGetRelationalDatabaseBlueprints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4773	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4774) {
4775	request, ok := in.Request.(*smithyhttp.Request)
4776	if !ok {
4777		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4778	}
4779
4780	input, ok := in.Parameters.(*GetRelationalDatabaseBlueprintsInput)
4781	_ = input
4782	if !ok {
4783		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4784	}
4785
4786	request.Request.URL.Path = "/"
4787	request.Request.Method = "POST"
4788	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4789	if err != nil {
4790		return out, metadata, &smithy.SerializationError{Err: err}
4791	}
4792	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4793	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseBlueprints")
4794
4795	jsonEncoder := smithyjson.NewEncoder()
4796	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseBlueprintsInput(input, jsonEncoder.Value); err != nil {
4797		return out, metadata, &smithy.SerializationError{Err: err}
4798	}
4799
4800	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4801		return out, metadata, &smithy.SerializationError{Err: err}
4802	}
4803
4804	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4805		return out, metadata, &smithy.SerializationError{Err: err}
4806	}
4807	in.Request = request
4808
4809	return next.HandleSerialize(ctx, in)
4810}
4811
4812type awsAwsjson11_serializeOpGetRelationalDatabaseBundles struct {
4813}
4814
4815func (*awsAwsjson11_serializeOpGetRelationalDatabaseBundles) ID() string {
4816	return "OperationSerializer"
4817}
4818
4819func (m *awsAwsjson11_serializeOpGetRelationalDatabaseBundles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4820	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4821) {
4822	request, ok := in.Request.(*smithyhttp.Request)
4823	if !ok {
4824		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4825	}
4826
4827	input, ok := in.Parameters.(*GetRelationalDatabaseBundlesInput)
4828	_ = input
4829	if !ok {
4830		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4831	}
4832
4833	request.Request.URL.Path = "/"
4834	request.Request.Method = "POST"
4835	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4836	if err != nil {
4837		return out, metadata, &smithy.SerializationError{Err: err}
4838	}
4839	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4840	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseBundles")
4841
4842	jsonEncoder := smithyjson.NewEncoder()
4843	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseBundlesInput(input, jsonEncoder.Value); err != nil {
4844		return out, metadata, &smithy.SerializationError{Err: err}
4845	}
4846
4847	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4848		return out, metadata, &smithy.SerializationError{Err: err}
4849	}
4850
4851	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4852		return out, metadata, &smithy.SerializationError{Err: err}
4853	}
4854	in.Request = request
4855
4856	return next.HandleSerialize(ctx, in)
4857}
4858
4859type awsAwsjson11_serializeOpGetRelationalDatabaseEvents struct {
4860}
4861
4862func (*awsAwsjson11_serializeOpGetRelationalDatabaseEvents) ID() string {
4863	return "OperationSerializer"
4864}
4865
4866func (m *awsAwsjson11_serializeOpGetRelationalDatabaseEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4867	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4868) {
4869	request, ok := in.Request.(*smithyhttp.Request)
4870	if !ok {
4871		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4872	}
4873
4874	input, ok := in.Parameters.(*GetRelationalDatabaseEventsInput)
4875	_ = input
4876	if !ok {
4877		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4878	}
4879
4880	request.Request.URL.Path = "/"
4881	request.Request.Method = "POST"
4882	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4883	if err != nil {
4884		return out, metadata, &smithy.SerializationError{Err: err}
4885	}
4886	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4887	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseEvents")
4888
4889	jsonEncoder := smithyjson.NewEncoder()
4890	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseEventsInput(input, jsonEncoder.Value); err != nil {
4891		return out, metadata, &smithy.SerializationError{Err: err}
4892	}
4893
4894	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4895		return out, metadata, &smithy.SerializationError{Err: err}
4896	}
4897
4898	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4899		return out, metadata, &smithy.SerializationError{Err: err}
4900	}
4901	in.Request = request
4902
4903	return next.HandleSerialize(ctx, in)
4904}
4905
4906type awsAwsjson11_serializeOpGetRelationalDatabaseLogEvents struct {
4907}
4908
4909func (*awsAwsjson11_serializeOpGetRelationalDatabaseLogEvents) ID() string {
4910	return "OperationSerializer"
4911}
4912
4913func (m *awsAwsjson11_serializeOpGetRelationalDatabaseLogEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4914	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4915) {
4916	request, ok := in.Request.(*smithyhttp.Request)
4917	if !ok {
4918		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4919	}
4920
4921	input, ok := in.Parameters.(*GetRelationalDatabaseLogEventsInput)
4922	_ = input
4923	if !ok {
4924		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4925	}
4926
4927	request.Request.URL.Path = "/"
4928	request.Request.Method = "POST"
4929	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4930	if err != nil {
4931		return out, metadata, &smithy.SerializationError{Err: err}
4932	}
4933	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4934	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseLogEvents")
4935
4936	jsonEncoder := smithyjson.NewEncoder()
4937	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseLogEventsInput(input, jsonEncoder.Value); err != nil {
4938		return out, metadata, &smithy.SerializationError{Err: err}
4939	}
4940
4941	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4942		return out, metadata, &smithy.SerializationError{Err: err}
4943	}
4944
4945	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4946		return out, metadata, &smithy.SerializationError{Err: err}
4947	}
4948	in.Request = request
4949
4950	return next.HandleSerialize(ctx, in)
4951}
4952
4953type awsAwsjson11_serializeOpGetRelationalDatabaseLogStreams struct {
4954}
4955
4956func (*awsAwsjson11_serializeOpGetRelationalDatabaseLogStreams) ID() string {
4957	return "OperationSerializer"
4958}
4959
4960func (m *awsAwsjson11_serializeOpGetRelationalDatabaseLogStreams) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4961	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4962) {
4963	request, ok := in.Request.(*smithyhttp.Request)
4964	if !ok {
4965		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4966	}
4967
4968	input, ok := in.Parameters.(*GetRelationalDatabaseLogStreamsInput)
4969	_ = input
4970	if !ok {
4971		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4972	}
4973
4974	request.Request.URL.Path = "/"
4975	request.Request.Method = "POST"
4976	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4977	if err != nil {
4978		return out, metadata, &smithy.SerializationError{Err: err}
4979	}
4980	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4981	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseLogStreams")
4982
4983	jsonEncoder := smithyjson.NewEncoder()
4984	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseLogStreamsInput(input, jsonEncoder.Value); err != nil {
4985		return out, metadata, &smithy.SerializationError{Err: err}
4986	}
4987
4988	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4989		return out, metadata, &smithy.SerializationError{Err: err}
4990	}
4991
4992	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4993		return out, metadata, &smithy.SerializationError{Err: err}
4994	}
4995	in.Request = request
4996
4997	return next.HandleSerialize(ctx, in)
4998}
4999
5000type awsAwsjson11_serializeOpGetRelationalDatabaseMasterUserPassword struct {
5001}
5002
5003func (*awsAwsjson11_serializeOpGetRelationalDatabaseMasterUserPassword) ID() string {
5004	return "OperationSerializer"
5005}
5006
5007func (m *awsAwsjson11_serializeOpGetRelationalDatabaseMasterUserPassword) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5008	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5009) {
5010	request, ok := in.Request.(*smithyhttp.Request)
5011	if !ok {
5012		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5013	}
5014
5015	input, ok := in.Parameters.(*GetRelationalDatabaseMasterUserPasswordInput)
5016	_ = input
5017	if !ok {
5018		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5019	}
5020
5021	request.Request.URL.Path = "/"
5022	request.Request.Method = "POST"
5023	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5024	if err != nil {
5025		return out, metadata, &smithy.SerializationError{Err: err}
5026	}
5027	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5028	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseMasterUserPassword")
5029
5030	jsonEncoder := smithyjson.NewEncoder()
5031	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseMasterUserPasswordInput(input, jsonEncoder.Value); err != nil {
5032		return out, metadata, &smithy.SerializationError{Err: err}
5033	}
5034
5035	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5036		return out, metadata, &smithy.SerializationError{Err: err}
5037	}
5038
5039	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5040		return out, metadata, &smithy.SerializationError{Err: err}
5041	}
5042	in.Request = request
5043
5044	return next.HandleSerialize(ctx, in)
5045}
5046
5047type awsAwsjson11_serializeOpGetRelationalDatabaseMetricData struct {
5048}
5049
5050func (*awsAwsjson11_serializeOpGetRelationalDatabaseMetricData) ID() string {
5051	return "OperationSerializer"
5052}
5053
5054func (m *awsAwsjson11_serializeOpGetRelationalDatabaseMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5055	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5056) {
5057	request, ok := in.Request.(*smithyhttp.Request)
5058	if !ok {
5059		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5060	}
5061
5062	input, ok := in.Parameters.(*GetRelationalDatabaseMetricDataInput)
5063	_ = input
5064	if !ok {
5065		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5066	}
5067
5068	request.Request.URL.Path = "/"
5069	request.Request.Method = "POST"
5070	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5071	if err != nil {
5072		return out, metadata, &smithy.SerializationError{Err: err}
5073	}
5074	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5075	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseMetricData")
5076
5077	jsonEncoder := smithyjson.NewEncoder()
5078	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseMetricDataInput(input, jsonEncoder.Value); err != nil {
5079		return out, metadata, &smithy.SerializationError{Err: err}
5080	}
5081
5082	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5083		return out, metadata, &smithy.SerializationError{Err: err}
5084	}
5085
5086	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5087		return out, metadata, &smithy.SerializationError{Err: err}
5088	}
5089	in.Request = request
5090
5091	return next.HandleSerialize(ctx, in)
5092}
5093
5094type awsAwsjson11_serializeOpGetRelationalDatabaseParameters struct {
5095}
5096
5097func (*awsAwsjson11_serializeOpGetRelationalDatabaseParameters) ID() string {
5098	return "OperationSerializer"
5099}
5100
5101func (m *awsAwsjson11_serializeOpGetRelationalDatabaseParameters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5102	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5103) {
5104	request, ok := in.Request.(*smithyhttp.Request)
5105	if !ok {
5106		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5107	}
5108
5109	input, ok := in.Parameters.(*GetRelationalDatabaseParametersInput)
5110	_ = input
5111	if !ok {
5112		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5113	}
5114
5115	request.Request.URL.Path = "/"
5116	request.Request.Method = "POST"
5117	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5118	if err != nil {
5119		return out, metadata, &smithy.SerializationError{Err: err}
5120	}
5121	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5122	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseParameters")
5123
5124	jsonEncoder := smithyjson.NewEncoder()
5125	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseParametersInput(input, jsonEncoder.Value); err != nil {
5126		return out, metadata, &smithy.SerializationError{Err: err}
5127	}
5128
5129	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5130		return out, metadata, &smithy.SerializationError{Err: err}
5131	}
5132
5133	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5134		return out, metadata, &smithy.SerializationError{Err: err}
5135	}
5136	in.Request = request
5137
5138	return next.HandleSerialize(ctx, in)
5139}
5140
5141type awsAwsjson11_serializeOpGetRelationalDatabases struct {
5142}
5143
5144func (*awsAwsjson11_serializeOpGetRelationalDatabases) ID() string {
5145	return "OperationSerializer"
5146}
5147
5148func (m *awsAwsjson11_serializeOpGetRelationalDatabases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5149	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5150) {
5151	request, ok := in.Request.(*smithyhttp.Request)
5152	if !ok {
5153		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5154	}
5155
5156	input, ok := in.Parameters.(*GetRelationalDatabasesInput)
5157	_ = input
5158	if !ok {
5159		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5160	}
5161
5162	request.Request.URL.Path = "/"
5163	request.Request.Method = "POST"
5164	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5165	if err != nil {
5166		return out, metadata, &smithy.SerializationError{Err: err}
5167	}
5168	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5169	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabases")
5170
5171	jsonEncoder := smithyjson.NewEncoder()
5172	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabasesInput(input, jsonEncoder.Value); err != nil {
5173		return out, metadata, &smithy.SerializationError{Err: err}
5174	}
5175
5176	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5177		return out, metadata, &smithy.SerializationError{Err: err}
5178	}
5179
5180	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5181		return out, metadata, &smithy.SerializationError{Err: err}
5182	}
5183	in.Request = request
5184
5185	return next.HandleSerialize(ctx, in)
5186}
5187
5188type awsAwsjson11_serializeOpGetRelationalDatabaseSnapshot struct {
5189}
5190
5191func (*awsAwsjson11_serializeOpGetRelationalDatabaseSnapshot) ID() string {
5192	return "OperationSerializer"
5193}
5194
5195func (m *awsAwsjson11_serializeOpGetRelationalDatabaseSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5196	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5197) {
5198	request, ok := in.Request.(*smithyhttp.Request)
5199	if !ok {
5200		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5201	}
5202
5203	input, ok := in.Parameters.(*GetRelationalDatabaseSnapshotInput)
5204	_ = input
5205	if !ok {
5206		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5207	}
5208
5209	request.Request.URL.Path = "/"
5210	request.Request.Method = "POST"
5211	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5212	if err != nil {
5213		return out, metadata, &smithy.SerializationError{Err: err}
5214	}
5215	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5216	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseSnapshot")
5217
5218	jsonEncoder := smithyjson.NewEncoder()
5219	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseSnapshotInput(input, jsonEncoder.Value); err != nil {
5220		return out, metadata, &smithy.SerializationError{Err: err}
5221	}
5222
5223	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5224		return out, metadata, &smithy.SerializationError{Err: err}
5225	}
5226
5227	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5228		return out, metadata, &smithy.SerializationError{Err: err}
5229	}
5230	in.Request = request
5231
5232	return next.HandleSerialize(ctx, in)
5233}
5234
5235type awsAwsjson11_serializeOpGetRelationalDatabaseSnapshots struct {
5236}
5237
5238func (*awsAwsjson11_serializeOpGetRelationalDatabaseSnapshots) ID() string {
5239	return "OperationSerializer"
5240}
5241
5242func (m *awsAwsjson11_serializeOpGetRelationalDatabaseSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5243	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5244) {
5245	request, ok := in.Request.(*smithyhttp.Request)
5246	if !ok {
5247		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5248	}
5249
5250	input, ok := in.Parameters.(*GetRelationalDatabaseSnapshotsInput)
5251	_ = input
5252	if !ok {
5253		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5254	}
5255
5256	request.Request.URL.Path = "/"
5257	request.Request.Method = "POST"
5258	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5259	if err != nil {
5260		return out, metadata, &smithy.SerializationError{Err: err}
5261	}
5262	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5263	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetRelationalDatabaseSnapshots")
5264
5265	jsonEncoder := smithyjson.NewEncoder()
5266	if err := awsAwsjson11_serializeOpDocumentGetRelationalDatabaseSnapshotsInput(input, jsonEncoder.Value); err != nil {
5267		return out, metadata, &smithy.SerializationError{Err: err}
5268	}
5269
5270	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5271		return out, metadata, &smithy.SerializationError{Err: err}
5272	}
5273
5274	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5275		return out, metadata, &smithy.SerializationError{Err: err}
5276	}
5277	in.Request = request
5278
5279	return next.HandleSerialize(ctx, in)
5280}
5281
5282type awsAwsjson11_serializeOpGetStaticIp struct {
5283}
5284
5285func (*awsAwsjson11_serializeOpGetStaticIp) ID() string {
5286	return "OperationSerializer"
5287}
5288
5289func (m *awsAwsjson11_serializeOpGetStaticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5290	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5291) {
5292	request, ok := in.Request.(*smithyhttp.Request)
5293	if !ok {
5294		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5295	}
5296
5297	input, ok := in.Parameters.(*GetStaticIpInput)
5298	_ = input
5299	if !ok {
5300		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5301	}
5302
5303	request.Request.URL.Path = "/"
5304	request.Request.Method = "POST"
5305	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5306	if err != nil {
5307		return out, metadata, &smithy.SerializationError{Err: err}
5308	}
5309	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5310	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetStaticIp")
5311
5312	jsonEncoder := smithyjson.NewEncoder()
5313	if err := awsAwsjson11_serializeOpDocumentGetStaticIpInput(input, jsonEncoder.Value); err != nil {
5314		return out, metadata, &smithy.SerializationError{Err: err}
5315	}
5316
5317	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5318		return out, metadata, &smithy.SerializationError{Err: err}
5319	}
5320
5321	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5322		return out, metadata, &smithy.SerializationError{Err: err}
5323	}
5324	in.Request = request
5325
5326	return next.HandleSerialize(ctx, in)
5327}
5328
5329type awsAwsjson11_serializeOpGetStaticIps struct {
5330}
5331
5332func (*awsAwsjson11_serializeOpGetStaticIps) ID() string {
5333	return "OperationSerializer"
5334}
5335
5336func (m *awsAwsjson11_serializeOpGetStaticIps) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5337	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5338) {
5339	request, ok := in.Request.(*smithyhttp.Request)
5340	if !ok {
5341		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5342	}
5343
5344	input, ok := in.Parameters.(*GetStaticIpsInput)
5345	_ = input
5346	if !ok {
5347		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5348	}
5349
5350	request.Request.URL.Path = "/"
5351	request.Request.Method = "POST"
5352	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5353	if err != nil {
5354		return out, metadata, &smithy.SerializationError{Err: err}
5355	}
5356	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5357	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.GetStaticIps")
5358
5359	jsonEncoder := smithyjson.NewEncoder()
5360	if err := awsAwsjson11_serializeOpDocumentGetStaticIpsInput(input, jsonEncoder.Value); err != nil {
5361		return out, metadata, &smithy.SerializationError{Err: err}
5362	}
5363
5364	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5365		return out, metadata, &smithy.SerializationError{Err: err}
5366	}
5367
5368	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5369		return out, metadata, &smithy.SerializationError{Err: err}
5370	}
5371	in.Request = request
5372
5373	return next.HandleSerialize(ctx, in)
5374}
5375
5376type awsAwsjson11_serializeOpImportKeyPair struct {
5377}
5378
5379func (*awsAwsjson11_serializeOpImportKeyPair) ID() string {
5380	return "OperationSerializer"
5381}
5382
5383func (m *awsAwsjson11_serializeOpImportKeyPair) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5384	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5385) {
5386	request, ok := in.Request.(*smithyhttp.Request)
5387	if !ok {
5388		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5389	}
5390
5391	input, ok := in.Parameters.(*ImportKeyPairInput)
5392	_ = input
5393	if !ok {
5394		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5395	}
5396
5397	request.Request.URL.Path = "/"
5398	request.Request.Method = "POST"
5399	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5400	if err != nil {
5401		return out, metadata, &smithy.SerializationError{Err: err}
5402	}
5403	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5404	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.ImportKeyPair")
5405
5406	jsonEncoder := smithyjson.NewEncoder()
5407	if err := awsAwsjson11_serializeOpDocumentImportKeyPairInput(input, jsonEncoder.Value); err != nil {
5408		return out, metadata, &smithy.SerializationError{Err: err}
5409	}
5410
5411	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5412		return out, metadata, &smithy.SerializationError{Err: err}
5413	}
5414
5415	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5416		return out, metadata, &smithy.SerializationError{Err: err}
5417	}
5418	in.Request = request
5419
5420	return next.HandleSerialize(ctx, in)
5421}
5422
5423type awsAwsjson11_serializeOpIsVpcPeered struct {
5424}
5425
5426func (*awsAwsjson11_serializeOpIsVpcPeered) ID() string {
5427	return "OperationSerializer"
5428}
5429
5430func (m *awsAwsjson11_serializeOpIsVpcPeered) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5431	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5432) {
5433	request, ok := in.Request.(*smithyhttp.Request)
5434	if !ok {
5435		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5436	}
5437
5438	input, ok := in.Parameters.(*IsVpcPeeredInput)
5439	_ = input
5440	if !ok {
5441		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5442	}
5443
5444	request.Request.URL.Path = "/"
5445	request.Request.Method = "POST"
5446	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5447	if err != nil {
5448		return out, metadata, &smithy.SerializationError{Err: err}
5449	}
5450	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5451	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.IsVpcPeered")
5452
5453	jsonEncoder := smithyjson.NewEncoder()
5454	if err := awsAwsjson11_serializeOpDocumentIsVpcPeeredInput(input, jsonEncoder.Value); err != nil {
5455		return out, metadata, &smithy.SerializationError{Err: err}
5456	}
5457
5458	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5459		return out, metadata, &smithy.SerializationError{Err: err}
5460	}
5461
5462	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5463		return out, metadata, &smithy.SerializationError{Err: err}
5464	}
5465	in.Request = request
5466
5467	return next.HandleSerialize(ctx, in)
5468}
5469
5470type awsAwsjson11_serializeOpOpenInstancePublicPorts struct {
5471}
5472
5473func (*awsAwsjson11_serializeOpOpenInstancePublicPorts) ID() string {
5474	return "OperationSerializer"
5475}
5476
5477func (m *awsAwsjson11_serializeOpOpenInstancePublicPorts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5478	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5479) {
5480	request, ok := in.Request.(*smithyhttp.Request)
5481	if !ok {
5482		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5483	}
5484
5485	input, ok := in.Parameters.(*OpenInstancePublicPortsInput)
5486	_ = input
5487	if !ok {
5488		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5489	}
5490
5491	request.Request.URL.Path = "/"
5492	request.Request.Method = "POST"
5493	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5494	if err != nil {
5495		return out, metadata, &smithy.SerializationError{Err: err}
5496	}
5497	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5498	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.OpenInstancePublicPorts")
5499
5500	jsonEncoder := smithyjson.NewEncoder()
5501	if err := awsAwsjson11_serializeOpDocumentOpenInstancePublicPortsInput(input, jsonEncoder.Value); err != nil {
5502		return out, metadata, &smithy.SerializationError{Err: err}
5503	}
5504
5505	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5506		return out, metadata, &smithy.SerializationError{Err: err}
5507	}
5508
5509	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5510		return out, metadata, &smithy.SerializationError{Err: err}
5511	}
5512	in.Request = request
5513
5514	return next.HandleSerialize(ctx, in)
5515}
5516
5517type awsAwsjson11_serializeOpPeerVpc struct {
5518}
5519
5520func (*awsAwsjson11_serializeOpPeerVpc) ID() string {
5521	return "OperationSerializer"
5522}
5523
5524func (m *awsAwsjson11_serializeOpPeerVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5525	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5526) {
5527	request, ok := in.Request.(*smithyhttp.Request)
5528	if !ok {
5529		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5530	}
5531
5532	input, ok := in.Parameters.(*PeerVpcInput)
5533	_ = input
5534	if !ok {
5535		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5536	}
5537
5538	request.Request.URL.Path = "/"
5539	request.Request.Method = "POST"
5540	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5541	if err != nil {
5542		return out, metadata, &smithy.SerializationError{Err: err}
5543	}
5544	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5545	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.PeerVpc")
5546
5547	jsonEncoder := smithyjson.NewEncoder()
5548	if err := awsAwsjson11_serializeOpDocumentPeerVpcInput(input, jsonEncoder.Value); err != nil {
5549		return out, metadata, &smithy.SerializationError{Err: err}
5550	}
5551
5552	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5553		return out, metadata, &smithy.SerializationError{Err: err}
5554	}
5555
5556	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5557		return out, metadata, &smithy.SerializationError{Err: err}
5558	}
5559	in.Request = request
5560
5561	return next.HandleSerialize(ctx, in)
5562}
5563
5564type awsAwsjson11_serializeOpPutAlarm struct {
5565}
5566
5567func (*awsAwsjson11_serializeOpPutAlarm) ID() string {
5568	return "OperationSerializer"
5569}
5570
5571func (m *awsAwsjson11_serializeOpPutAlarm) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5572	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5573) {
5574	request, ok := in.Request.(*smithyhttp.Request)
5575	if !ok {
5576		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5577	}
5578
5579	input, ok := in.Parameters.(*PutAlarmInput)
5580	_ = input
5581	if !ok {
5582		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5583	}
5584
5585	request.Request.URL.Path = "/"
5586	request.Request.Method = "POST"
5587	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5588	if err != nil {
5589		return out, metadata, &smithy.SerializationError{Err: err}
5590	}
5591	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5592	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.PutAlarm")
5593
5594	jsonEncoder := smithyjson.NewEncoder()
5595	if err := awsAwsjson11_serializeOpDocumentPutAlarmInput(input, jsonEncoder.Value); err != nil {
5596		return out, metadata, &smithy.SerializationError{Err: err}
5597	}
5598
5599	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5600		return out, metadata, &smithy.SerializationError{Err: err}
5601	}
5602
5603	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5604		return out, metadata, &smithy.SerializationError{Err: err}
5605	}
5606	in.Request = request
5607
5608	return next.HandleSerialize(ctx, in)
5609}
5610
5611type awsAwsjson11_serializeOpPutInstancePublicPorts struct {
5612}
5613
5614func (*awsAwsjson11_serializeOpPutInstancePublicPorts) ID() string {
5615	return "OperationSerializer"
5616}
5617
5618func (m *awsAwsjson11_serializeOpPutInstancePublicPorts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5619	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5620) {
5621	request, ok := in.Request.(*smithyhttp.Request)
5622	if !ok {
5623		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5624	}
5625
5626	input, ok := in.Parameters.(*PutInstancePublicPortsInput)
5627	_ = input
5628	if !ok {
5629		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5630	}
5631
5632	request.Request.URL.Path = "/"
5633	request.Request.Method = "POST"
5634	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5635	if err != nil {
5636		return out, metadata, &smithy.SerializationError{Err: err}
5637	}
5638	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5639	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.PutInstancePublicPorts")
5640
5641	jsonEncoder := smithyjson.NewEncoder()
5642	if err := awsAwsjson11_serializeOpDocumentPutInstancePublicPortsInput(input, jsonEncoder.Value); err != nil {
5643		return out, metadata, &smithy.SerializationError{Err: err}
5644	}
5645
5646	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5647		return out, metadata, &smithy.SerializationError{Err: err}
5648	}
5649
5650	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5651		return out, metadata, &smithy.SerializationError{Err: err}
5652	}
5653	in.Request = request
5654
5655	return next.HandleSerialize(ctx, in)
5656}
5657
5658type awsAwsjson11_serializeOpRebootInstance struct {
5659}
5660
5661func (*awsAwsjson11_serializeOpRebootInstance) ID() string {
5662	return "OperationSerializer"
5663}
5664
5665func (m *awsAwsjson11_serializeOpRebootInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5666	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5667) {
5668	request, ok := in.Request.(*smithyhttp.Request)
5669	if !ok {
5670		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5671	}
5672
5673	input, ok := in.Parameters.(*RebootInstanceInput)
5674	_ = input
5675	if !ok {
5676		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5677	}
5678
5679	request.Request.URL.Path = "/"
5680	request.Request.Method = "POST"
5681	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5682	if err != nil {
5683		return out, metadata, &smithy.SerializationError{Err: err}
5684	}
5685	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5686	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.RebootInstance")
5687
5688	jsonEncoder := smithyjson.NewEncoder()
5689	if err := awsAwsjson11_serializeOpDocumentRebootInstanceInput(input, jsonEncoder.Value); err != nil {
5690		return out, metadata, &smithy.SerializationError{Err: err}
5691	}
5692
5693	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5694		return out, metadata, &smithy.SerializationError{Err: err}
5695	}
5696
5697	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5698		return out, metadata, &smithy.SerializationError{Err: err}
5699	}
5700	in.Request = request
5701
5702	return next.HandleSerialize(ctx, in)
5703}
5704
5705type awsAwsjson11_serializeOpRebootRelationalDatabase struct {
5706}
5707
5708func (*awsAwsjson11_serializeOpRebootRelationalDatabase) ID() string {
5709	return "OperationSerializer"
5710}
5711
5712func (m *awsAwsjson11_serializeOpRebootRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5713	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5714) {
5715	request, ok := in.Request.(*smithyhttp.Request)
5716	if !ok {
5717		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5718	}
5719
5720	input, ok := in.Parameters.(*RebootRelationalDatabaseInput)
5721	_ = input
5722	if !ok {
5723		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5724	}
5725
5726	request.Request.URL.Path = "/"
5727	request.Request.Method = "POST"
5728	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5729	if err != nil {
5730		return out, metadata, &smithy.SerializationError{Err: err}
5731	}
5732	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5733	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.RebootRelationalDatabase")
5734
5735	jsonEncoder := smithyjson.NewEncoder()
5736	if err := awsAwsjson11_serializeOpDocumentRebootRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
5737		return out, metadata, &smithy.SerializationError{Err: err}
5738	}
5739
5740	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5741		return out, metadata, &smithy.SerializationError{Err: err}
5742	}
5743
5744	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5745		return out, metadata, &smithy.SerializationError{Err: err}
5746	}
5747	in.Request = request
5748
5749	return next.HandleSerialize(ctx, in)
5750}
5751
5752type awsAwsjson11_serializeOpRegisterContainerImage struct {
5753}
5754
5755func (*awsAwsjson11_serializeOpRegisterContainerImage) ID() string {
5756	return "OperationSerializer"
5757}
5758
5759func (m *awsAwsjson11_serializeOpRegisterContainerImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5760	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5761) {
5762	request, ok := in.Request.(*smithyhttp.Request)
5763	if !ok {
5764		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5765	}
5766
5767	input, ok := in.Parameters.(*RegisterContainerImageInput)
5768	_ = input
5769	if !ok {
5770		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5771	}
5772
5773	request.Request.URL.Path = "/"
5774	request.Request.Method = "POST"
5775	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5776	if err != nil {
5777		return out, metadata, &smithy.SerializationError{Err: err}
5778	}
5779	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5780	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.RegisterContainerImage")
5781
5782	jsonEncoder := smithyjson.NewEncoder()
5783	if err := awsAwsjson11_serializeOpDocumentRegisterContainerImageInput(input, jsonEncoder.Value); err != nil {
5784		return out, metadata, &smithy.SerializationError{Err: err}
5785	}
5786
5787	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5788		return out, metadata, &smithy.SerializationError{Err: err}
5789	}
5790
5791	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5792		return out, metadata, &smithy.SerializationError{Err: err}
5793	}
5794	in.Request = request
5795
5796	return next.HandleSerialize(ctx, in)
5797}
5798
5799type awsAwsjson11_serializeOpReleaseStaticIp struct {
5800}
5801
5802func (*awsAwsjson11_serializeOpReleaseStaticIp) ID() string {
5803	return "OperationSerializer"
5804}
5805
5806func (m *awsAwsjson11_serializeOpReleaseStaticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5807	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5808) {
5809	request, ok := in.Request.(*smithyhttp.Request)
5810	if !ok {
5811		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5812	}
5813
5814	input, ok := in.Parameters.(*ReleaseStaticIpInput)
5815	_ = input
5816	if !ok {
5817		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5818	}
5819
5820	request.Request.URL.Path = "/"
5821	request.Request.Method = "POST"
5822	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5823	if err != nil {
5824		return out, metadata, &smithy.SerializationError{Err: err}
5825	}
5826	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5827	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.ReleaseStaticIp")
5828
5829	jsonEncoder := smithyjson.NewEncoder()
5830	if err := awsAwsjson11_serializeOpDocumentReleaseStaticIpInput(input, jsonEncoder.Value); err != nil {
5831		return out, metadata, &smithy.SerializationError{Err: err}
5832	}
5833
5834	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5835		return out, metadata, &smithy.SerializationError{Err: err}
5836	}
5837
5838	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5839		return out, metadata, &smithy.SerializationError{Err: err}
5840	}
5841	in.Request = request
5842
5843	return next.HandleSerialize(ctx, in)
5844}
5845
5846type awsAwsjson11_serializeOpResetDistributionCache struct {
5847}
5848
5849func (*awsAwsjson11_serializeOpResetDistributionCache) ID() string {
5850	return "OperationSerializer"
5851}
5852
5853func (m *awsAwsjson11_serializeOpResetDistributionCache) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5854	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5855) {
5856	request, ok := in.Request.(*smithyhttp.Request)
5857	if !ok {
5858		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5859	}
5860
5861	input, ok := in.Parameters.(*ResetDistributionCacheInput)
5862	_ = input
5863	if !ok {
5864		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5865	}
5866
5867	request.Request.URL.Path = "/"
5868	request.Request.Method = "POST"
5869	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5870	if err != nil {
5871		return out, metadata, &smithy.SerializationError{Err: err}
5872	}
5873	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5874	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.ResetDistributionCache")
5875
5876	jsonEncoder := smithyjson.NewEncoder()
5877	if err := awsAwsjson11_serializeOpDocumentResetDistributionCacheInput(input, jsonEncoder.Value); err != nil {
5878		return out, metadata, &smithy.SerializationError{Err: err}
5879	}
5880
5881	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5882		return out, metadata, &smithy.SerializationError{Err: err}
5883	}
5884
5885	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5886		return out, metadata, &smithy.SerializationError{Err: err}
5887	}
5888	in.Request = request
5889
5890	return next.HandleSerialize(ctx, in)
5891}
5892
5893type awsAwsjson11_serializeOpSendContactMethodVerification struct {
5894}
5895
5896func (*awsAwsjson11_serializeOpSendContactMethodVerification) ID() string {
5897	return "OperationSerializer"
5898}
5899
5900func (m *awsAwsjson11_serializeOpSendContactMethodVerification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5901	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5902) {
5903	request, ok := in.Request.(*smithyhttp.Request)
5904	if !ok {
5905		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5906	}
5907
5908	input, ok := in.Parameters.(*SendContactMethodVerificationInput)
5909	_ = input
5910	if !ok {
5911		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5912	}
5913
5914	request.Request.URL.Path = "/"
5915	request.Request.Method = "POST"
5916	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5917	if err != nil {
5918		return out, metadata, &smithy.SerializationError{Err: err}
5919	}
5920	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5921	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.SendContactMethodVerification")
5922
5923	jsonEncoder := smithyjson.NewEncoder()
5924	if err := awsAwsjson11_serializeOpDocumentSendContactMethodVerificationInput(input, jsonEncoder.Value); err != nil {
5925		return out, metadata, &smithy.SerializationError{Err: err}
5926	}
5927
5928	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5929		return out, metadata, &smithy.SerializationError{Err: err}
5930	}
5931
5932	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5933		return out, metadata, &smithy.SerializationError{Err: err}
5934	}
5935	in.Request = request
5936
5937	return next.HandleSerialize(ctx, in)
5938}
5939
5940type awsAwsjson11_serializeOpSetIpAddressType struct {
5941}
5942
5943func (*awsAwsjson11_serializeOpSetIpAddressType) ID() string {
5944	return "OperationSerializer"
5945}
5946
5947func (m *awsAwsjson11_serializeOpSetIpAddressType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5948	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5949) {
5950	request, ok := in.Request.(*smithyhttp.Request)
5951	if !ok {
5952		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5953	}
5954
5955	input, ok := in.Parameters.(*SetIpAddressTypeInput)
5956	_ = input
5957	if !ok {
5958		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5959	}
5960
5961	request.Request.URL.Path = "/"
5962	request.Request.Method = "POST"
5963	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5964	if err != nil {
5965		return out, metadata, &smithy.SerializationError{Err: err}
5966	}
5967	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
5968	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.SetIpAddressType")
5969
5970	jsonEncoder := smithyjson.NewEncoder()
5971	if err := awsAwsjson11_serializeOpDocumentSetIpAddressTypeInput(input, jsonEncoder.Value); err != nil {
5972		return out, metadata, &smithy.SerializationError{Err: err}
5973	}
5974
5975	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5976		return out, metadata, &smithy.SerializationError{Err: err}
5977	}
5978
5979	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
5980		return out, metadata, &smithy.SerializationError{Err: err}
5981	}
5982	in.Request = request
5983
5984	return next.HandleSerialize(ctx, in)
5985}
5986
5987type awsAwsjson11_serializeOpStartInstance struct {
5988}
5989
5990func (*awsAwsjson11_serializeOpStartInstance) ID() string {
5991	return "OperationSerializer"
5992}
5993
5994func (m *awsAwsjson11_serializeOpStartInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5995	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5996) {
5997	request, ok := in.Request.(*smithyhttp.Request)
5998	if !ok {
5999		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6000	}
6001
6002	input, ok := in.Parameters.(*StartInstanceInput)
6003	_ = input
6004	if !ok {
6005		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6006	}
6007
6008	request.Request.URL.Path = "/"
6009	request.Request.Method = "POST"
6010	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6011	if err != nil {
6012		return out, metadata, &smithy.SerializationError{Err: err}
6013	}
6014	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6015	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.StartInstance")
6016
6017	jsonEncoder := smithyjson.NewEncoder()
6018	if err := awsAwsjson11_serializeOpDocumentStartInstanceInput(input, jsonEncoder.Value); err != nil {
6019		return out, metadata, &smithy.SerializationError{Err: err}
6020	}
6021
6022	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6023		return out, metadata, &smithy.SerializationError{Err: err}
6024	}
6025
6026	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6027		return out, metadata, &smithy.SerializationError{Err: err}
6028	}
6029	in.Request = request
6030
6031	return next.HandleSerialize(ctx, in)
6032}
6033
6034type awsAwsjson11_serializeOpStartRelationalDatabase struct {
6035}
6036
6037func (*awsAwsjson11_serializeOpStartRelationalDatabase) ID() string {
6038	return "OperationSerializer"
6039}
6040
6041func (m *awsAwsjson11_serializeOpStartRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6042	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6043) {
6044	request, ok := in.Request.(*smithyhttp.Request)
6045	if !ok {
6046		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6047	}
6048
6049	input, ok := in.Parameters.(*StartRelationalDatabaseInput)
6050	_ = input
6051	if !ok {
6052		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6053	}
6054
6055	request.Request.URL.Path = "/"
6056	request.Request.Method = "POST"
6057	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6058	if err != nil {
6059		return out, metadata, &smithy.SerializationError{Err: err}
6060	}
6061	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6062	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.StartRelationalDatabase")
6063
6064	jsonEncoder := smithyjson.NewEncoder()
6065	if err := awsAwsjson11_serializeOpDocumentStartRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
6066		return out, metadata, &smithy.SerializationError{Err: err}
6067	}
6068
6069	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6070		return out, metadata, &smithy.SerializationError{Err: err}
6071	}
6072
6073	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6074		return out, metadata, &smithy.SerializationError{Err: err}
6075	}
6076	in.Request = request
6077
6078	return next.HandleSerialize(ctx, in)
6079}
6080
6081type awsAwsjson11_serializeOpStopInstance struct {
6082}
6083
6084func (*awsAwsjson11_serializeOpStopInstance) ID() string {
6085	return "OperationSerializer"
6086}
6087
6088func (m *awsAwsjson11_serializeOpStopInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6089	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6090) {
6091	request, ok := in.Request.(*smithyhttp.Request)
6092	if !ok {
6093		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6094	}
6095
6096	input, ok := in.Parameters.(*StopInstanceInput)
6097	_ = input
6098	if !ok {
6099		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6100	}
6101
6102	request.Request.URL.Path = "/"
6103	request.Request.Method = "POST"
6104	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6105	if err != nil {
6106		return out, metadata, &smithy.SerializationError{Err: err}
6107	}
6108	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6109	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.StopInstance")
6110
6111	jsonEncoder := smithyjson.NewEncoder()
6112	if err := awsAwsjson11_serializeOpDocumentStopInstanceInput(input, jsonEncoder.Value); err != nil {
6113		return out, metadata, &smithy.SerializationError{Err: err}
6114	}
6115
6116	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6117		return out, metadata, &smithy.SerializationError{Err: err}
6118	}
6119
6120	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6121		return out, metadata, &smithy.SerializationError{Err: err}
6122	}
6123	in.Request = request
6124
6125	return next.HandleSerialize(ctx, in)
6126}
6127
6128type awsAwsjson11_serializeOpStopRelationalDatabase struct {
6129}
6130
6131func (*awsAwsjson11_serializeOpStopRelationalDatabase) ID() string {
6132	return "OperationSerializer"
6133}
6134
6135func (m *awsAwsjson11_serializeOpStopRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6136	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6137) {
6138	request, ok := in.Request.(*smithyhttp.Request)
6139	if !ok {
6140		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6141	}
6142
6143	input, ok := in.Parameters.(*StopRelationalDatabaseInput)
6144	_ = input
6145	if !ok {
6146		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6147	}
6148
6149	request.Request.URL.Path = "/"
6150	request.Request.Method = "POST"
6151	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6152	if err != nil {
6153		return out, metadata, &smithy.SerializationError{Err: err}
6154	}
6155	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6156	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.StopRelationalDatabase")
6157
6158	jsonEncoder := smithyjson.NewEncoder()
6159	if err := awsAwsjson11_serializeOpDocumentStopRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
6160		return out, metadata, &smithy.SerializationError{Err: err}
6161	}
6162
6163	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6164		return out, metadata, &smithy.SerializationError{Err: err}
6165	}
6166
6167	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6168		return out, metadata, &smithy.SerializationError{Err: err}
6169	}
6170	in.Request = request
6171
6172	return next.HandleSerialize(ctx, in)
6173}
6174
6175type awsAwsjson11_serializeOpTagResource struct {
6176}
6177
6178func (*awsAwsjson11_serializeOpTagResource) ID() string {
6179	return "OperationSerializer"
6180}
6181
6182func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6183	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6184) {
6185	request, ok := in.Request.(*smithyhttp.Request)
6186	if !ok {
6187		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6188	}
6189
6190	input, ok := in.Parameters.(*TagResourceInput)
6191	_ = input
6192	if !ok {
6193		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6194	}
6195
6196	request.Request.URL.Path = "/"
6197	request.Request.Method = "POST"
6198	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6199	if err != nil {
6200		return out, metadata, &smithy.SerializationError{Err: err}
6201	}
6202	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6203	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.TagResource")
6204
6205	jsonEncoder := smithyjson.NewEncoder()
6206	if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
6207		return out, metadata, &smithy.SerializationError{Err: err}
6208	}
6209
6210	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6211		return out, metadata, &smithy.SerializationError{Err: err}
6212	}
6213
6214	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6215		return out, metadata, &smithy.SerializationError{Err: err}
6216	}
6217	in.Request = request
6218
6219	return next.HandleSerialize(ctx, in)
6220}
6221
6222type awsAwsjson11_serializeOpTestAlarm struct {
6223}
6224
6225func (*awsAwsjson11_serializeOpTestAlarm) ID() string {
6226	return "OperationSerializer"
6227}
6228
6229func (m *awsAwsjson11_serializeOpTestAlarm) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6230	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6231) {
6232	request, ok := in.Request.(*smithyhttp.Request)
6233	if !ok {
6234		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6235	}
6236
6237	input, ok := in.Parameters.(*TestAlarmInput)
6238	_ = input
6239	if !ok {
6240		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6241	}
6242
6243	request.Request.URL.Path = "/"
6244	request.Request.Method = "POST"
6245	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6246	if err != nil {
6247		return out, metadata, &smithy.SerializationError{Err: err}
6248	}
6249	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6250	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.TestAlarm")
6251
6252	jsonEncoder := smithyjson.NewEncoder()
6253	if err := awsAwsjson11_serializeOpDocumentTestAlarmInput(input, jsonEncoder.Value); err != nil {
6254		return out, metadata, &smithy.SerializationError{Err: err}
6255	}
6256
6257	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6258		return out, metadata, &smithy.SerializationError{Err: err}
6259	}
6260
6261	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6262		return out, metadata, &smithy.SerializationError{Err: err}
6263	}
6264	in.Request = request
6265
6266	return next.HandleSerialize(ctx, in)
6267}
6268
6269type awsAwsjson11_serializeOpUnpeerVpc struct {
6270}
6271
6272func (*awsAwsjson11_serializeOpUnpeerVpc) ID() string {
6273	return "OperationSerializer"
6274}
6275
6276func (m *awsAwsjson11_serializeOpUnpeerVpc) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6277	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6278) {
6279	request, ok := in.Request.(*smithyhttp.Request)
6280	if !ok {
6281		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6282	}
6283
6284	input, ok := in.Parameters.(*UnpeerVpcInput)
6285	_ = input
6286	if !ok {
6287		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6288	}
6289
6290	request.Request.URL.Path = "/"
6291	request.Request.Method = "POST"
6292	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6293	if err != nil {
6294		return out, metadata, &smithy.SerializationError{Err: err}
6295	}
6296	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6297	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UnpeerVpc")
6298
6299	jsonEncoder := smithyjson.NewEncoder()
6300	if err := awsAwsjson11_serializeOpDocumentUnpeerVpcInput(input, jsonEncoder.Value); err != nil {
6301		return out, metadata, &smithy.SerializationError{Err: err}
6302	}
6303
6304	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6305		return out, metadata, &smithy.SerializationError{Err: err}
6306	}
6307
6308	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6309		return out, metadata, &smithy.SerializationError{Err: err}
6310	}
6311	in.Request = request
6312
6313	return next.HandleSerialize(ctx, in)
6314}
6315
6316type awsAwsjson11_serializeOpUntagResource struct {
6317}
6318
6319func (*awsAwsjson11_serializeOpUntagResource) ID() string {
6320	return "OperationSerializer"
6321}
6322
6323func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6324	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6325) {
6326	request, ok := in.Request.(*smithyhttp.Request)
6327	if !ok {
6328		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6329	}
6330
6331	input, ok := in.Parameters.(*UntagResourceInput)
6332	_ = input
6333	if !ok {
6334		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6335	}
6336
6337	request.Request.URL.Path = "/"
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.UntagResource")
6345
6346	jsonEncoder := smithyjson.NewEncoder()
6347	if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(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	return next.HandleSerialize(ctx, in)
6361}
6362
6363type awsAwsjson11_serializeOpUpdateContainerService struct {
6364}
6365
6366func (*awsAwsjson11_serializeOpUpdateContainerService) ID() string {
6367	return "OperationSerializer"
6368}
6369
6370func (m *awsAwsjson11_serializeOpUpdateContainerService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6371	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6372) {
6373	request, ok := in.Request.(*smithyhttp.Request)
6374	if !ok {
6375		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6376	}
6377
6378	input, ok := in.Parameters.(*UpdateContainerServiceInput)
6379	_ = input
6380	if !ok {
6381		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6382	}
6383
6384	request.Request.URL.Path = "/"
6385	request.Request.Method = "POST"
6386	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6387	if err != nil {
6388		return out, metadata, &smithy.SerializationError{Err: err}
6389	}
6390	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6391	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateContainerService")
6392
6393	jsonEncoder := smithyjson.NewEncoder()
6394	if err := awsAwsjson11_serializeOpDocumentUpdateContainerServiceInput(input, jsonEncoder.Value); err != nil {
6395		return out, metadata, &smithy.SerializationError{Err: err}
6396	}
6397
6398	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6399		return out, metadata, &smithy.SerializationError{Err: err}
6400	}
6401
6402	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6403		return out, metadata, &smithy.SerializationError{Err: err}
6404	}
6405	in.Request = request
6406
6407	return next.HandleSerialize(ctx, in)
6408}
6409
6410type awsAwsjson11_serializeOpUpdateDistribution struct {
6411}
6412
6413func (*awsAwsjson11_serializeOpUpdateDistribution) ID() string {
6414	return "OperationSerializer"
6415}
6416
6417func (m *awsAwsjson11_serializeOpUpdateDistribution) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6418	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6419) {
6420	request, ok := in.Request.(*smithyhttp.Request)
6421	if !ok {
6422		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6423	}
6424
6425	input, ok := in.Parameters.(*UpdateDistributionInput)
6426	_ = input
6427	if !ok {
6428		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6429	}
6430
6431	request.Request.URL.Path = "/"
6432	request.Request.Method = "POST"
6433	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6434	if err != nil {
6435		return out, metadata, &smithy.SerializationError{Err: err}
6436	}
6437	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6438	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateDistribution")
6439
6440	jsonEncoder := smithyjson.NewEncoder()
6441	if err := awsAwsjson11_serializeOpDocumentUpdateDistributionInput(input, jsonEncoder.Value); err != nil {
6442		return out, metadata, &smithy.SerializationError{Err: err}
6443	}
6444
6445	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6446		return out, metadata, &smithy.SerializationError{Err: err}
6447	}
6448
6449	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6450		return out, metadata, &smithy.SerializationError{Err: err}
6451	}
6452	in.Request = request
6453
6454	return next.HandleSerialize(ctx, in)
6455}
6456
6457type awsAwsjson11_serializeOpUpdateDistributionBundle struct {
6458}
6459
6460func (*awsAwsjson11_serializeOpUpdateDistributionBundle) ID() string {
6461	return "OperationSerializer"
6462}
6463
6464func (m *awsAwsjson11_serializeOpUpdateDistributionBundle) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6465	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6466) {
6467	request, ok := in.Request.(*smithyhttp.Request)
6468	if !ok {
6469		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6470	}
6471
6472	input, ok := in.Parameters.(*UpdateDistributionBundleInput)
6473	_ = input
6474	if !ok {
6475		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6476	}
6477
6478	request.Request.URL.Path = "/"
6479	request.Request.Method = "POST"
6480	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6481	if err != nil {
6482		return out, metadata, &smithy.SerializationError{Err: err}
6483	}
6484	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6485	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateDistributionBundle")
6486
6487	jsonEncoder := smithyjson.NewEncoder()
6488	if err := awsAwsjson11_serializeOpDocumentUpdateDistributionBundleInput(input, jsonEncoder.Value); err != nil {
6489		return out, metadata, &smithy.SerializationError{Err: err}
6490	}
6491
6492	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6493		return out, metadata, &smithy.SerializationError{Err: err}
6494	}
6495
6496	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6497		return out, metadata, &smithy.SerializationError{Err: err}
6498	}
6499	in.Request = request
6500
6501	return next.HandleSerialize(ctx, in)
6502}
6503
6504type awsAwsjson11_serializeOpUpdateDomainEntry struct {
6505}
6506
6507func (*awsAwsjson11_serializeOpUpdateDomainEntry) ID() string {
6508	return "OperationSerializer"
6509}
6510
6511func (m *awsAwsjson11_serializeOpUpdateDomainEntry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6512	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6513) {
6514	request, ok := in.Request.(*smithyhttp.Request)
6515	if !ok {
6516		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6517	}
6518
6519	input, ok := in.Parameters.(*UpdateDomainEntryInput)
6520	_ = input
6521	if !ok {
6522		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6523	}
6524
6525	request.Request.URL.Path = "/"
6526	request.Request.Method = "POST"
6527	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6528	if err != nil {
6529		return out, metadata, &smithy.SerializationError{Err: err}
6530	}
6531	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6532	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateDomainEntry")
6533
6534	jsonEncoder := smithyjson.NewEncoder()
6535	if err := awsAwsjson11_serializeOpDocumentUpdateDomainEntryInput(input, jsonEncoder.Value); err != nil {
6536		return out, metadata, &smithy.SerializationError{Err: err}
6537	}
6538
6539	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6540		return out, metadata, &smithy.SerializationError{Err: err}
6541	}
6542
6543	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6544		return out, metadata, &smithy.SerializationError{Err: err}
6545	}
6546	in.Request = request
6547
6548	return next.HandleSerialize(ctx, in)
6549}
6550
6551type awsAwsjson11_serializeOpUpdateLoadBalancerAttribute struct {
6552}
6553
6554func (*awsAwsjson11_serializeOpUpdateLoadBalancerAttribute) ID() string {
6555	return "OperationSerializer"
6556}
6557
6558func (m *awsAwsjson11_serializeOpUpdateLoadBalancerAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6559	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6560) {
6561	request, ok := in.Request.(*smithyhttp.Request)
6562	if !ok {
6563		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6564	}
6565
6566	input, ok := in.Parameters.(*UpdateLoadBalancerAttributeInput)
6567	_ = input
6568	if !ok {
6569		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6570	}
6571
6572	request.Request.URL.Path = "/"
6573	request.Request.Method = "POST"
6574	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6575	if err != nil {
6576		return out, metadata, &smithy.SerializationError{Err: err}
6577	}
6578	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6579	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateLoadBalancerAttribute")
6580
6581	jsonEncoder := smithyjson.NewEncoder()
6582	if err := awsAwsjson11_serializeOpDocumentUpdateLoadBalancerAttributeInput(input, jsonEncoder.Value); err != nil {
6583		return out, metadata, &smithy.SerializationError{Err: err}
6584	}
6585
6586	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6587		return out, metadata, &smithy.SerializationError{Err: err}
6588	}
6589
6590	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6591		return out, metadata, &smithy.SerializationError{Err: err}
6592	}
6593	in.Request = request
6594
6595	return next.HandleSerialize(ctx, in)
6596}
6597
6598type awsAwsjson11_serializeOpUpdateRelationalDatabase struct {
6599}
6600
6601func (*awsAwsjson11_serializeOpUpdateRelationalDatabase) ID() string {
6602	return "OperationSerializer"
6603}
6604
6605func (m *awsAwsjson11_serializeOpUpdateRelationalDatabase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6606	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6607) {
6608	request, ok := in.Request.(*smithyhttp.Request)
6609	if !ok {
6610		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6611	}
6612
6613	input, ok := in.Parameters.(*UpdateRelationalDatabaseInput)
6614	_ = input
6615	if !ok {
6616		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6617	}
6618
6619	request.Request.URL.Path = "/"
6620	request.Request.Method = "POST"
6621	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6622	if err != nil {
6623		return out, metadata, &smithy.SerializationError{Err: err}
6624	}
6625	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6626	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateRelationalDatabase")
6627
6628	jsonEncoder := smithyjson.NewEncoder()
6629	if err := awsAwsjson11_serializeOpDocumentUpdateRelationalDatabaseInput(input, jsonEncoder.Value); err != nil {
6630		return out, metadata, &smithy.SerializationError{Err: err}
6631	}
6632
6633	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6634		return out, metadata, &smithy.SerializationError{Err: err}
6635	}
6636
6637	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6638		return out, metadata, &smithy.SerializationError{Err: err}
6639	}
6640	in.Request = request
6641
6642	return next.HandleSerialize(ctx, in)
6643}
6644
6645type awsAwsjson11_serializeOpUpdateRelationalDatabaseParameters struct {
6646}
6647
6648func (*awsAwsjson11_serializeOpUpdateRelationalDatabaseParameters) ID() string {
6649	return "OperationSerializer"
6650}
6651
6652func (m *awsAwsjson11_serializeOpUpdateRelationalDatabaseParameters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6653	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6654) {
6655	request, ok := in.Request.(*smithyhttp.Request)
6656	if !ok {
6657		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6658	}
6659
6660	input, ok := in.Parameters.(*UpdateRelationalDatabaseParametersInput)
6661	_ = input
6662	if !ok {
6663		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6664	}
6665
6666	request.Request.URL.Path = "/"
6667	request.Request.Method = "POST"
6668	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6669	if err != nil {
6670		return out, metadata, &smithy.SerializationError{Err: err}
6671	}
6672	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
6673	httpBindingEncoder.SetHeader("X-Amz-Target").String("Lightsail_20161128.UpdateRelationalDatabaseParameters")
6674
6675	jsonEncoder := smithyjson.NewEncoder()
6676	if err := awsAwsjson11_serializeOpDocumentUpdateRelationalDatabaseParametersInput(input, jsonEncoder.Value); err != nil {
6677		return out, metadata, &smithy.SerializationError{Err: err}
6678	}
6679
6680	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6681		return out, metadata, &smithy.SerializationError{Err: err}
6682	}
6683
6684	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
6685		return out, metadata, &smithy.SerializationError{Err: err}
6686	}
6687	in.Request = request
6688
6689	return next.HandleSerialize(ctx, in)
6690}
6691func awsAwsjson11_serializeDocumentAddOnRequest(v *types.AddOnRequest, value smithyjson.Value) error {
6692	object := value.Object()
6693	defer object.Close()
6694
6695	if len(v.AddOnType) > 0 {
6696		ok := object.Key("addOnType")
6697		ok.String(string(v.AddOnType))
6698	}
6699
6700	if v.AutoSnapshotAddOnRequest != nil {
6701		ok := object.Key("autoSnapshotAddOnRequest")
6702		if err := awsAwsjson11_serializeDocumentAutoSnapshotAddOnRequest(v.AutoSnapshotAddOnRequest, ok); err != nil {
6703			return err
6704		}
6705	}
6706
6707	return nil
6708}
6709
6710func awsAwsjson11_serializeDocumentAddOnRequestList(v []types.AddOnRequest, value smithyjson.Value) error {
6711	array := value.Array()
6712	defer array.Close()
6713
6714	for i := range v {
6715		av := array.Value()
6716		if err := awsAwsjson11_serializeDocumentAddOnRequest(&v[i], av); err != nil {
6717			return err
6718		}
6719	}
6720	return nil
6721}
6722
6723func awsAwsjson11_serializeDocumentAttachedDiskMap(v map[string][]types.DiskMap, value smithyjson.Value) error {
6724	object := value.Object()
6725	defer object.Close()
6726
6727	for key := range v {
6728		om := object.Key(key)
6729		if vv := v[key]; vv == nil {
6730			continue
6731		}
6732		if err := awsAwsjson11_serializeDocumentDiskMapList(v[key], om); err != nil {
6733			return err
6734		}
6735	}
6736	return nil
6737}
6738
6739func awsAwsjson11_serializeDocumentAutoSnapshotAddOnRequest(v *types.AutoSnapshotAddOnRequest, value smithyjson.Value) error {
6740	object := value.Object()
6741	defer object.Close()
6742
6743	if v.SnapshotTimeOfDay != nil {
6744		ok := object.Key("snapshotTimeOfDay")
6745		ok.String(*v.SnapshotTimeOfDay)
6746	}
6747
6748	return nil
6749}
6750
6751func awsAwsjson11_serializeDocumentCacheBehavior(v *types.CacheBehavior, value smithyjson.Value) error {
6752	object := value.Object()
6753	defer object.Close()
6754
6755	if len(v.Behavior) > 0 {
6756		ok := object.Key("behavior")
6757		ok.String(string(v.Behavior))
6758	}
6759
6760	return nil
6761}
6762
6763func awsAwsjson11_serializeDocumentCacheBehaviorList(v []types.CacheBehaviorPerPath, value smithyjson.Value) error {
6764	array := value.Array()
6765	defer array.Close()
6766
6767	for i := range v {
6768		av := array.Value()
6769		if err := awsAwsjson11_serializeDocumentCacheBehaviorPerPath(&v[i], av); err != nil {
6770			return err
6771		}
6772	}
6773	return nil
6774}
6775
6776func awsAwsjson11_serializeDocumentCacheBehaviorPerPath(v *types.CacheBehaviorPerPath, value smithyjson.Value) error {
6777	object := value.Object()
6778	defer object.Close()
6779
6780	if len(v.Behavior) > 0 {
6781		ok := object.Key("behavior")
6782		ok.String(string(v.Behavior))
6783	}
6784
6785	if v.Path != nil {
6786		ok := object.Key("path")
6787		ok.String(*v.Path)
6788	}
6789
6790	return nil
6791}
6792
6793func awsAwsjson11_serializeDocumentCacheSettings(v *types.CacheSettings, value smithyjson.Value) error {
6794	object := value.Object()
6795	defer object.Close()
6796
6797	if v.AllowedHTTPMethods != nil {
6798		ok := object.Key("allowedHTTPMethods")
6799		ok.String(*v.AllowedHTTPMethods)
6800	}
6801
6802	if v.CachedHTTPMethods != nil {
6803		ok := object.Key("cachedHTTPMethods")
6804		ok.String(*v.CachedHTTPMethods)
6805	}
6806
6807	if v.DefaultTTL != nil {
6808		ok := object.Key("defaultTTL")
6809		ok.Long(*v.DefaultTTL)
6810	}
6811
6812	if v.ForwardedCookies != nil {
6813		ok := object.Key("forwardedCookies")
6814		if err := awsAwsjson11_serializeDocumentCookieObject(v.ForwardedCookies, ok); err != nil {
6815			return err
6816		}
6817	}
6818
6819	if v.ForwardedHeaders != nil {
6820		ok := object.Key("forwardedHeaders")
6821		if err := awsAwsjson11_serializeDocumentHeaderObject(v.ForwardedHeaders, ok); err != nil {
6822			return err
6823		}
6824	}
6825
6826	if v.ForwardedQueryStrings != nil {
6827		ok := object.Key("forwardedQueryStrings")
6828		if err := awsAwsjson11_serializeDocumentQueryStringObject(v.ForwardedQueryStrings, ok); err != nil {
6829			return err
6830		}
6831	}
6832
6833	if v.MaximumTTL != nil {
6834		ok := object.Key("maximumTTL")
6835		ok.Long(*v.MaximumTTL)
6836	}
6837
6838	if v.MinimumTTL != nil {
6839		ok := object.Key("minimumTTL")
6840		ok.Long(*v.MinimumTTL)
6841	}
6842
6843	return nil
6844}
6845
6846func awsAwsjson11_serializeDocumentCertificateStatusList(v []types.CertificateStatus, value smithyjson.Value) error {
6847	array := value.Array()
6848	defer array.Close()
6849
6850	for i := range v {
6851		av := array.Value()
6852		av.String(string(v[i]))
6853	}
6854	return nil
6855}
6856
6857func awsAwsjson11_serializeDocumentContactProtocolsList(v []types.ContactProtocol, value smithyjson.Value) error {
6858	array := value.Array()
6859	defer array.Close()
6860
6861	for i := range v {
6862		av := array.Value()
6863		av.String(string(v[i]))
6864	}
6865	return nil
6866}
6867
6868func awsAwsjson11_serializeDocumentContainer(v *types.Container, value smithyjson.Value) error {
6869	object := value.Object()
6870	defer object.Close()
6871
6872	if v.Command != nil {
6873		ok := object.Key("command")
6874		if err := awsAwsjson11_serializeDocumentStringList(v.Command, ok); err != nil {
6875			return err
6876		}
6877	}
6878
6879	if v.Environment != nil {
6880		ok := object.Key("environment")
6881		if err := awsAwsjson11_serializeDocumentEnvironment(v.Environment, ok); err != nil {
6882			return err
6883		}
6884	}
6885
6886	if v.Image != nil {
6887		ok := object.Key("image")
6888		ok.String(*v.Image)
6889	}
6890
6891	if v.Ports != nil {
6892		ok := object.Key("ports")
6893		if err := awsAwsjson11_serializeDocumentPortMap(v.Ports, ok); err != nil {
6894			return err
6895		}
6896	}
6897
6898	return nil
6899}
6900
6901func awsAwsjson11_serializeDocumentContainerMap(v map[string]types.Container, value smithyjson.Value) error {
6902	object := value.Object()
6903	defer object.Close()
6904
6905	for key := range v {
6906		om := object.Key(key)
6907		mapVar := v[key]
6908		if err := awsAwsjson11_serializeDocumentContainer(&mapVar, om); err != nil {
6909			return err
6910		}
6911	}
6912	return nil
6913}
6914
6915func awsAwsjson11_serializeDocumentContainerServiceDeploymentRequest(v *types.ContainerServiceDeploymentRequest, value smithyjson.Value) error {
6916	object := value.Object()
6917	defer object.Close()
6918
6919	if v.Containers != nil {
6920		ok := object.Key("containers")
6921		if err := awsAwsjson11_serializeDocumentContainerMap(v.Containers, ok); err != nil {
6922			return err
6923		}
6924	}
6925
6926	if v.PublicEndpoint != nil {
6927		ok := object.Key("publicEndpoint")
6928		if err := awsAwsjson11_serializeDocumentEndpointRequest(v.PublicEndpoint, ok); err != nil {
6929			return err
6930		}
6931	}
6932
6933	return nil
6934}
6935
6936func awsAwsjson11_serializeDocumentContainerServiceHealthCheckConfig(v *types.ContainerServiceHealthCheckConfig, value smithyjson.Value) error {
6937	object := value.Object()
6938	defer object.Close()
6939
6940	if v.HealthyThreshold != nil {
6941		ok := object.Key("healthyThreshold")
6942		ok.Integer(*v.HealthyThreshold)
6943	}
6944
6945	if v.IntervalSeconds != nil {
6946		ok := object.Key("intervalSeconds")
6947		ok.Integer(*v.IntervalSeconds)
6948	}
6949
6950	if v.Path != nil {
6951		ok := object.Key("path")
6952		ok.String(*v.Path)
6953	}
6954
6955	if v.SuccessCodes != nil {
6956		ok := object.Key("successCodes")
6957		ok.String(*v.SuccessCodes)
6958	}
6959
6960	if v.TimeoutSeconds != nil {
6961		ok := object.Key("timeoutSeconds")
6962		ok.Integer(*v.TimeoutSeconds)
6963	}
6964
6965	if v.UnhealthyThreshold != nil {
6966		ok := object.Key("unhealthyThreshold")
6967		ok.Integer(*v.UnhealthyThreshold)
6968	}
6969
6970	return nil
6971}
6972
6973func awsAwsjson11_serializeDocumentContainerServicePublicDomains(v map[string][]string, value smithyjson.Value) error {
6974	object := value.Object()
6975	defer object.Close()
6976
6977	for key := range v {
6978		om := object.Key(key)
6979		if vv := v[key]; vv == nil {
6980			continue
6981		}
6982		if err := awsAwsjson11_serializeDocumentContainerServicePublicDomainsList(v[key], om); err != nil {
6983			return err
6984		}
6985	}
6986	return nil
6987}
6988
6989func awsAwsjson11_serializeDocumentContainerServicePublicDomainsList(v []string, value smithyjson.Value) error {
6990	array := value.Array()
6991	defer array.Close()
6992
6993	for i := range v {
6994		av := array.Value()
6995		av.String(v[i])
6996	}
6997	return nil
6998}
6999
7000func awsAwsjson11_serializeDocumentCookieObject(v *types.CookieObject, value smithyjson.Value) error {
7001	object := value.Object()
7002	defer object.Close()
7003
7004	if v.CookiesAllowList != nil {
7005		ok := object.Key("cookiesAllowList")
7006		if err := awsAwsjson11_serializeDocumentStringList(v.CookiesAllowList, ok); err != nil {
7007			return err
7008		}
7009	}
7010
7011	if len(v.Option) > 0 {
7012		ok := object.Key("option")
7013		ok.String(string(v.Option))
7014	}
7015
7016	return nil
7017}
7018
7019func awsAwsjson11_serializeDocumentDiskMap(v *types.DiskMap, value smithyjson.Value) error {
7020	object := value.Object()
7021	defer object.Close()
7022
7023	if v.NewDiskName != nil {
7024		ok := object.Key("newDiskName")
7025		ok.String(*v.NewDiskName)
7026	}
7027
7028	if v.OriginalDiskPath != nil {
7029		ok := object.Key("originalDiskPath")
7030		ok.String(*v.OriginalDiskPath)
7031	}
7032
7033	return nil
7034}
7035
7036func awsAwsjson11_serializeDocumentDiskMapList(v []types.DiskMap, value smithyjson.Value) error {
7037	array := value.Array()
7038	defer array.Close()
7039
7040	for i := range v {
7041		av := array.Value()
7042		if err := awsAwsjson11_serializeDocumentDiskMap(&v[i], av); err != nil {
7043			return err
7044		}
7045	}
7046	return nil
7047}
7048
7049func awsAwsjson11_serializeDocumentDomainEntry(v *types.DomainEntry, value smithyjson.Value) error {
7050	object := value.Object()
7051	defer object.Close()
7052
7053	if v.Id != nil {
7054		ok := object.Key("id")
7055		ok.String(*v.Id)
7056	}
7057
7058	if v.IsAlias != nil {
7059		ok := object.Key("isAlias")
7060		ok.Boolean(*v.IsAlias)
7061	}
7062
7063	if v.Name != nil {
7064		ok := object.Key("name")
7065		ok.String(*v.Name)
7066	}
7067
7068	if v.Options != nil {
7069		ok := object.Key("options")
7070		if err := awsAwsjson11_serializeDocumentDomainEntryOptions(v.Options, ok); err != nil {
7071			return err
7072		}
7073	}
7074
7075	if v.Target != nil {
7076		ok := object.Key("target")
7077		ok.String(*v.Target)
7078	}
7079
7080	if v.Type != nil {
7081		ok := object.Key("type")
7082		ok.String(*v.Type)
7083	}
7084
7085	return nil
7086}
7087
7088func awsAwsjson11_serializeDocumentDomainEntryOptions(v map[string]string, value smithyjson.Value) error {
7089	object := value.Object()
7090	defer object.Close()
7091
7092	for key := range v {
7093		om := object.Key(key)
7094		om.String(v[key])
7095	}
7096	return nil
7097}
7098
7099func awsAwsjson11_serializeDocumentDomainNameList(v []string, value smithyjson.Value) error {
7100	array := value.Array()
7101	defer array.Close()
7102
7103	for i := range v {
7104		av := array.Value()
7105		av.String(v[i])
7106	}
7107	return nil
7108}
7109
7110func awsAwsjson11_serializeDocumentEndpointRequest(v *types.EndpointRequest, value smithyjson.Value) error {
7111	object := value.Object()
7112	defer object.Close()
7113
7114	if v.ContainerName != nil {
7115		ok := object.Key("containerName")
7116		ok.String(*v.ContainerName)
7117	}
7118
7119	if v.ContainerPort != nil {
7120		ok := object.Key("containerPort")
7121		ok.Integer(*v.ContainerPort)
7122	}
7123
7124	if v.HealthCheck != nil {
7125		ok := object.Key("healthCheck")
7126		if err := awsAwsjson11_serializeDocumentContainerServiceHealthCheckConfig(v.HealthCheck, ok); err != nil {
7127			return err
7128		}
7129	}
7130
7131	return nil
7132}
7133
7134func awsAwsjson11_serializeDocumentEnvironment(v map[string]string, value smithyjson.Value) error {
7135	object := value.Object()
7136	defer object.Close()
7137
7138	for key := range v {
7139		om := object.Key(key)
7140		om.String(v[key])
7141	}
7142	return nil
7143}
7144
7145func awsAwsjson11_serializeDocumentHeaderForwardList(v []types.HeaderEnum, value smithyjson.Value) error {
7146	array := value.Array()
7147	defer array.Close()
7148
7149	for i := range v {
7150		av := array.Value()
7151		av.String(string(v[i]))
7152	}
7153	return nil
7154}
7155
7156func awsAwsjson11_serializeDocumentHeaderObject(v *types.HeaderObject, value smithyjson.Value) error {
7157	object := value.Object()
7158	defer object.Close()
7159
7160	if v.HeadersAllowList != nil {
7161		ok := object.Key("headersAllowList")
7162		if err := awsAwsjson11_serializeDocumentHeaderForwardList(v.HeadersAllowList, ok); err != nil {
7163			return err
7164		}
7165	}
7166
7167	if len(v.Option) > 0 {
7168		ok := object.Key("option")
7169		ok.String(string(v.Option))
7170	}
7171
7172	return nil
7173}
7174
7175func awsAwsjson11_serializeDocumentInputOrigin(v *types.InputOrigin, value smithyjson.Value) error {
7176	object := value.Object()
7177	defer object.Close()
7178
7179	if v.Name != nil {
7180		ok := object.Key("name")
7181		ok.String(*v.Name)
7182	}
7183
7184	if len(v.ProtocolPolicy) > 0 {
7185		ok := object.Key("protocolPolicy")
7186		ok.String(string(v.ProtocolPolicy))
7187	}
7188
7189	if len(v.RegionName) > 0 {
7190		ok := object.Key("regionName")
7191		ok.String(string(v.RegionName))
7192	}
7193
7194	return nil
7195}
7196
7197func awsAwsjson11_serializeDocumentInstanceEntry(v *types.InstanceEntry, value smithyjson.Value) error {
7198	object := value.Object()
7199	defer object.Close()
7200
7201	if v.AvailabilityZone != nil {
7202		ok := object.Key("availabilityZone")
7203		ok.String(*v.AvailabilityZone)
7204	}
7205
7206	if v.InstanceType != nil {
7207		ok := object.Key("instanceType")
7208		ok.String(*v.InstanceType)
7209	}
7210
7211	if len(v.PortInfoSource) > 0 {
7212		ok := object.Key("portInfoSource")
7213		ok.String(string(v.PortInfoSource))
7214	}
7215
7216	if v.SourceName != nil {
7217		ok := object.Key("sourceName")
7218		ok.String(*v.SourceName)
7219	}
7220
7221	if v.UserData != nil {
7222		ok := object.Key("userData")
7223		ok.String(*v.UserData)
7224	}
7225
7226	return nil
7227}
7228
7229func awsAwsjson11_serializeDocumentInstanceEntryList(v []types.InstanceEntry, value smithyjson.Value) error {
7230	array := value.Array()
7231	defer array.Close()
7232
7233	for i := range v {
7234		av := array.Value()
7235		if err := awsAwsjson11_serializeDocumentInstanceEntry(&v[i], av); err != nil {
7236			return err
7237		}
7238	}
7239	return nil
7240}
7241
7242func awsAwsjson11_serializeDocumentMetricStatisticList(v []types.MetricStatistic, value smithyjson.Value) error {
7243	array := value.Array()
7244	defer array.Close()
7245
7246	for i := range v {
7247		av := array.Value()
7248		av.String(string(v[i]))
7249	}
7250	return nil
7251}
7252
7253func awsAwsjson11_serializeDocumentNotificationTriggerList(v []types.AlarmState, value smithyjson.Value) error {
7254	array := value.Array()
7255	defer array.Close()
7256
7257	for i := range v {
7258		av := array.Value()
7259		av.String(string(v[i]))
7260	}
7261	return nil
7262}
7263
7264func awsAwsjson11_serializeDocumentPortInfo(v *types.PortInfo, value smithyjson.Value) error {
7265	object := value.Object()
7266	defer object.Close()
7267
7268	if v.CidrListAliases != nil {
7269		ok := object.Key("cidrListAliases")
7270		if err := awsAwsjson11_serializeDocumentStringList(v.CidrListAliases, ok); err != nil {
7271			return err
7272		}
7273	}
7274
7275	if v.Cidrs != nil {
7276		ok := object.Key("cidrs")
7277		if err := awsAwsjson11_serializeDocumentStringList(v.Cidrs, ok); err != nil {
7278			return err
7279		}
7280	}
7281
7282	if v.FromPort != 0 {
7283		ok := object.Key("fromPort")
7284		ok.Integer(v.FromPort)
7285	}
7286
7287	if v.Ipv6Cidrs != nil {
7288		ok := object.Key("ipv6Cidrs")
7289		if err := awsAwsjson11_serializeDocumentStringList(v.Ipv6Cidrs, ok); err != nil {
7290			return err
7291		}
7292	}
7293
7294	if len(v.Protocol) > 0 {
7295		ok := object.Key("protocol")
7296		ok.String(string(v.Protocol))
7297	}
7298
7299	if v.ToPort != 0 {
7300		ok := object.Key("toPort")
7301		ok.Integer(v.ToPort)
7302	}
7303
7304	return nil
7305}
7306
7307func awsAwsjson11_serializeDocumentPortInfoList(v []types.PortInfo, value smithyjson.Value) error {
7308	array := value.Array()
7309	defer array.Close()
7310
7311	for i := range v {
7312		av := array.Value()
7313		if err := awsAwsjson11_serializeDocumentPortInfo(&v[i], av); err != nil {
7314			return err
7315		}
7316	}
7317	return nil
7318}
7319
7320func awsAwsjson11_serializeDocumentPortMap(v map[string]types.ContainerServiceProtocol, value smithyjson.Value) error {
7321	object := value.Object()
7322	defer object.Close()
7323
7324	for key := range v {
7325		om := object.Key(key)
7326		om.String(string(v[key]))
7327	}
7328	return nil
7329}
7330
7331func awsAwsjson11_serializeDocumentQueryStringObject(v *types.QueryStringObject, value smithyjson.Value) error {
7332	object := value.Object()
7333	defer object.Close()
7334
7335	if v.Option != nil {
7336		ok := object.Key("option")
7337		ok.Boolean(*v.Option)
7338	}
7339
7340	if v.QueryStringsAllowList != nil {
7341		ok := object.Key("queryStringsAllowList")
7342		if err := awsAwsjson11_serializeDocumentStringList(v.QueryStringsAllowList, ok); err != nil {
7343			return err
7344		}
7345	}
7346
7347	return nil
7348}
7349
7350func awsAwsjson11_serializeDocumentRelationalDatabaseParameter(v *types.RelationalDatabaseParameter, value smithyjson.Value) error {
7351	object := value.Object()
7352	defer object.Close()
7353
7354	if v.AllowedValues != nil {
7355		ok := object.Key("allowedValues")
7356		ok.String(*v.AllowedValues)
7357	}
7358
7359	if v.ApplyMethod != nil {
7360		ok := object.Key("applyMethod")
7361		ok.String(*v.ApplyMethod)
7362	}
7363
7364	if v.ApplyType != nil {
7365		ok := object.Key("applyType")
7366		ok.String(*v.ApplyType)
7367	}
7368
7369	if v.DataType != nil {
7370		ok := object.Key("dataType")
7371		ok.String(*v.DataType)
7372	}
7373
7374	if v.Description != nil {
7375		ok := object.Key("description")
7376		ok.String(*v.Description)
7377	}
7378
7379	if v.IsModifiable != nil {
7380		ok := object.Key("isModifiable")
7381		ok.Boolean(*v.IsModifiable)
7382	}
7383
7384	if v.ParameterName != nil {
7385		ok := object.Key("parameterName")
7386		ok.String(*v.ParameterName)
7387	}
7388
7389	if v.ParameterValue != nil {
7390		ok := object.Key("parameterValue")
7391		ok.String(*v.ParameterValue)
7392	}
7393
7394	return nil
7395}
7396
7397func awsAwsjson11_serializeDocumentRelationalDatabaseParameterList(v []types.RelationalDatabaseParameter, value smithyjson.Value) error {
7398	array := value.Array()
7399	defer array.Close()
7400
7401	for i := range v {
7402		av := array.Value()
7403		if err := awsAwsjson11_serializeDocumentRelationalDatabaseParameter(&v[i], av); err != nil {
7404			return err
7405		}
7406	}
7407	return nil
7408}
7409
7410func awsAwsjson11_serializeDocumentResourceNameList(v []string, value smithyjson.Value) error {
7411	array := value.Array()
7412	defer array.Close()
7413
7414	for i := range v {
7415		av := array.Value()
7416		av.String(v[i])
7417	}
7418	return nil
7419}
7420
7421func awsAwsjson11_serializeDocumentStringList(v []string, value smithyjson.Value) error {
7422	array := value.Array()
7423	defer array.Close()
7424
7425	for i := range v {
7426		av := array.Value()
7427		av.String(v[i])
7428	}
7429	return nil
7430}
7431
7432func awsAwsjson11_serializeDocumentSubjectAlternativeNameList(v []string, value smithyjson.Value) error {
7433	array := value.Array()
7434	defer array.Close()
7435
7436	for i := range v {
7437		av := array.Value()
7438		av.String(v[i])
7439	}
7440	return nil
7441}
7442
7443func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
7444	object := value.Object()
7445	defer object.Close()
7446
7447	if v.Key != nil {
7448		ok := object.Key("key")
7449		ok.String(*v.Key)
7450	}
7451
7452	if v.Value != nil {
7453		ok := object.Key("value")
7454		ok.String(*v.Value)
7455	}
7456
7457	return nil
7458}
7459
7460func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
7461	array := value.Array()
7462	defer array.Close()
7463
7464	for i := range v {
7465		av := array.Value()
7466		av.String(v[i])
7467	}
7468	return nil
7469}
7470
7471func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
7472	array := value.Array()
7473	defer array.Close()
7474
7475	for i := range v {
7476		av := array.Value()
7477		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
7478			return err
7479		}
7480	}
7481	return nil
7482}
7483
7484func awsAwsjson11_serializeOpDocumentAllocateStaticIpInput(v *AllocateStaticIpInput, value smithyjson.Value) error {
7485	object := value.Object()
7486	defer object.Close()
7487
7488	if v.StaticIpName != nil {
7489		ok := object.Key("staticIpName")
7490		ok.String(*v.StaticIpName)
7491	}
7492
7493	return nil
7494}
7495
7496func awsAwsjson11_serializeOpDocumentAttachCertificateToDistributionInput(v *AttachCertificateToDistributionInput, value smithyjson.Value) error {
7497	object := value.Object()
7498	defer object.Close()
7499
7500	if v.CertificateName != nil {
7501		ok := object.Key("certificateName")
7502		ok.String(*v.CertificateName)
7503	}
7504
7505	if v.DistributionName != nil {
7506		ok := object.Key("distributionName")
7507		ok.String(*v.DistributionName)
7508	}
7509
7510	return nil
7511}
7512
7513func awsAwsjson11_serializeOpDocumentAttachDiskInput(v *AttachDiskInput, value smithyjson.Value) error {
7514	object := value.Object()
7515	defer object.Close()
7516
7517	if v.DiskName != nil {
7518		ok := object.Key("diskName")
7519		ok.String(*v.DiskName)
7520	}
7521
7522	if v.DiskPath != nil {
7523		ok := object.Key("diskPath")
7524		ok.String(*v.DiskPath)
7525	}
7526
7527	if v.InstanceName != nil {
7528		ok := object.Key("instanceName")
7529		ok.String(*v.InstanceName)
7530	}
7531
7532	return nil
7533}
7534
7535func awsAwsjson11_serializeOpDocumentAttachInstancesToLoadBalancerInput(v *AttachInstancesToLoadBalancerInput, value smithyjson.Value) error {
7536	object := value.Object()
7537	defer object.Close()
7538
7539	if v.InstanceNames != nil {
7540		ok := object.Key("instanceNames")
7541		if err := awsAwsjson11_serializeDocumentResourceNameList(v.InstanceNames, ok); err != nil {
7542			return err
7543		}
7544	}
7545
7546	if v.LoadBalancerName != nil {
7547		ok := object.Key("loadBalancerName")
7548		ok.String(*v.LoadBalancerName)
7549	}
7550
7551	return nil
7552}
7553
7554func awsAwsjson11_serializeOpDocumentAttachLoadBalancerTlsCertificateInput(v *AttachLoadBalancerTlsCertificateInput, value smithyjson.Value) error {
7555	object := value.Object()
7556	defer object.Close()
7557
7558	if v.CertificateName != nil {
7559		ok := object.Key("certificateName")
7560		ok.String(*v.CertificateName)
7561	}
7562
7563	if v.LoadBalancerName != nil {
7564		ok := object.Key("loadBalancerName")
7565		ok.String(*v.LoadBalancerName)
7566	}
7567
7568	return nil
7569}
7570
7571func awsAwsjson11_serializeOpDocumentAttachStaticIpInput(v *AttachStaticIpInput, value smithyjson.Value) error {
7572	object := value.Object()
7573	defer object.Close()
7574
7575	if v.InstanceName != nil {
7576		ok := object.Key("instanceName")
7577		ok.String(*v.InstanceName)
7578	}
7579
7580	if v.StaticIpName != nil {
7581		ok := object.Key("staticIpName")
7582		ok.String(*v.StaticIpName)
7583	}
7584
7585	return nil
7586}
7587
7588func awsAwsjson11_serializeOpDocumentCloseInstancePublicPortsInput(v *CloseInstancePublicPortsInput, value smithyjson.Value) error {
7589	object := value.Object()
7590	defer object.Close()
7591
7592	if v.InstanceName != nil {
7593		ok := object.Key("instanceName")
7594		ok.String(*v.InstanceName)
7595	}
7596
7597	if v.PortInfo != nil {
7598		ok := object.Key("portInfo")
7599		if err := awsAwsjson11_serializeDocumentPortInfo(v.PortInfo, ok); err != nil {
7600			return err
7601		}
7602	}
7603
7604	return nil
7605}
7606
7607func awsAwsjson11_serializeOpDocumentCopySnapshotInput(v *CopySnapshotInput, value smithyjson.Value) error {
7608	object := value.Object()
7609	defer object.Close()
7610
7611	if v.RestoreDate != nil {
7612		ok := object.Key("restoreDate")
7613		ok.String(*v.RestoreDate)
7614	}
7615
7616	if len(v.SourceRegion) > 0 {
7617		ok := object.Key("sourceRegion")
7618		ok.String(string(v.SourceRegion))
7619	}
7620
7621	if v.SourceResourceName != nil {
7622		ok := object.Key("sourceResourceName")
7623		ok.String(*v.SourceResourceName)
7624	}
7625
7626	if v.SourceSnapshotName != nil {
7627		ok := object.Key("sourceSnapshotName")
7628		ok.String(*v.SourceSnapshotName)
7629	}
7630
7631	if v.TargetSnapshotName != nil {
7632		ok := object.Key("targetSnapshotName")
7633		ok.String(*v.TargetSnapshotName)
7634	}
7635
7636	if v.UseLatestRestorableAutoSnapshot != nil {
7637		ok := object.Key("useLatestRestorableAutoSnapshot")
7638		ok.Boolean(*v.UseLatestRestorableAutoSnapshot)
7639	}
7640
7641	return nil
7642}
7643
7644func awsAwsjson11_serializeOpDocumentCreateCertificateInput(v *CreateCertificateInput, value smithyjson.Value) error {
7645	object := value.Object()
7646	defer object.Close()
7647
7648	if v.CertificateName != nil {
7649		ok := object.Key("certificateName")
7650		ok.String(*v.CertificateName)
7651	}
7652
7653	if v.DomainName != nil {
7654		ok := object.Key("domainName")
7655		ok.String(*v.DomainName)
7656	}
7657
7658	if v.SubjectAlternativeNames != nil {
7659		ok := object.Key("subjectAlternativeNames")
7660		if err := awsAwsjson11_serializeDocumentSubjectAlternativeNameList(v.SubjectAlternativeNames, ok); err != nil {
7661			return err
7662		}
7663	}
7664
7665	if v.Tags != nil {
7666		ok := object.Key("tags")
7667		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
7668			return err
7669		}
7670	}
7671
7672	return nil
7673}
7674
7675func awsAwsjson11_serializeOpDocumentCreateCloudFormationStackInput(v *CreateCloudFormationStackInput, value smithyjson.Value) error {
7676	object := value.Object()
7677	defer object.Close()
7678
7679	if v.Instances != nil {
7680		ok := object.Key("instances")
7681		if err := awsAwsjson11_serializeDocumentInstanceEntryList(v.Instances, ok); err != nil {
7682			return err
7683		}
7684	}
7685
7686	return nil
7687}
7688
7689func awsAwsjson11_serializeOpDocumentCreateContactMethodInput(v *CreateContactMethodInput, value smithyjson.Value) error {
7690	object := value.Object()
7691	defer object.Close()
7692
7693	if v.ContactEndpoint != nil {
7694		ok := object.Key("contactEndpoint")
7695		ok.String(*v.ContactEndpoint)
7696	}
7697
7698	if len(v.Protocol) > 0 {
7699		ok := object.Key("protocol")
7700		ok.String(string(v.Protocol))
7701	}
7702
7703	return nil
7704}
7705
7706func awsAwsjson11_serializeOpDocumentCreateContainerServiceDeploymentInput(v *CreateContainerServiceDeploymentInput, value smithyjson.Value) error {
7707	object := value.Object()
7708	defer object.Close()
7709
7710	if v.Containers != nil {
7711		ok := object.Key("containers")
7712		if err := awsAwsjson11_serializeDocumentContainerMap(v.Containers, ok); err != nil {
7713			return err
7714		}
7715	}
7716
7717	if v.PublicEndpoint != nil {
7718		ok := object.Key("publicEndpoint")
7719		if err := awsAwsjson11_serializeDocumentEndpointRequest(v.PublicEndpoint, ok); err != nil {
7720			return err
7721		}
7722	}
7723
7724	if v.ServiceName != nil {
7725		ok := object.Key("serviceName")
7726		ok.String(*v.ServiceName)
7727	}
7728
7729	return nil
7730}
7731
7732func awsAwsjson11_serializeOpDocumentCreateContainerServiceInput(v *CreateContainerServiceInput, value smithyjson.Value) error {
7733	object := value.Object()
7734	defer object.Close()
7735
7736	if v.Deployment != nil {
7737		ok := object.Key("deployment")
7738		if err := awsAwsjson11_serializeDocumentContainerServiceDeploymentRequest(v.Deployment, ok); err != nil {
7739			return err
7740		}
7741	}
7742
7743	if len(v.Power) > 0 {
7744		ok := object.Key("power")
7745		ok.String(string(v.Power))
7746	}
7747
7748	if v.PublicDomainNames != nil {
7749		ok := object.Key("publicDomainNames")
7750		if err := awsAwsjson11_serializeDocumentContainerServicePublicDomains(v.PublicDomainNames, ok); err != nil {
7751			return err
7752		}
7753	}
7754
7755	if v.Scale != nil {
7756		ok := object.Key("scale")
7757		ok.Integer(*v.Scale)
7758	}
7759
7760	if v.ServiceName != nil {
7761		ok := object.Key("serviceName")
7762		ok.String(*v.ServiceName)
7763	}
7764
7765	if v.Tags != nil {
7766		ok := object.Key("tags")
7767		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
7768			return err
7769		}
7770	}
7771
7772	return nil
7773}
7774
7775func awsAwsjson11_serializeOpDocumentCreateContainerServiceRegistryLoginInput(v *CreateContainerServiceRegistryLoginInput, value smithyjson.Value) error {
7776	object := value.Object()
7777	defer object.Close()
7778
7779	return nil
7780}
7781
7782func awsAwsjson11_serializeOpDocumentCreateDiskFromSnapshotInput(v *CreateDiskFromSnapshotInput, value smithyjson.Value) error {
7783	object := value.Object()
7784	defer object.Close()
7785
7786	if v.AddOns != nil {
7787		ok := object.Key("addOns")
7788		if err := awsAwsjson11_serializeDocumentAddOnRequestList(v.AddOns, ok); err != nil {
7789			return err
7790		}
7791	}
7792
7793	if v.AvailabilityZone != nil {
7794		ok := object.Key("availabilityZone")
7795		ok.String(*v.AvailabilityZone)
7796	}
7797
7798	if v.DiskName != nil {
7799		ok := object.Key("diskName")
7800		ok.String(*v.DiskName)
7801	}
7802
7803	if v.DiskSnapshotName != nil {
7804		ok := object.Key("diskSnapshotName")
7805		ok.String(*v.DiskSnapshotName)
7806	}
7807
7808	if v.RestoreDate != nil {
7809		ok := object.Key("restoreDate")
7810		ok.String(*v.RestoreDate)
7811	}
7812
7813	if v.SizeInGb != nil {
7814		ok := object.Key("sizeInGb")
7815		ok.Integer(*v.SizeInGb)
7816	}
7817
7818	if v.SourceDiskName != nil {
7819		ok := object.Key("sourceDiskName")
7820		ok.String(*v.SourceDiskName)
7821	}
7822
7823	if v.Tags != nil {
7824		ok := object.Key("tags")
7825		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
7826			return err
7827		}
7828	}
7829
7830	if v.UseLatestRestorableAutoSnapshot != nil {
7831		ok := object.Key("useLatestRestorableAutoSnapshot")
7832		ok.Boolean(*v.UseLatestRestorableAutoSnapshot)
7833	}
7834
7835	return nil
7836}
7837
7838func awsAwsjson11_serializeOpDocumentCreateDiskInput(v *CreateDiskInput, value smithyjson.Value) error {
7839	object := value.Object()
7840	defer object.Close()
7841
7842	if v.AddOns != nil {
7843		ok := object.Key("addOns")
7844		if err := awsAwsjson11_serializeDocumentAddOnRequestList(v.AddOns, ok); err != nil {
7845			return err
7846		}
7847	}
7848
7849	if v.AvailabilityZone != nil {
7850		ok := object.Key("availabilityZone")
7851		ok.String(*v.AvailabilityZone)
7852	}
7853
7854	if v.DiskName != nil {
7855		ok := object.Key("diskName")
7856		ok.String(*v.DiskName)
7857	}
7858
7859	if v.SizeInGb != nil {
7860		ok := object.Key("sizeInGb")
7861		ok.Integer(*v.SizeInGb)
7862	}
7863
7864	if v.Tags != nil {
7865		ok := object.Key("tags")
7866		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
7867			return err
7868		}
7869	}
7870
7871	return nil
7872}
7873
7874func awsAwsjson11_serializeOpDocumentCreateDiskSnapshotInput(v *CreateDiskSnapshotInput, value smithyjson.Value) error {
7875	object := value.Object()
7876	defer object.Close()
7877
7878	if v.DiskName != nil {
7879		ok := object.Key("diskName")
7880		ok.String(*v.DiskName)
7881	}
7882
7883	if v.DiskSnapshotName != nil {
7884		ok := object.Key("diskSnapshotName")
7885		ok.String(*v.DiskSnapshotName)
7886	}
7887
7888	if v.InstanceName != nil {
7889		ok := object.Key("instanceName")
7890		ok.String(*v.InstanceName)
7891	}
7892
7893	if v.Tags != nil {
7894		ok := object.Key("tags")
7895		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
7896			return err
7897		}
7898	}
7899
7900	return nil
7901}
7902
7903func awsAwsjson11_serializeOpDocumentCreateDistributionInput(v *CreateDistributionInput, value smithyjson.Value) error {
7904	object := value.Object()
7905	defer object.Close()
7906
7907	if v.BundleId != nil {
7908		ok := object.Key("bundleId")
7909		ok.String(*v.BundleId)
7910	}
7911
7912	if v.CacheBehaviors != nil {
7913		ok := object.Key("cacheBehaviors")
7914		if err := awsAwsjson11_serializeDocumentCacheBehaviorList(v.CacheBehaviors, ok); err != nil {
7915			return err
7916		}
7917	}
7918
7919	if v.CacheBehaviorSettings != nil {
7920		ok := object.Key("cacheBehaviorSettings")
7921		if err := awsAwsjson11_serializeDocumentCacheSettings(v.CacheBehaviorSettings, ok); err != nil {
7922			return err
7923		}
7924	}
7925
7926	if v.DefaultCacheBehavior != nil {
7927		ok := object.Key("defaultCacheBehavior")
7928		if err := awsAwsjson11_serializeDocumentCacheBehavior(v.DefaultCacheBehavior, ok); err != nil {
7929			return err
7930		}
7931	}
7932
7933	if v.DistributionName != nil {
7934		ok := object.Key("distributionName")
7935		ok.String(*v.DistributionName)
7936	}
7937
7938	if len(v.IpAddressType) > 0 {
7939		ok := object.Key("ipAddressType")
7940		ok.String(string(v.IpAddressType))
7941	}
7942
7943	if v.Origin != nil {
7944		ok := object.Key("origin")
7945		if err := awsAwsjson11_serializeDocumentInputOrigin(v.Origin, ok); err != nil {
7946			return err
7947		}
7948	}
7949
7950	if v.Tags != nil {
7951		ok := object.Key("tags")
7952		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
7953			return err
7954		}
7955	}
7956
7957	return nil
7958}
7959
7960func awsAwsjson11_serializeOpDocumentCreateDomainEntryInput(v *CreateDomainEntryInput, value smithyjson.Value) error {
7961	object := value.Object()
7962	defer object.Close()
7963
7964	if v.DomainEntry != nil {
7965		ok := object.Key("domainEntry")
7966		if err := awsAwsjson11_serializeDocumentDomainEntry(v.DomainEntry, ok); err != nil {
7967			return err
7968		}
7969	}
7970
7971	if v.DomainName != nil {
7972		ok := object.Key("domainName")
7973		ok.String(*v.DomainName)
7974	}
7975
7976	return nil
7977}
7978
7979func awsAwsjson11_serializeOpDocumentCreateDomainInput(v *CreateDomainInput, value smithyjson.Value) error {
7980	object := value.Object()
7981	defer object.Close()
7982
7983	if v.DomainName != nil {
7984		ok := object.Key("domainName")
7985		ok.String(*v.DomainName)
7986	}
7987
7988	if v.Tags != nil {
7989		ok := object.Key("tags")
7990		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
7991			return err
7992		}
7993	}
7994
7995	return nil
7996}
7997
7998func awsAwsjson11_serializeOpDocumentCreateInstancesFromSnapshotInput(v *CreateInstancesFromSnapshotInput, value smithyjson.Value) error {
7999	object := value.Object()
8000	defer object.Close()
8001
8002	if v.AddOns != nil {
8003		ok := object.Key("addOns")
8004		if err := awsAwsjson11_serializeDocumentAddOnRequestList(v.AddOns, ok); err != nil {
8005			return err
8006		}
8007	}
8008
8009	if v.AttachedDiskMapping != nil {
8010		ok := object.Key("attachedDiskMapping")
8011		if err := awsAwsjson11_serializeDocumentAttachedDiskMap(v.AttachedDiskMapping, ok); err != nil {
8012			return err
8013		}
8014	}
8015
8016	if v.AvailabilityZone != nil {
8017		ok := object.Key("availabilityZone")
8018		ok.String(*v.AvailabilityZone)
8019	}
8020
8021	if v.BundleId != nil {
8022		ok := object.Key("bundleId")
8023		ok.String(*v.BundleId)
8024	}
8025
8026	if v.InstanceNames != nil {
8027		ok := object.Key("instanceNames")
8028		if err := awsAwsjson11_serializeDocumentStringList(v.InstanceNames, ok); err != nil {
8029			return err
8030		}
8031	}
8032
8033	if v.InstanceSnapshotName != nil {
8034		ok := object.Key("instanceSnapshotName")
8035		ok.String(*v.InstanceSnapshotName)
8036	}
8037
8038	if len(v.IpAddressType) > 0 {
8039		ok := object.Key("ipAddressType")
8040		ok.String(string(v.IpAddressType))
8041	}
8042
8043	if v.KeyPairName != nil {
8044		ok := object.Key("keyPairName")
8045		ok.String(*v.KeyPairName)
8046	}
8047
8048	if v.RestoreDate != nil {
8049		ok := object.Key("restoreDate")
8050		ok.String(*v.RestoreDate)
8051	}
8052
8053	if v.SourceInstanceName != nil {
8054		ok := object.Key("sourceInstanceName")
8055		ok.String(*v.SourceInstanceName)
8056	}
8057
8058	if v.Tags != nil {
8059		ok := object.Key("tags")
8060		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
8061			return err
8062		}
8063	}
8064
8065	if v.UseLatestRestorableAutoSnapshot != nil {
8066		ok := object.Key("useLatestRestorableAutoSnapshot")
8067		ok.Boolean(*v.UseLatestRestorableAutoSnapshot)
8068	}
8069
8070	if v.UserData != nil {
8071		ok := object.Key("userData")
8072		ok.String(*v.UserData)
8073	}
8074
8075	return nil
8076}
8077
8078func awsAwsjson11_serializeOpDocumentCreateInstancesInput(v *CreateInstancesInput, value smithyjson.Value) error {
8079	object := value.Object()
8080	defer object.Close()
8081
8082	if v.AddOns != nil {
8083		ok := object.Key("addOns")
8084		if err := awsAwsjson11_serializeDocumentAddOnRequestList(v.AddOns, ok); err != nil {
8085			return err
8086		}
8087	}
8088
8089	if v.AvailabilityZone != nil {
8090		ok := object.Key("availabilityZone")
8091		ok.String(*v.AvailabilityZone)
8092	}
8093
8094	if v.BlueprintId != nil {
8095		ok := object.Key("blueprintId")
8096		ok.String(*v.BlueprintId)
8097	}
8098
8099	if v.BundleId != nil {
8100		ok := object.Key("bundleId")
8101		ok.String(*v.BundleId)
8102	}
8103
8104	if v.CustomImageName != nil {
8105		ok := object.Key("customImageName")
8106		ok.String(*v.CustomImageName)
8107	}
8108
8109	if v.InstanceNames != nil {
8110		ok := object.Key("instanceNames")
8111		if err := awsAwsjson11_serializeDocumentStringList(v.InstanceNames, ok); err != nil {
8112			return err
8113		}
8114	}
8115
8116	if len(v.IpAddressType) > 0 {
8117		ok := object.Key("ipAddressType")
8118		ok.String(string(v.IpAddressType))
8119	}
8120
8121	if v.KeyPairName != nil {
8122		ok := object.Key("keyPairName")
8123		ok.String(*v.KeyPairName)
8124	}
8125
8126	if v.Tags != nil {
8127		ok := object.Key("tags")
8128		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
8129			return err
8130		}
8131	}
8132
8133	if v.UserData != nil {
8134		ok := object.Key("userData")
8135		ok.String(*v.UserData)
8136	}
8137
8138	return nil
8139}
8140
8141func awsAwsjson11_serializeOpDocumentCreateInstanceSnapshotInput(v *CreateInstanceSnapshotInput, value smithyjson.Value) error {
8142	object := value.Object()
8143	defer object.Close()
8144
8145	if v.InstanceName != nil {
8146		ok := object.Key("instanceName")
8147		ok.String(*v.InstanceName)
8148	}
8149
8150	if v.InstanceSnapshotName != nil {
8151		ok := object.Key("instanceSnapshotName")
8152		ok.String(*v.InstanceSnapshotName)
8153	}
8154
8155	if v.Tags != nil {
8156		ok := object.Key("tags")
8157		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
8158			return err
8159		}
8160	}
8161
8162	return nil
8163}
8164
8165func awsAwsjson11_serializeOpDocumentCreateKeyPairInput(v *CreateKeyPairInput, value smithyjson.Value) error {
8166	object := value.Object()
8167	defer object.Close()
8168
8169	if v.KeyPairName != nil {
8170		ok := object.Key("keyPairName")
8171		ok.String(*v.KeyPairName)
8172	}
8173
8174	if v.Tags != nil {
8175		ok := object.Key("tags")
8176		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
8177			return err
8178		}
8179	}
8180
8181	return nil
8182}
8183
8184func awsAwsjson11_serializeOpDocumentCreateLoadBalancerInput(v *CreateLoadBalancerInput, value smithyjson.Value) error {
8185	object := value.Object()
8186	defer object.Close()
8187
8188	if v.CertificateAlternativeNames != nil {
8189		ok := object.Key("certificateAlternativeNames")
8190		if err := awsAwsjson11_serializeDocumentDomainNameList(v.CertificateAlternativeNames, ok); err != nil {
8191			return err
8192		}
8193	}
8194
8195	if v.CertificateDomainName != nil {
8196		ok := object.Key("certificateDomainName")
8197		ok.String(*v.CertificateDomainName)
8198	}
8199
8200	if v.CertificateName != nil {
8201		ok := object.Key("certificateName")
8202		ok.String(*v.CertificateName)
8203	}
8204
8205	if v.HealthCheckPath != nil {
8206		ok := object.Key("healthCheckPath")
8207		ok.String(*v.HealthCheckPath)
8208	}
8209
8210	{
8211		ok := object.Key("instancePort")
8212		ok.Integer(v.InstancePort)
8213	}
8214
8215	if len(v.IpAddressType) > 0 {
8216		ok := object.Key("ipAddressType")
8217		ok.String(string(v.IpAddressType))
8218	}
8219
8220	if v.LoadBalancerName != nil {
8221		ok := object.Key("loadBalancerName")
8222		ok.String(*v.LoadBalancerName)
8223	}
8224
8225	if v.Tags != nil {
8226		ok := object.Key("tags")
8227		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
8228			return err
8229		}
8230	}
8231
8232	return nil
8233}
8234
8235func awsAwsjson11_serializeOpDocumentCreateLoadBalancerTlsCertificateInput(v *CreateLoadBalancerTlsCertificateInput, value smithyjson.Value) error {
8236	object := value.Object()
8237	defer object.Close()
8238
8239	if v.CertificateAlternativeNames != nil {
8240		ok := object.Key("certificateAlternativeNames")
8241		if err := awsAwsjson11_serializeDocumentDomainNameList(v.CertificateAlternativeNames, ok); err != nil {
8242			return err
8243		}
8244	}
8245
8246	if v.CertificateDomainName != nil {
8247		ok := object.Key("certificateDomainName")
8248		ok.String(*v.CertificateDomainName)
8249	}
8250
8251	if v.CertificateName != nil {
8252		ok := object.Key("certificateName")
8253		ok.String(*v.CertificateName)
8254	}
8255
8256	if v.LoadBalancerName != nil {
8257		ok := object.Key("loadBalancerName")
8258		ok.String(*v.LoadBalancerName)
8259	}
8260
8261	if v.Tags != nil {
8262		ok := object.Key("tags")
8263		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
8264			return err
8265		}
8266	}
8267
8268	return nil
8269}
8270
8271func awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseFromSnapshotInput(v *CreateRelationalDatabaseFromSnapshotInput, value smithyjson.Value) error {
8272	object := value.Object()
8273	defer object.Close()
8274
8275	if v.AvailabilityZone != nil {
8276		ok := object.Key("availabilityZone")
8277		ok.String(*v.AvailabilityZone)
8278	}
8279
8280	if v.PubliclyAccessible != nil {
8281		ok := object.Key("publiclyAccessible")
8282		ok.Boolean(*v.PubliclyAccessible)
8283	}
8284
8285	if v.RelationalDatabaseBundleId != nil {
8286		ok := object.Key("relationalDatabaseBundleId")
8287		ok.String(*v.RelationalDatabaseBundleId)
8288	}
8289
8290	if v.RelationalDatabaseName != nil {
8291		ok := object.Key("relationalDatabaseName")
8292		ok.String(*v.RelationalDatabaseName)
8293	}
8294
8295	if v.RelationalDatabaseSnapshotName != nil {
8296		ok := object.Key("relationalDatabaseSnapshotName")
8297		ok.String(*v.RelationalDatabaseSnapshotName)
8298	}
8299
8300	if v.RestoreTime != nil {
8301		ok := object.Key("restoreTime")
8302		ok.Double(smithytime.FormatEpochSeconds(*v.RestoreTime))
8303	}
8304
8305	if v.SourceRelationalDatabaseName != nil {
8306		ok := object.Key("sourceRelationalDatabaseName")
8307		ok.String(*v.SourceRelationalDatabaseName)
8308	}
8309
8310	if v.Tags != nil {
8311		ok := object.Key("tags")
8312		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
8313			return err
8314		}
8315	}
8316
8317	if v.UseLatestRestorableTime != nil {
8318		ok := object.Key("useLatestRestorableTime")
8319		ok.Boolean(*v.UseLatestRestorableTime)
8320	}
8321
8322	return nil
8323}
8324
8325func awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseInput(v *CreateRelationalDatabaseInput, value smithyjson.Value) error {
8326	object := value.Object()
8327	defer object.Close()
8328
8329	if v.AvailabilityZone != nil {
8330		ok := object.Key("availabilityZone")
8331		ok.String(*v.AvailabilityZone)
8332	}
8333
8334	if v.MasterDatabaseName != nil {
8335		ok := object.Key("masterDatabaseName")
8336		ok.String(*v.MasterDatabaseName)
8337	}
8338
8339	if v.MasterUsername != nil {
8340		ok := object.Key("masterUsername")
8341		ok.String(*v.MasterUsername)
8342	}
8343
8344	if v.MasterUserPassword != nil {
8345		ok := object.Key("masterUserPassword")
8346		ok.String(*v.MasterUserPassword)
8347	}
8348
8349	if v.PreferredBackupWindow != nil {
8350		ok := object.Key("preferredBackupWindow")
8351		ok.String(*v.PreferredBackupWindow)
8352	}
8353
8354	if v.PreferredMaintenanceWindow != nil {
8355		ok := object.Key("preferredMaintenanceWindow")
8356		ok.String(*v.PreferredMaintenanceWindow)
8357	}
8358
8359	if v.PubliclyAccessible != nil {
8360		ok := object.Key("publiclyAccessible")
8361		ok.Boolean(*v.PubliclyAccessible)
8362	}
8363
8364	if v.RelationalDatabaseBlueprintId != nil {
8365		ok := object.Key("relationalDatabaseBlueprintId")
8366		ok.String(*v.RelationalDatabaseBlueprintId)
8367	}
8368
8369	if v.RelationalDatabaseBundleId != nil {
8370		ok := object.Key("relationalDatabaseBundleId")
8371		ok.String(*v.RelationalDatabaseBundleId)
8372	}
8373
8374	if v.RelationalDatabaseName != nil {
8375		ok := object.Key("relationalDatabaseName")
8376		ok.String(*v.RelationalDatabaseName)
8377	}
8378
8379	if v.Tags != nil {
8380		ok := object.Key("tags")
8381		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
8382			return err
8383		}
8384	}
8385
8386	return nil
8387}
8388
8389func awsAwsjson11_serializeOpDocumentCreateRelationalDatabaseSnapshotInput(v *CreateRelationalDatabaseSnapshotInput, value smithyjson.Value) error {
8390	object := value.Object()
8391	defer object.Close()
8392
8393	if v.RelationalDatabaseName != nil {
8394		ok := object.Key("relationalDatabaseName")
8395		ok.String(*v.RelationalDatabaseName)
8396	}
8397
8398	if v.RelationalDatabaseSnapshotName != nil {
8399		ok := object.Key("relationalDatabaseSnapshotName")
8400		ok.String(*v.RelationalDatabaseSnapshotName)
8401	}
8402
8403	if v.Tags != nil {
8404		ok := object.Key("tags")
8405		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
8406			return err
8407		}
8408	}
8409
8410	return nil
8411}
8412
8413func awsAwsjson11_serializeOpDocumentDeleteAlarmInput(v *DeleteAlarmInput, value smithyjson.Value) error {
8414	object := value.Object()
8415	defer object.Close()
8416
8417	if v.AlarmName != nil {
8418		ok := object.Key("alarmName")
8419		ok.String(*v.AlarmName)
8420	}
8421
8422	return nil
8423}
8424
8425func awsAwsjson11_serializeOpDocumentDeleteAutoSnapshotInput(v *DeleteAutoSnapshotInput, value smithyjson.Value) error {
8426	object := value.Object()
8427	defer object.Close()
8428
8429	if v.Date != nil {
8430		ok := object.Key("date")
8431		ok.String(*v.Date)
8432	}
8433
8434	if v.ResourceName != nil {
8435		ok := object.Key("resourceName")
8436		ok.String(*v.ResourceName)
8437	}
8438
8439	return nil
8440}
8441
8442func awsAwsjson11_serializeOpDocumentDeleteCertificateInput(v *DeleteCertificateInput, value smithyjson.Value) error {
8443	object := value.Object()
8444	defer object.Close()
8445
8446	if v.CertificateName != nil {
8447		ok := object.Key("certificateName")
8448		ok.String(*v.CertificateName)
8449	}
8450
8451	return nil
8452}
8453
8454func awsAwsjson11_serializeOpDocumentDeleteContactMethodInput(v *DeleteContactMethodInput, value smithyjson.Value) error {
8455	object := value.Object()
8456	defer object.Close()
8457
8458	if len(v.Protocol) > 0 {
8459		ok := object.Key("protocol")
8460		ok.String(string(v.Protocol))
8461	}
8462
8463	return nil
8464}
8465
8466func awsAwsjson11_serializeOpDocumentDeleteContainerImageInput(v *DeleteContainerImageInput, value smithyjson.Value) error {
8467	object := value.Object()
8468	defer object.Close()
8469
8470	if v.Image != nil {
8471		ok := object.Key("image")
8472		ok.String(*v.Image)
8473	}
8474
8475	if v.ServiceName != nil {
8476		ok := object.Key("serviceName")
8477		ok.String(*v.ServiceName)
8478	}
8479
8480	return nil
8481}
8482
8483func awsAwsjson11_serializeOpDocumentDeleteContainerServiceInput(v *DeleteContainerServiceInput, value smithyjson.Value) error {
8484	object := value.Object()
8485	defer object.Close()
8486
8487	if v.ServiceName != nil {
8488		ok := object.Key("serviceName")
8489		ok.String(*v.ServiceName)
8490	}
8491
8492	return nil
8493}
8494
8495func awsAwsjson11_serializeOpDocumentDeleteDiskInput(v *DeleteDiskInput, value smithyjson.Value) error {
8496	object := value.Object()
8497	defer object.Close()
8498
8499	if v.DiskName != nil {
8500		ok := object.Key("diskName")
8501		ok.String(*v.DiskName)
8502	}
8503
8504	if v.ForceDeleteAddOns != nil {
8505		ok := object.Key("forceDeleteAddOns")
8506		ok.Boolean(*v.ForceDeleteAddOns)
8507	}
8508
8509	return nil
8510}
8511
8512func awsAwsjson11_serializeOpDocumentDeleteDiskSnapshotInput(v *DeleteDiskSnapshotInput, value smithyjson.Value) error {
8513	object := value.Object()
8514	defer object.Close()
8515
8516	if v.DiskSnapshotName != nil {
8517		ok := object.Key("diskSnapshotName")
8518		ok.String(*v.DiskSnapshotName)
8519	}
8520
8521	return nil
8522}
8523
8524func awsAwsjson11_serializeOpDocumentDeleteDistributionInput(v *DeleteDistributionInput, value smithyjson.Value) error {
8525	object := value.Object()
8526	defer object.Close()
8527
8528	if v.DistributionName != nil {
8529		ok := object.Key("distributionName")
8530		ok.String(*v.DistributionName)
8531	}
8532
8533	return nil
8534}
8535
8536func awsAwsjson11_serializeOpDocumentDeleteDomainEntryInput(v *DeleteDomainEntryInput, value smithyjson.Value) error {
8537	object := value.Object()
8538	defer object.Close()
8539
8540	if v.DomainEntry != nil {
8541		ok := object.Key("domainEntry")
8542		if err := awsAwsjson11_serializeDocumentDomainEntry(v.DomainEntry, ok); err != nil {
8543			return err
8544		}
8545	}
8546
8547	if v.DomainName != nil {
8548		ok := object.Key("domainName")
8549		ok.String(*v.DomainName)
8550	}
8551
8552	return nil
8553}
8554
8555func awsAwsjson11_serializeOpDocumentDeleteDomainInput(v *DeleteDomainInput, value smithyjson.Value) error {
8556	object := value.Object()
8557	defer object.Close()
8558
8559	if v.DomainName != nil {
8560		ok := object.Key("domainName")
8561		ok.String(*v.DomainName)
8562	}
8563
8564	return nil
8565}
8566
8567func awsAwsjson11_serializeOpDocumentDeleteInstanceInput(v *DeleteInstanceInput, value smithyjson.Value) error {
8568	object := value.Object()
8569	defer object.Close()
8570
8571	if v.ForceDeleteAddOns != nil {
8572		ok := object.Key("forceDeleteAddOns")
8573		ok.Boolean(*v.ForceDeleteAddOns)
8574	}
8575
8576	if v.InstanceName != nil {
8577		ok := object.Key("instanceName")
8578		ok.String(*v.InstanceName)
8579	}
8580
8581	return nil
8582}
8583
8584func awsAwsjson11_serializeOpDocumentDeleteInstanceSnapshotInput(v *DeleteInstanceSnapshotInput, value smithyjson.Value) error {
8585	object := value.Object()
8586	defer object.Close()
8587
8588	if v.InstanceSnapshotName != nil {
8589		ok := object.Key("instanceSnapshotName")
8590		ok.String(*v.InstanceSnapshotName)
8591	}
8592
8593	return nil
8594}
8595
8596func awsAwsjson11_serializeOpDocumentDeleteKeyPairInput(v *DeleteKeyPairInput, value smithyjson.Value) error {
8597	object := value.Object()
8598	defer object.Close()
8599
8600	if v.KeyPairName != nil {
8601		ok := object.Key("keyPairName")
8602		ok.String(*v.KeyPairName)
8603	}
8604
8605	return nil
8606}
8607
8608func awsAwsjson11_serializeOpDocumentDeleteKnownHostKeysInput(v *DeleteKnownHostKeysInput, value smithyjson.Value) error {
8609	object := value.Object()
8610	defer object.Close()
8611
8612	if v.InstanceName != nil {
8613		ok := object.Key("instanceName")
8614		ok.String(*v.InstanceName)
8615	}
8616
8617	return nil
8618}
8619
8620func awsAwsjson11_serializeOpDocumentDeleteLoadBalancerInput(v *DeleteLoadBalancerInput, value smithyjson.Value) error {
8621	object := value.Object()
8622	defer object.Close()
8623
8624	if v.LoadBalancerName != nil {
8625		ok := object.Key("loadBalancerName")
8626		ok.String(*v.LoadBalancerName)
8627	}
8628
8629	return nil
8630}
8631
8632func awsAwsjson11_serializeOpDocumentDeleteLoadBalancerTlsCertificateInput(v *DeleteLoadBalancerTlsCertificateInput, value smithyjson.Value) error {
8633	object := value.Object()
8634	defer object.Close()
8635
8636	if v.CertificateName != nil {
8637		ok := object.Key("certificateName")
8638		ok.String(*v.CertificateName)
8639	}
8640
8641	if v.Force != nil {
8642		ok := object.Key("force")
8643		ok.Boolean(*v.Force)
8644	}
8645
8646	if v.LoadBalancerName != nil {
8647		ok := object.Key("loadBalancerName")
8648		ok.String(*v.LoadBalancerName)
8649	}
8650
8651	return nil
8652}
8653
8654func awsAwsjson11_serializeOpDocumentDeleteRelationalDatabaseInput(v *DeleteRelationalDatabaseInput, value smithyjson.Value) error {
8655	object := value.Object()
8656	defer object.Close()
8657
8658	if v.FinalRelationalDatabaseSnapshotName != nil {
8659		ok := object.Key("finalRelationalDatabaseSnapshotName")
8660		ok.String(*v.FinalRelationalDatabaseSnapshotName)
8661	}
8662
8663	if v.RelationalDatabaseName != nil {
8664		ok := object.Key("relationalDatabaseName")
8665		ok.String(*v.RelationalDatabaseName)
8666	}
8667
8668	if v.SkipFinalSnapshot != nil {
8669		ok := object.Key("skipFinalSnapshot")
8670		ok.Boolean(*v.SkipFinalSnapshot)
8671	}
8672
8673	return nil
8674}
8675
8676func awsAwsjson11_serializeOpDocumentDeleteRelationalDatabaseSnapshotInput(v *DeleteRelationalDatabaseSnapshotInput, value smithyjson.Value) error {
8677	object := value.Object()
8678	defer object.Close()
8679
8680	if v.RelationalDatabaseSnapshotName != nil {
8681		ok := object.Key("relationalDatabaseSnapshotName")
8682		ok.String(*v.RelationalDatabaseSnapshotName)
8683	}
8684
8685	return nil
8686}
8687
8688func awsAwsjson11_serializeOpDocumentDetachCertificateFromDistributionInput(v *DetachCertificateFromDistributionInput, value smithyjson.Value) error {
8689	object := value.Object()
8690	defer object.Close()
8691
8692	if v.DistributionName != nil {
8693		ok := object.Key("distributionName")
8694		ok.String(*v.DistributionName)
8695	}
8696
8697	return nil
8698}
8699
8700func awsAwsjson11_serializeOpDocumentDetachDiskInput(v *DetachDiskInput, value smithyjson.Value) error {
8701	object := value.Object()
8702	defer object.Close()
8703
8704	if v.DiskName != nil {
8705		ok := object.Key("diskName")
8706		ok.String(*v.DiskName)
8707	}
8708
8709	return nil
8710}
8711
8712func awsAwsjson11_serializeOpDocumentDetachInstancesFromLoadBalancerInput(v *DetachInstancesFromLoadBalancerInput, value smithyjson.Value) error {
8713	object := value.Object()
8714	defer object.Close()
8715
8716	if v.InstanceNames != nil {
8717		ok := object.Key("instanceNames")
8718		if err := awsAwsjson11_serializeDocumentResourceNameList(v.InstanceNames, ok); err != nil {
8719			return err
8720		}
8721	}
8722
8723	if v.LoadBalancerName != nil {
8724		ok := object.Key("loadBalancerName")
8725		ok.String(*v.LoadBalancerName)
8726	}
8727
8728	return nil
8729}
8730
8731func awsAwsjson11_serializeOpDocumentDetachStaticIpInput(v *DetachStaticIpInput, value smithyjson.Value) error {
8732	object := value.Object()
8733	defer object.Close()
8734
8735	if v.StaticIpName != nil {
8736		ok := object.Key("staticIpName")
8737		ok.String(*v.StaticIpName)
8738	}
8739
8740	return nil
8741}
8742
8743func awsAwsjson11_serializeOpDocumentDisableAddOnInput(v *DisableAddOnInput, value smithyjson.Value) error {
8744	object := value.Object()
8745	defer object.Close()
8746
8747	if len(v.AddOnType) > 0 {
8748		ok := object.Key("addOnType")
8749		ok.String(string(v.AddOnType))
8750	}
8751
8752	if v.ResourceName != nil {
8753		ok := object.Key("resourceName")
8754		ok.String(*v.ResourceName)
8755	}
8756
8757	return nil
8758}
8759
8760func awsAwsjson11_serializeOpDocumentDownloadDefaultKeyPairInput(v *DownloadDefaultKeyPairInput, value smithyjson.Value) error {
8761	object := value.Object()
8762	defer object.Close()
8763
8764	return nil
8765}
8766
8767func awsAwsjson11_serializeOpDocumentEnableAddOnInput(v *EnableAddOnInput, value smithyjson.Value) error {
8768	object := value.Object()
8769	defer object.Close()
8770
8771	if v.AddOnRequest != nil {
8772		ok := object.Key("addOnRequest")
8773		if err := awsAwsjson11_serializeDocumentAddOnRequest(v.AddOnRequest, ok); err != nil {
8774			return err
8775		}
8776	}
8777
8778	if v.ResourceName != nil {
8779		ok := object.Key("resourceName")
8780		ok.String(*v.ResourceName)
8781	}
8782
8783	return nil
8784}
8785
8786func awsAwsjson11_serializeOpDocumentExportSnapshotInput(v *ExportSnapshotInput, value smithyjson.Value) error {
8787	object := value.Object()
8788	defer object.Close()
8789
8790	if v.SourceSnapshotName != nil {
8791		ok := object.Key("sourceSnapshotName")
8792		ok.String(*v.SourceSnapshotName)
8793	}
8794
8795	return nil
8796}
8797
8798func awsAwsjson11_serializeOpDocumentGetActiveNamesInput(v *GetActiveNamesInput, value smithyjson.Value) error {
8799	object := value.Object()
8800	defer object.Close()
8801
8802	if v.PageToken != nil {
8803		ok := object.Key("pageToken")
8804		ok.String(*v.PageToken)
8805	}
8806
8807	return nil
8808}
8809
8810func awsAwsjson11_serializeOpDocumentGetAlarmsInput(v *GetAlarmsInput, value smithyjson.Value) error {
8811	object := value.Object()
8812	defer object.Close()
8813
8814	if v.AlarmName != nil {
8815		ok := object.Key("alarmName")
8816		ok.String(*v.AlarmName)
8817	}
8818
8819	if v.MonitoredResourceName != nil {
8820		ok := object.Key("monitoredResourceName")
8821		ok.String(*v.MonitoredResourceName)
8822	}
8823
8824	if v.PageToken != nil {
8825		ok := object.Key("pageToken")
8826		ok.String(*v.PageToken)
8827	}
8828
8829	return nil
8830}
8831
8832func awsAwsjson11_serializeOpDocumentGetAutoSnapshotsInput(v *GetAutoSnapshotsInput, value smithyjson.Value) error {
8833	object := value.Object()
8834	defer object.Close()
8835
8836	if v.ResourceName != nil {
8837		ok := object.Key("resourceName")
8838		ok.String(*v.ResourceName)
8839	}
8840
8841	return nil
8842}
8843
8844func awsAwsjson11_serializeOpDocumentGetBlueprintsInput(v *GetBlueprintsInput, value smithyjson.Value) error {
8845	object := value.Object()
8846	defer object.Close()
8847
8848	if v.IncludeInactive != nil {
8849		ok := object.Key("includeInactive")
8850		ok.Boolean(*v.IncludeInactive)
8851	}
8852
8853	if v.PageToken != nil {
8854		ok := object.Key("pageToken")
8855		ok.String(*v.PageToken)
8856	}
8857
8858	return nil
8859}
8860
8861func awsAwsjson11_serializeOpDocumentGetBundlesInput(v *GetBundlesInput, value smithyjson.Value) error {
8862	object := value.Object()
8863	defer object.Close()
8864
8865	if v.IncludeInactive != nil {
8866		ok := object.Key("includeInactive")
8867		ok.Boolean(*v.IncludeInactive)
8868	}
8869
8870	if v.PageToken != nil {
8871		ok := object.Key("pageToken")
8872		ok.String(*v.PageToken)
8873	}
8874
8875	return nil
8876}
8877
8878func awsAwsjson11_serializeOpDocumentGetCertificatesInput(v *GetCertificatesInput, value smithyjson.Value) error {
8879	object := value.Object()
8880	defer object.Close()
8881
8882	if v.CertificateName != nil {
8883		ok := object.Key("certificateName")
8884		ok.String(*v.CertificateName)
8885	}
8886
8887	if v.CertificateStatuses != nil {
8888		ok := object.Key("certificateStatuses")
8889		if err := awsAwsjson11_serializeDocumentCertificateStatusList(v.CertificateStatuses, ok); err != nil {
8890			return err
8891		}
8892	}
8893
8894	if v.IncludeCertificateDetails {
8895		ok := object.Key("includeCertificateDetails")
8896		ok.Boolean(v.IncludeCertificateDetails)
8897	}
8898
8899	return nil
8900}
8901
8902func awsAwsjson11_serializeOpDocumentGetCloudFormationStackRecordsInput(v *GetCloudFormationStackRecordsInput, value smithyjson.Value) error {
8903	object := value.Object()
8904	defer object.Close()
8905
8906	if v.PageToken != nil {
8907		ok := object.Key("pageToken")
8908		ok.String(*v.PageToken)
8909	}
8910
8911	return nil
8912}
8913
8914func awsAwsjson11_serializeOpDocumentGetContactMethodsInput(v *GetContactMethodsInput, value smithyjson.Value) error {
8915	object := value.Object()
8916	defer object.Close()
8917
8918	if v.Protocols != nil {
8919		ok := object.Key("protocols")
8920		if err := awsAwsjson11_serializeDocumentContactProtocolsList(v.Protocols, ok); err != nil {
8921			return err
8922		}
8923	}
8924
8925	return nil
8926}
8927
8928func awsAwsjson11_serializeOpDocumentGetContainerAPIMetadataInput(v *GetContainerAPIMetadataInput, value smithyjson.Value) error {
8929	object := value.Object()
8930	defer object.Close()
8931
8932	return nil
8933}
8934
8935func awsAwsjson11_serializeOpDocumentGetContainerImagesInput(v *GetContainerImagesInput, value smithyjson.Value) error {
8936	object := value.Object()
8937	defer object.Close()
8938
8939	if v.ServiceName != nil {
8940		ok := object.Key("serviceName")
8941		ok.String(*v.ServiceName)
8942	}
8943
8944	return nil
8945}
8946
8947func awsAwsjson11_serializeOpDocumentGetContainerLogInput(v *GetContainerLogInput, value smithyjson.Value) error {
8948	object := value.Object()
8949	defer object.Close()
8950
8951	if v.ContainerName != nil {
8952		ok := object.Key("containerName")
8953		ok.String(*v.ContainerName)
8954	}
8955
8956	if v.EndTime != nil {
8957		ok := object.Key("endTime")
8958		ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
8959	}
8960
8961	if v.FilterPattern != nil {
8962		ok := object.Key("filterPattern")
8963		ok.String(*v.FilterPattern)
8964	}
8965
8966	if v.PageToken != nil {
8967		ok := object.Key("pageToken")
8968		ok.String(*v.PageToken)
8969	}
8970
8971	if v.ServiceName != nil {
8972		ok := object.Key("serviceName")
8973		ok.String(*v.ServiceName)
8974	}
8975
8976	if v.StartTime != nil {
8977		ok := object.Key("startTime")
8978		ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
8979	}
8980
8981	return nil
8982}
8983
8984func awsAwsjson11_serializeOpDocumentGetContainerServiceDeploymentsInput(v *GetContainerServiceDeploymentsInput, value smithyjson.Value) error {
8985	object := value.Object()
8986	defer object.Close()
8987
8988	if v.ServiceName != nil {
8989		ok := object.Key("serviceName")
8990		ok.String(*v.ServiceName)
8991	}
8992
8993	return nil
8994}
8995
8996func awsAwsjson11_serializeOpDocumentGetContainerServiceMetricDataInput(v *GetContainerServiceMetricDataInput, value smithyjson.Value) error {
8997	object := value.Object()
8998	defer object.Close()
8999
9000	if v.EndTime != nil {
9001		ok := object.Key("endTime")
9002		ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
9003	}
9004
9005	if len(v.MetricName) > 0 {
9006		ok := object.Key("metricName")
9007		ok.String(string(v.MetricName))
9008	}
9009
9010	{
9011		ok := object.Key("period")
9012		ok.Integer(v.Period)
9013	}
9014
9015	if v.ServiceName != nil {
9016		ok := object.Key("serviceName")
9017		ok.String(*v.ServiceName)
9018	}
9019
9020	if v.StartTime != nil {
9021		ok := object.Key("startTime")
9022		ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
9023	}
9024
9025	if v.Statistics != nil {
9026		ok := object.Key("statistics")
9027		if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
9028			return err
9029		}
9030	}
9031
9032	return nil
9033}
9034
9035func awsAwsjson11_serializeOpDocumentGetContainerServicePowersInput(v *GetContainerServicePowersInput, value smithyjson.Value) error {
9036	object := value.Object()
9037	defer object.Close()
9038
9039	return nil
9040}
9041
9042func awsAwsjson11_serializeOpDocumentGetContainerServicesInput(v *GetContainerServicesInput, value smithyjson.Value) error {
9043	object := value.Object()
9044	defer object.Close()
9045
9046	if v.ServiceName != nil {
9047		ok := object.Key("serviceName")
9048		ok.String(*v.ServiceName)
9049	}
9050
9051	return nil
9052}
9053
9054func awsAwsjson11_serializeOpDocumentGetDiskInput(v *GetDiskInput, value smithyjson.Value) error {
9055	object := value.Object()
9056	defer object.Close()
9057
9058	if v.DiskName != nil {
9059		ok := object.Key("diskName")
9060		ok.String(*v.DiskName)
9061	}
9062
9063	return nil
9064}
9065
9066func awsAwsjson11_serializeOpDocumentGetDisksInput(v *GetDisksInput, value smithyjson.Value) error {
9067	object := value.Object()
9068	defer object.Close()
9069
9070	if v.PageToken != nil {
9071		ok := object.Key("pageToken")
9072		ok.String(*v.PageToken)
9073	}
9074
9075	return nil
9076}
9077
9078func awsAwsjson11_serializeOpDocumentGetDiskSnapshotInput(v *GetDiskSnapshotInput, value smithyjson.Value) error {
9079	object := value.Object()
9080	defer object.Close()
9081
9082	if v.DiskSnapshotName != nil {
9083		ok := object.Key("diskSnapshotName")
9084		ok.String(*v.DiskSnapshotName)
9085	}
9086
9087	return nil
9088}
9089
9090func awsAwsjson11_serializeOpDocumentGetDiskSnapshotsInput(v *GetDiskSnapshotsInput, value smithyjson.Value) error {
9091	object := value.Object()
9092	defer object.Close()
9093
9094	if v.PageToken != nil {
9095		ok := object.Key("pageToken")
9096		ok.String(*v.PageToken)
9097	}
9098
9099	return nil
9100}
9101
9102func awsAwsjson11_serializeOpDocumentGetDistributionBundlesInput(v *GetDistributionBundlesInput, value smithyjson.Value) error {
9103	object := value.Object()
9104	defer object.Close()
9105
9106	return nil
9107}
9108
9109func awsAwsjson11_serializeOpDocumentGetDistributionLatestCacheResetInput(v *GetDistributionLatestCacheResetInput, value smithyjson.Value) error {
9110	object := value.Object()
9111	defer object.Close()
9112
9113	if v.DistributionName != nil {
9114		ok := object.Key("distributionName")
9115		ok.String(*v.DistributionName)
9116	}
9117
9118	return nil
9119}
9120
9121func awsAwsjson11_serializeOpDocumentGetDistributionMetricDataInput(v *GetDistributionMetricDataInput, value smithyjson.Value) error {
9122	object := value.Object()
9123	defer object.Close()
9124
9125	if v.DistributionName != nil {
9126		ok := object.Key("distributionName")
9127		ok.String(*v.DistributionName)
9128	}
9129
9130	if v.EndTime != nil {
9131		ok := object.Key("endTime")
9132		ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
9133	}
9134
9135	if len(v.MetricName) > 0 {
9136		ok := object.Key("metricName")
9137		ok.String(string(v.MetricName))
9138	}
9139
9140	{
9141		ok := object.Key("period")
9142		ok.Integer(v.Period)
9143	}
9144
9145	if v.StartTime != nil {
9146		ok := object.Key("startTime")
9147		ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
9148	}
9149
9150	if v.Statistics != nil {
9151		ok := object.Key("statistics")
9152		if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
9153			return err
9154		}
9155	}
9156
9157	if len(v.Unit) > 0 {
9158		ok := object.Key("unit")
9159		ok.String(string(v.Unit))
9160	}
9161
9162	return nil
9163}
9164
9165func awsAwsjson11_serializeOpDocumentGetDistributionsInput(v *GetDistributionsInput, value smithyjson.Value) error {
9166	object := value.Object()
9167	defer object.Close()
9168
9169	if v.DistributionName != nil {
9170		ok := object.Key("distributionName")
9171		ok.String(*v.DistributionName)
9172	}
9173
9174	if v.PageToken != nil {
9175		ok := object.Key("pageToken")
9176		ok.String(*v.PageToken)
9177	}
9178
9179	return nil
9180}
9181
9182func awsAwsjson11_serializeOpDocumentGetDomainInput(v *GetDomainInput, value smithyjson.Value) error {
9183	object := value.Object()
9184	defer object.Close()
9185
9186	if v.DomainName != nil {
9187		ok := object.Key("domainName")
9188		ok.String(*v.DomainName)
9189	}
9190
9191	return nil
9192}
9193
9194func awsAwsjson11_serializeOpDocumentGetDomainsInput(v *GetDomainsInput, value smithyjson.Value) error {
9195	object := value.Object()
9196	defer object.Close()
9197
9198	if v.PageToken != nil {
9199		ok := object.Key("pageToken")
9200		ok.String(*v.PageToken)
9201	}
9202
9203	return nil
9204}
9205
9206func awsAwsjson11_serializeOpDocumentGetExportSnapshotRecordsInput(v *GetExportSnapshotRecordsInput, value smithyjson.Value) error {
9207	object := value.Object()
9208	defer object.Close()
9209
9210	if v.PageToken != nil {
9211		ok := object.Key("pageToken")
9212		ok.String(*v.PageToken)
9213	}
9214
9215	return nil
9216}
9217
9218func awsAwsjson11_serializeOpDocumentGetInstanceAccessDetailsInput(v *GetInstanceAccessDetailsInput, value smithyjson.Value) error {
9219	object := value.Object()
9220	defer object.Close()
9221
9222	if v.InstanceName != nil {
9223		ok := object.Key("instanceName")
9224		ok.String(*v.InstanceName)
9225	}
9226
9227	if len(v.Protocol) > 0 {
9228		ok := object.Key("protocol")
9229		ok.String(string(v.Protocol))
9230	}
9231
9232	return nil
9233}
9234
9235func awsAwsjson11_serializeOpDocumentGetInstanceInput(v *GetInstanceInput, value smithyjson.Value) error {
9236	object := value.Object()
9237	defer object.Close()
9238
9239	if v.InstanceName != nil {
9240		ok := object.Key("instanceName")
9241		ok.String(*v.InstanceName)
9242	}
9243
9244	return nil
9245}
9246
9247func awsAwsjson11_serializeOpDocumentGetInstanceMetricDataInput(v *GetInstanceMetricDataInput, value smithyjson.Value) error {
9248	object := value.Object()
9249	defer object.Close()
9250
9251	if v.EndTime != nil {
9252		ok := object.Key("endTime")
9253		ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
9254	}
9255
9256	if v.InstanceName != nil {
9257		ok := object.Key("instanceName")
9258		ok.String(*v.InstanceName)
9259	}
9260
9261	if len(v.MetricName) > 0 {
9262		ok := object.Key("metricName")
9263		ok.String(string(v.MetricName))
9264	}
9265
9266	{
9267		ok := object.Key("period")
9268		ok.Integer(v.Period)
9269	}
9270
9271	if v.StartTime != nil {
9272		ok := object.Key("startTime")
9273		ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
9274	}
9275
9276	if v.Statistics != nil {
9277		ok := object.Key("statistics")
9278		if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
9279			return err
9280		}
9281	}
9282
9283	if len(v.Unit) > 0 {
9284		ok := object.Key("unit")
9285		ok.String(string(v.Unit))
9286	}
9287
9288	return nil
9289}
9290
9291func awsAwsjson11_serializeOpDocumentGetInstancePortStatesInput(v *GetInstancePortStatesInput, value smithyjson.Value) error {
9292	object := value.Object()
9293	defer object.Close()
9294
9295	if v.InstanceName != nil {
9296		ok := object.Key("instanceName")
9297		ok.String(*v.InstanceName)
9298	}
9299
9300	return nil
9301}
9302
9303func awsAwsjson11_serializeOpDocumentGetInstancesInput(v *GetInstancesInput, value smithyjson.Value) error {
9304	object := value.Object()
9305	defer object.Close()
9306
9307	if v.PageToken != nil {
9308		ok := object.Key("pageToken")
9309		ok.String(*v.PageToken)
9310	}
9311
9312	return nil
9313}
9314
9315func awsAwsjson11_serializeOpDocumentGetInstanceSnapshotInput(v *GetInstanceSnapshotInput, value smithyjson.Value) error {
9316	object := value.Object()
9317	defer object.Close()
9318
9319	if v.InstanceSnapshotName != nil {
9320		ok := object.Key("instanceSnapshotName")
9321		ok.String(*v.InstanceSnapshotName)
9322	}
9323
9324	return nil
9325}
9326
9327func awsAwsjson11_serializeOpDocumentGetInstanceSnapshotsInput(v *GetInstanceSnapshotsInput, value smithyjson.Value) error {
9328	object := value.Object()
9329	defer object.Close()
9330
9331	if v.PageToken != nil {
9332		ok := object.Key("pageToken")
9333		ok.String(*v.PageToken)
9334	}
9335
9336	return nil
9337}
9338
9339func awsAwsjson11_serializeOpDocumentGetInstanceStateInput(v *GetInstanceStateInput, value smithyjson.Value) error {
9340	object := value.Object()
9341	defer object.Close()
9342
9343	if v.InstanceName != nil {
9344		ok := object.Key("instanceName")
9345		ok.String(*v.InstanceName)
9346	}
9347
9348	return nil
9349}
9350
9351func awsAwsjson11_serializeOpDocumentGetKeyPairInput(v *GetKeyPairInput, value smithyjson.Value) error {
9352	object := value.Object()
9353	defer object.Close()
9354
9355	if v.KeyPairName != nil {
9356		ok := object.Key("keyPairName")
9357		ok.String(*v.KeyPairName)
9358	}
9359
9360	return nil
9361}
9362
9363func awsAwsjson11_serializeOpDocumentGetKeyPairsInput(v *GetKeyPairsInput, value smithyjson.Value) error {
9364	object := value.Object()
9365	defer object.Close()
9366
9367	if v.PageToken != nil {
9368		ok := object.Key("pageToken")
9369		ok.String(*v.PageToken)
9370	}
9371
9372	return nil
9373}
9374
9375func awsAwsjson11_serializeOpDocumentGetLoadBalancerInput(v *GetLoadBalancerInput, value smithyjson.Value) error {
9376	object := value.Object()
9377	defer object.Close()
9378
9379	if v.LoadBalancerName != nil {
9380		ok := object.Key("loadBalancerName")
9381		ok.String(*v.LoadBalancerName)
9382	}
9383
9384	return nil
9385}
9386
9387func awsAwsjson11_serializeOpDocumentGetLoadBalancerMetricDataInput(v *GetLoadBalancerMetricDataInput, value smithyjson.Value) error {
9388	object := value.Object()
9389	defer object.Close()
9390
9391	if v.EndTime != nil {
9392		ok := object.Key("endTime")
9393		ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
9394	}
9395
9396	if v.LoadBalancerName != nil {
9397		ok := object.Key("loadBalancerName")
9398		ok.String(*v.LoadBalancerName)
9399	}
9400
9401	if len(v.MetricName) > 0 {
9402		ok := object.Key("metricName")
9403		ok.String(string(v.MetricName))
9404	}
9405
9406	{
9407		ok := object.Key("period")
9408		ok.Integer(v.Period)
9409	}
9410
9411	if v.StartTime != nil {
9412		ok := object.Key("startTime")
9413		ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
9414	}
9415
9416	if v.Statistics != nil {
9417		ok := object.Key("statistics")
9418		if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
9419			return err
9420		}
9421	}
9422
9423	if len(v.Unit) > 0 {
9424		ok := object.Key("unit")
9425		ok.String(string(v.Unit))
9426	}
9427
9428	return nil
9429}
9430
9431func awsAwsjson11_serializeOpDocumentGetLoadBalancersInput(v *GetLoadBalancersInput, value smithyjson.Value) error {
9432	object := value.Object()
9433	defer object.Close()
9434
9435	if v.PageToken != nil {
9436		ok := object.Key("pageToken")
9437		ok.String(*v.PageToken)
9438	}
9439
9440	return nil
9441}
9442
9443func awsAwsjson11_serializeOpDocumentGetLoadBalancerTlsCertificatesInput(v *GetLoadBalancerTlsCertificatesInput, value smithyjson.Value) error {
9444	object := value.Object()
9445	defer object.Close()
9446
9447	if v.LoadBalancerName != nil {
9448		ok := object.Key("loadBalancerName")
9449		ok.String(*v.LoadBalancerName)
9450	}
9451
9452	return nil
9453}
9454
9455func awsAwsjson11_serializeOpDocumentGetOperationInput(v *GetOperationInput, value smithyjson.Value) error {
9456	object := value.Object()
9457	defer object.Close()
9458
9459	if v.OperationId != nil {
9460		ok := object.Key("operationId")
9461		ok.String(*v.OperationId)
9462	}
9463
9464	return nil
9465}
9466
9467func awsAwsjson11_serializeOpDocumentGetOperationsForResourceInput(v *GetOperationsForResourceInput, value smithyjson.Value) error {
9468	object := value.Object()
9469	defer object.Close()
9470
9471	if v.PageToken != nil {
9472		ok := object.Key("pageToken")
9473		ok.String(*v.PageToken)
9474	}
9475
9476	if v.ResourceName != nil {
9477		ok := object.Key("resourceName")
9478		ok.String(*v.ResourceName)
9479	}
9480
9481	return nil
9482}
9483
9484func awsAwsjson11_serializeOpDocumentGetOperationsInput(v *GetOperationsInput, value smithyjson.Value) error {
9485	object := value.Object()
9486	defer object.Close()
9487
9488	if v.PageToken != nil {
9489		ok := object.Key("pageToken")
9490		ok.String(*v.PageToken)
9491	}
9492
9493	return nil
9494}
9495
9496func awsAwsjson11_serializeOpDocumentGetRegionsInput(v *GetRegionsInput, value smithyjson.Value) error {
9497	object := value.Object()
9498	defer object.Close()
9499
9500	if v.IncludeAvailabilityZones != nil {
9501		ok := object.Key("includeAvailabilityZones")
9502		ok.Boolean(*v.IncludeAvailabilityZones)
9503	}
9504
9505	if v.IncludeRelationalDatabaseAvailabilityZones != nil {
9506		ok := object.Key("includeRelationalDatabaseAvailabilityZones")
9507		ok.Boolean(*v.IncludeRelationalDatabaseAvailabilityZones)
9508	}
9509
9510	return nil
9511}
9512
9513func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseBlueprintsInput(v *GetRelationalDatabaseBlueprintsInput, value smithyjson.Value) error {
9514	object := value.Object()
9515	defer object.Close()
9516
9517	if v.PageToken != nil {
9518		ok := object.Key("pageToken")
9519		ok.String(*v.PageToken)
9520	}
9521
9522	return nil
9523}
9524
9525func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseBundlesInput(v *GetRelationalDatabaseBundlesInput, value smithyjson.Value) error {
9526	object := value.Object()
9527	defer object.Close()
9528
9529	if v.PageToken != nil {
9530		ok := object.Key("pageToken")
9531		ok.String(*v.PageToken)
9532	}
9533
9534	return nil
9535}
9536
9537func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseEventsInput(v *GetRelationalDatabaseEventsInput, value smithyjson.Value) error {
9538	object := value.Object()
9539	defer object.Close()
9540
9541	if v.DurationInMinutes != nil {
9542		ok := object.Key("durationInMinutes")
9543		ok.Integer(*v.DurationInMinutes)
9544	}
9545
9546	if v.PageToken != nil {
9547		ok := object.Key("pageToken")
9548		ok.String(*v.PageToken)
9549	}
9550
9551	if v.RelationalDatabaseName != nil {
9552		ok := object.Key("relationalDatabaseName")
9553		ok.String(*v.RelationalDatabaseName)
9554	}
9555
9556	return nil
9557}
9558
9559func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseInput(v *GetRelationalDatabaseInput, value smithyjson.Value) error {
9560	object := value.Object()
9561	defer object.Close()
9562
9563	if v.RelationalDatabaseName != nil {
9564		ok := object.Key("relationalDatabaseName")
9565		ok.String(*v.RelationalDatabaseName)
9566	}
9567
9568	return nil
9569}
9570
9571func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseLogEventsInput(v *GetRelationalDatabaseLogEventsInput, value smithyjson.Value) error {
9572	object := value.Object()
9573	defer object.Close()
9574
9575	if v.EndTime != nil {
9576		ok := object.Key("endTime")
9577		ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
9578	}
9579
9580	if v.LogStreamName != nil {
9581		ok := object.Key("logStreamName")
9582		ok.String(*v.LogStreamName)
9583	}
9584
9585	if v.PageToken != nil {
9586		ok := object.Key("pageToken")
9587		ok.String(*v.PageToken)
9588	}
9589
9590	if v.RelationalDatabaseName != nil {
9591		ok := object.Key("relationalDatabaseName")
9592		ok.String(*v.RelationalDatabaseName)
9593	}
9594
9595	if v.StartFromHead != nil {
9596		ok := object.Key("startFromHead")
9597		ok.Boolean(*v.StartFromHead)
9598	}
9599
9600	if v.StartTime != nil {
9601		ok := object.Key("startTime")
9602		ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
9603	}
9604
9605	return nil
9606}
9607
9608func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseLogStreamsInput(v *GetRelationalDatabaseLogStreamsInput, value smithyjson.Value) error {
9609	object := value.Object()
9610	defer object.Close()
9611
9612	if v.RelationalDatabaseName != nil {
9613		ok := object.Key("relationalDatabaseName")
9614		ok.String(*v.RelationalDatabaseName)
9615	}
9616
9617	return nil
9618}
9619
9620func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseMasterUserPasswordInput(v *GetRelationalDatabaseMasterUserPasswordInput, value smithyjson.Value) error {
9621	object := value.Object()
9622	defer object.Close()
9623
9624	if len(v.PasswordVersion) > 0 {
9625		ok := object.Key("passwordVersion")
9626		ok.String(string(v.PasswordVersion))
9627	}
9628
9629	if v.RelationalDatabaseName != nil {
9630		ok := object.Key("relationalDatabaseName")
9631		ok.String(*v.RelationalDatabaseName)
9632	}
9633
9634	return nil
9635}
9636
9637func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseMetricDataInput(v *GetRelationalDatabaseMetricDataInput, value smithyjson.Value) error {
9638	object := value.Object()
9639	defer object.Close()
9640
9641	if v.EndTime != nil {
9642		ok := object.Key("endTime")
9643		ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
9644	}
9645
9646	if len(v.MetricName) > 0 {
9647		ok := object.Key("metricName")
9648		ok.String(string(v.MetricName))
9649	}
9650
9651	{
9652		ok := object.Key("period")
9653		ok.Integer(v.Period)
9654	}
9655
9656	if v.RelationalDatabaseName != nil {
9657		ok := object.Key("relationalDatabaseName")
9658		ok.String(*v.RelationalDatabaseName)
9659	}
9660
9661	if v.StartTime != nil {
9662		ok := object.Key("startTime")
9663		ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
9664	}
9665
9666	if v.Statistics != nil {
9667		ok := object.Key("statistics")
9668		if err := awsAwsjson11_serializeDocumentMetricStatisticList(v.Statistics, ok); err != nil {
9669			return err
9670		}
9671	}
9672
9673	if len(v.Unit) > 0 {
9674		ok := object.Key("unit")
9675		ok.String(string(v.Unit))
9676	}
9677
9678	return nil
9679}
9680
9681func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseParametersInput(v *GetRelationalDatabaseParametersInput, value smithyjson.Value) error {
9682	object := value.Object()
9683	defer object.Close()
9684
9685	if v.PageToken != nil {
9686		ok := object.Key("pageToken")
9687		ok.String(*v.PageToken)
9688	}
9689
9690	if v.RelationalDatabaseName != nil {
9691		ok := object.Key("relationalDatabaseName")
9692		ok.String(*v.RelationalDatabaseName)
9693	}
9694
9695	return nil
9696}
9697
9698func awsAwsjson11_serializeOpDocumentGetRelationalDatabasesInput(v *GetRelationalDatabasesInput, value smithyjson.Value) error {
9699	object := value.Object()
9700	defer object.Close()
9701
9702	if v.PageToken != nil {
9703		ok := object.Key("pageToken")
9704		ok.String(*v.PageToken)
9705	}
9706
9707	return nil
9708}
9709
9710func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseSnapshotInput(v *GetRelationalDatabaseSnapshotInput, value smithyjson.Value) error {
9711	object := value.Object()
9712	defer object.Close()
9713
9714	if v.RelationalDatabaseSnapshotName != nil {
9715		ok := object.Key("relationalDatabaseSnapshotName")
9716		ok.String(*v.RelationalDatabaseSnapshotName)
9717	}
9718
9719	return nil
9720}
9721
9722func awsAwsjson11_serializeOpDocumentGetRelationalDatabaseSnapshotsInput(v *GetRelationalDatabaseSnapshotsInput, value smithyjson.Value) error {
9723	object := value.Object()
9724	defer object.Close()
9725
9726	if v.PageToken != nil {
9727		ok := object.Key("pageToken")
9728		ok.String(*v.PageToken)
9729	}
9730
9731	return nil
9732}
9733
9734func awsAwsjson11_serializeOpDocumentGetStaticIpInput(v *GetStaticIpInput, value smithyjson.Value) error {
9735	object := value.Object()
9736	defer object.Close()
9737
9738	if v.StaticIpName != nil {
9739		ok := object.Key("staticIpName")
9740		ok.String(*v.StaticIpName)
9741	}
9742
9743	return nil
9744}
9745
9746func awsAwsjson11_serializeOpDocumentGetStaticIpsInput(v *GetStaticIpsInput, value smithyjson.Value) error {
9747	object := value.Object()
9748	defer object.Close()
9749
9750	if v.PageToken != nil {
9751		ok := object.Key("pageToken")
9752		ok.String(*v.PageToken)
9753	}
9754
9755	return nil
9756}
9757
9758func awsAwsjson11_serializeOpDocumentImportKeyPairInput(v *ImportKeyPairInput, value smithyjson.Value) error {
9759	object := value.Object()
9760	defer object.Close()
9761
9762	if v.KeyPairName != nil {
9763		ok := object.Key("keyPairName")
9764		ok.String(*v.KeyPairName)
9765	}
9766
9767	if v.PublicKeyBase64 != nil {
9768		ok := object.Key("publicKeyBase64")
9769		ok.String(*v.PublicKeyBase64)
9770	}
9771
9772	return nil
9773}
9774
9775func awsAwsjson11_serializeOpDocumentIsVpcPeeredInput(v *IsVpcPeeredInput, value smithyjson.Value) error {
9776	object := value.Object()
9777	defer object.Close()
9778
9779	return nil
9780}
9781
9782func awsAwsjson11_serializeOpDocumentOpenInstancePublicPortsInput(v *OpenInstancePublicPortsInput, value smithyjson.Value) error {
9783	object := value.Object()
9784	defer object.Close()
9785
9786	if v.InstanceName != nil {
9787		ok := object.Key("instanceName")
9788		ok.String(*v.InstanceName)
9789	}
9790
9791	if v.PortInfo != nil {
9792		ok := object.Key("portInfo")
9793		if err := awsAwsjson11_serializeDocumentPortInfo(v.PortInfo, ok); err != nil {
9794			return err
9795		}
9796	}
9797
9798	return nil
9799}
9800
9801func awsAwsjson11_serializeOpDocumentPeerVpcInput(v *PeerVpcInput, value smithyjson.Value) error {
9802	object := value.Object()
9803	defer object.Close()
9804
9805	return nil
9806}
9807
9808func awsAwsjson11_serializeOpDocumentPutAlarmInput(v *PutAlarmInput, value smithyjson.Value) error {
9809	object := value.Object()
9810	defer object.Close()
9811
9812	if v.AlarmName != nil {
9813		ok := object.Key("alarmName")
9814		ok.String(*v.AlarmName)
9815	}
9816
9817	if len(v.ComparisonOperator) > 0 {
9818		ok := object.Key("comparisonOperator")
9819		ok.String(string(v.ComparisonOperator))
9820	}
9821
9822	if v.ContactProtocols != nil {
9823		ok := object.Key("contactProtocols")
9824		if err := awsAwsjson11_serializeDocumentContactProtocolsList(v.ContactProtocols, ok); err != nil {
9825			return err
9826		}
9827	}
9828
9829	if v.DatapointsToAlarm != nil {
9830		ok := object.Key("datapointsToAlarm")
9831		ok.Integer(*v.DatapointsToAlarm)
9832	}
9833
9834	if v.EvaluationPeriods != nil {
9835		ok := object.Key("evaluationPeriods")
9836		ok.Integer(*v.EvaluationPeriods)
9837	}
9838
9839	if len(v.MetricName) > 0 {
9840		ok := object.Key("metricName")
9841		ok.String(string(v.MetricName))
9842	}
9843
9844	if v.MonitoredResourceName != nil {
9845		ok := object.Key("monitoredResourceName")
9846		ok.String(*v.MonitoredResourceName)
9847	}
9848
9849	if v.NotificationEnabled != nil {
9850		ok := object.Key("notificationEnabled")
9851		ok.Boolean(*v.NotificationEnabled)
9852	}
9853
9854	if v.NotificationTriggers != nil {
9855		ok := object.Key("notificationTriggers")
9856		if err := awsAwsjson11_serializeDocumentNotificationTriggerList(v.NotificationTriggers, ok); err != nil {
9857			return err
9858		}
9859	}
9860
9861	if v.Threshold != nil {
9862		ok := object.Key("threshold")
9863		ok.Double(*v.Threshold)
9864	}
9865
9866	if len(v.TreatMissingData) > 0 {
9867		ok := object.Key("treatMissingData")
9868		ok.String(string(v.TreatMissingData))
9869	}
9870
9871	return nil
9872}
9873
9874func awsAwsjson11_serializeOpDocumentPutInstancePublicPortsInput(v *PutInstancePublicPortsInput, value smithyjson.Value) error {
9875	object := value.Object()
9876	defer object.Close()
9877
9878	if v.InstanceName != nil {
9879		ok := object.Key("instanceName")
9880		ok.String(*v.InstanceName)
9881	}
9882
9883	if v.PortInfos != nil {
9884		ok := object.Key("portInfos")
9885		if err := awsAwsjson11_serializeDocumentPortInfoList(v.PortInfos, ok); err != nil {
9886			return err
9887		}
9888	}
9889
9890	return nil
9891}
9892
9893func awsAwsjson11_serializeOpDocumentRebootInstanceInput(v *RebootInstanceInput, value smithyjson.Value) error {
9894	object := value.Object()
9895	defer object.Close()
9896
9897	if v.InstanceName != nil {
9898		ok := object.Key("instanceName")
9899		ok.String(*v.InstanceName)
9900	}
9901
9902	return nil
9903}
9904
9905func awsAwsjson11_serializeOpDocumentRebootRelationalDatabaseInput(v *RebootRelationalDatabaseInput, value smithyjson.Value) error {
9906	object := value.Object()
9907	defer object.Close()
9908
9909	if v.RelationalDatabaseName != nil {
9910		ok := object.Key("relationalDatabaseName")
9911		ok.String(*v.RelationalDatabaseName)
9912	}
9913
9914	return nil
9915}
9916
9917func awsAwsjson11_serializeOpDocumentRegisterContainerImageInput(v *RegisterContainerImageInput, value smithyjson.Value) error {
9918	object := value.Object()
9919	defer object.Close()
9920
9921	if v.Digest != nil {
9922		ok := object.Key("digest")
9923		ok.String(*v.Digest)
9924	}
9925
9926	if v.Label != nil {
9927		ok := object.Key("label")
9928		ok.String(*v.Label)
9929	}
9930
9931	if v.ServiceName != nil {
9932		ok := object.Key("serviceName")
9933		ok.String(*v.ServiceName)
9934	}
9935
9936	return nil
9937}
9938
9939func awsAwsjson11_serializeOpDocumentReleaseStaticIpInput(v *ReleaseStaticIpInput, value smithyjson.Value) error {
9940	object := value.Object()
9941	defer object.Close()
9942
9943	if v.StaticIpName != nil {
9944		ok := object.Key("staticIpName")
9945		ok.String(*v.StaticIpName)
9946	}
9947
9948	return nil
9949}
9950
9951func awsAwsjson11_serializeOpDocumentResetDistributionCacheInput(v *ResetDistributionCacheInput, value smithyjson.Value) error {
9952	object := value.Object()
9953	defer object.Close()
9954
9955	if v.DistributionName != nil {
9956		ok := object.Key("distributionName")
9957		ok.String(*v.DistributionName)
9958	}
9959
9960	return nil
9961}
9962
9963func awsAwsjson11_serializeOpDocumentSendContactMethodVerificationInput(v *SendContactMethodVerificationInput, value smithyjson.Value) error {
9964	object := value.Object()
9965	defer object.Close()
9966
9967	if len(v.Protocol) > 0 {
9968		ok := object.Key("protocol")
9969		ok.String(string(v.Protocol))
9970	}
9971
9972	return nil
9973}
9974
9975func awsAwsjson11_serializeOpDocumentSetIpAddressTypeInput(v *SetIpAddressTypeInput, value smithyjson.Value) error {
9976	object := value.Object()
9977	defer object.Close()
9978
9979	if len(v.IpAddressType) > 0 {
9980		ok := object.Key("ipAddressType")
9981		ok.String(string(v.IpAddressType))
9982	}
9983
9984	if v.ResourceName != nil {
9985		ok := object.Key("resourceName")
9986		ok.String(*v.ResourceName)
9987	}
9988
9989	if len(v.ResourceType) > 0 {
9990		ok := object.Key("resourceType")
9991		ok.String(string(v.ResourceType))
9992	}
9993
9994	return nil
9995}
9996
9997func awsAwsjson11_serializeOpDocumentStartInstanceInput(v *StartInstanceInput, value smithyjson.Value) error {
9998	object := value.Object()
9999	defer object.Close()
10000
10001	if v.InstanceName != nil {
10002		ok := object.Key("instanceName")
10003		ok.String(*v.InstanceName)
10004	}
10005
10006	return nil
10007}
10008
10009func awsAwsjson11_serializeOpDocumentStartRelationalDatabaseInput(v *StartRelationalDatabaseInput, value smithyjson.Value) error {
10010	object := value.Object()
10011	defer object.Close()
10012
10013	if v.RelationalDatabaseName != nil {
10014		ok := object.Key("relationalDatabaseName")
10015		ok.String(*v.RelationalDatabaseName)
10016	}
10017
10018	return nil
10019}
10020
10021func awsAwsjson11_serializeOpDocumentStopInstanceInput(v *StopInstanceInput, value smithyjson.Value) error {
10022	object := value.Object()
10023	defer object.Close()
10024
10025	if v.Force != nil {
10026		ok := object.Key("force")
10027		ok.Boolean(*v.Force)
10028	}
10029
10030	if v.InstanceName != nil {
10031		ok := object.Key("instanceName")
10032		ok.String(*v.InstanceName)
10033	}
10034
10035	return nil
10036}
10037
10038func awsAwsjson11_serializeOpDocumentStopRelationalDatabaseInput(v *StopRelationalDatabaseInput, value smithyjson.Value) error {
10039	object := value.Object()
10040	defer object.Close()
10041
10042	if v.RelationalDatabaseName != nil {
10043		ok := object.Key("relationalDatabaseName")
10044		ok.String(*v.RelationalDatabaseName)
10045	}
10046
10047	if v.RelationalDatabaseSnapshotName != nil {
10048		ok := object.Key("relationalDatabaseSnapshotName")
10049		ok.String(*v.RelationalDatabaseSnapshotName)
10050	}
10051
10052	return nil
10053}
10054
10055func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
10056	object := value.Object()
10057	defer object.Close()
10058
10059	if v.ResourceArn != nil {
10060		ok := object.Key("resourceArn")
10061		ok.String(*v.ResourceArn)
10062	}
10063
10064	if v.ResourceName != nil {
10065		ok := object.Key("resourceName")
10066		ok.String(*v.ResourceName)
10067	}
10068
10069	if v.Tags != nil {
10070		ok := object.Key("tags")
10071		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
10072			return err
10073		}
10074	}
10075
10076	return nil
10077}
10078
10079func awsAwsjson11_serializeOpDocumentTestAlarmInput(v *TestAlarmInput, value smithyjson.Value) error {
10080	object := value.Object()
10081	defer object.Close()
10082
10083	if v.AlarmName != nil {
10084		ok := object.Key("alarmName")
10085		ok.String(*v.AlarmName)
10086	}
10087
10088	if len(v.State) > 0 {
10089		ok := object.Key("state")
10090		ok.String(string(v.State))
10091	}
10092
10093	return nil
10094}
10095
10096func awsAwsjson11_serializeOpDocumentUnpeerVpcInput(v *UnpeerVpcInput, value smithyjson.Value) error {
10097	object := value.Object()
10098	defer object.Close()
10099
10100	return nil
10101}
10102
10103func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
10104	object := value.Object()
10105	defer object.Close()
10106
10107	if v.ResourceArn != nil {
10108		ok := object.Key("resourceArn")
10109		ok.String(*v.ResourceArn)
10110	}
10111
10112	if v.ResourceName != nil {
10113		ok := object.Key("resourceName")
10114		ok.String(*v.ResourceName)
10115	}
10116
10117	if v.TagKeys != nil {
10118		ok := object.Key("tagKeys")
10119		if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
10120			return err
10121		}
10122	}
10123
10124	return nil
10125}
10126
10127func awsAwsjson11_serializeOpDocumentUpdateContainerServiceInput(v *UpdateContainerServiceInput, value smithyjson.Value) error {
10128	object := value.Object()
10129	defer object.Close()
10130
10131	if v.IsDisabled != nil {
10132		ok := object.Key("isDisabled")
10133		ok.Boolean(*v.IsDisabled)
10134	}
10135
10136	if len(v.Power) > 0 {
10137		ok := object.Key("power")
10138		ok.String(string(v.Power))
10139	}
10140
10141	if v.PublicDomainNames != nil {
10142		ok := object.Key("publicDomainNames")
10143		if err := awsAwsjson11_serializeDocumentContainerServicePublicDomains(v.PublicDomainNames, ok); err != nil {
10144			return err
10145		}
10146	}
10147
10148	if v.Scale != nil {
10149		ok := object.Key("scale")
10150		ok.Integer(*v.Scale)
10151	}
10152
10153	if v.ServiceName != nil {
10154		ok := object.Key("serviceName")
10155		ok.String(*v.ServiceName)
10156	}
10157
10158	return nil
10159}
10160
10161func awsAwsjson11_serializeOpDocumentUpdateDistributionBundleInput(v *UpdateDistributionBundleInput, value smithyjson.Value) error {
10162	object := value.Object()
10163	defer object.Close()
10164
10165	if v.BundleId != nil {
10166		ok := object.Key("bundleId")
10167		ok.String(*v.BundleId)
10168	}
10169
10170	if v.DistributionName != nil {
10171		ok := object.Key("distributionName")
10172		ok.String(*v.DistributionName)
10173	}
10174
10175	return nil
10176}
10177
10178func awsAwsjson11_serializeOpDocumentUpdateDistributionInput(v *UpdateDistributionInput, value smithyjson.Value) error {
10179	object := value.Object()
10180	defer object.Close()
10181
10182	if v.CacheBehaviors != nil {
10183		ok := object.Key("cacheBehaviors")
10184		if err := awsAwsjson11_serializeDocumentCacheBehaviorList(v.CacheBehaviors, ok); err != nil {
10185			return err
10186		}
10187	}
10188
10189	if v.CacheBehaviorSettings != nil {
10190		ok := object.Key("cacheBehaviorSettings")
10191		if err := awsAwsjson11_serializeDocumentCacheSettings(v.CacheBehaviorSettings, ok); err != nil {
10192			return err
10193		}
10194	}
10195
10196	if v.DefaultCacheBehavior != nil {
10197		ok := object.Key("defaultCacheBehavior")
10198		if err := awsAwsjson11_serializeDocumentCacheBehavior(v.DefaultCacheBehavior, ok); err != nil {
10199			return err
10200		}
10201	}
10202
10203	if v.DistributionName != nil {
10204		ok := object.Key("distributionName")
10205		ok.String(*v.DistributionName)
10206	}
10207
10208	if v.IsEnabled != nil {
10209		ok := object.Key("isEnabled")
10210		ok.Boolean(*v.IsEnabled)
10211	}
10212
10213	if v.Origin != nil {
10214		ok := object.Key("origin")
10215		if err := awsAwsjson11_serializeDocumentInputOrigin(v.Origin, ok); err != nil {
10216			return err
10217		}
10218	}
10219
10220	return nil
10221}
10222
10223func awsAwsjson11_serializeOpDocumentUpdateDomainEntryInput(v *UpdateDomainEntryInput, value smithyjson.Value) error {
10224	object := value.Object()
10225	defer object.Close()
10226
10227	if v.DomainEntry != nil {
10228		ok := object.Key("domainEntry")
10229		if err := awsAwsjson11_serializeDocumentDomainEntry(v.DomainEntry, ok); err != nil {
10230			return err
10231		}
10232	}
10233
10234	if v.DomainName != nil {
10235		ok := object.Key("domainName")
10236		ok.String(*v.DomainName)
10237	}
10238
10239	return nil
10240}
10241
10242func awsAwsjson11_serializeOpDocumentUpdateLoadBalancerAttributeInput(v *UpdateLoadBalancerAttributeInput, value smithyjson.Value) error {
10243	object := value.Object()
10244	defer object.Close()
10245
10246	if len(v.AttributeName) > 0 {
10247		ok := object.Key("attributeName")
10248		ok.String(string(v.AttributeName))
10249	}
10250
10251	if v.AttributeValue != nil {
10252		ok := object.Key("attributeValue")
10253		ok.String(*v.AttributeValue)
10254	}
10255
10256	if v.LoadBalancerName != nil {
10257		ok := object.Key("loadBalancerName")
10258		ok.String(*v.LoadBalancerName)
10259	}
10260
10261	return nil
10262}
10263
10264func awsAwsjson11_serializeOpDocumentUpdateRelationalDatabaseInput(v *UpdateRelationalDatabaseInput, value smithyjson.Value) error {
10265	object := value.Object()
10266	defer object.Close()
10267
10268	if v.ApplyImmediately != nil {
10269		ok := object.Key("applyImmediately")
10270		ok.Boolean(*v.ApplyImmediately)
10271	}
10272
10273	if v.CaCertificateIdentifier != nil {
10274		ok := object.Key("caCertificateIdentifier")
10275		ok.String(*v.CaCertificateIdentifier)
10276	}
10277
10278	if v.DisableBackupRetention != nil {
10279		ok := object.Key("disableBackupRetention")
10280		ok.Boolean(*v.DisableBackupRetention)
10281	}
10282
10283	if v.EnableBackupRetention != nil {
10284		ok := object.Key("enableBackupRetention")
10285		ok.Boolean(*v.EnableBackupRetention)
10286	}
10287
10288	if v.MasterUserPassword != nil {
10289		ok := object.Key("masterUserPassword")
10290		ok.String(*v.MasterUserPassword)
10291	}
10292
10293	if v.PreferredBackupWindow != nil {
10294		ok := object.Key("preferredBackupWindow")
10295		ok.String(*v.PreferredBackupWindow)
10296	}
10297
10298	if v.PreferredMaintenanceWindow != nil {
10299		ok := object.Key("preferredMaintenanceWindow")
10300		ok.String(*v.PreferredMaintenanceWindow)
10301	}
10302
10303	if v.PubliclyAccessible != nil {
10304		ok := object.Key("publiclyAccessible")
10305		ok.Boolean(*v.PubliclyAccessible)
10306	}
10307
10308	if v.RelationalDatabaseName != nil {
10309		ok := object.Key("relationalDatabaseName")
10310		ok.String(*v.RelationalDatabaseName)
10311	}
10312
10313	if v.RotateMasterUserPassword != nil {
10314		ok := object.Key("rotateMasterUserPassword")
10315		ok.Boolean(*v.RotateMasterUserPassword)
10316	}
10317
10318	return nil
10319}
10320
10321func awsAwsjson11_serializeOpDocumentUpdateRelationalDatabaseParametersInput(v *UpdateRelationalDatabaseParametersInput, value smithyjson.Value) error {
10322	object := value.Object()
10323	defer object.Close()
10324
10325	if v.Parameters != nil {
10326		ok := object.Key("parameters")
10327		if err := awsAwsjson11_serializeDocumentRelationalDatabaseParameterList(v.Parameters, ok); err != nil {
10328			return err
10329		}
10330	}
10331
10332	if v.RelationalDatabaseName != nil {
10333		ok := object.Key("relationalDatabaseName")
10334		ok.String(*v.RelationalDatabaseName)
10335	}
10336
10337	return nil
10338}
10339