1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package opsworks
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/opsworks/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	smithyhttp "github.com/aws/smithy-go/transport/http"
15	"strings"
16)
17
18type awsAwsjson11_serializeOpAssignInstance struct {
19}
20
21func (*awsAwsjson11_serializeOpAssignInstance) ID() string {
22	return "OperationSerializer"
23}
24
25func (m *awsAwsjson11_serializeOpAssignInstance) 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.(*AssignInstanceInput)
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("OpsWorks_20130218.AssignInstance")
47
48	jsonEncoder := smithyjson.NewEncoder()
49	if err := awsAwsjson11_serializeOpDocumentAssignInstanceInput(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_serializeOpAssignVolume struct {
66}
67
68func (*awsAwsjson11_serializeOpAssignVolume) ID() string {
69	return "OperationSerializer"
70}
71
72func (m *awsAwsjson11_serializeOpAssignVolume) 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.(*AssignVolumeInput)
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("OpsWorks_20130218.AssignVolume")
94
95	jsonEncoder := smithyjson.NewEncoder()
96	if err := awsAwsjson11_serializeOpDocumentAssignVolumeInput(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_serializeOpAssociateElasticIp struct {
113}
114
115func (*awsAwsjson11_serializeOpAssociateElasticIp) ID() string {
116	return "OperationSerializer"
117}
118
119func (m *awsAwsjson11_serializeOpAssociateElasticIp) 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.(*AssociateElasticIpInput)
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("OpsWorks_20130218.AssociateElasticIp")
141
142	jsonEncoder := smithyjson.NewEncoder()
143	if err := awsAwsjson11_serializeOpDocumentAssociateElasticIpInput(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_serializeOpAttachElasticLoadBalancer struct {
160}
161
162func (*awsAwsjson11_serializeOpAttachElasticLoadBalancer) ID() string {
163	return "OperationSerializer"
164}
165
166func (m *awsAwsjson11_serializeOpAttachElasticLoadBalancer) 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.(*AttachElasticLoadBalancerInput)
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("OpsWorks_20130218.AttachElasticLoadBalancer")
188
189	jsonEncoder := smithyjson.NewEncoder()
190	if err := awsAwsjson11_serializeOpDocumentAttachElasticLoadBalancerInput(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_serializeOpCloneStack struct {
207}
208
209func (*awsAwsjson11_serializeOpCloneStack) ID() string {
210	return "OperationSerializer"
211}
212
213func (m *awsAwsjson11_serializeOpCloneStack) 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.(*CloneStackInput)
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("OpsWorks_20130218.CloneStack")
235
236	jsonEncoder := smithyjson.NewEncoder()
237	if err := awsAwsjson11_serializeOpDocumentCloneStackInput(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_serializeOpCreateApp struct {
254}
255
256func (*awsAwsjson11_serializeOpCreateApp) ID() string {
257	return "OperationSerializer"
258}
259
260func (m *awsAwsjson11_serializeOpCreateApp) 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.(*CreateAppInput)
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("OpsWorks_20130218.CreateApp")
282
283	jsonEncoder := smithyjson.NewEncoder()
284	if err := awsAwsjson11_serializeOpDocumentCreateAppInput(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_serializeOpCreateDeployment struct {
301}
302
303func (*awsAwsjson11_serializeOpCreateDeployment) ID() string {
304	return "OperationSerializer"
305}
306
307func (m *awsAwsjson11_serializeOpCreateDeployment) 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.(*CreateDeploymentInput)
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("OpsWorks_20130218.CreateDeployment")
329
330	jsonEncoder := smithyjson.NewEncoder()
331	if err := awsAwsjson11_serializeOpDocumentCreateDeploymentInput(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_serializeOpCreateInstance struct {
348}
349
350func (*awsAwsjson11_serializeOpCreateInstance) ID() string {
351	return "OperationSerializer"
352}
353
354func (m *awsAwsjson11_serializeOpCreateInstance) 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.(*CreateInstanceInput)
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("OpsWorks_20130218.CreateInstance")
376
377	jsonEncoder := smithyjson.NewEncoder()
378	if err := awsAwsjson11_serializeOpDocumentCreateInstanceInput(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_serializeOpCreateLayer struct {
395}
396
397func (*awsAwsjson11_serializeOpCreateLayer) ID() string {
398	return "OperationSerializer"
399}
400
401func (m *awsAwsjson11_serializeOpCreateLayer) 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.(*CreateLayerInput)
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("OpsWorks_20130218.CreateLayer")
423
424	jsonEncoder := smithyjson.NewEncoder()
425	if err := awsAwsjson11_serializeOpDocumentCreateLayerInput(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_serializeOpCreateStack struct {
442}
443
444func (*awsAwsjson11_serializeOpCreateStack) ID() string {
445	return "OperationSerializer"
446}
447
448func (m *awsAwsjson11_serializeOpCreateStack) 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.(*CreateStackInput)
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("OpsWorks_20130218.CreateStack")
470
471	jsonEncoder := smithyjson.NewEncoder()
472	if err := awsAwsjson11_serializeOpDocumentCreateStackInput(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_serializeOpCreateUserProfile struct {
489}
490
491func (*awsAwsjson11_serializeOpCreateUserProfile) ID() string {
492	return "OperationSerializer"
493}
494
495func (m *awsAwsjson11_serializeOpCreateUserProfile) 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.(*CreateUserProfileInput)
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("OpsWorks_20130218.CreateUserProfile")
517
518	jsonEncoder := smithyjson.NewEncoder()
519	if err := awsAwsjson11_serializeOpDocumentCreateUserProfileInput(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_serializeOpDeleteApp struct {
536}
537
538func (*awsAwsjson11_serializeOpDeleteApp) ID() string {
539	return "OperationSerializer"
540}
541
542func (m *awsAwsjson11_serializeOpDeleteApp) 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.(*DeleteAppInput)
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("OpsWorks_20130218.DeleteApp")
564
565	jsonEncoder := smithyjson.NewEncoder()
566	if err := awsAwsjson11_serializeOpDocumentDeleteAppInput(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_serializeOpDeleteInstance struct {
583}
584
585func (*awsAwsjson11_serializeOpDeleteInstance) ID() string {
586	return "OperationSerializer"
587}
588
589func (m *awsAwsjson11_serializeOpDeleteInstance) 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.(*DeleteInstanceInput)
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("OpsWorks_20130218.DeleteInstance")
611
612	jsonEncoder := smithyjson.NewEncoder()
613	if err := awsAwsjson11_serializeOpDocumentDeleteInstanceInput(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_serializeOpDeleteLayer struct {
630}
631
632func (*awsAwsjson11_serializeOpDeleteLayer) ID() string {
633	return "OperationSerializer"
634}
635
636func (m *awsAwsjson11_serializeOpDeleteLayer) 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.(*DeleteLayerInput)
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("OpsWorks_20130218.DeleteLayer")
658
659	jsonEncoder := smithyjson.NewEncoder()
660	if err := awsAwsjson11_serializeOpDocumentDeleteLayerInput(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_serializeOpDeleteStack struct {
677}
678
679func (*awsAwsjson11_serializeOpDeleteStack) ID() string {
680	return "OperationSerializer"
681}
682
683func (m *awsAwsjson11_serializeOpDeleteStack) 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.(*DeleteStackInput)
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("OpsWorks_20130218.DeleteStack")
705
706	jsonEncoder := smithyjson.NewEncoder()
707	if err := awsAwsjson11_serializeOpDocumentDeleteStackInput(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_serializeOpDeleteUserProfile struct {
724}
725
726func (*awsAwsjson11_serializeOpDeleteUserProfile) ID() string {
727	return "OperationSerializer"
728}
729
730func (m *awsAwsjson11_serializeOpDeleteUserProfile) 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.(*DeleteUserProfileInput)
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("OpsWorks_20130218.DeleteUserProfile")
752
753	jsonEncoder := smithyjson.NewEncoder()
754	if err := awsAwsjson11_serializeOpDocumentDeleteUserProfileInput(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_serializeOpDeregisterEcsCluster struct {
771}
772
773func (*awsAwsjson11_serializeOpDeregisterEcsCluster) ID() string {
774	return "OperationSerializer"
775}
776
777func (m *awsAwsjson11_serializeOpDeregisterEcsCluster) 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.(*DeregisterEcsClusterInput)
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("OpsWorks_20130218.DeregisterEcsCluster")
799
800	jsonEncoder := smithyjson.NewEncoder()
801	if err := awsAwsjson11_serializeOpDocumentDeregisterEcsClusterInput(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_serializeOpDeregisterElasticIp struct {
818}
819
820func (*awsAwsjson11_serializeOpDeregisterElasticIp) ID() string {
821	return "OperationSerializer"
822}
823
824func (m *awsAwsjson11_serializeOpDeregisterElasticIp) 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.(*DeregisterElasticIpInput)
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("OpsWorks_20130218.DeregisterElasticIp")
846
847	jsonEncoder := smithyjson.NewEncoder()
848	if err := awsAwsjson11_serializeOpDocumentDeregisterElasticIpInput(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_serializeOpDeregisterInstance struct {
865}
866
867func (*awsAwsjson11_serializeOpDeregisterInstance) ID() string {
868	return "OperationSerializer"
869}
870
871func (m *awsAwsjson11_serializeOpDeregisterInstance) 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.(*DeregisterInstanceInput)
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("OpsWorks_20130218.DeregisterInstance")
893
894	jsonEncoder := smithyjson.NewEncoder()
895	if err := awsAwsjson11_serializeOpDocumentDeregisterInstanceInput(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_serializeOpDeregisterRdsDbInstance struct {
912}
913
914func (*awsAwsjson11_serializeOpDeregisterRdsDbInstance) ID() string {
915	return "OperationSerializer"
916}
917
918func (m *awsAwsjson11_serializeOpDeregisterRdsDbInstance) 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.(*DeregisterRdsDbInstanceInput)
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("OpsWorks_20130218.DeregisterRdsDbInstance")
940
941	jsonEncoder := smithyjson.NewEncoder()
942	if err := awsAwsjson11_serializeOpDocumentDeregisterRdsDbInstanceInput(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_serializeOpDeregisterVolume struct {
959}
960
961func (*awsAwsjson11_serializeOpDeregisterVolume) ID() string {
962	return "OperationSerializer"
963}
964
965func (m *awsAwsjson11_serializeOpDeregisterVolume) 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.(*DeregisterVolumeInput)
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("OpsWorks_20130218.DeregisterVolume")
987
988	jsonEncoder := smithyjson.NewEncoder()
989	if err := awsAwsjson11_serializeOpDocumentDeregisterVolumeInput(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_serializeOpDescribeAgentVersions struct {
1006}
1007
1008func (*awsAwsjson11_serializeOpDescribeAgentVersions) ID() string {
1009	return "OperationSerializer"
1010}
1011
1012func (m *awsAwsjson11_serializeOpDescribeAgentVersions) 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.(*DescribeAgentVersionsInput)
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("OpsWorks_20130218.DescribeAgentVersions")
1034
1035	jsonEncoder := smithyjson.NewEncoder()
1036	if err := awsAwsjson11_serializeOpDocumentDescribeAgentVersionsInput(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_serializeOpDescribeApps struct {
1053}
1054
1055func (*awsAwsjson11_serializeOpDescribeApps) ID() string {
1056	return "OperationSerializer"
1057}
1058
1059func (m *awsAwsjson11_serializeOpDescribeApps) 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.(*DescribeAppsInput)
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("OpsWorks_20130218.DescribeApps")
1081
1082	jsonEncoder := smithyjson.NewEncoder()
1083	if err := awsAwsjson11_serializeOpDocumentDescribeAppsInput(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_serializeOpDescribeCommands struct {
1100}
1101
1102func (*awsAwsjson11_serializeOpDescribeCommands) ID() string {
1103	return "OperationSerializer"
1104}
1105
1106func (m *awsAwsjson11_serializeOpDescribeCommands) 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.(*DescribeCommandsInput)
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("OpsWorks_20130218.DescribeCommands")
1128
1129	jsonEncoder := smithyjson.NewEncoder()
1130	if err := awsAwsjson11_serializeOpDocumentDescribeCommandsInput(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_serializeOpDescribeDeployments struct {
1147}
1148
1149func (*awsAwsjson11_serializeOpDescribeDeployments) ID() string {
1150	return "OperationSerializer"
1151}
1152
1153func (m *awsAwsjson11_serializeOpDescribeDeployments) 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.(*DescribeDeploymentsInput)
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("OpsWorks_20130218.DescribeDeployments")
1175
1176	jsonEncoder := smithyjson.NewEncoder()
1177	if err := awsAwsjson11_serializeOpDocumentDescribeDeploymentsInput(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_serializeOpDescribeEcsClusters struct {
1194}
1195
1196func (*awsAwsjson11_serializeOpDescribeEcsClusters) ID() string {
1197	return "OperationSerializer"
1198}
1199
1200func (m *awsAwsjson11_serializeOpDescribeEcsClusters) 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.(*DescribeEcsClustersInput)
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("OpsWorks_20130218.DescribeEcsClusters")
1222
1223	jsonEncoder := smithyjson.NewEncoder()
1224	if err := awsAwsjson11_serializeOpDocumentDescribeEcsClustersInput(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_serializeOpDescribeElasticIps struct {
1241}
1242
1243func (*awsAwsjson11_serializeOpDescribeElasticIps) ID() string {
1244	return "OperationSerializer"
1245}
1246
1247func (m *awsAwsjson11_serializeOpDescribeElasticIps) 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.(*DescribeElasticIpsInput)
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("OpsWorks_20130218.DescribeElasticIps")
1269
1270	jsonEncoder := smithyjson.NewEncoder()
1271	if err := awsAwsjson11_serializeOpDocumentDescribeElasticIpsInput(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_serializeOpDescribeElasticLoadBalancers struct {
1288}
1289
1290func (*awsAwsjson11_serializeOpDescribeElasticLoadBalancers) ID() string {
1291	return "OperationSerializer"
1292}
1293
1294func (m *awsAwsjson11_serializeOpDescribeElasticLoadBalancers) 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.(*DescribeElasticLoadBalancersInput)
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("OpsWorks_20130218.DescribeElasticLoadBalancers")
1316
1317	jsonEncoder := smithyjson.NewEncoder()
1318	if err := awsAwsjson11_serializeOpDocumentDescribeElasticLoadBalancersInput(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_serializeOpDescribeInstances struct {
1335}
1336
1337func (*awsAwsjson11_serializeOpDescribeInstances) ID() string {
1338	return "OperationSerializer"
1339}
1340
1341func (m *awsAwsjson11_serializeOpDescribeInstances) 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.(*DescribeInstancesInput)
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("OpsWorks_20130218.DescribeInstances")
1363
1364	jsonEncoder := smithyjson.NewEncoder()
1365	if err := awsAwsjson11_serializeOpDocumentDescribeInstancesInput(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_serializeOpDescribeLayers struct {
1382}
1383
1384func (*awsAwsjson11_serializeOpDescribeLayers) ID() string {
1385	return "OperationSerializer"
1386}
1387
1388func (m *awsAwsjson11_serializeOpDescribeLayers) 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.(*DescribeLayersInput)
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("OpsWorks_20130218.DescribeLayers")
1410
1411	jsonEncoder := smithyjson.NewEncoder()
1412	if err := awsAwsjson11_serializeOpDocumentDescribeLayersInput(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_serializeOpDescribeLoadBasedAutoScaling struct {
1429}
1430
1431func (*awsAwsjson11_serializeOpDescribeLoadBasedAutoScaling) ID() string {
1432	return "OperationSerializer"
1433}
1434
1435func (m *awsAwsjson11_serializeOpDescribeLoadBasedAutoScaling) 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.(*DescribeLoadBasedAutoScalingInput)
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("OpsWorks_20130218.DescribeLoadBasedAutoScaling")
1457
1458	jsonEncoder := smithyjson.NewEncoder()
1459	if err := awsAwsjson11_serializeOpDocumentDescribeLoadBasedAutoScalingInput(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_serializeOpDescribeMyUserProfile struct {
1476}
1477
1478func (*awsAwsjson11_serializeOpDescribeMyUserProfile) ID() string {
1479	return "OperationSerializer"
1480}
1481
1482func (m *awsAwsjson11_serializeOpDescribeMyUserProfile) 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.(*DescribeMyUserProfileInput)
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("OpsWorks_20130218.DescribeMyUserProfile")
1504
1505	if request, err = request.SetStream(strings.NewReader(`{}`)); err != nil {
1506		return out, metadata, &smithy.SerializationError{Err: err}
1507	}
1508
1509	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1510		return out, metadata, &smithy.SerializationError{Err: err}
1511	}
1512	in.Request = request
1513
1514	return next.HandleSerialize(ctx, in)
1515}
1516
1517type awsAwsjson11_serializeOpDescribeOperatingSystems struct {
1518}
1519
1520func (*awsAwsjson11_serializeOpDescribeOperatingSystems) ID() string {
1521	return "OperationSerializer"
1522}
1523
1524func (m *awsAwsjson11_serializeOpDescribeOperatingSystems) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1525	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1526) {
1527	request, ok := in.Request.(*smithyhttp.Request)
1528	if !ok {
1529		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1530	}
1531
1532	input, ok := in.Parameters.(*DescribeOperatingSystemsInput)
1533	_ = input
1534	if !ok {
1535		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1536	}
1537
1538	request.Request.URL.Path = "/"
1539	request.Request.Method = "POST"
1540	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1541	if err != nil {
1542		return out, metadata, &smithy.SerializationError{Err: err}
1543	}
1544	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1545	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribeOperatingSystems")
1546
1547	if request, err = request.SetStream(strings.NewReader(`{}`)); err != nil {
1548		return out, metadata, &smithy.SerializationError{Err: err}
1549	}
1550
1551	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1552		return out, metadata, &smithy.SerializationError{Err: err}
1553	}
1554	in.Request = request
1555
1556	return next.HandleSerialize(ctx, in)
1557}
1558
1559type awsAwsjson11_serializeOpDescribePermissions struct {
1560}
1561
1562func (*awsAwsjson11_serializeOpDescribePermissions) ID() string {
1563	return "OperationSerializer"
1564}
1565
1566func (m *awsAwsjson11_serializeOpDescribePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1567	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1568) {
1569	request, ok := in.Request.(*smithyhttp.Request)
1570	if !ok {
1571		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1572	}
1573
1574	input, ok := in.Parameters.(*DescribePermissionsInput)
1575	_ = input
1576	if !ok {
1577		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1578	}
1579
1580	request.Request.URL.Path = "/"
1581	request.Request.Method = "POST"
1582	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1583	if err != nil {
1584		return out, metadata, &smithy.SerializationError{Err: err}
1585	}
1586	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1587	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribePermissions")
1588
1589	jsonEncoder := smithyjson.NewEncoder()
1590	if err := awsAwsjson11_serializeOpDocumentDescribePermissionsInput(input, jsonEncoder.Value); err != nil {
1591		return out, metadata, &smithy.SerializationError{Err: err}
1592	}
1593
1594	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1595		return out, metadata, &smithy.SerializationError{Err: err}
1596	}
1597
1598	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1599		return out, metadata, &smithy.SerializationError{Err: err}
1600	}
1601	in.Request = request
1602
1603	return next.HandleSerialize(ctx, in)
1604}
1605
1606type awsAwsjson11_serializeOpDescribeRaidArrays struct {
1607}
1608
1609func (*awsAwsjson11_serializeOpDescribeRaidArrays) ID() string {
1610	return "OperationSerializer"
1611}
1612
1613func (m *awsAwsjson11_serializeOpDescribeRaidArrays) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1614	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1615) {
1616	request, ok := in.Request.(*smithyhttp.Request)
1617	if !ok {
1618		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1619	}
1620
1621	input, ok := in.Parameters.(*DescribeRaidArraysInput)
1622	_ = input
1623	if !ok {
1624		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1625	}
1626
1627	request.Request.URL.Path = "/"
1628	request.Request.Method = "POST"
1629	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1630	if err != nil {
1631		return out, metadata, &smithy.SerializationError{Err: err}
1632	}
1633	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1634	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribeRaidArrays")
1635
1636	jsonEncoder := smithyjson.NewEncoder()
1637	if err := awsAwsjson11_serializeOpDocumentDescribeRaidArraysInput(input, jsonEncoder.Value); err != nil {
1638		return out, metadata, &smithy.SerializationError{Err: err}
1639	}
1640
1641	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1642		return out, metadata, &smithy.SerializationError{Err: err}
1643	}
1644
1645	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1646		return out, metadata, &smithy.SerializationError{Err: err}
1647	}
1648	in.Request = request
1649
1650	return next.HandleSerialize(ctx, in)
1651}
1652
1653type awsAwsjson11_serializeOpDescribeRdsDbInstances struct {
1654}
1655
1656func (*awsAwsjson11_serializeOpDescribeRdsDbInstances) ID() string {
1657	return "OperationSerializer"
1658}
1659
1660func (m *awsAwsjson11_serializeOpDescribeRdsDbInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1661	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1662) {
1663	request, ok := in.Request.(*smithyhttp.Request)
1664	if !ok {
1665		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1666	}
1667
1668	input, ok := in.Parameters.(*DescribeRdsDbInstancesInput)
1669	_ = input
1670	if !ok {
1671		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1672	}
1673
1674	request.Request.URL.Path = "/"
1675	request.Request.Method = "POST"
1676	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1677	if err != nil {
1678		return out, metadata, &smithy.SerializationError{Err: err}
1679	}
1680	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1681	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribeRdsDbInstances")
1682
1683	jsonEncoder := smithyjson.NewEncoder()
1684	if err := awsAwsjson11_serializeOpDocumentDescribeRdsDbInstancesInput(input, jsonEncoder.Value); err != nil {
1685		return out, metadata, &smithy.SerializationError{Err: err}
1686	}
1687
1688	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1689		return out, metadata, &smithy.SerializationError{Err: err}
1690	}
1691
1692	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1693		return out, metadata, &smithy.SerializationError{Err: err}
1694	}
1695	in.Request = request
1696
1697	return next.HandleSerialize(ctx, in)
1698}
1699
1700type awsAwsjson11_serializeOpDescribeServiceErrors struct {
1701}
1702
1703func (*awsAwsjson11_serializeOpDescribeServiceErrors) ID() string {
1704	return "OperationSerializer"
1705}
1706
1707func (m *awsAwsjson11_serializeOpDescribeServiceErrors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1708	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1709) {
1710	request, ok := in.Request.(*smithyhttp.Request)
1711	if !ok {
1712		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1713	}
1714
1715	input, ok := in.Parameters.(*DescribeServiceErrorsInput)
1716	_ = input
1717	if !ok {
1718		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1719	}
1720
1721	request.Request.URL.Path = "/"
1722	request.Request.Method = "POST"
1723	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1724	if err != nil {
1725		return out, metadata, &smithy.SerializationError{Err: err}
1726	}
1727	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1728	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribeServiceErrors")
1729
1730	jsonEncoder := smithyjson.NewEncoder()
1731	if err := awsAwsjson11_serializeOpDocumentDescribeServiceErrorsInput(input, jsonEncoder.Value); err != nil {
1732		return out, metadata, &smithy.SerializationError{Err: err}
1733	}
1734
1735	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1736		return out, metadata, &smithy.SerializationError{Err: err}
1737	}
1738
1739	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1740		return out, metadata, &smithy.SerializationError{Err: err}
1741	}
1742	in.Request = request
1743
1744	return next.HandleSerialize(ctx, in)
1745}
1746
1747type awsAwsjson11_serializeOpDescribeStackProvisioningParameters struct {
1748}
1749
1750func (*awsAwsjson11_serializeOpDescribeStackProvisioningParameters) ID() string {
1751	return "OperationSerializer"
1752}
1753
1754func (m *awsAwsjson11_serializeOpDescribeStackProvisioningParameters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1755	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1756) {
1757	request, ok := in.Request.(*smithyhttp.Request)
1758	if !ok {
1759		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1760	}
1761
1762	input, ok := in.Parameters.(*DescribeStackProvisioningParametersInput)
1763	_ = input
1764	if !ok {
1765		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1766	}
1767
1768	request.Request.URL.Path = "/"
1769	request.Request.Method = "POST"
1770	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1771	if err != nil {
1772		return out, metadata, &smithy.SerializationError{Err: err}
1773	}
1774	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1775	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribeStackProvisioningParameters")
1776
1777	jsonEncoder := smithyjson.NewEncoder()
1778	if err := awsAwsjson11_serializeOpDocumentDescribeStackProvisioningParametersInput(input, jsonEncoder.Value); err != nil {
1779		return out, metadata, &smithy.SerializationError{Err: err}
1780	}
1781
1782	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1783		return out, metadata, &smithy.SerializationError{Err: err}
1784	}
1785
1786	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1787		return out, metadata, &smithy.SerializationError{Err: err}
1788	}
1789	in.Request = request
1790
1791	return next.HandleSerialize(ctx, in)
1792}
1793
1794type awsAwsjson11_serializeOpDescribeStacks struct {
1795}
1796
1797func (*awsAwsjson11_serializeOpDescribeStacks) ID() string {
1798	return "OperationSerializer"
1799}
1800
1801func (m *awsAwsjson11_serializeOpDescribeStacks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1802	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1803) {
1804	request, ok := in.Request.(*smithyhttp.Request)
1805	if !ok {
1806		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1807	}
1808
1809	input, ok := in.Parameters.(*DescribeStacksInput)
1810	_ = input
1811	if !ok {
1812		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1813	}
1814
1815	request.Request.URL.Path = "/"
1816	request.Request.Method = "POST"
1817	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1818	if err != nil {
1819		return out, metadata, &smithy.SerializationError{Err: err}
1820	}
1821	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1822	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribeStacks")
1823
1824	jsonEncoder := smithyjson.NewEncoder()
1825	if err := awsAwsjson11_serializeOpDocumentDescribeStacksInput(input, jsonEncoder.Value); err != nil {
1826		return out, metadata, &smithy.SerializationError{Err: err}
1827	}
1828
1829	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1830		return out, metadata, &smithy.SerializationError{Err: err}
1831	}
1832
1833	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1834		return out, metadata, &smithy.SerializationError{Err: err}
1835	}
1836	in.Request = request
1837
1838	return next.HandleSerialize(ctx, in)
1839}
1840
1841type awsAwsjson11_serializeOpDescribeStackSummary struct {
1842}
1843
1844func (*awsAwsjson11_serializeOpDescribeStackSummary) ID() string {
1845	return "OperationSerializer"
1846}
1847
1848func (m *awsAwsjson11_serializeOpDescribeStackSummary) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1849	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1850) {
1851	request, ok := in.Request.(*smithyhttp.Request)
1852	if !ok {
1853		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1854	}
1855
1856	input, ok := in.Parameters.(*DescribeStackSummaryInput)
1857	_ = input
1858	if !ok {
1859		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1860	}
1861
1862	request.Request.URL.Path = "/"
1863	request.Request.Method = "POST"
1864	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1865	if err != nil {
1866		return out, metadata, &smithy.SerializationError{Err: err}
1867	}
1868	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1869	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribeStackSummary")
1870
1871	jsonEncoder := smithyjson.NewEncoder()
1872	if err := awsAwsjson11_serializeOpDocumentDescribeStackSummaryInput(input, jsonEncoder.Value); err != nil {
1873		return out, metadata, &smithy.SerializationError{Err: err}
1874	}
1875
1876	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1877		return out, metadata, &smithy.SerializationError{Err: err}
1878	}
1879
1880	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1881		return out, metadata, &smithy.SerializationError{Err: err}
1882	}
1883	in.Request = request
1884
1885	return next.HandleSerialize(ctx, in)
1886}
1887
1888type awsAwsjson11_serializeOpDescribeTimeBasedAutoScaling struct {
1889}
1890
1891func (*awsAwsjson11_serializeOpDescribeTimeBasedAutoScaling) ID() string {
1892	return "OperationSerializer"
1893}
1894
1895func (m *awsAwsjson11_serializeOpDescribeTimeBasedAutoScaling) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1896	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1897) {
1898	request, ok := in.Request.(*smithyhttp.Request)
1899	if !ok {
1900		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1901	}
1902
1903	input, ok := in.Parameters.(*DescribeTimeBasedAutoScalingInput)
1904	_ = input
1905	if !ok {
1906		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1907	}
1908
1909	request.Request.URL.Path = "/"
1910	request.Request.Method = "POST"
1911	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1912	if err != nil {
1913		return out, metadata, &smithy.SerializationError{Err: err}
1914	}
1915	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1916	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribeTimeBasedAutoScaling")
1917
1918	jsonEncoder := smithyjson.NewEncoder()
1919	if err := awsAwsjson11_serializeOpDocumentDescribeTimeBasedAutoScalingInput(input, jsonEncoder.Value); err != nil {
1920		return out, metadata, &smithy.SerializationError{Err: err}
1921	}
1922
1923	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1924		return out, metadata, &smithy.SerializationError{Err: err}
1925	}
1926
1927	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1928		return out, metadata, &smithy.SerializationError{Err: err}
1929	}
1930	in.Request = request
1931
1932	return next.HandleSerialize(ctx, in)
1933}
1934
1935type awsAwsjson11_serializeOpDescribeUserProfiles struct {
1936}
1937
1938func (*awsAwsjson11_serializeOpDescribeUserProfiles) ID() string {
1939	return "OperationSerializer"
1940}
1941
1942func (m *awsAwsjson11_serializeOpDescribeUserProfiles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1943	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1944) {
1945	request, ok := in.Request.(*smithyhttp.Request)
1946	if !ok {
1947		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1948	}
1949
1950	input, ok := in.Parameters.(*DescribeUserProfilesInput)
1951	_ = input
1952	if !ok {
1953		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1954	}
1955
1956	request.Request.URL.Path = "/"
1957	request.Request.Method = "POST"
1958	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1959	if err != nil {
1960		return out, metadata, &smithy.SerializationError{Err: err}
1961	}
1962	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1963	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribeUserProfiles")
1964
1965	jsonEncoder := smithyjson.NewEncoder()
1966	if err := awsAwsjson11_serializeOpDocumentDescribeUserProfilesInput(input, jsonEncoder.Value); err != nil {
1967		return out, metadata, &smithy.SerializationError{Err: err}
1968	}
1969
1970	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1971		return out, metadata, &smithy.SerializationError{Err: err}
1972	}
1973
1974	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1975		return out, metadata, &smithy.SerializationError{Err: err}
1976	}
1977	in.Request = request
1978
1979	return next.HandleSerialize(ctx, in)
1980}
1981
1982type awsAwsjson11_serializeOpDescribeVolumes struct {
1983}
1984
1985func (*awsAwsjson11_serializeOpDescribeVolumes) ID() string {
1986	return "OperationSerializer"
1987}
1988
1989func (m *awsAwsjson11_serializeOpDescribeVolumes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1990	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1991) {
1992	request, ok := in.Request.(*smithyhttp.Request)
1993	if !ok {
1994		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1995	}
1996
1997	input, ok := in.Parameters.(*DescribeVolumesInput)
1998	_ = input
1999	if !ok {
2000		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2001	}
2002
2003	request.Request.URL.Path = "/"
2004	request.Request.Method = "POST"
2005	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2006	if err != nil {
2007		return out, metadata, &smithy.SerializationError{Err: err}
2008	}
2009	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2010	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DescribeVolumes")
2011
2012	jsonEncoder := smithyjson.NewEncoder()
2013	if err := awsAwsjson11_serializeOpDocumentDescribeVolumesInput(input, jsonEncoder.Value); err != nil {
2014		return out, metadata, &smithy.SerializationError{Err: err}
2015	}
2016
2017	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2018		return out, metadata, &smithy.SerializationError{Err: err}
2019	}
2020
2021	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2022		return out, metadata, &smithy.SerializationError{Err: err}
2023	}
2024	in.Request = request
2025
2026	return next.HandleSerialize(ctx, in)
2027}
2028
2029type awsAwsjson11_serializeOpDetachElasticLoadBalancer struct {
2030}
2031
2032func (*awsAwsjson11_serializeOpDetachElasticLoadBalancer) ID() string {
2033	return "OperationSerializer"
2034}
2035
2036func (m *awsAwsjson11_serializeOpDetachElasticLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2037	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2038) {
2039	request, ok := in.Request.(*smithyhttp.Request)
2040	if !ok {
2041		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2042	}
2043
2044	input, ok := in.Parameters.(*DetachElasticLoadBalancerInput)
2045	_ = input
2046	if !ok {
2047		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2048	}
2049
2050	request.Request.URL.Path = "/"
2051	request.Request.Method = "POST"
2052	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2053	if err != nil {
2054		return out, metadata, &smithy.SerializationError{Err: err}
2055	}
2056	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2057	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DetachElasticLoadBalancer")
2058
2059	jsonEncoder := smithyjson.NewEncoder()
2060	if err := awsAwsjson11_serializeOpDocumentDetachElasticLoadBalancerInput(input, jsonEncoder.Value); err != nil {
2061		return out, metadata, &smithy.SerializationError{Err: err}
2062	}
2063
2064	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2065		return out, metadata, &smithy.SerializationError{Err: err}
2066	}
2067
2068	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2069		return out, metadata, &smithy.SerializationError{Err: err}
2070	}
2071	in.Request = request
2072
2073	return next.HandleSerialize(ctx, in)
2074}
2075
2076type awsAwsjson11_serializeOpDisassociateElasticIp struct {
2077}
2078
2079func (*awsAwsjson11_serializeOpDisassociateElasticIp) ID() string {
2080	return "OperationSerializer"
2081}
2082
2083func (m *awsAwsjson11_serializeOpDisassociateElasticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2084	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2085) {
2086	request, ok := in.Request.(*smithyhttp.Request)
2087	if !ok {
2088		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2089	}
2090
2091	input, ok := in.Parameters.(*DisassociateElasticIpInput)
2092	_ = input
2093	if !ok {
2094		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2095	}
2096
2097	request.Request.URL.Path = "/"
2098	request.Request.Method = "POST"
2099	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2100	if err != nil {
2101		return out, metadata, &smithy.SerializationError{Err: err}
2102	}
2103	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2104	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.DisassociateElasticIp")
2105
2106	jsonEncoder := smithyjson.NewEncoder()
2107	if err := awsAwsjson11_serializeOpDocumentDisassociateElasticIpInput(input, jsonEncoder.Value); err != nil {
2108		return out, metadata, &smithy.SerializationError{Err: err}
2109	}
2110
2111	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2112		return out, metadata, &smithy.SerializationError{Err: err}
2113	}
2114
2115	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2116		return out, metadata, &smithy.SerializationError{Err: err}
2117	}
2118	in.Request = request
2119
2120	return next.HandleSerialize(ctx, in)
2121}
2122
2123type awsAwsjson11_serializeOpGetHostnameSuggestion struct {
2124}
2125
2126func (*awsAwsjson11_serializeOpGetHostnameSuggestion) ID() string {
2127	return "OperationSerializer"
2128}
2129
2130func (m *awsAwsjson11_serializeOpGetHostnameSuggestion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2131	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2132) {
2133	request, ok := in.Request.(*smithyhttp.Request)
2134	if !ok {
2135		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2136	}
2137
2138	input, ok := in.Parameters.(*GetHostnameSuggestionInput)
2139	_ = input
2140	if !ok {
2141		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2142	}
2143
2144	request.Request.URL.Path = "/"
2145	request.Request.Method = "POST"
2146	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2147	if err != nil {
2148		return out, metadata, &smithy.SerializationError{Err: err}
2149	}
2150	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2151	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.GetHostnameSuggestion")
2152
2153	jsonEncoder := smithyjson.NewEncoder()
2154	if err := awsAwsjson11_serializeOpDocumentGetHostnameSuggestionInput(input, jsonEncoder.Value); err != nil {
2155		return out, metadata, &smithy.SerializationError{Err: err}
2156	}
2157
2158	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2159		return out, metadata, &smithy.SerializationError{Err: err}
2160	}
2161
2162	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2163		return out, metadata, &smithy.SerializationError{Err: err}
2164	}
2165	in.Request = request
2166
2167	return next.HandleSerialize(ctx, in)
2168}
2169
2170type awsAwsjson11_serializeOpGrantAccess struct {
2171}
2172
2173func (*awsAwsjson11_serializeOpGrantAccess) ID() string {
2174	return "OperationSerializer"
2175}
2176
2177func (m *awsAwsjson11_serializeOpGrantAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2178	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2179) {
2180	request, ok := in.Request.(*smithyhttp.Request)
2181	if !ok {
2182		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2183	}
2184
2185	input, ok := in.Parameters.(*GrantAccessInput)
2186	_ = input
2187	if !ok {
2188		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2189	}
2190
2191	request.Request.URL.Path = "/"
2192	request.Request.Method = "POST"
2193	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2194	if err != nil {
2195		return out, metadata, &smithy.SerializationError{Err: err}
2196	}
2197	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2198	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.GrantAccess")
2199
2200	jsonEncoder := smithyjson.NewEncoder()
2201	if err := awsAwsjson11_serializeOpDocumentGrantAccessInput(input, jsonEncoder.Value); err != nil {
2202		return out, metadata, &smithy.SerializationError{Err: err}
2203	}
2204
2205	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2206		return out, metadata, &smithy.SerializationError{Err: err}
2207	}
2208
2209	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2210		return out, metadata, &smithy.SerializationError{Err: err}
2211	}
2212	in.Request = request
2213
2214	return next.HandleSerialize(ctx, in)
2215}
2216
2217type awsAwsjson11_serializeOpListTags struct {
2218}
2219
2220func (*awsAwsjson11_serializeOpListTags) ID() string {
2221	return "OperationSerializer"
2222}
2223
2224func (m *awsAwsjson11_serializeOpListTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2225	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2226) {
2227	request, ok := in.Request.(*smithyhttp.Request)
2228	if !ok {
2229		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2230	}
2231
2232	input, ok := in.Parameters.(*ListTagsInput)
2233	_ = input
2234	if !ok {
2235		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2236	}
2237
2238	request.Request.URL.Path = "/"
2239	request.Request.Method = "POST"
2240	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2241	if err != nil {
2242		return out, metadata, &smithy.SerializationError{Err: err}
2243	}
2244	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2245	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.ListTags")
2246
2247	jsonEncoder := smithyjson.NewEncoder()
2248	if err := awsAwsjson11_serializeOpDocumentListTagsInput(input, jsonEncoder.Value); err != nil {
2249		return out, metadata, &smithy.SerializationError{Err: err}
2250	}
2251
2252	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2253		return out, metadata, &smithy.SerializationError{Err: err}
2254	}
2255
2256	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2257		return out, metadata, &smithy.SerializationError{Err: err}
2258	}
2259	in.Request = request
2260
2261	return next.HandleSerialize(ctx, in)
2262}
2263
2264type awsAwsjson11_serializeOpRebootInstance struct {
2265}
2266
2267func (*awsAwsjson11_serializeOpRebootInstance) ID() string {
2268	return "OperationSerializer"
2269}
2270
2271func (m *awsAwsjson11_serializeOpRebootInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2272	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2273) {
2274	request, ok := in.Request.(*smithyhttp.Request)
2275	if !ok {
2276		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2277	}
2278
2279	input, ok := in.Parameters.(*RebootInstanceInput)
2280	_ = input
2281	if !ok {
2282		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2283	}
2284
2285	request.Request.URL.Path = "/"
2286	request.Request.Method = "POST"
2287	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2288	if err != nil {
2289		return out, metadata, &smithy.SerializationError{Err: err}
2290	}
2291	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2292	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.RebootInstance")
2293
2294	jsonEncoder := smithyjson.NewEncoder()
2295	if err := awsAwsjson11_serializeOpDocumentRebootInstanceInput(input, jsonEncoder.Value); err != nil {
2296		return out, metadata, &smithy.SerializationError{Err: err}
2297	}
2298
2299	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2300		return out, metadata, &smithy.SerializationError{Err: err}
2301	}
2302
2303	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2304		return out, metadata, &smithy.SerializationError{Err: err}
2305	}
2306	in.Request = request
2307
2308	return next.HandleSerialize(ctx, in)
2309}
2310
2311type awsAwsjson11_serializeOpRegisterEcsCluster struct {
2312}
2313
2314func (*awsAwsjson11_serializeOpRegisterEcsCluster) ID() string {
2315	return "OperationSerializer"
2316}
2317
2318func (m *awsAwsjson11_serializeOpRegisterEcsCluster) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2319	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2320) {
2321	request, ok := in.Request.(*smithyhttp.Request)
2322	if !ok {
2323		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2324	}
2325
2326	input, ok := in.Parameters.(*RegisterEcsClusterInput)
2327	_ = input
2328	if !ok {
2329		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2330	}
2331
2332	request.Request.URL.Path = "/"
2333	request.Request.Method = "POST"
2334	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2335	if err != nil {
2336		return out, metadata, &smithy.SerializationError{Err: err}
2337	}
2338	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2339	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.RegisterEcsCluster")
2340
2341	jsonEncoder := smithyjson.NewEncoder()
2342	if err := awsAwsjson11_serializeOpDocumentRegisterEcsClusterInput(input, jsonEncoder.Value); err != nil {
2343		return out, metadata, &smithy.SerializationError{Err: err}
2344	}
2345
2346	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2347		return out, metadata, &smithy.SerializationError{Err: err}
2348	}
2349
2350	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2351		return out, metadata, &smithy.SerializationError{Err: err}
2352	}
2353	in.Request = request
2354
2355	return next.HandleSerialize(ctx, in)
2356}
2357
2358type awsAwsjson11_serializeOpRegisterElasticIp struct {
2359}
2360
2361func (*awsAwsjson11_serializeOpRegisterElasticIp) ID() string {
2362	return "OperationSerializer"
2363}
2364
2365func (m *awsAwsjson11_serializeOpRegisterElasticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2366	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2367) {
2368	request, ok := in.Request.(*smithyhttp.Request)
2369	if !ok {
2370		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2371	}
2372
2373	input, ok := in.Parameters.(*RegisterElasticIpInput)
2374	_ = input
2375	if !ok {
2376		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2377	}
2378
2379	request.Request.URL.Path = "/"
2380	request.Request.Method = "POST"
2381	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2382	if err != nil {
2383		return out, metadata, &smithy.SerializationError{Err: err}
2384	}
2385	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2386	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.RegisterElasticIp")
2387
2388	jsonEncoder := smithyjson.NewEncoder()
2389	if err := awsAwsjson11_serializeOpDocumentRegisterElasticIpInput(input, jsonEncoder.Value); err != nil {
2390		return out, metadata, &smithy.SerializationError{Err: err}
2391	}
2392
2393	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2394		return out, metadata, &smithy.SerializationError{Err: err}
2395	}
2396
2397	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2398		return out, metadata, &smithy.SerializationError{Err: err}
2399	}
2400	in.Request = request
2401
2402	return next.HandleSerialize(ctx, in)
2403}
2404
2405type awsAwsjson11_serializeOpRegisterInstance struct {
2406}
2407
2408func (*awsAwsjson11_serializeOpRegisterInstance) ID() string {
2409	return "OperationSerializer"
2410}
2411
2412func (m *awsAwsjson11_serializeOpRegisterInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2413	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2414) {
2415	request, ok := in.Request.(*smithyhttp.Request)
2416	if !ok {
2417		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2418	}
2419
2420	input, ok := in.Parameters.(*RegisterInstanceInput)
2421	_ = input
2422	if !ok {
2423		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2424	}
2425
2426	request.Request.URL.Path = "/"
2427	request.Request.Method = "POST"
2428	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2429	if err != nil {
2430		return out, metadata, &smithy.SerializationError{Err: err}
2431	}
2432	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2433	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.RegisterInstance")
2434
2435	jsonEncoder := smithyjson.NewEncoder()
2436	if err := awsAwsjson11_serializeOpDocumentRegisterInstanceInput(input, jsonEncoder.Value); err != nil {
2437		return out, metadata, &smithy.SerializationError{Err: err}
2438	}
2439
2440	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2441		return out, metadata, &smithy.SerializationError{Err: err}
2442	}
2443
2444	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2445		return out, metadata, &smithy.SerializationError{Err: err}
2446	}
2447	in.Request = request
2448
2449	return next.HandleSerialize(ctx, in)
2450}
2451
2452type awsAwsjson11_serializeOpRegisterRdsDbInstance struct {
2453}
2454
2455func (*awsAwsjson11_serializeOpRegisterRdsDbInstance) ID() string {
2456	return "OperationSerializer"
2457}
2458
2459func (m *awsAwsjson11_serializeOpRegisterRdsDbInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2460	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2461) {
2462	request, ok := in.Request.(*smithyhttp.Request)
2463	if !ok {
2464		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2465	}
2466
2467	input, ok := in.Parameters.(*RegisterRdsDbInstanceInput)
2468	_ = input
2469	if !ok {
2470		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2471	}
2472
2473	request.Request.URL.Path = "/"
2474	request.Request.Method = "POST"
2475	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2476	if err != nil {
2477		return out, metadata, &smithy.SerializationError{Err: err}
2478	}
2479	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2480	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.RegisterRdsDbInstance")
2481
2482	jsonEncoder := smithyjson.NewEncoder()
2483	if err := awsAwsjson11_serializeOpDocumentRegisterRdsDbInstanceInput(input, jsonEncoder.Value); err != nil {
2484		return out, metadata, &smithy.SerializationError{Err: err}
2485	}
2486
2487	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2488		return out, metadata, &smithy.SerializationError{Err: err}
2489	}
2490
2491	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2492		return out, metadata, &smithy.SerializationError{Err: err}
2493	}
2494	in.Request = request
2495
2496	return next.HandleSerialize(ctx, in)
2497}
2498
2499type awsAwsjson11_serializeOpRegisterVolume struct {
2500}
2501
2502func (*awsAwsjson11_serializeOpRegisterVolume) ID() string {
2503	return "OperationSerializer"
2504}
2505
2506func (m *awsAwsjson11_serializeOpRegisterVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2507	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2508) {
2509	request, ok := in.Request.(*smithyhttp.Request)
2510	if !ok {
2511		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2512	}
2513
2514	input, ok := in.Parameters.(*RegisterVolumeInput)
2515	_ = input
2516	if !ok {
2517		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2518	}
2519
2520	request.Request.URL.Path = "/"
2521	request.Request.Method = "POST"
2522	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2523	if err != nil {
2524		return out, metadata, &smithy.SerializationError{Err: err}
2525	}
2526	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2527	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.RegisterVolume")
2528
2529	jsonEncoder := smithyjson.NewEncoder()
2530	if err := awsAwsjson11_serializeOpDocumentRegisterVolumeInput(input, jsonEncoder.Value); err != nil {
2531		return out, metadata, &smithy.SerializationError{Err: err}
2532	}
2533
2534	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2535		return out, metadata, &smithy.SerializationError{Err: err}
2536	}
2537
2538	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2539		return out, metadata, &smithy.SerializationError{Err: err}
2540	}
2541	in.Request = request
2542
2543	return next.HandleSerialize(ctx, in)
2544}
2545
2546type awsAwsjson11_serializeOpSetLoadBasedAutoScaling struct {
2547}
2548
2549func (*awsAwsjson11_serializeOpSetLoadBasedAutoScaling) ID() string {
2550	return "OperationSerializer"
2551}
2552
2553func (m *awsAwsjson11_serializeOpSetLoadBasedAutoScaling) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2554	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2555) {
2556	request, ok := in.Request.(*smithyhttp.Request)
2557	if !ok {
2558		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2559	}
2560
2561	input, ok := in.Parameters.(*SetLoadBasedAutoScalingInput)
2562	_ = input
2563	if !ok {
2564		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2565	}
2566
2567	request.Request.URL.Path = "/"
2568	request.Request.Method = "POST"
2569	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2570	if err != nil {
2571		return out, metadata, &smithy.SerializationError{Err: err}
2572	}
2573	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2574	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.SetLoadBasedAutoScaling")
2575
2576	jsonEncoder := smithyjson.NewEncoder()
2577	if err := awsAwsjson11_serializeOpDocumentSetLoadBasedAutoScalingInput(input, jsonEncoder.Value); err != nil {
2578		return out, metadata, &smithy.SerializationError{Err: err}
2579	}
2580
2581	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2582		return out, metadata, &smithy.SerializationError{Err: err}
2583	}
2584
2585	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2586		return out, metadata, &smithy.SerializationError{Err: err}
2587	}
2588	in.Request = request
2589
2590	return next.HandleSerialize(ctx, in)
2591}
2592
2593type awsAwsjson11_serializeOpSetPermission struct {
2594}
2595
2596func (*awsAwsjson11_serializeOpSetPermission) ID() string {
2597	return "OperationSerializer"
2598}
2599
2600func (m *awsAwsjson11_serializeOpSetPermission) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2601	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2602) {
2603	request, ok := in.Request.(*smithyhttp.Request)
2604	if !ok {
2605		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2606	}
2607
2608	input, ok := in.Parameters.(*SetPermissionInput)
2609	_ = input
2610	if !ok {
2611		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2612	}
2613
2614	request.Request.URL.Path = "/"
2615	request.Request.Method = "POST"
2616	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2617	if err != nil {
2618		return out, metadata, &smithy.SerializationError{Err: err}
2619	}
2620	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2621	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.SetPermission")
2622
2623	jsonEncoder := smithyjson.NewEncoder()
2624	if err := awsAwsjson11_serializeOpDocumentSetPermissionInput(input, jsonEncoder.Value); err != nil {
2625		return out, metadata, &smithy.SerializationError{Err: err}
2626	}
2627
2628	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2629		return out, metadata, &smithy.SerializationError{Err: err}
2630	}
2631
2632	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2633		return out, metadata, &smithy.SerializationError{Err: err}
2634	}
2635	in.Request = request
2636
2637	return next.HandleSerialize(ctx, in)
2638}
2639
2640type awsAwsjson11_serializeOpSetTimeBasedAutoScaling struct {
2641}
2642
2643func (*awsAwsjson11_serializeOpSetTimeBasedAutoScaling) ID() string {
2644	return "OperationSerializer"
2645}
2646
2647func (m *awsAwsjson11_serializeOpSetTimeBasedAutoScaling) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2648	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2649) {
2650	request, ok := in.Request.(*smithyhttp.Request)
2651	if !ok {
2652		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2653	}
2654
2655	input, ok := in.Parameters.(*SetTimeBasedAutoScalingInput)
2656	_ = input
2657	if !ok {
2658		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2659	}
2660
2661	request.Request.URL.Path = "/"
2662	request.Request.Method = "POST"
2663	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2664	if err != nil {
2665		return out, metadata, &smithy.SerializationError{Err: err}
2666	}
2667	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2668	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.SetTimeBasedAutoScaling")
2669
2670	jsonEncoder := smithyjson.NewEncoder()
2671	if err := awsAwsjson11_serializeOpDocumentSetTimeBasedAutoScalingInput(input, jsonEncoder.Value); err != nil {
2672		return out, metadata, &smithy.SerializationError{Err: err}
2673	}
2674
2675	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2676		return out, metadata, &smithy.SerializationError{Err: err}
2677	}
2678
2679	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2680		return out, metadata, &smithy.SerializationError{Err: err}
2681	}
2682	in.Request = request
2683
2684	return next.HandleSerialize(ctx, in)
2685}
2686
2687type awsAwsjson11_serializeOpStartInstance struct {
2688}
2689
2690func (*awsAwsjson11_serializeOpStartInstance) ID() string {
2691	return "OperationSerializer"
2692}
2693
2694func (m *awsAwsjson11_serializeOpStartInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2695	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2696) {
2697	request, ok := in.Request.(*smithyhttp.Request)
2698	if !ok {
2699		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2700	}
2701
2702	input, ok := in.Parameters.(*StartInstanceInput)
2703	_ = input
2704	if !ok {
2705		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2706	}
2707
2708	request.Request.URL.Path = "/"
2709	request.Request.Method = "POST"
2710	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2711	if err != nil {
2712		return out, metadata, &smithy.SerializationError{Err: err}
2713	}
2714	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2715	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.StartInstance")
2716
2717	jsonEncoder := smithyjson.NewEncoder()
2718	if err := awsAwsjson11_serializeOpDocumentStartInstanceInput(input, jsonEncoder.Value); err != nil {
2719		return out, metadata, &smithy.SerializationError{Err: err}
2720	}
2721
2722	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2723		return out, metadata, &smithy.SerializationError{Err: err}
2724	}
2725
2726	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2727		return out, metadata, &smithy.SerializationError{Err: err}
2728	}
2729	in.Request = request
2730
2731	return next.HandleSerialize(ctx, in)
2732}
2733
2734type awsAwsjson11_serializeOpStartStack struct {
2735}
2736
2737func (*awsAwsjson11_serializeOpStartStack) ID() string {
2738	return "OperationSerializer"
2739}
2740
2741func (m *awsAwsjson11_serializeOpStartStack) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2742	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2743) {
2744	request, ok := in.Request.(*smithyhttp.Request)
2745	if !ok {
2746		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2747	}
2748
2749	input, ok := in.Parameters.(*StartStackInput)
2750	_ = input
2751	if !ok {
2752		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2753	}
2754
2755	request.Request.URL.Path = "/"
2756	request.Request.Method = "POST"
2757	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2758	if err != nil {
2759		return out, metadata, &smithy.SerializationError{Err: err}
2760	}
2761	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2762	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.StartStack")
2763
2764	jsonEncoder := smithyjson.NewEncoder()
2765	if err := awsAwsjson11_serializeOpDocumentStartStackInput(input, jsonEncoder.Value); err != nil {
2766		return out, metadata, &smithy.SerializationError{Err: err}
2767	}
2768
2769	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2770		return out, metadata, &smithy.SerializationError{Err: err}
2771	}
2772
2773	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2774		return out, metadata, &smithy.SerializationError{Err: err}
2775	}
2776	in.Request = request
2777
2778	return next.HandleSerialize(ctx, in)
2779}
2780
2781type awsAwsjson11_serializeOpStopInstance struct {
2782}
2783
2784func (*awsAwsjson11_serializeOpStopInstance) ID() string {
2785	return "OperationSerializer"
2786}
2787
2788func (m *awsAwsjson11_serializeOpStopInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2789	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2790) {
2791	request, ok := in.Request.(*smithyhttp.Request)
2792	if !ok {
2793		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2794	}
2795
2796	input, ok := in.Parameters.(*StopInstanceInput)
2797	_ = input
2798	if !ok {
2799		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2800	}
2801
2802	request.Request.URL.Path = "/"
2803	request.Request.Method = "POST"
2804	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2805	if err != nil {
2806		return out, metadata, &smithy.SerializationError{Err: err}
2807	}
2808	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2809	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.StopInstance")
2810
2811	jsonEncoder := smithyjson.NewEncoder()
2812	if err := awsAwsjson11_serializeOpDocumentStopInstanceInput(input, jsonEncoder.Value); err != nil {
2813		return out, metadata, &smithy.SerializationError{Err: err}
2814	}
2815
2816	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2817		return out, metadata, &smithy.SerializationError{Err: err}
2818	}
2819
2820	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2821		return out, metadata, &smithy.SerializationError{Err: err}
2822	}
2823	in.Request = request
2824
2825	return next.HandleSerialize(ctx, in)
2826}
2827
2828type awsAwsjson11_serializeOpStopStack struct {
2829}
2830
2831func (*awsAwsjson11_serializeOpStopStack) ID() string {
2832	return "OperationSerializer"
2833}
2834
2835func (m *awsAwsjson11_serializeOpStopStack) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2836	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2837) {
2838	request, ok := in.Request.(*smithyhttp.Request)
2839	if !ok {
2840		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2841	}
2842
2843	input, ok := in.Parameters.(*StopStackInput)
2844	_ = input
2845	if !ok {
2846		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2847	}
2848
2849	request.Request.URL.Path = "/"
2850	request.Request.Method = "POST"
2851	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2852	if err != nil {
2853		return out, metadata, &smithy.SerializationError{Err: err}
2854	}
2855	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2856	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.StopStack")
2857
2858	jsonEncoder := smithyjson.NewEncoder()
2859	if err := awsAwsjson11_serializeOpDocumentStopStackInput(input, jsonEncoder.Value); err != nil {
2860		return out, metadata, &smithy.SerializationError{Err: err}
2861	}
2862
2863	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2864		return out, metadata, &smithy.SerializationError{Err: err}
2865	}
2866
2867	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2868		return out, metadata, &smithy.SerializationError{Err: err}
2869	}
2870	in.Request = request
2871
2872	return next.HandleSerialize(ctx, in)
2873}
2874
2875type awsAwsjson11_serializeOpTagResource struct {
2876}
2877
2878func (*awsAwsjson11_serializeOpTagResource) ID() string {
2879	return "OperationSerializer"
2880}
2881
2882func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2883	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2884) {
2885	request, ok := in.Request.(*smithyhttp.Request)
2886	if !ok {
2887		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2888	}
2889
2890	input, ok := in.Parameters.(*TagResourceInput)
2891	_ = input
2892	if !ok {
2893		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2894	}
2895
2896	request.Request.URL.Path = "/"
2897	request.Request.Method = "POST"
2898	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2899	if err != nil {
2900		return out, metadata, &smithy.SerializationError{Err: err}
2901	}
2902	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2903	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.TagResource")
2904
2905	jsonEncoder := smithyjson.NewEncoder()
2906	if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
2907		return out, metadata, &smithy.SerializationError{Err: err}
2908	}
2909
2910	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2911		return out, metadata, &smithy.SerializationError{Err: err}
2912	}
2913
2914	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2915		return out, metadata, &smithy.SerializationError{Err: err}
2916	}
2917	in.Request = request
2918
2919	return next.HandleSerialize(ctx, in)
2920}
2921
2922type awsAwsjson11_serializeOpUnassignInstance struct {
2923}
2924
2925func (*awsAwsjson11_serializeOpUnassignInstance) ID() string {
2926	return "OperationSerializer"
2927}
2928
2929func (m *awsAwsjson11_serializeOpUnassignInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2930	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2931) {
2932	request, ok := in.Request.(*smithyhttp.Request)
2933	if !ok {
2934		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2935	}
2936
2937	input, ok := in.Parameters.(*UnassignInstanceInput)
2938	_ = input
2939	if !ok {
2940		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2941	}
2942
2943	request.Request.URL.Path = "/"
2944	request.Request.Method = "POST"
2945	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2946	if err != nil {
2947		return out, metadata, &smithy.SerializationError{Err: err}
2948	}
2949	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2950	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UnassignInstance")
2951
2952	jsonEncoder := smithyjson.NewEncoder()
2953	if err := awsAwsjson11_serializeOpDocumentUnassignInstanceInput(input, jsonEncoder.Value); err != nil {
2954		return out, metadata, &smithy.SerializationError{Err: err}
2955	}
2956
2957	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2958		return out, metadata, &smithy.SerializationError{Err: err}
2959	}
2960
2961	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2962		return out, metadata, &smithy.SerializationError{Err: err}
2963	}
2964	in.Request = request
2965
2966	return next.HandleSerialize(ctx, in)
2967}
2968
2969type awsAwsjson11_serializeOpUnassignVolume struct {
2970}
2971
2972func (*awsAwsjson11_serializeOpUnassignVolume) ID() string {
2973	return "OperationSerializer"
2974}
2975
2976func (m *awsAwsjson11_serializeOpUnassignVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2977	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2978) {
2979	request, ok := in.Request.(*smithyhttp.Request)
2980	if !ok {
2981		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2982	}
2983
2984	input, ok := in.Parameters.(*UnassignVolumeInput)
2985	_ = input
2986	if !ok {
2987		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2988	}
2989
2990	request.Request.URL.Path = "/"
2991	request.Request.Method = "POST"
2992	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2993	if err != nil {
2994		return out, metadata, &smithy.SerializationError{Err: err}
2995	}
2996	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2997	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UnassignVolume")
2998
2999	jsonEncoder := smithyjson.NewEncoder()
3000	if err := awsAwsjson11_serializeOpDocumentUnassignVolumeInput(input, jsonEncoder.Value); err != nil {
3001		return out, metadata, &smithy.SerializationError{Err: err}
3002	}
3003
3004	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3005		return out, metadata, &smithy.SerializationError{Err: err}
3006	}
3007
3008	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3009		return out, metadata, &smithy.SerializationError{Err: err}
3010	}
3011	in.Request = request
3012
3013	return next.HandleSerialize(ctx, in)
3014}
3015
3016type awsAwsjson11_serializeOpUntagResource struct {
3017}
3018
3019func (*awsAwsjson11_serializeOpUntagResource) ID() string {
3020	return "OperationSerializer"
3021}
3022
3023func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3024	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3025) {
3026	request, ok := in.Request.(*smithyhttp.Request)
3027	if !ok {
3028		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3029	}
3030
3031	input, ok := in.Parameters.(*UntagResourceInput)
3032	_ = input
3033	if !ok {
3034		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3035	}
3036
3037	request.Request.URL.Path = "/"
3038	request.Request.Method = "POST"
3039	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3040	if err != nil {
3041		return out, metadata, &smithy.SerializationError{Err: err}
3042	}
3043	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3044	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UntagResource")
3045
3046	jsonEncoder := smithyjson.NewEncoder()
3047	if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
3048		return out, metadata, &smithy.SerializationError{Err: err}
3049	}
3050
3051	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3052		return out, metadata, &smithy.SerializationError{Err: err}
3053	}
3054
3055	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3056		return out, metadata, &smithy.SerializationError{Err: err}
3057	}
3058	in.Request = request
3059
3060	return next.HandleSerialize(ctx, in)
3061}
3062
3063type awsAwsjson11_serializeOpUpdateApp struct {
3064}
3065
3066func (*awsAwsjson11_serializeOpUpdateApp) ID() string {
3067	return "OperationSerializer"
3068}
3069
3070func (m *awsAwsjson11_serializeOpUpdateApp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3071	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3072) {
3073	request, ok := in.Request.(*smithyhttp.Request)
3074	if !ok {
3075		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3076	}
3077
3078	input, ok := in.Parameters.(*UpdateAppInput)
3079	_ = input
3080	if !ok {
3081		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3082	}
3083
3084	request.Request.URL.Path = "/"
3085	request.Request.Method = "POST"
3086	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3087	if err != nil {
3088		return out, metadata, &smithy.SerializationError{Err: err}
3089	}
3090	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3091	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UpdateApp")
3092
3093	jsonEncoder := smithyjson.NewEncoder()
3094	if err := awsAwsjson11_serializeOpDocumentUpdateAppInput(input, jsonEncoder.Value); err != nil {
3095		return out, metadata, &smithy.SerializationError{Err: err}
3096	}
3097
3098	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3099		return out, metadata, &smithy.SerializationError{Err: err}
3100	}
3101
3102	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3103		return out, metadata, &smithy.SerializationError{Err: err}
3104	}
3105	in.Request = request
3106
3107	return next.HandleSerialize(ctx, in)
3108}
3109
3110type awsAwsjson11_serializeOpUpdateElasticIp struct {
3111}
3112
3113func (*awsAwsjson11_serializeOpUpdateElasticIp) ID() string {
3114	return "OperationSerializer"
3115}
3116
3117func (m *awsAwsjson11_serializeOpUpdateElasticIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3118	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3119) {
3120	request, ok := in.Request.(*smithyhttp.Request)
3121	if !ok {
3122		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3123	}
3124
3125	input, ok := in.Parameters.(*UpdateElasticIpInput)
3126	_ = input
3127	if !ok {
3128		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3129	}
3130
3131	request.Request.URL.Path = "/"
3132	request.Request.Method = "POST"
3133	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3134	if err != nil {
3135		return out, metadata, &smithy.SerializationError{Err: err}
3136	}
3137	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3138	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UpdateElasticIp")
3139
3140	jsonEncoder := smithyjson.NewEncoder()
3141	if err := awsAwsjson11_serializeOpDocumentUpdateElasticIpInput(input, jsonEncoder.Value); err != nil {
3142		return out, metadata, &smithy.SerializationError{Err: err}
3143	}
3144
3145	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3146		return out, metadata, &smithy.SerializationError{Err: err}
3147	}
3148
3149	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3150		return out, metadata, &smithy.SerializationError{Err: err}
3151	}
3152	in.Request = request
3153
3154	return next.HandleSerialize(ctx, in)
3155}
3156
3157type awsAwsjson11_serializeOpUpdateInstance struct {
3158}
3159
3160func (*awsAwsjson11_serializeOpUpdateInstance) ID() string {
3161	return "OperationSerializer"
3162}
3163
3164func (m *awsAwsjson11_serializeOpUpdateInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3165	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3166) {
3167	request, ok := in.Request.(*smithyhttp.Request)
3168	if !ok {
3169		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3170	}
3171
3172	input, ok := in.Parameters.(*UpdateInstanceInput)
3173	_ = input
3174	if !ok {
3175		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3176	}
3177
3178	request.Request.URL.Path = "/"
3179	request.Request.Method = "POST"
3180	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3181	if err != nil {
3182		return out, metadata, &smithy.SerializationError{Err: err}
3183	}
3184	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3185	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UpdateInstance")
3186
3187	jsonEncoder := smithyjson.NewEncoder()
3188	if err := awsAwsjson11_serializeOpDocumentUpdateInstanceInput(input, jsonEncoder.Value); err != nil {
3189		return out, metadata, &smithy.SerializationError{Err: err}
3190	}
3191
3192	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3193		return out, metadata, &smithy.SerializationError{Err: err}
3194	}
3195
3196	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3197		return out, metadata, &smithy.SerializationError{Err: err}
3198	}
3199	in.Request = request
3200
3201	return next.HandleSerialize(ctx, in)
3202}
3203
3204type awsAwsjson11_serializeOpUpdateLayer struct {
3205}
3206
3207func (*awsAwsjson11_serializeOpUpdateLayer) ID() string {
3208	return "OperationSerializer"
3209}
3210
3211func (m *awsAwsjson11_serializeOpUpdateLayer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3212	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3213) {
3214	request, ok := in.Request.(*smithyhttp.Request)
3215	if !ok {
3216		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3217	}
3218
3219	input, ok := in.Parameters.(*UpdateLayerInput)
3220	_ = input
3221	if !ok {
3222		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3223	}
3224
3225	request.Request.URL.Path = "/"
3226	request.Request.Method = "POST"
3227	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3228	if err != nil {
3229		return out, metadata, &smithy.SerializationError{Err: err}
3230	}
3231	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3232	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UpdateLayer")
3233
3234	jsonEncoder := smithyjson.NewEncoder()
3235	if err := awsAwsjson11_serializeOpDocumentUpdateLayerInput(input, jsonEncoder.Value); err != nil {
3236		return out, metadata, &smithy.SerializationError{Err: err}
3237	}
3238
3239	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3240		return out, metadata, &smithy.SerializationError{Err: err}
3241	}
3242
3243	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3244		return out, metadata, &smithy.SerializationError{Err: err}
3245	}
3246	in.Request = request
3247
3248	return next.HandleSerialize(ctx, in)
3249}
3250
3251type awsAwsjson11_serializeOpUpdateMyUserProfile struct {
3252}
3253
3254func (*awsAwsjson11_serializeOpUpdateMyUserProfile) ID() string {
3255	return "OperationSerializer"
3256}
3257
3258func (m *awsAwsjson11_serializeOpUpdateMyUserProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3259	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3260) {
3261	request, ok := in.Request.(*smithyhttp.Request)
3262	if !ok {
3263		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3264	}
3265
3266	input, ok := in.Parameters.(*UpdateMyUserProfileInput)
3267	_ = input
3268	if !ok {
3269		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3270	}
3271
3272	request.Request.URL.Path = "/"
3273	request.Request.Method = "POST"
3274	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3275	if err != nil {
3276		return out, metadata, &smithy.SerializationError{Err: err}
3277	}
3278	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3279	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UpdateMyUserProfile")
3280
3281	jsonEncoder := smithyjson.NewEncoder()
3282	if err := awsAwsjson11_serializeOpDocumentUpdateMyUserProfileInput(input, jsonEncoder.Value); err != nil {
3283		return out, metadata, &smithy.SerializationError{Err: err}
3284	}
3285
3286	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3287		return out, metadata, &smithy.SerializationError{Err: err}
3288	}
3289
3290	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3291		return out, metadata, &smithy.SerializationError{Err: err}
3292	}
3293	in.Request = request
3294
3295	return next.HandleSerialize(ctx, in)
3296}
3297
3298type awsAwsjson11_serializeOpUpdateRdsDbInstance struct {
3299}
3300
3301func (*awsAwsjson11_serializeOpUpdateRdsDbInstance) ID() string {
3302	return "OperationSerializer"
3303}
3304
3305func (m *awsAwsjson11_serializeOpUpdateRdsDbInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3306	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3307) {
3308	request, ok := in.Request.(*smithyhttp.Request)
3309	if !ok {
3310		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3311	}
3312
3313	input, ok := in.Parameters.(*UpdateRdsDbInstanceInput)
3314	_ = input
3315	if !ok {
3316		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3317	}
3318
3319	request.Request.URL.Path = "/"
3320	request.Request.Method = "POST"
3321	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3322	if err != nil {
3323		return out, metadata, &smithy.SerializationError{Err: err}
3324	}
3325	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3326	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UpdateRdsDbInstance")
3327
3328	jsonEncoder := smithyjson.NewEncoder()
3329	if err := awsAwsjson11_serializeOpDocumentUpdateRdsDbInstanceInput(input, jsonEncoder.Value); err != nil {
3330		return out, metadata, &smithy.SerializationError{Err: err}
3331	}
3332
3333	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3334		return out, metadata, &smithy.SerializationError{Err: err}
3335	}
3336
3337	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3338		return out, metadata, &smithy.SerializationError{Err: err}
3339	}
3340	in.Request = request
3341
3342	return next.HandleSerialize(ctx, in)
3343}
3344
3345type awsAwsjson11_serializeOpUpdateStack struct {
3346}
3347
3348func (*awsAwsjson11_serializeOpUpdateStack) ID() string {
3349	return "OperationSerializer"
3350}
3351
3352func (m *awsAwsjson11_serializeOpUpdateStack) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3353	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3354) {
3355	request, ok := in.Request.(*smithyhttp.Request)
3356	if !ok {
3357		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3358	}
3359
3360	input, ok := in.Parameters.(*UpdateStackInput)
3361	_ = input
3362	if !ok {
3363		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3364	}
3365
3366	request.Request.URL.Path = "/"
3367	request.Request.Method = "POST"
3368	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3369	if err != nil {
3370		return out, metadata, &smithy.SerializationError{Err: err}
3371	}
3372	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3373	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UpdateStack")
3374
3375	jsonEncoder := smithyjson.NewEncoder()
3376	if err := awsAwsjson11_serializeOpDocumentUpdateStackInput(input, jsonEncoder.Value); err != nil {
3377		return out, metadata, &smithy.SerializationError{Err: err}
3378	}
3379
3380	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3381		return out, metadata, &smithy.SerializationError{Err: err}
3382	}
3383
3384	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3385		return out, metadata, &smithy.SerializationError{Err: err}
3386	}
3387	in.Request = request
3388
3389	return next.HandleSerialize(ctx, in)
3390}
3391
3392type awsAwsjson11_serializeOpUpdateUserProfile struct {
3393}
3394
3395func (*awsAwsjson11_serializeOpUpdateUserProfile) ID() string {
3396	return "OperationSerializer"
3397}
3398
3399func (m *awsAwsjson11_serializeOpUpdateUserProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3400	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3401) {
3402	request, ok := in.Request.(*smithyhttp.Request)
3403	if !ok {
3404		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3405	}
3406
3407	input, ok := in.Parameters.(*UpdateUserProfileInput)
3408	_ = input
3409	if !ok {
3410		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3411	}
3412
3413	request.Request.URL.Path = "/"
3414	request.Request.Method = "POST"
3415	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3416	if err != nil {
3417		return out, metadata, &smithy.SerializationError{Err: err}
3418	}
3419	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3420	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UpdateUserProfile")
3421
3422	jsonEncoder := smithyjson.NewEncoder()
3423	if err := awsAwsjson11_serializeOpDocumentUpdateUserProfileInput(input, jsonEncoder.Value); err != nil {
3424		return out, metadata, &smithy.SerializationError{Err: err}
3425	}
3426
3427	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3428		return out, metadata, &smithy.SerializationError{Err: err}
3429	}
3430
3431	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3432		return out, metadata, &smithy.SerializationError{Err: err}
3433	}
3434	in.Request = request
3435
3436	return next.HandleSerialize(ctx, in)
3437}
3438
3439type awsAwsjson11_serializeOpUpdateVolume struct {
3440}
3441
3442func (*awsAwsjson11_serializeOpUpdateVolume) ID() string {
3443	return "OperationSerializer"
3444}
3445
3446func (m *awsAwsjson11_serializeOpUpdateVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3447	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3448) {
3449	request, ok := in.Request.(*smithyhttp.Request)
3450	if !ok {
3451		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3452	}
3453
3454	input, ok := in.Parameters.(*UpdateVolumeInput)
3455	_ = input
3456	if !ok {
3457		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3458	}
3459
3460	request.Request.URL.Path = "/"
3461	request.Request.Method = "POST"
3462	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3463	if err != nil {
3464		return out, metadata, &smithy.SerializationError{Err: err}
3465	}
3466	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3467	httpBindingEncoder.SetHeader("X-Amz-Target").String("OpsWorks_20130218.UpdateVolume")
3468
3469	jsonEncoder := smithyjson.NewEncoder()
3470	if err := awsAwsjson11_serializeOpDocumentUpdateVolumeInput(input, jsonEncoder.Value); err != nil {
3471		return out, metadata, &smithy.SerializationError{Err: err}
3472	}
3473
3474	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3475		return out, metadata, &smithy.SerializationError{Err: err}
3476	}
3477
3478	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3479		return out, metadata, &smithy.SerializationError{Err: err}
3480	}
3481	in.Request = request
3482
3483	return next.HandleSerialize(ctx, in)
3484}
3485func awsAwsjson11_serializeDocumentAppAttributes(v map[string]string, value smithyjson.Value) error {
3486	object := value.Object()
3487	defer object.Close()
3488
3489	for key := range v {
3490		om := object.Key(key)
3491		om.String(v[key])
3492	}
3493	return nil
3494}
3495
3496func awsAwsjson11_serializeDocumentAutoScalingThresholds(v *types.AutoScalingThresholds, value smithyjson.Value) error {
3497	object := value.Object()
3498	defer object.Close()
3499
3500	if v.Alarms != nil {
3501		ok := object.Key("Alarms")
3502		if err := awsAwsjson11_serializeDocumentStrings(v.Alarms, ok); err != nil {
3503			return err
3504		}
3505	}
3506
3507	if v.CpuThreshold != nil {
3508		ok := object.Key("CpuThreshold")
3509		ok.Double(*v.CpuThreshold)
3510	}
3511
3512	if v.IgnoreMetricsTime != nil {
3513		ok := object.Key("IgnoreMetricsTime")
3514		ok.Integer(*v.IgnoreMetricsTime)
3515	}
3516
3517	if v.InstanceCount != nil {
3518		ok := object.Key("InstanceCount")
3519		ok.Integer(*v.InstanceCount)
3520	}
3521
3522	if v.LoadThreshold != nil {
3523		ok := object.Key("LoadThreshold")
3524		ok.Double(*v.LoadThreshold)
3525	}
3526
3527	if v.MemoryThreshold != nil {
3528		ok := object.Key("MemoryThreshold")
3529		ok.Double(*v.MemoryThreshold)
3530	}
3531
3532	if v.ThresholdsWaitTime != nil {
3533		ok := object.Key("ThresholdsWaitTime")
3534		ok.Integer(*v.ThresholdsWaitTime)
3535	}
3536
3537	return nil
3538}
3539
3540func awsAwsjson11_serializeDocumentBlockDeviceMapping(v *types.BlockDeviceMapping, value smithyjson.Value) error {
3541	object := value.Object()
3542	defer object.Close()
3543
3544	if v.DeviceName != nil {
3545		ok := object.Key("DeviceName")
3546		ok.String(*v.DeviceName)
3547	}
3548
3549	if v.Ebs != nil {
3550		ok := object.Key("Ebs")
3551		if err := awsAwsjson11_serializeDocumentEbsBlockDevice(v.Ebs, ok); err != nil {
3552			return err
3553		}
3554	}
3555
3556	if v.NoDevice != nil {
3557		ok := object.Key("NoDevice")
3558		ok.String(*v.NoDevice)
3559	}
3560
3561	if v.VirtualName != nil {
3562		ok := object.Key("VirtualName")
3563		ok.String(*v.VirtualName)
3564	}
3565
3566	return nil
3567}
3568
3569func awsAwsjson11_serializeDocumentBlockDeviceMappings(v []types.BlockDeviceMapping, value smithyjson.Value) error {
3570	array := value.Array()
3571	defer array.Close()
3572
3573	for i := range v {
3574		av := array.Value()
3575		if err := awsAwsjson11_serializeDocumentBlockDeviceMapping(&v[i], av); err != nil {
3576			return err
3577		}
3578	}
3579	return nil
3580}
3581
3582func awsAwsjson11_serializeDocumentChefConfiguration(v *types.ChefConfiguration, value smithyjson.Value) error {
3583	object := value.Object()
3584	defer object.Close()
3585
3586	if v.BerkshelfVersion != nil {
3587		ok := object.Key("BerkshelfVersion")
3588		ok.String(*v.BerkshelfVersion)
3589	}
3590
3591	if v.ManageBerkshelf != nil {
3592		ok := object.Key("ManageBerkshelf")
3593		ok.Boolean(*v.ManageBerkshelf)
3594	}
3595
3596	return nil
3597}
3598
3599func awsAwsjson11_serializeDocumentCloudWatchLogsConfiguration(v *types.CloudWatchLogsConfiguration, value smithyjson.Value) error {
3600	object := value.Object()
3601	defer object.Close()
3602
3603	if v.Enabled != nil {
3604		ok := object.Key("Enabled")
3605		ok.Boolean(*v.Enabled)
3606	}
3607
3608	if v.LogStreams != nil {
3609		ok := object.Key("LogStreams")
3610		if err := awsAwsjson11_serializeDocumentCloudWatchLogsLogStreams(v.LogStreams, ok); err != nil {
3611			return err
3612		}
3613	}
3614
3615	return nil
3616}
3617
3618func awsAwsjson11_serializeDocumentCloudWatchLogsLogStream(v *types.CloudWatchLogsLogStream, value smithyjson.Value) error {
3619	object := value.Object()
3620	defer object.Close()
3621
3622	if v.BatchCount != nil {
3623		ok := object.Key("BatchCount")
3624		ok.Integer(*v.BatchCount)
3625	}
3626
3627	if v.BatchSize != nil {
3628		ok := object.Key("BatchSize")
3629		ok.Integer(*v.BatchSize)
3630	}
3631
3632	if v.BufferDuration != nil {
3633		ok := object.Key("BufferDuration")
3634		ok.Integer(*v.BufferDuration)
3635	}
3636
3637	if v.DatetimeFormat != nil {
3638		ok := object.Key("DatetimeFormat")
3639		ok.String(*v.DatetimeFormat)
3640	}
3641
3642	if len(v.Encoding) > 0 {
3643		ok := object.Key("Encoding")
3644		ok.String(string(v.Encoding))
3645	}
3646
3647	if v.File != nil {
3648		ok := object.Key("File")
3649		ok.String(*v.File)
3650	}
3651
3652	if v.FileFingerprintLines != nil {
3653		ok := object.Key("FileFingerprintLines")
3654		ok.String(*v.FileFingerprintLines)
3655	}
3656
3657	if len(v.InitialPosition) > 0 {
3658		ok := object.Key("InitialPosition")
3659		ok.String(string(v.InitialPosition))
3660	}
3661
3662	if v.LogGroupName != nil {
3663		ok := object.Key("LogGroupName")
3664		ok.String(*v.LogGroupName)
3665	}
3666
3667	if v.MultiLineStartPattern != nil {
3668		ok := object.Key("MultiLineStartPattern")
3669		ok.String(*v.MultiLineStartPattern)
3670	}
3671
3672	if len(v.TimeZone) > 0 {
3673		ok := object.Key("TimeZone")
3674		ok.String(string(v.TimeZone))
3675	}
3676
3677	return nil
3678}
3679
3680func awsAwsjson11_serializeDocumentCloudWatchLogsLogStreams(v []types.CloudWatchLogsLogStream, value smithyjson.Value) error {
3681	array := value.Array()
3682	defer array.Close()
3683
3684	for i := range v {
3685		av := array.Value()
3686		if err := awsAwsjson11_serializeDocumentCloudWatchLogsLogStream(&v[i], av); err != nil {
3687			return err
3688		}
3689	}
3690	return nil
3691}
3692
3693func awsAwsjson11_serializeDocumentDailyAutoScalingSchedule(v map[string]string, value smithyjson.Value) error {
3694	object := value.Object()
3695	defer object.Close()
3696
3697	for key := range v {
3698		om := object.Key(key)
3699		om.String(v[key])
3700	}
3701	return nil
3702}
3703
3704func awsAwsjson11_serializeDocumentDataSource(v *types.DataSource, value smithyjson.Value) error {
3705	object := value.Object()
3706	defer object.Close()
3707
3708	if v.Arn != nil {
3709		ok := object.Key("Arn")
3710		ok.String(*v.Arn)
3711	}
3712
3713	if v.DatabaseName != nil {
3714		ok := object.Key("DatabaseName")
3715		ok.String(*v.DatabaseName)
3716	}
3717
3718	if v.Type != nil {
3719		ok := object.Key("Type")
3720		ok.String(*v.Type)
3721	}
3722
3723	return nil
3724}
3725
3726func awsAwsjson11_serializeDocumentDataSources(v []types.DataSource, value smithyjson.Value) error {
3727	array := value.Array()
3728	defer array.Close()
3729
3730	for i := range v {
3731		av := array.Value()
3732		if err := awsAwsjson11_serializeDocumentDataSource(&v[i], av); err != nil {
3733			return err
3734		}
3735	}
3736	return nil
3737}
3738
3739func awsAwsjson11_serializeDocumentDeploymentCommand(v *types.DeploymentCommand, value smithyjson.Value) error {
3740	object := value.Object()
3741	defer object.Close()
3742
3743	if v.Args != nil {
3744		ok := object.Key("Args")
3745		if err := awsAwsjson11_serializeDocumentDeploymentCommandArgs(v.Args, ok); err != nil {
3746			return err
3747		}
3748	}
3749
3750	if len(v.Name) > 0 {
3751		ok := object.Key("Name")
3752		ok.String(string(v.Name))
3753	}
3754
3755	return nil
3756}
3757
3758func awsAwsjson11_serializeDocumentDeploymentCommandArgs(v map[string][]string, value smithyjson.Value) error {
3759	object := value.Object()
3760	defer object.Close()
3761
3762	for key := range v {
3763		om := object.Key(key)
3764		if vv := v[key]; vv == nil {
3765			continue
3766		}
3767		if err := awsAwsjson11_serializeDocumentStrings(v[key], om); err != nil {
3768			return err
3769		}
3770	}
3771	return nil
3772}
3773
3774func awsAwsjson11_serializeDocumentEbsBlockDevice(v *types.EbsBlockDevice, value smithyjson.Value) error {
3775	object := value.Object()
3776	defer object.Close()
3777
3778	if v.DeleteOnTermination != nil {
3779		ok := object.Key("DeleteOnTermination")
3780		ok.Boolean(*v.DeleteOnTermination)
3781	}
3782
3783	if v.Iops != nil {
3784		ok := object.Key("Iops")
3785		ok.Integer(*v.Iops)
3786	}
3787
3788	if v.SnapshotId != nil {
3789		ok := object.Key("SnapshotId")
3790		ok.String(*v.SnapshotId)
3791	}
3792
3793	if v.VolumeSize != nil {
3794		ok := object.Key("VolumeSize")
3795		ok.Integer(*v.VolumeSize)
3796	}
3797
3798	if len(v.VolumeType) > 0 {
3799		ok := object.Key("VolumeType")
3800		ok.String(string(v.VolumeType))
3801	}
3802
3803	return nil
3804}
3805
3806func awsAwsjson11_serializeDocumentEnvironmentVariable(v *types.EnvironmentVariable, value smithyjson.Value) error {
3807	object := value.Object()
3808	defer object.Close()
3809
3810	if v.Key != nil {
3811		ok := object.Key("Key")
3812		ok.String(*v.Key)
3813	}
3814
3815	if v.Secure != nil {
3816		ok := object.Key("Secure")
3817		ok.Boolean(*v.Secure)
3818	}
3819
3820	if v.Value != nil {
3821		ok := object.Key("Value")
3822		ok.String(*v.Value)
3823	}
3824
3825	return nil
3826}
3827
3828func awsAwsjson11_serializeDocumentEnvironmentVariables(v []types.EnvironmentVariable, value smithyjson.Value) error {
3829	array := value.Array()
3830	defer array.Close()
3831
3832	for i := range v {
3833		av := array.Value()
3834		if err := awsAwsjson11_serializeDocumentEnvironmentVariable(&v[i], av); err != nil {
3835			return err
3836		}
3837	}
3838	return nil
3839}
3840
3841func awsAwsjson11_serializeDocumentInstanceIdentity(v *types.InstanceIdentity, value smithyjson.Value) error {
3842	object := value.Object()
3843	defer object.Close()
3844
3845	if v.Document != nil {
3846		ok := object.Key("Document")
3847		ok.String(*v.Document)
3848	}
3849
3850	if v.Signature != nil {
3851		ok := object.Key("Signature")
3852		ok.String(*v.Signature)
3853	}
3854
3855	return nil
3856}
3857
3858func awsAwsjson11_serializeDocumentLayerAttributes(v map[string]string, value smithyjson.Value) error {
3859	object := value.Object()
3860	defer object.Close()
3861
3862	for key := range v {
3863		om := object.Key(key)
3864		om.String(v[key])
3865	}
3866	return nil
3867}
3868
3869func awsAwsjson11_serializeDocumentLifecycleEventConfiguration(v *types.LifecycleEventConfiguration, value smithyjson.Value) error {
3870	object := value.Object()
3871	defer object.Close()
3872
3873	if v.Shutdown != nil {
3874		ok := object.Key("Shutdown")
3875		if err := awsAwsjson11_serializeDocumentShutdownEventConfiguration(v.Shutdown, ok); err != nil {
3876			return err
3877		}
3878	}
3879
3880	return nil
3881}
3882
3883func awsAwsjson11_serializeDocumentRecipes(v *types.Recipes, value smithyjson.Value) error {
3884	object := value.Object()
3885	defer object.Close()
3886
3887	if v.Configure != nil {
3888		ok := object.Key("Configure")
3889		if err := awsAwsjson11_serializeDocumentStrings(v.Configure, ok); err != nil {
3890			return err
3891		}
3892	}
3893
3894	if v.Deploy != nil {
3895		ok := object.Key("Deploy")
3896		if err := awsAwsjson11_serializeDocumentStrings(v.Deploy, ok); err != nil {
3897			return err
3898		}
3899	}
3900
3901	if v.Setup != nil {
3902		ok := object.Key("Setup")
3903		if err := awsAwsjson11_serializeDocumentStrings(v.Setup, ok); err != nil {
3904			return err
3905		}
3906	}
3907
3908	if v.Shutdown != nil {
3909		ok := object.Key("Shutdown")
3910		if err := awsAwsjson11_serializeDocumentStrings(v.Shutdown, ok); err != nil {
3911			return err
3912		}
3913	}
3914
3915	if v.Undeploy != nil {
3916		ok := object.Key("Undeploy")
3917		if err := awsAwsjson11_serializeDocumentStrings(v.Undeploy, ok); err != nil {
3918			return err
3919		}
3920	}
3921
3922	return nil
3923}
3924
3925func awsAwsjson11_serializeDocumentShutdownEventConfiguration(v *types.ShutdownEventConfiguration, value smithyjson.Value) error {
3926	object := value.Object()
3927	defer object.Close()
3928
3929	if v.DelayUntilElbConnectionsDrained != nil {
3930		ok := object.Key("DelayUntilElbConnectionsDrained")
3931		ok.Boolean(*v.DelayUntilElbConnectionsDrained)
3932	}
3933
3934	if v.ExecutionTimeout != nil {
3935		ok := object.Key("ExecutionTimeout")
3936		ok.Integer(*v.ExecutionTimeout)
3937	}
3938
3939	return nil
3940}
3941
3942func awsAwsjson11_serializeDocumentSource(v *types.Source, value smithyjson.Value) error {
3943	object := value.Object()
3944	defer object.Close()
3945
3946	if v.Password != nil {
3947		ok := object.Key("Password")
3948		ok.String(*v.Password)
3949	}
3950
3951	if v.Revision != nil {
3952		ok := object.Key("Revision")
3953		ok.String(*v.Revision)
3954	}
3955
3956	if v.SshKey != nil {
3957		ok := object.Key("SshKey")
3958		ok.String(*v.SshKey)
3959	}
3960
3961	if len(v.Type) > 0 {
3962		ok := object.Key("Type")
3963		ok.String(string(v.Type))
3964	}
3965
3966	if v.Url != nil {
3967		ok := object.Key("Url")
3968		ok.String(*v.Url)
3969	}
3970
3971	if v.Username != nil {
3972		ok := object.Key("Username")
3973		ok.String(*v.Username)
3974	}
3975
3976	return nil
3977}
3978
3979func awsAwsjson11_serializeDocumentSslConfiguration(v *types.SslConfiguration, value smithyjson.Value) error {
3980	object := value.Object()
3981	defer object.Close()
3982
3983	if v.Certificate != nil {
3984		ok := object.Key("Certificate")
3985		ok.String(*v.Certificate)
3986	}
3987
3988	if v.Chain != nil {
3989		ok := object.Key("Chain")
3990		ok.String(*v.Chain)
3991	}
3992
3993	if v.PrivateKey != nil {
3994		ok := object.Key("PrivateKey")
3995		ok.String(*v.PrivateKey)
3996	}
3997
3998	return nil
3999}
4000
4001func awsAwsjson11_serializeDocumentStackAttributes(v map[string]string, value smithyjson.Value) error {
4002	object := value.Object()
4003	defer object.Close()
4004
4005	for key := range v {
4006		om := object.Key(key)
4007		om.String(v[key])
4008	}
4009	return nil
4010}
4011
4012func awsAwsjson11_serializeDocumentStackConfigurationManager(v *types.StackConfigurationManager, value smithyjson.Value) error {
4013	object := value.Object()
4014	defer object.Close()
4015
4016	if v.Name != nil {
4017		ok := object.Key("Name")
4018		ok.String(*v.Name)
4019	}
4020
4021	if v.Version != nil {
4022		ok := object.Key("Version")
4023		ok.String(*v.Version)
4024	}
4025
4026	return nil
4027}
4028
4029func awsAwsjson11_serializeDocumentStrings(v []string, value smithyjson.Value) error {
4030	array := value.Array()
4031	defer array.Close()
4032
4033	for i := range v {
4034		av := array.Value()
4035		av.String(v[i])
4036	}
4037	return nil
4038}
4039
4040func awsAwsjson11_serializeDocumentTagKeys(v []string, value smithyjson.Value) error {
4041	array := value.Array()
4042	defer array.Close()
4043
4044	for i := range v {
4045		av := array.Value()
4046		av.String(v[i])
4047	}
4048	return nil
4049}
4050
4051func awsAwsjson11_serializeDocumentTags(v map[string]string, value smithyjson.Value) error {
4052	object := value.Object()
4053	defer object.Close()
4054
4055	for key := range v {
4056		om := object.Key(key)
4057		om.String(v[key])
4058	}
4059	return nil
4060}
4061
4062func awsAwsjson11_serializeDocumentVolumeConfiguration(v *types.VolumeConfiguration, value smithyjson.Value) error {
4063	object := value.Object()
4064	defer object.Close()
4065
4066	if v.Encrypted != nil {
4067		ok := object.Key("Encrypted")
4068		ok.Boolean(*v.Encrypted)
4069	}
4070
4071	if v.Iops != nil {
4072		ok := object.Key("Iops")
4073		ok.Integer(*v.Iops)
4074	}
4075
4076	if v.MountPoint != nil {
4077		ok := object.Key("MountPoint")
4078		ok.String(*v.MountPoint)
4079	}
4080
4081	if v.NumberOfDisks != nil {
4082		ok := object.Key("NumberOfDisks")
4083		ok.Integer(*v.NumberOfDisks)
4084	}
4085
4086	if v.RaidLevel != nil {
4087		ok := object.Key("RaidLevel")
4088		ok.Integer(*v.RaidLevel)
4089	}
4090
4091	if v.Size != nil {
4092		ok := object.Key("Size")
4093		ok.Integer(*v.Size)
4094	}
4095
4096	if v.VolumeType != nil {
4097		ok := object.Key("VolumeType")
4098		ok.String(*v.VolumeType)
4099	}
4100
4101	return nil
4102}
4103
4104func awsAwsjson11_serializeDocumentVolumeConfigurations(v []types.VolumeConfiguration, value smithyjson.Value) error {
4105	array := value.Array()
4106	defer array.Close()
4107
4108	for i := range v {
4109		av := array.Value()
4110		if err := awsAwsjson11_serializeDocumentVolumeConfiguration(&v[i], av); err != nil {
4111			return err
4112		}
4113	}
4114	return nil
4115}
4116
4117func awsAwsjson11_serializeDocumentWeeklyAutoScalingSchedule(v *types.WeeklyAutoScalingSchedule, value smithyjson.Value) error {
4118	object := value.Object()
4119	defer object.Close()
4120
4121	if v.Friday != nil {
4122		ok := object.Key("Friday")
4123		if err := awsAwsjson11_serializeDocumentDailyAutoScalingSchedule(v.Friday, ok); err != nil {
4124			return err
4125		}
4126	}
4127
4128	if v.Monday != nil {
4129		ok := object.Key("Monday")
4130		if err := awsAwsjson11_serializeDocumentDailyAutoScalingSchedule(v.Monday, ok); err != nil {
4131			return err
4132		}
4133	}
4134
4135	if v.Saturday != nil {
4136		ok := object.Key("Saturday")
4137		if err := awsAwsjson11_serializeDocumentDailyAutoScalingSchedule(v.Saturday, ok); err != nil {
4138			return err
4139		}
4140	}
4141
4142	if v.Sunday != nil {
4143		ok := object.Key("Sunday")
4144		if err := awsAwsjson11_serializeDocumentDailyAutoScalingSchedule(v.Sunday, ok); err != nil {
4145			return err
4146		}
4147	}
4148
4149	if v.Thursday != nil {
4150		ok := object.Key("Thursday")
4151		if err := awsAwsjson11_serializeDocumentDailyAutoScalingSchedule(v.Thursday, ok); err != nil {
4152			return err
4153		}
4154	}
4155
4156	if v.Tuesday != nil {
4157		ok := object.Key("Tuesday")
4158		if err := awsAwsjson11_serializeDocumentDailyAutoScalingSchedule(v.Tuesday, ok); err != nil {
4159			return err
4160		}
4161	}
4162
4163	if v.Wednesday != nil {
4164		ok := object.Key("Wednesday")
4165		if err := awsAwsjson11_serializeDocumentDailyAutoScalingSchedule(v.Wednesday, ok); err != nil {
4166			return err
4167		}
4168	}
4169
4170	return nil
4171}
4172
4173func awsAwsjson11_serializeOpDocumentAssignInstanceInput(v *AssignInstanceInput, value smithyjson.Value) error {
4174	object := value.Object()
4175	defer object.Close()
4176
4177	if v.InstanceId != nil {
4178		ok := object.Key("InstanceId")
4179		ok.String(*v.InstanceId)
4180	}
4181
4182	if v.LayerIds != nil {
4183		ok := object.Key("LayerIds")
4184		if err := awsAwsjson11_serializeDocumentStrings(v.LayerIds, ok); err != nil {
4185			return err
4186		}
4187	}
4188
4189	return nil
4190}
4191
4192func awsAwsjson11_serializeOpDocumentAssignVolumeInput(v *AssignVolumeInput, value smithyjson.Value) error {
4193	object := value.Object()
4194	defer object.Close()
4195
4196	if v.InstanceId != nil {
4197		ok := object.Key("InstanceId")
4198		ok.String(*v.InstanceId)
4199	}
4200
4201	if v.VolumeId != nil {
4202		ok := object.Key("VolumeId")
4203		ok.String(*v.VolumeId)
4204	}
4205
4206	return nil
4207}
4208
4209func awsAwsjson11_serializeOpDocumentAssociateElasticIpInput(v *AssociateElasticIpInput, value smithyjson.Value) error {
4210	object := value.Object()
4211	defer object.Close()
4212
4213	if v.ElasticIp != nil {
4214		ok := object.Key("ElasticIp")
4215		ok.String(*v.ElasticIp)
4216	}
4217
4218	if v.InstanceId != nil {
4219		ok := object.Key("InstanceId")
4220		ok.String(*v.InstanceId)
4221	}
4222
4223	return nil
4224}
4225
4226func awsAwsjson11_serializeOpDocumentAttachElasticLoadBalancerInput(v *AttachElasticLoadBalancerInput, value smithyjson.Value) error {
4227	object := value.Object()
4228	defer object.Close()
4229
4230	if v.ElasticLoadBalancerName != nil {
4231		ok := object.Key("ElasticLoadBalancerName")
4232		ok.String(*v.ElasticLoadBalancerName)
4233	}
4234
4235	if v.LayerId != nil {
4236		ok := object.Key("LayerId")
4237		ok.String(*v.LayerId)
4238	}
4239
4240	return nil
4241}
4242
4243func awsAwsjson11_serializeOpDocumentCloneStackInput(v *CloneStackInput, value smithyjson.Value) error {
4244	object := value.Object()
4245	defer object.Close()
4246
4247	if v.AgentVersion != nil {
4248		ok := object.Key("AgentVersion")
4249		ok.String(*v.AgentVersion)
4250	}
4251
4252	if v.Attributes != nil {
4253		ok := object.Key("Attributes")
4254		if err := awsAwsjson11_serializeDocumentStackAttributes(v.Attributes, ok); err != nil {
4255			return err
4256		}
4257	}
4258
4259	if v.ChefConfiguration != nil {
4260		ok := object.Key("ChefConfiguration")
4261		if err := awsAwsjson11_serializeDocumentChefConfiguration(v.ChefConfiguration, ok); err != nil {
4262			return err
4263		}
4264	}
4265
4266	if v.CloneAppIds != nil {
4267		ok := object.Key("CloneAppIds")
4268		if err := awsAwsjson11_serializeDocumentStrings(v.CloneAppIds, ok); err != nil {
4269			return err
4270		}
4271	}
4272
4273	if v.ClonePermissions != nil {
4274		ok := object.Key("ClonePermissions")
4275		ok.Boolean(*v.ClonePermissions)
4276	}
4277
4278	if v.ConfigurationManager != nil {
4279		ok := object.Key("ConfigurationManager")
4280		if err := awsAwsjson11_serializeDocumentStackConfigurationManager(v.ConfigurationManager, ok); err != nil {
4281			return err
4282		}
4283	}
4284
4285	if v.CustomCookbooksSource != nil {
4286		ok := object.Key("CustomCookbooksSource")
4287		if err := awsAwsjson11_serializeDocumentSource(v.CustomCookbooksSource, ok); err != nil {
4288			return err
4289		}
4290	}
4291
4292	if v.CustomJson != nil {
4293		ok := object.Key("CustomJson")
4294		ok.String(*v.CustomJson)
4295	}
4296
4297	if v.DefaultAvailabilityZone != nil {
4298		ok := object.Key("DefaultAvailabilityZone")
4299		ok.String(*v.DefaultAvailabilityZone)
4300	}
4301
4302	if v.DefaultInstanceProfileArn != nil {
4303		ok := object.Key("DefaultInstanceProfileArn")
4304		ok.String(*v.DefaultInstanceProfileArn)
4305	}
4306
4307	if v.DefaultOs != nil {
4308		ok := object.Key("DefaultOs")
4309		ok.String(*v.DefaultOs)
4310	}
4311
4312	if len(v.DefaultRootDeviceType) > 0 {
4313		ok := object.Key("DefaultRootDeviceType")
4314		ok.String(string(v.DefaultRootDeviceType))
4315	}
4316
4317	if v.DefaultSshKeyName != nil {
4318		ok := object.Key("DefaultSshKeyName")
4319		ok.String(*v.DefaultSshKeyName)
4320	}
4321
4322	if v.DefaultSubnetId != nil {
4323		ok := object.Key("DefaultSubnetId")
4324		ok.String(*v.DefaultSubnetId)
4325	}
4326
4327	if v.HostnameTheme != nil {
4328		ok := object.Key("HostnameTheme")
4329		ok.String(*v.HostnameTheme)
4330	}
4331
4332	if v.Name != nil {
4333		ok := object.Key("Name")
4334		ok.String(*v.Name)
4335	}
4336
4337	if v.Region != nil {
4338		ok := object.Key("Region")
4339		ok.String(*v.Region)
4340	}
4341
4342	if v.ServiceRoleArn != nil {
4343		ok := object.Key("ServiceRoleArn")
4344		ok.String(*v.ServiceRoleArn)
4345	}
4346
4347	if v.SourceStackId != nil {
4348		ok := object.Key("SourceStackId")
4349		ok.String(*v.SourceStackId)
4350	}
4351
4352	if v.UseCustomCookbooks != nil {
4353		ok := object.Key("UseCustomCookbooks")
4354		ok.Boolean(*v.UseCustomCookbooks)
4355	}
4356
4357	if v.UseOpsworksSecurityGroups != nil {
4358		ok := object.Key("UseOpsworksSecurityGroups")
4359		ok.Boolean(*v.UseOpsworksSecurityGroups)
4360	}
4361
4362	if v.VpcId != nil {
4363		ok := object.Key("VpcId")
4364		ok.String(*v.VpcId)
4365	}
4366
4367	return nil
4368}
4369
4370func awsAwsjson11_serializeOpDocumentCreateAppInput(v *CreateAppInput, value smithyjson.Value) error {
4371	object := value.Object()
4372	defer object.Close()
4373
4374	if v.AppSource != nil {
4375		ok := object.Key("AppSource")
4376		if err := awsAwsjson11_serializeDocumentSource(v.AppSource, ok); err != nil {
4377			return err
4378		}
4379	}
4380
4381	if v.Attributes != nil {
4382		ok := object.Key("Attributes")
4383		if err := awsAwsjson11_serializeDocumentAppAttributes(v.Attributes, ok); err != nil {
4384			return err
4385		}
4386	}
4387
4388	if v.DataSources != nil {
4389		ok := object.Key("DataSources")
4390		if err := awsAwsjson11_serializeDocumentDataSources(v.DataSources, ok); err != nil {
4391			return err
4392		}
4393	}
4394
4395	if v.Description != nil {
4396		ok := object.Key("Description")
4397		ok.String(*v.Description)
4398	}
4399
4400	if v.Domains != nil {
4401		ok := object.Key("Domains")
4402		if err := awsAwsjson11_serializeDocumentStrings(v.Domains, ok); err != nil {
4403			return err
4404		}
4405	}
4406
4407	if v.EnableSsl != nil {
4408		ok := object.Key("EnableSsl")
4409		ok.Boolean(*v.EnableSsl)
4410	}
4411
4412	if v.Environment != nil {
4413		ok := object.Key("Environment")
4414		if err := awsAwsjson11_serializeDocumentEnvironmentVariables(v.Environment, ok); err != nil {
4415			return err
4416		}
4417	}
4418
4419	if v.Name != nil {
4420		ok := object.Key("Name")
4421		ok.String(*v.Name)
4422	}
4423
4424	if v.Shortname != nil {
4425		ok := object.Key("Shortname")
4426		ok.String(*v.Shortname)
4427	}
4428
4429	if v.SslConfiguration != nil {
4430		ok := object.Key("SslConfiguration")
4431		if err := awsAwsjson11_serializeDocumentSslConfiguration(v.SslConfiguration, ok); err != nil {
4432			return err
4433		}
4434	}
4435
4436	if v.StackId != nil {
4437		ok := object.Key("StackId")
4438		ok.String(*v.StackId)
4439	}
4440
4441	if len(v.Type) > 0 {
4442		ok := object.Key("Type")
4443		ok.String(string(v.Type))
4444	}
4445
4446	return nil
4447}
4448
4449func awsAwsjson11_serializeOpDocumentCreateDeploymentInput(v *CreateDeploymentInput, value smithyjson.Value) error {
4450	object := value.Object()
4451	defer object.Close()
4452
4453	if v.AppId != nil {
4454		ok := object.Key("AppId")
4455		ok.String(*v.AppId)
4456	}
4457
4458	if v.Command != nil {
4459		ok := object.Key("Command")
4460		if err := awsAwsjson11_serializeDocumentDeploymentCommand(v.Command, ok); err != nil {
4461			return err
4462		}
4463	}
4464
4465	if v.Comment != nil {
4466		ok := object.Key("Comment")
4467		ok.String(*v.Comment)
4468	}
4469
4470	if v.CustomJson != nil {
4471		ok := object.Key("CustomJson")
4472		ok.String(*v.CustomJson)
4473	}
4474
4475	if v.InstanceIds != nil {
4476		ok := object.Key("InstanceIds")
4477		if err := awsAwsjson11_serializeDocumentStrings(v.InstanceIds, ok); err != nil {
4478			return err
4479		}
4480	}
4481
4482	if v.LayerIds != nil {
4483		ok := object.Key("LayerIds")
4484		if err := awsAwsjson11_serializeDocumentStrings(v.LayerIds, ok); err != nil {
4485			return err
4486		}
4487	}
4488
4489	if v.StackId != nil {
4490		ok := object.Key("StackId")
4491		ok.String(*v.StackId)
4492	}
4493
4494	return nil
4495}
4496
4497func awsAwsjson11_serializeOpDocumentCreateInstanceInput(v *CreateInstanceInput, value smithyjson.Value) error {
4498	object := value.Object()
4499	defer object.Close()
4500
4501	if v.AgentVersion != nil {
4502		ok := object.Key("AgentVersion")
4503		ok.String(*v.AgentVersion)
4504	}
4505
4506	if v.AmiId != nil {
4507		ok := object.Key("AmiId")
4508		ok.String(*v.AmiId)
4509	}
4510
4511	if len(v.Architecture) > 0 {
4512		ok := object.Key("Architecture")
4513		ok.String(string(v.Architecture))
4514	}
4515
4516	if len(v.AutoScalingType) > 0 {
4517		ok := object.Key("AutoScalingType")
4518		ok.String(string(v.AutoScalingType))
4519	}
4520
4521	if v.AvailabilityZone != nil {
4522		ok := object.Key("AvailabilityZone")
4523		ok.String(*v.AvailabilityZone)
4524	}
4525
4526	if v.BlockDeviceMappings != nil {
4527		ok := object.Key("BlockDeviceMappings")
4528		if err := awsAwsjson11_serializeDocumentBlockDeviceMappings(v.BlockDeviceMappings, ok); err != nil {
4529			return err
4530		}
4531	}
4532
4533	if v.EbsOptimized != nil {
4534		ok := object.Key("EbsOptimized")
4535		ok.Boolean(*v.EbsOptimized)
4536	}
4537
4538	if v.Hostname != nil {
4539		ok := object.Key("Hostname")
4540		ok.String(*v.Hostname)
4541	}
4542
4543	if v.InstallUpdatesOnBoot != nil {
4544		ok := object.Key("InstallUpdatesOnBoot")
4545		ok.Boolean(*v.InstallUpdatesOnBoot)
4546	}
4547
4548	if v.InstanceType != nil {
4549		ok := object.Key("InstanceType")
4550		ok.String(*v.InstanceType)
4551	}
4552
4553	if v.LayerIds != nil {
4554		ok := object.Key("LayerIds")
4555		if err := awsAwsjson11_serializeDocumentStrings(v.LayerIds, ok); err != nil {
4556			return err
4557		}
4558	}
4559
4560	if v.Os != nil {
4561		ok := object.Key("Os")
4562		ok.String(*v.Os)
4563	}
4564
4565	if len(v.RootDeviceType) > 0 {
4566		ok := object.Key("RootDeviceType")
4567		ok.String(string(v.RootDeviceType))
4568	}
4569
4570	if v.SshKeyName != nil {
4571		ok := object.Key("SshKeyName")
4572		ok.String(*v.SshKeyName)
4573	}
4574
4575	if v.StackId != nil {
4576		ok := object.Key("StackId")
4577		ok.String(*v.StackId)
4578	}
4579
4580	if v.SubnetId != nil {
4581		ok := object.Key("SubnetId")
4582		ok.String(*v.SubnetId)
4583	}
4584
4585	if v.Tenancy != nil {
4586		ok := object.Key("Tenancy")
4587		ok.String(*v.Tenancy)
4588	}
4589
4590	if v.VirtualizationType != nil {
4591		ok := object.Key("VirtualizationType")
4592		ok.String(*v.VirtualizationType)
4593	}
4594
4595	return nil
4596}
4597
4598func awsAwsjson11_serializeOpDocumentCreateLayerInput(v *CreateLayerInput, value smithyjson.Value) error {
4599	object := value.Object()
4600	defer object.Close()
4601
4602	if v.Attributes != nil {
4603		ok := object.Key("Attributes")
4604		if err := awsAwsjson11_serializeDocumentLayerAttributes(v.Attributes, ok); err != nil {
4605			return err
4606		}
4607	}
4608
4609	if v.AutoAssignElasticIps != nil {
4610		ok := object.Key("AutoAssignElasticIps")
4611		ok.Boolean(*v.AutoAssignElasticIps)
4612	}
4613
4614	if v.AutoAssignPublicIps != nil {
4615		ok := object.Key("AutoAssignPublicIps")
4616		ok.Boolean(*v.AutoAssignPublicIps)
4617	}
4618
4619	if v.CloudWatchLogsConfiguration != nil {
4620		ok := object.Key("CloudWatchLogsConfiguration")
4621		if err := awsAwsjson11_serializeDocumentCloudWatchLogsConfiguration(v.CloudWatchLogsConfiguration, ok); err != nil {
4622			return err
4623		}
4624	}
4625
4626	if v.CustomInstanceProfileArn != nil {
4627		ok := object.Key("CustomInstanceProfileArn")
4628		ok.String(*v.CustomInstanceProfileArn)
4629	}
4630
4631	if v.CustomJson != nil {
4632		ok := object.Key("CustomJson")
4633		ok.String(*v.CustomJson)
4634	}
4635
4636	if v.CustomRecipes != nil {
4637		ok := object.Key("CustomRecipes")
4638		if err := awsAwsjson11_serializeDocumentRecipes(v.CustomRecipes, ok); err != nil {
4639			return err
4640		}
4641	}
4642
4643	if v.CustomSecurityGroupIds != nil {
4644		ok := object.Key("CustomSecurityGroupIds")
4645		if err := awsAwsjson11_serializeDocumentStrings(v.CustomSecurityGroupIds, ok); err != nil {
4646			return err
4647		}
4648	}
4649
4650	if v.EnableAutoHealing != nil {
4651		ok := object.Key("EnableAutoHealing")
4652		ok.Boolean(*v.EnableAutoHealing)
4653	}
4654
4655	if v.InstallUpdatesOnBoot != nil {
4656		ok := object.Key("InstallUpdatesOnBoot")
4657		ok.Boolean(*v.InstallUpdatesOnBoot)
4658	}
4659
4660	if v.LifecycleEventConfiguration != nil {
4661		ok := object.Key("LifecycleEventConfiguration")
4662		if err := awsAwsjson11_serializeDocumentLifecycleEventConfiguration(v.LifecycleEventConfiguration, ok); err != nil {
4663			return err
4664		}
4665	}
4666
4667	if v.Name != nil {
4668		ok := object.Key("Name")
4669		ok.String(*v.Name)
4670	}
4671
4672	if v.Packages != nil {
4673		ok := object.Key("Packages")
4674		if err := awsAwsjson11_serializeDocumentStrings(v.Packages, ok); err != nil {
4675			return err
4676		}
4677	}
4678
4679	if v.Shortname != nil {
4680		ok := object.Key("Shortname")
4681		ok.String(*v.Shortname)
4682	}
4683
4684	if v.StackId != nil {
4685		ok := object.Key("StackId")
4686		ok.String(*v.StackId)
4687	}
4688
4689	if len(v.Type) > 0 {
4690		ok := object.Key("Type")
4691		ok.String(string(v.Type))
4692	}
4693
4694	if v.UseEbsOptimizedInstances != nil {
4695		ok := object.Key("UseEbsOptimizedInstances")
4696		ok.Boolean(*v.UseEbsOptimizedInstances)
4697	}
4698
4699	if v.VolumeConfigurations != nil {
4700		ok := object.Key("VolumeConfigurations")
4701		if err := awsAwsjson11_serializeDocumentVolumeConfigurations(v.VolumeConfigurations, ok); err != nil {
4702			return err
4703		}
4704	}
4705
4706	return nil
4707}
4708
4709func awsAwsjson11_serializeOpDocumentCreateStackInput(v *CreateStackInput, value smithyjson.Value) error {
4710	object := value.Object()
4711	defer object.Close()
4712
4713	if v.AgentVersion != nil {
4714		ok := object.Key("AgentVersion")
4715		ok.String(*v.AgentVersion)
4716	}
4717
4718	if v.Attributes != nil {
4719		ok := object.Key("Attributes")
4720		if err := awsAwsjson11_serializeDocumentStackAttributes(v.Attributes, ok); err != nil {
4721			return err
4722		}
4723	}
4724
4725	if v.ChefConfiguration != nil {
4726		ok := object.Key("ChefConfiguration")
4727		if err := awsAwsjson11_serializeDocumentChefConfiguration(v.ChefConfiguration, ok); err != nil {
4728			return err
4729		}
4730	}
4731
4732	if v.ConfigurationManager != nil {
4733		ok := object.Key("ConfigurationManager")
4734		if err := awsAwsjson11_serializeDocumentStackConfigurationManager(v.ConfigurationManager, ok); err != nil {
4735			return err
4736		}
4737	}
4738
4739	if v.CustomCookbooksSource != nil {
4740		ok := object.Key("CustomCookbooksSource")
4741		if err := awsAwsjson11_serializeDocumentSource(v.CustomCookbooksSource, ok); err != nil {
4742			return err
4743		}
4744	}
4745
4746	if v.CustomJson != nil {
4747		ok := object.Key("CustomJson")
4748		ok.String(*v.CustomJson)
4749	}
4750
4751	if v.DefaultAvailabilityZone != nil {
4752		ok := object.Key("DefaultAvailabilityZone")
4753		ok.String(*v.DefaultAvailabilityZone)
4754	}
4755
4756	if v.DefaultInstanceProfileArn != nil {
4757		ok := object.Key("DefaultInstanceProfileArn")
4758		ok.String(*v.DefaultInstanceProfileArn)
4759	}
4760
4761	if v.DefaultOs != nil {
4762		ok := object.Key("DefaultOs")
4763		ok.String(*v.DefaultOs)
4764	}
4765
4766	if len(v.DefaultRootDeviceType) > 0 {
4767		ok := object.Key("DefaultRootDeviceType")
4768		ok.String(string(v.DefaultRootDeviceType))
4769	}
4770
4771	if v.DefaultSshKeyName != nil {
4772		ok := object.Key("DefaultSshKeyName")
4773		ok.String(*v.DefaultSshKeyName)
4774	}
4775
4776	if v.DefaultSubnetId != nil {
4777		ok := object.Key("DefaultSubnetId")
4778		ok.String(*v.DefaultSubnetId)
4779	}
4780
4781	if v.HostnameTheme != nil {
4782		ok := object.Key("HostnameTheme")
4783		ok.String(*v.HostnameTheme)
4784	}
4785
4786	if v.Name != nil {
4787		ok := object.Key("Name")
4788		ok.String(*v.Name)
4789	}
4790
4791	if v.Region != nil {
4792		ok := object.Key("Region")
4793		ok.String(*v.Region)
4794	}
4795
4796	if v.ServiceRoleArn != nil {
4797		ok := object.Key("ServiceRoleArn")
4798		ok.String(*v.ServiceRoleArn)
4799	}
4800
4801	if v.UseCustomCookbooks != nil {
4802		ok := object.Key("UseCustomCookbooks")
4803		ok.Boolean(*v.UseCustomCookbooks)
4804	}
4805
4806	if v.UseOpsworksSecurityGroups != nil {
4807		ok := object.Key("UseOpsworksSecurityGroups")
4808		ok.Boolean(*v.UseOpsworksSecurityGroups)
4809	}
4810
4811	if v.VpcId != nil {
4812		ok := object.Key("VpcId")
4813		ok.String(*v.VpcId)
4814	}
4815
4816	return nil
4817}
4818
4819func awsAwsjson11_serializeOpDocumentCreateUserProfileInput(v *CreateUserProfileInput, value smithyjson.Value) error {
4820	object := value.Object()
4821	defer object.Close()
4822
4823	if v.AllowSelfManagement != nil {
4824		ok := object.Key("AllowSelfManagement")
4825		ok.Boolean(*v.AllowSelfManagement)
4826	}
4827
4828	if v.IamUserArn != nil {
4829		ok := object.Key("IamUserArn")
4830		ok.String(*v.IamUserArn)
4831	}
4832
4833	if v.SshPublicKey != nil {
4834		ok := object.Key("SshPublicKey")
4835		ok.String(*v.SshPublicKey)
4836	}
4837
4838	if v.SshUsername != nil {
4839		ok := object.Key("SshUsername")
4840		ok.String(*v.SshUsername)
4841	}
4842
4843	return nil
4844}
4845
4846func awsAwsjson11_serializeOpDocumentDeleteAppInput(v *DeleteAppInput, value smithyjson.Value) error {
4847	object := value.Object()
4848	defer object.Close()
4849
4850	if v.AppId != nil {
4851		ok := object.Key("AppId")
4852		ok.String(*v.AppId)
4853	}
4854
4855	return nil
4856}
4857
4858func awsAwsjson11_serializeOpDocumentDeleteInstanceInput(v *DeleteInstanceInput, value smithyjson.Value) error {
4859	object := value.Object()
4860	defer object.Close()
4861
4862	if v.DeleteElasticIp != nil {
4863		ok := object.Key("DeleteElasticIp")
4864		ok.Boolean(*v.DeleteElasticIp)
4865	}
4866
4867	if v.DeleteVolumes != nil {
4868		ok := object.Key("DeleteVolumes")
4869		ok.Boolean(*v.DeleteVolumes)
4870	}
4871
4872	if v.InstanceId != nil {
4873		ok := object.Key("InstanceId")
4874		ok.String(*v.InstanceId)
4875	}
4876
4877	return nil
4878}
4879
4880func awsAwsjson11_serializeOpDocumentDeleteLayerInput(v *DeleteLayerInput, value smithyjson.Value) error {
4881	object := value.Object()
4882	defer object.Close()
4883
4884	if v.LayerId != nil {
4885		ok := object.Key("LayerId")
4886		ok.String(*v.LayerId)
4887	}
4888
4889	return nil
4890}
4891
4892func awsAwsjson11_serializeOpDocumentDeleteStackInput(v *DeleteStackInput, value smithyjson.Value) error {
4893	object := value.Object()
4894	defer object.Close()
4895
4896	if v.StackId != nil {
4897		ok := object.Key("StackId")
4898		ok.String(*v.StackId)
4899	}
4900
4901	return nil
4902}
4903
4904func awsAwsjson11_serializeOpDocumentDeleteUserProfileInput(v *DeleteUserProfileInput, value smithyjson.Value) error {
4905	object := value.Object()
4906	defer object.Close()
4907
4908	if v.IamUserArn != nil {
4909		ok := object.Key("IamUserArn")
4910		ok.String(*v.IamUserArn)
4911	}
4912
4913	return nil
4914}
4915
4916func awsAwsjson11_serializeOpDocumentDeregisterEcsClusterInput(v *DeregisterEcsClusterInput, value smithyjson.Value) error {
4917	object := value.Object()
4918	defer object.Close()
4919
4920	if v.EcsClusterArn != nil {
4921		ok := object.Key("EcsClusterArn")
4922		ok.String(*v.EcsClusterArn)
4923	}
4924
4925	return nil
4926}
4927
4928func awsAwsjson11_serializeOpDocumentDeregisterElasticIpInput(v *DeregisterElasticIpInput, value smithyjson.Value) error {
4929	object := value.Object()
4930	defer object.Close()
4931
4932	if v.ElasticIp != nil {
4933		ok := object.Key("ElasticIp")
4934		ok.String(*v.ElasticIp)
4935	}
4936
4937	return nil
4938}
4939
4940func awsAwsjson11_serializeOpDocumentDeregisterInstanceInput(v *DeregisterInstanceInput, value smithyjson.Value) error {
4941	object := value.Object()
4942	defer object.Close()
4943
4944	if v.InstanceId != nil {
4945		ok := object.Key("InstanceId")
4946		ok.String(*v.InstanceId)
4947	}
4948
4949	return nil
4950}
4951
4952func awsAwsjson11_serializeOpDocumentDeregisterRdsDbInstanceInput(v *DeregisterRdsDbInstanceInput, value smithyjson.Value) error {
4953	object := value.Object()
4954	defer object.Close()
4955
4956	if v.RdsDbInstanceArn != nil {
4957		ok := object.Key("RdsDbInstanceArn")
4958		ok.String(*v.RdsDbInstanceArn)
4959	}
4960
4961	return nil
4962}
4963
4964func awsAwsjson11_serializeOpDocumentDeregisterVolumeInput(v *DeregisterVolumeInput, value smithyjson.Value) error {
4965	object := value.Object()
4966	defer object.Close()
4967
4968	if v.VolumeId != nil {
4969		ok := object.Key("VolumeId")
4970		ok.String(*v.VolumeId)
4971	}
4972
4973	return nil
4974}
4975
4976func awsAwsjson11_serializeOpDocumentDescribeAgentVersionsInput(v *DescribeAgentVersionsInput, value smithyjson.Value) error {
4977	object := value.Object()
4978	defer object.Close()
4979
4980	if v.ConfigurationManager != nil {
4981		ok := object.Key("ConfigurationManager")
4982		if err := awsAwsjson11_serializeDocumentStackConfigurationManager(v.ConfigurationManager, ok); err != nil {
4983			return err
4984		}
4985	}
4986
4987	if v.StackId != nil {
4988		ok := object.Key("StackId")
4989		ok.String(*v.StackId)
4990	}
4991
4992	return nil
4993}
4994
4995func awsAwsjson11_serializeOpDocumentDescribeAppsInput(v *DescribeAppsInput, value smithyjson.Value) error {
4996	object := value.Object()
4997	defer object.Close()
4998
4999	if v.AppIds != nil {
5000		ok := object.Key("AppIds")
5001		if err := awsAwsjson11_serializeDocumentStrings(v.AppIds, ok); err != nil {
5002			return err
5003		}
5004	}
5005
5006	if v.StackId != nil {
5007		ok := object.Key("StackId")
5008		ok.String(*v.StackId)
5009	}
5010
5011	return nil
5012}
5013
5014func awsAwsjson11_serializeOpDocumentDescribeCommandsInput(v *DescribeCommandsInput, value smithyjson.Value) error {
5015	object := value.Object()
5016	defer object.Close()
5017
5018	if v.CommandIds != nil {
5019		ok := object.Key("CommandIds")
5020		if err := awsAwsjson11_serializeDocumentStrings(v.CommandIds, ok); err != nil {
5021			return err
5022		}
5023	}
5024
5025	if v.DeploymentId != nil {
5026		ok := object.Key("DeploymentId")
5027		ok.String(*v.DeploymentId)
5028	}
5029
5030	if v.InstanceId != nil {
5031		ok := object.Key("InstanceId")
5032		ok.String(*v.InstanceId)
5033	}
5034
5035	return nil
5036}
5037
5038func awsAwsjson11_serializeOpDocumentDescribeDeploymentsInput(v *DescribeDeploymentsInput, value smithyjson.Value) error {
5039	object := value.Object()
5040	defer object.Close()
5041
5042	if v.AppId != nil {
5043		ok := object.Key("AppId")
5044		ok.String(*v.AppId)
5045	}
5046
5047	if v.DeploymentIds != nil {
5048		ok := object.Key("DeploymentIds")
5049		if err := awsAwsjson11_serializeDocumentStrings(v.DeploymentIds, ok); err != nil {
5050			return err
5051		}
5052	}
5053
5054	if v.StackId != nil {
5055		ok := object.Key("StackId")
5056		ok.String(*v.StackId)
5057	}
5058
5059	return nil
5060}
5061
5062func awsAwsjson11_serializeOpDocumentDescribeEcsClustersInput(v *DescribeEcsClustersInput, value smithyjson.Value) error {
5063	object := value.Object()
5064	defer object.Close()
5065
5066	if v.EcsClusterArns != nil {
5067		ok := object.Key("EcsClusterArns")
5068		if err := awsAwsjson11_serializeDocumentStrings(v.EcsClusterArns, ok); err != nil {
5069			return err
5070		}
5071	}
5072
5073	if v.MaxResults != nil {
5074		ok := object.Key("MaxResults")
5075		ok.Integer(*v.MaxResults)
5076	}
5077
5078	if v.NextToken != nil {
5079		ok := object.Key("NextToken")
5080		ok.String(*v.NextToken)
5081	}
5082
5083	if v.StackId != nil {
5084		ok := object.Key("StackId")
5085		ok.String(*v.StackId)
5086	}
5087
5088	return nil
5089}
5090
5091func awsAwsjson11_serializeOpDocumentDescribeElasticIpsInput(v *DescribeElasticIpsInput, value smithyjson.Value) error {
5092	object := value.Object()
5093	defer object.Close()
5094
5095	if v.InstanceId != nil {
5096		ok := object.Key("InstanceId")
5097		ok.String(*v.InstanceId)
5098	}
5099
5100	if v.Ips != nil {
5101		ok := object.Key("Ips")
5102		if err := awsAwsjson11_serializeDocumentStrings(v.Ips, ok); err != nil {
5103			return err
5104		}
5105	}
5106
5107	if v.StackId != nil {
5108		ok := object.Key("StackId")
5109		ok.String(*v.StackId)
5110	}
5111
5112	return nil
5113}
5114
5115func awsAwsjson11_serializeOpDocumentDescribeElasticLoadBalancersInput(v *DescribeElasticLoadBalancersInput, value smithyjson.Value) error {
5116	object := value.Object()
5117	defer object.Close()
5118
5119	if v.LayerIds != nil {
5120		ok := object.Key("LayerIds")
5121		if err := awsAwsjson11_serializeDocumentStrings(v.LayerIds, ok); err != nil {
5122			return err
5123		}
5124	}
5125
5126	if v.StackId != nil {
5127		ok := object.Key("StackId")
5128		ok.String(*v.StackId)
5129	}
5130
5131	return nil
5132}
5133
5134func awsAwsjson11_serializeOpDocumentDescribeInstancesInput(v *DescribeInstancesInput, value smithyjson.Value) error {
5135	object := value.Object()
5136	defer object.Close()
5137
5138	if v.InstanceIds != nil {
5139		ok := object.Key("InstanceIds")
5140		if err := awsAwsjson11_serializeDocumentStrings(v.InstanceIds, ok); err != nil {
5141			return err
5142		}
5143	}
5144
5145	if v.LayerId != nil {
5146		ok := object.Key("LayerId")
5147		ok.String(*v.LayerId)
5148	}
5149
5150	if v.StackId != nil {
5151		ok := object.Key("StackId")
5152		ok.String(*v.StackId)
5153	}
5154
5155	return nil
5156}
5157
5158func awsAwsjson11_serializeOpDocumentDescribeLayersInput(v *DescribeLayersInput, value smithyjson.Value) error {
5159	object := value.Object()
5160	defer object.Close()
5161
5162	if v.LayerIds != nil {
5163		ok := object.Key("LayerIds")
5164		if err := awsAwsjson11_serializeDocumentStrings(v.LayerIds, ok); err != nil {
5165			return err
5166		}
5167	}
5168
5169	if v.StackId != nil {
5170		ok := object.Key("StackId")
5171		ok.String(*v.StackId)
5172	}
5173
5174	return nil
5175}
5176
5177func awsAwsjson11_serializeOpDocumentDescribeLoadBasedAutoScalingInput(v *DescribeLoadBasedAutoScalingInput, value smithyjson.Value) error {
5178	object := value.Object()
5179	defer object.Close()
5180
5181	if v.LayerIds != nil {
5182		ok := object.Key("LayerIds")
5183		if err := awsAwsjson11_serializeDocumentStrings(v.LayerIds, ok); err != nil {
5184			return err
5185		}
5186	}
5187
5188	return nil
5189}
5190
5191func awsAwsjson11_serializeOpDocumentDescribePermissionsInput(v *DescribePermissionsInput, value smithyjson.Value) error {
5192	object := value.Object()
5193	defer object.Close()
5194
5195	if v.IamUserArn != nil {
5196		ok := object.Key("IamUserArn")
5197		ok.String(*v.IamUserArn)
5198	}
5199
5200	if v.StackId != nil {
5201		ok := object.Key("StackId")
5202		ok.String(*v.StackId)
5203	}
5204
5205	return nil
5206}
5207
5208func awsAwsjson11_serializeOpDocumentDescribeRaidArraysInput(v *DescribeRaidArraysInput, value smithyjson.Value) error {
5209	object := value.Object()
5210	defer object.Close()
5211
5212	if v.InstanceId != nil {
5213		ok := object.Key("InstanceId")
5214		ok.String(*v.InstanceId)
5215	}
5216
5217	if v.RaidArrayIds != nil {
5218		ok := object.Key("RaidArrayIds")
5219		if err := awsAwsjson11_serializeDocumentStrings(v.RaidArrayIds, ok); err != nil {
5220			return err
5221		}
5222	}
5223
5224	if v.StackId != nil {
5225		ok := object.Key("StackId")
5226		ok.String(*v.StackId)
5227	}
5228
5229	return nil
5230}
5231
5232func awsAwsjson11_serializeOpDocumentDescribeRdsDbInstancesInput(v *DescribeRdsDbInstancesInput, value smithyjson.Value) error {
5233	object := value.Object()
5234	defer object.Close()
5235
5236	if v.RdsDbInstanceArns != nil {
5237		ok := object.Key("RdsDbInstanceArns")
5238		if err := awsAwsjson11_serializeDocumentStrings(v.RdsDbInstanceArns, ok); err != nil {
5239			return err
5240		}
5241	}
5242
5243	if v.StackId != nil {
5244		ok := object.Key("StackId")
5245		ok.String(*v.StackId)
5246	}
5247
5248	return nil
5249}
5250
5251func awsAwsjson11_serializeOpDocumentDescribeServiceErrorsInput(v *DescribeServiceErrorsInput, value smithyjson.Value) error {
5252	object := value.Object()
5253	defer object.Close()
5254
5255	if v.InstanceId != nil {
5256		ok := object.Key("InstanceId")
5257		ok.String(*v.InstanceId)
5258	}
5259
5260	if v.ServiceErrorIds != nil {
5261		ok := object.Key("ServiceErrorIds")
5262		if err := awsAwsjson11_serializeDocumentStrings(v.ServiceErrorIds, ok); err != nil {
5263			return err
5264		}
5265	}
5266
5267	if v.StackId != nil {
5268		ok := object.Key("StackId")
5269		ok.String(*v.StackId)
5270	}
5271
5272	return nil
5273}
5274
5275func awsAwsjson11_serializeOpDocumentDescribeStackProvisioningParametersInput(v *DescribeStackProvisioningParametersInput, value smithyjson.Value) error {
5276	object := value.Object()
5277	defer object.Close()
5278
5279	if v.StackId != nil {
5280		ok := object.Key("StackId")
5281		ok.String(*v.StackId)
5282	}
5283
5284	return nil
5285}
5286
5287func awsAwsjson11_serializeOpDocumentDescribeStacksInput(v *DescribeStacksInput, value smithyjson.Value) error {
5288	object := value.Object()
5289	defer object.Close()
5290
5291	if v.StackIds != nil {
5292		ok := object.Key("StackIds")
5293		if err := awsAwsjson11_serializeDocumentStrings(v.StackIds, ok); err != nil {
5294			return err
5295		}
5296	}
5297
5298	return nil
5299}
5300
5301func awsAwsjson11_serializeOpDocumentDescribeStackSummaryInput(v *DescribeStackSummaryInput, value smithyjson.Value) error {
5302	object := value.Object()
5303	defer object.Close()
5304
5305	if v.StackId != nil {
5306		ok := object.Key("StackId")
5307		ok.String(*v.StackId)
5308	}
5309
5310	return nil
5311}
5312
5313func awsAwsjson11_serializeOpDocumentDescribeTimeBasedAutoScalingInput(v *DescribeTimeBasedAutoScalingInput, value smithyjson.Value) error {
5314	object := value.Object()
5315	defer object.Close()
5316
5317	if v.InstanceIds != nil {
5318		ok := object.Key("InstanceIds")
5319		if err := awsAwsjson11_serializeDocumentStrings(v.InstanceIds, ok); err != nil {
5320			return err
5321		}
5322	}
5323
5324	return nil
5325}
5326
5327func awsAwsjson11_serializeOpDocumentDescribeUserProfilesInput(v *DescribeUserProfilesInput, value smithyjson.Value) error {
5328	object := value.Object()
5329	defer object.Close()
5330
5331	if v.IamUserArns != nil {
5332		ok := object.Key("IamUserArns")
5333		if err := awsAwsjson11_serializeDocumentStrings(v.IamUserArns, ok); err != nil {
5334			return err
5335		}
5336	}
5337
5338	return nil
5339}
5340
5341func awsAwsjson11_serializeOpDocumentDescribeVolumesInput(v *DescribeVolumesInput, value smithyjson.Value) error {
5342	object := value.Object()
5343	defer object.Close()
5344
5345	if v.InstanceId != nil {
5346		ok := object.Key("InstanceId")
5347		ok.String(*v.InstanceId)
5348	}
5349
5350	if v.RaidArrayId != nil {
5351		ok := object.Key("RaidArrayId")
5352		ok.String(*v.RaidArrayId)
5353	}
5354
5355	if v.StackId != nil {
5356		ok := object.Key("StackId")
5357		ok.String(*v.StackId)
5358	}
5359
5360	if v.VolumeIds != nil {
5361		ok := object.Key("VolumeIds")
5362		if err := awsAwsjson11_serializeDocumentStrings(v.VolumeIds, ok); err != nil {
5363			return err
5364		}
5365	}
5366
5367	return nil
5368}
5369
5370func awsAwsjson11_serializeOpDocumentDetachElasticLoadBalancerInput(v *DetachElasticLoadBalancerInput, value smithyjson.Value) error {
5371	object := value.Object()
5372	defer object.Close()
5373
5374	if v.ElasticLoadBalancerName != nil {
5375		ok := object.Key("ElasticLoadBalancerName")
5376		ok.String(*v.ElasticLoadBalancerName)
5377	}
5378
5379	if v.LayerId != nil {
5380		ok := object.Key("LayerId")
5381		ok.String(*v.LayerId)
5382	}
5383
5384	return nil
5385}
5386
5387func awsAwsjson11_serializeOpDocumentDisassociateElasticIpInput(v *DisassociateElasticIpInput, value smithyjson.Value) error {
5388	object := value.Object()
5389	defer object.Close()
5390
5391	if v.ElasticIp != nil {
5392		ok := object.Key("ElasticIp")
5393		ok.String(*v.ElasticIp)
5394	}
5395
5396	return nil
5397}
5398
5399func awsAwsjson11_serializeOpDocumentGetHostnameSuggestionInput(v *GetHostnameSuggestionInput, value smithyjson.Value) error {
5400	object := value.Object()
5401	defer object.Close()
5402
5403	if v.LayerId != nil {
5404		ok := object.Key("LayerId")
5405		ok.String(*v.LayerId)
5406	}
5407
5408	return nil
5409}
5410
5411func awsAwsjson11_serializeOpDocumentGrantAccessInput(v *GrantAccessInput, value smithyjson.Value) error {
5412	object := value.Object()
5413	defer object.Close()
5414
5415	if v.InstanceId != nil {
5416		ok := object.Key("InstanceId")
5417		ok.String(*v.InstanceId)
5418	}
5419
5420	if v.ValidForInMinutes != nil {
5421		ok := object.Key("ValidForInMinutes")
5422		ok.Integer(*v.ValidForInMinutes)
5423	}
5424
5425	return nil
5426}
5427
5428func awsAwsjson11_serializeOpDocumentListTagsInput(v *ListTagsInput, value smithyjson.Value) error {
5429	object := value.Object()
5430	defer object.Close()
5431
5432	if v.MaxResults != 0 {
5433		ok := object.Key("MaxResults")
5434		ok.Integer(v.MaxResults)
5435	}
5436
5437	if v.NextToken != nil {
5438		ok := object.Key("NextToken")
5439		ok.String(*v.NextToken)
5440	}
5441
5442	if v.ResourceArn != nil {
5443		ok := object.Key("ResourceArn")
5444		ok.String(*v.ResourceArn)
5445	}
5446
5447	return nil
5448}
5449
5450func awsAwsjson11_serializeOpDocumentRebootInstanceInput(v *RebootInstanceInput, value smithyjson.Value) error {
5451	object := value.Object()
5452	defer object.Close()
5453
5454	if v.InstanceId != nil {
5455		ok := object.Key("InstanceId")
5456		ok.String(*v.InstanceId)
5457	}
5458
5459	return nil
5460}
5461
5462func awsAwsjson11_serializeOpDocumentRegisterEcsClusterInput(v *RegisterEcsClusterInput, value smithyjson.Value) error {
5463	object := value.Object()
5464	defer object.Close()
5465
5466	if v.EcsClusterArn != nil {
5467		ok := object.Key("EcsClusterArn")
5468		ok.String(*v.EcsClusterArn)
5469	}
5470
5471	if v.StackId != nil {
5472		ok := object.Key("StackId")
5473		ok.String(*v.StackId)
5474	}
5475
5476	return nil
5477}
5478
5479func awsAwsjson11_serializeOpDocumentRegisterElasticIpInput(v *RegisterElasticIpInput, value smithyjson.Value) error {
5480	object := value.Object()
5481	defer object.Close()
5482
5483	if v.ElasticIp != nil {
5484		ok := object.Key("ElasticIp")
5485		ok.String(*v.ElasticIp)
5486	}
5487
5488	if v.StackId != nil {
5489		ok := object.Key("StackId")
5490		ok.String(*v.StackId)
5491	}
5492
5493	return nil
5494}
5495
5496func awsAwsjson11_serializeOpDocumentRegisterInstanceInput(v *RegisterInstanceInput, value smithyjson.Value) error {
5497	object := value.Object()
5498	defer object.Close()
5499
5500	if v.Hostname != nil {
5501		ok := object.Key("Hostname")
5502		ok.String(*v.Hostname)
5503	}
5504
5505	if v.InstanceIdentity != nil {
5506		ok := object.Key("InstanceIdentity")
5507		if err := awsAwsjson11_serializeDocumentInstanceIdentity(v.InstanceIdentity, ok); err != nil {
5508			return err
5509		}
5510	}
5511
5512	if v.PrivateIp != nil {
5513		ok := object.Key("PrivateIp")
5514		ok.String(*v.PrivateIp)
5515	}
5516
5517	if v.PublicIp != nil {
5518		ok := object.Key("PublicIp")
5519		ok.String(*v.PublicIp)
5520	}
5521
5522	if v.RsaPublicKey != nil {
5523		ok := object.Key("RsaPublicKey")
5524		ok.String(*v.RsaPublicKey)
5525	}
5526
5527	if v.RsaPublicKeyFingerprint != nil {
5528		ok := object.Key("RsaPublicKeyFingerprint")
5529		ok.String(*v.RsaPublicKeyFingerprint)
5530	}
5531
5532	if v.StackId != nil {
5533		ok := object.Key("StackId")
5534		ok.String(*v.StackId)
5535	}
5536
5537	return nil
5538}
5539
5540func awsAwsjson11_serializeOpDocumentRegisterRdsDbInstanceInput(v *RegisterRdsDbInstanceInput, value smithyjson.Value) error {
5541	object := value.Object()
5542	defer object.Close()
5543
5544	if v.DbPassword != nil {
5545		ok := object.Key("DbPassword")
5546		ok.String(*v.DbPassword)
5547	}
5548
5549	if v.DbUser != nil {
5550		ok := object.Key("DbUser")
5551		ok.String(*v.DbUser)
5552	}
5553
5554	if v.RdsDbInstanceArn != nil {
5555		ok := object.Key("RdsDbInstanceArn")
5556		ok.String(*v.RdsDbInstanceArn)
5557	}
5558
5559	if v.StackId != nil {
5560		ok := object.Key("StackId")
5561		ok.String(*v.StackId)
5562	}
5563
5564	return nil
5565}
5566
5567func awsAwsjson11_serializeOpDocumentRegisterVolumeInput(v *RegisterVolumeInput, value smithyjson.Value) error {
5568	object := value.Object()
5569	defer object.Close()
5570
5571	if v.Ec2VolumeId != nil {
5572		ok := object.Key("Ec2VolumeId")
5573		ok.String(*v.Ec2VolumeId)
5574	}
5575
5576	if v.StackId != nil {
5577		ok := object.Key("StackId")
5578		ok.String(*v.StackId)
5579	}
5580
5581	return nil
5582}
5583
5584func awsAwsjson11_serializeOpDocumentSetLoadBasedAutoScalingInput(v *SetLoadBasedAutoScalingInput, value smithyjson.Value) error {
5585	object := value.Object()
5586	defer object.Close()
5587
5588	if v.DownScaling != nil {
5589		ok := object.Key("DownScaling")
5590		if err := awsAwsjson11_serializeDocumentAutoScalingThresholds(v.DownScaling, ok); err != nil {
5591			return err
5592		}
5593	}
5594
5595	if v.Enable != nil {
5596		ok := object.Key("Enable")
5597		ok.Boolean(*v.Enable)
5598	}
5599
5600	if v.LayerId != nil {
5601		ok := object.Key("LayerId")
5602		ok.String(*v.LayerId)
5603	}
5604
5605	if v.UpScaling != nil {
5606		ok := object.Key("UpScaling")
5607		if err := awsAwsjson11_serializeDocumentAutoScalingThresholds(v.UpScaling, ok); err != nil {
5608			return err
5609		}
5610	}
5611
5612	return nil
5613}
5614
5615func awsAwsjson11_serializeOpDocumentSetPermissionInput(v *SetPermissionInput, value smithyjson.Value) error {
5616	object := value.Object()
5617	defer object.Close()
5618
5619	if v.AllowSsh != nil {
5620		ok := object.Key("AllowSsh")
5621		ok.Boolean(*v.AllowSsh)
5622	}
5623
5624	if v.AllowSudo != nil {
5625		ok := object.Key("AllowSudo")
5626		ok.Boolean(*v.AllowSudo)
5627	}
5628
5629	if v.IamUserArn != nil {
5630		ok := object.Key("IamUserArn")
5631		ok.String(*v.IamUserArn)
5632	}
5633
5634	if v.Level != nil {
5635		ok := object.Key("Level")
5636		ok.String(*v.Level)
5637	}
5638
5639	if v.StackId != nil {
5640		ok := object.Key("StackId")
5641		ok.String(*v.StackId)
5642	}
5643
5644	return nil
5645}
5646
5647func awsAwsjson11_serializeOpDocumentSetTimeBasedAutoScalingInput(v *SetTimeBasedAutoScalingInput, value smithyjson.Value) error {
5648	object := value.Object()
5649	defer object.Close()
5650
5651	if v.AutoScalingSchedule != nil {
5652		ok := object.Key("AutoScalingSchedule")
5653		if err := awsAwsjson11_serializeDocumentWeeklyAutoScalingSchedule(v.AutoScalingSchedule, ok); err != nil {
5654			return err
5655		}
5656	}
5657
5658	if v.InstanceId != nil {
5659		ok := object.Key("InstanceId")
5660		ok.String(*v.InstanceId)
5661	}
5662
5663	return nil
5664}
5665
5666func awsAwsjson11_serializeOpDocumentStartInstanceInput(v *StartInstanceInput, value smithyjson.Value) error {
5667	object := value.Object()
5668	defer object.Close()
5669
5670	if v.InstanceId != nil {
5671		ok := object.Key("InstanceId")
5672		ok.String(*v.InstanceId)
5673	}
5674
5675	return nil
5676}
5677
5678func awsAwsjson11_serializeOpDocumentStartStackInput(v *StartStackInput, value smithyjson.Value) error {
5679	object := value.Object()
5680	defer object.Close()
5681
5682	if v.StackId != nil {
5683		ok := object.Key("StackId")
5684		ok.String(*v.StackId)
5685	}
5686
5687	return nil
5688}
5689
5690func awsAwsjson11_serializeOpDocumentStopInstanceInput(v *StopInstanceInput, value smithyjson.Value) error {
5691	object := value.Object()
5692	defer object.Close()
5693
5694	if v.Force != nil {
5695		ok := object.Key("Force")
5696		ok.Boolean(*v.Force)
5697	}
5698
5699	if v.InstanceId != nil {
5700		ok := object.Key("InstanceId")
5701		ok.String(*v.InstanceId)
5702	}
5703
5704	return nil
5705}
5706
5707func awsAwsjson11_serializeOpDocumentStopStackInput(v *StopStackInput, value smithyjson.Value) error {
5708	object := value.Object()
5709	defer object.Close()
5710
5711	if v.StackId != nil {
5712		ok := object.Key("StackId")
5713		ok.String(*v.StackId)
5714	}
5715
5716	return nil
5717}
5718
5719func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
5720	object := value.Object()
5721	defer object.Close()
5722
5723	if v.ResourceArn != nil {
5724		ok := object.Key("ResourceArn")
5725		ok.String(*v.ResourceArn)
5726	}
5727
5728	if v.Tags != nil {
5729		ok := object.Key("Tags")
5730		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5731			return err
5732		}
5733	}
5734
5735	return nil
5736}
5737
5738func awsAwsjson11_serializeOpDocumentUnassignInstanceInput(v *UnassignInstanceInput, value smithyjson.Value) error {
5739	object := value.Object()
5740	defer object.Close()
5741
5742	if v.InstanceId != nil {
5743		ok := object.Key("InstanceId")
5744		ok.String(*v.InstanceId)
5745	}
5746
5747	return nil
5748}
5749
5750func awsAwsjson11_serializeOpDocumentUnassignVolumeInput(v *UnassignVolumeInput, value smithyjson.Value) error {
5751	object := value.Object()
5752	defer object.Close()
5753
5754	if v.VolumeId != nil {
5755		ok := object.Key("VolumeId")
5756		ok.String(*v.VolumeId)
5757	}
5758
5759	return nil
5760}
5761
5762func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
5763	object := value.Object()
5764	defer object.Close()
5765
5766	if v.ResourceArn != nil {
5767		ok := object.Key("ResourceArn")
5768		ok.String(*v.ResourceArn)
5769	}
5770
5771	if v.TagKeys != nil {
5772		ok := object.Key("TagKeys")
5773		if err := awsAwsjson11_serializeDocumentTagKeys(v.TagKeys, ok); err != nil {
5774			return err
5775		}
5776	}
5777
5778	return nil
5779}
5780
5781func awsAwsjson11_serializeOpDocumentUpdateAppInput(v *UpdateAppInput, value smithyjson.Value) error {
5782	object := value.Object()
5783	defer object.Close()
5784
5785	if v.AppId != nil {
5786		ok := object.Key("AppId")
5787		ok.String(*v.AppId)
5788	}
5789
5790	if v.AppSource != nil {
5791		ok := object.Key("AppSource")
5792		if err := awsAwsjson11_serializeDocumentSource(v.AppSource, ok); err != nil {
5793			return err
5794		}
5795	}
5796
5797	if v.Attributes != nil {
5798		ok := object.Key("Attributes")
5799		if err := awsAwsjson11_serializeDocumentAppAttributes(v.Attributes, ok); err != nil {
5800			return err
5801		}
5802	}
5803
5804	if v.DataSources != nil {
5805		ok := object.Key("DataSources")
5806		if err := awsAwsjson11_serializeDocumentDataSources(v.DataSources, ok); err != nil {
5807			return err
5808		}
5809	}
5810
5811	if v.Description != nil {
5812		ok := object.Key("Description")
5813		ok.String(*v.Description)
5814	}
5815
5816	if v.Domains != nil {
5817		ok := object.Key("Domains")
5818		if err := awsAwsjson11_serializeDocumentStrings(v.Domains, ok); err != nil {
5819			return err
5820		}
5821	}
5822
5823	if v.EnableSsl != nil {
5824		ok := object.Key("EnableSsl")
5825		ok.Boolean(*v.EnableSsl)
5826	}
5827
5828	if v.Environment != nil {
5829		ok := object.Key("Environment")
5830		if err := awsAwsjson11_serializeDocumentEnvironmentVariables(v.Environment, ok); err != nil {
5831			return err
5832		}
5833	}
5834
5835	if v.Name != nil {
5836		ok := object.Key("Name")
5837		ok.String(*v.Name)
5838	}
5839
5840	if v.SslConfiguration != nil {
5841		ok := object.Key("SslConfiguration")
5842		if err := awsAwsjson11_serializeDocumentSslConfiguration(v.SslConfiguration, ok); err != nil {
5843			return err
5844		}
5845	}
5846
5847	if len(v.Type) > 0 {
5848		ok := object.Key("Type")
5849		ok.String(string(v.Type))
5850	}
5851
5852	return nil
5853}
5854
5855func awsAwsjson11_serializeOpDocumentUpdateElasticIpInput(v *UpdateElasticIpInput, value smithyjson.Value) error {
5856	object := value.Object()
5857	defer object.Close()
5858
5859	if v.ElasticIp != nil {
5860		ok := object.Key("ElasticIp")
5861		ok.String(*v.ElasticIp)
5862	}
5863
5864	if v.Name != nil {
5865		ok := object.Key("Name")
5866		ok.String(*v.Name)
5867	}
5868
5869	return nil
5870}
5871
5872func awsAwsjson11_serializeOpDocumentUpdateInstanceInput(v *UpdateInstanceInput, value smithyjson.Value) error {
5873	object := value.Object()
5874	defer object.Close()
5875
5876	if v.AgentVersion != nil {
5877		ok := object.Key("AgentVersion")
5878		ok.String(*v.AgentVersion)
5879	}
5880
5881	if v.AmiId != nil {
5882		ok := object.Key("AmiId")
5883		ok.String(*v.AmiId)
5884	}
5885
5886	if len(v.Architecture) > 0 {
5887		ok := object.Key("Architecture")
5888		ok.String(string(v.Architecture))
5889	}
5890
5891	if len(v.AutoScalingType) > 0 {
5892		ok := object.Key("AutoScalingType")
5893		ok.String(string(v.AutoScalingType))
5894	}
5895
5896	if v.EbsOptimized != nil {
5897		ok := object.Key("EbsOptimized")
5898		ok.Boolean(*v.EbsOptimized)
5899	}
5900
5901	if v.Hostname != nil {
5902		ok := object.Key("Hostname")
5903		ok.String(*v.Hostname)
5904	}
5905
5906	if v.InstallUpdatesOnBoot != nil {
5907		ok := object.Key("InstallUpdatesOnBoot")
5908		ok.Boolean(*v.InstallUpdatesOnBoot)
5909	}
5910
5911	if v.InstanceId != nil {
5912		ok := object.Key("InstanceId")
5913		ok.String(*v.InstanceId)
5914	}
5915
5916	if v.InstanceType != nil {
5917		ok := object.Key("InstanceType")
5918		ok.String(*v.InstanceType)
5919	}
5920
5921	if v.LayerIds != nil {
5922		ok := object.Key("LayerIds")
5923		if err := awsAwsjson11_serializeDocumentStrings(v.LayerIds, ok); err != nil {
5924			return err
5925		}
5926	}
5927
5928	if v.Os != nil {
5929		ok := object.Key("Os")
5930		ok.String(*v.Os)
5931	}
5932
5933	if v.SshKeyName != nil {
5934		ok := object.Key("SshKeyName")
5935		ok.String(*v.SshKeyName)
5936	}
5937
5938	return nil
5939}
5940
5941func awsAwsjson11_serializeOpDocumentUpdateLayerInput(v *UpdateLayerInput, value smithyjson.Value) error {
5942	object := value.Object()
5943	defer object.Close()
5944
5945	if v.Attributes != nil {
5946		ok := object.Key("Attributes")
5947		if err := awsAwsjson11_serializeDocumentLayerAttributes(v.Attributes, ok); err != nil {
5948			return err
5949		}
5950	}
5951
5952	if v.AutoAssignElasticIps != nil {
5953		ok := object.Key("AutoAssignElasticIps")
5954		ok.Boolean(*v.AutoAssignElasticIps)
5955	}
5956
5957	if v.AutoAssignPublicIps != nil {
5958		ok := object.Key("AutoAssignPublicIps")
5959		ok.Boolean(*v.AutoAssignPublicIps)
5960	}
5961
5962	if v.CloudWatchLogsConfiguration != nil {
5963		ok := object.Key("CloudWatchLogsConfiguration")
5964		if err := awsAwsjson11_serializeDocumentCloudWatchLogsConfiguration(v.CloudWatchLogsConfiguration, ok); err != nil {
5965			return err
5966		}
5967	}
5968
5969	if v.CustomInstanceProfileArn != nil {
5970		ok := object.Key("CustomInstanceProfileArn")
5971		ok.String(*v.CustomInstanceProfileArn)
5972	}
5973
5974	if v.CustomJson != nil {
5975		ok := object.Key("CustomJson")
5976		ok.String(*v.CustomJson)
5977	}
5978
5979	if v.CustomRecipes != nil {
5980		ok := object.Key("CustomRecipes")
5981		if err := awsAwsjson11_serializeDocumentRecipes(v.CustomRecipes, ok); err != nil {
5982			return err
5983		}
5984	}
5985
5986	if v.CustomSecurityGroupIds != nil {
5987		ok := object.Key("CustomSecurityGroupIds")
5988		if err := awsAwsjson11_serializeDocumentStrings(v.CustomSecurityGroupIds, ok); err != nil {
5989			return err
5990		}
5991	}
5992
5993	if v.EnableAutoHealing != nil {
5994		ok := object.Key("EnableAutoHealing")
5995		ok.Boolean(*v.EnableAutoHealing)
5996	}
5997
5998	if v.InstallUpdatesOnBoot != nil {
5999		ok := object.Key("InstallUpdatesOnBoot")
6000		ok.Boolean(*v.InstallUpdatesOnBoot)
6001	}
6002
6003	if v.LayerId != nil {
6004		ok := object.Key("LayerId")
6005		ok.String(*v.LayerId)
6006	}
6007
6008	if v.LifecycleEventConfiguration != nil {
6009		ok := object.Key("LifecycleEventConfiguration")
6010		if err := awsAwsjson11_serializeDocumentLifecycleEventConfiguration(v.LifecycleEventConfiguration, ok); err != nil {
6011			return err
6012		}
6013	}
6014
6015	if v.Name != nil {
6016		ok := object.Key("Name")
6017		ok.String(*v.Name)
6018	}
6019
6020	if v.Packages != nil {
6021		ok := object.Key("Packages")
6022		if err := awsAwsjson11_serializeDocumentStrings(v.Packages, ok); err != nil {
6023			return err
6024		}
6025	}
6026
6027	if v.Shortname != nil {
6028		ok := object.Key("Shortname")
6029		ok.String(*v.Shortname)
6030	}
6031
6032	if v.UseEbsOptimizedInstances != nil {
6033		ok := object.Key("UseEbsOptimizedInstances")
6034		ok.Boolean(*v.UseEbsOptimizedInstances)
6035	}
6036
6037	if v.VolumeConfigurations != nil {
6038		ok := object.Key("VolumeConfigurations")
6039		if err := awsAwsjson11_serializeDocumentVolumeConfigurations(v.VolumeConfigurations, ok); err != nil {
6040			return err
6041		}
6042	}
6043
6044	return nil
6045}
6046
6047func awsAwsjson11_serializeOpDocumentUpdateMyUserProfileInput(v *UpdateMyUserProfileInput, value smithyjson.Value) error {
6048	object := value.Object()
6049	defer object.Close()
6050
6051	if v.SshPublicKey != nil {
6052		ok := object.Key("SshPublicKey")
6053		ok.String(*v.SshPublicKey)
6054	}
6055
6056	return nil
6057}
6058
6059func awsAwsjson11_serializeOpDocumentUpdateRdsDbInstanceInput(v *UpdateRdsDbInstanceInput, value smithyjson.Value) error {
6060	object := value.Object()
6061	defer object.Close()
6062
6063	if v.DbPassword != nil {
6064		ok := object.Key("DbPassword")
6065		ok.String(*v.DbPassword)
6066	}
6067
6068	if v.DbUser != nil {
6069		ok := object.Key("DbUser")
6070		ok.String(*v.DbUser)
6071	}
6072
6073	if v.RdsDbInstanceArn != nil {
6074		ok := object.Key("RdsDbInstanceArn")
6075		ok.String(*v.RdsDbInstanceArn)
6076	}
6077
6078	return nil
6079}
6080
6081func awsAwsjson11_serializeOpDocumentUpdateStackInput(v *UpdateStackInput, value smithyjson.Value) error {
6082	object := value.Object()
6083	defer object.Close()
6084
6085	if v.AgentVersion != nil {
6086		ok := object.Key("AgentVersion")
6087		ok.String(*v.AgentVersion)
6088	}
6089
6090	if v.Attributes != nil {
6091		ok := object.Key("Attributes")
6092		if err := awsAwsjson11_serializeDocumentStackAttributes(v.Attributes, ok); err != nil {
6093			return err
6094		}
6095	}
6096
6097	if v.ChefConfiguration != nil {
6098		ok := object.Key("ChefConfiguration")
6099		if err := awsAwsjson11_serializeDocumentChefConfiguration(v.ChefConfiguration, ok); err != nil {
6100			return err
6101		}
6102	}
6103
6104	if v.ConfigurationManager != nil {
6105		ok := object.Key("ConfigurationManager")
6106		if err := awsAwsjson11_serializeDocumentStackConfigurationManager(v.ConfigurationManager, ok); err != nil {
6107			return err
6108		}
6109	}
6110
6111	if v.CustomCookbooksSource != nil {
6112		ok := object.Key("CustomCookbooksSource")
6113		if err := awsAwsjson11_serializeDocumentSource(v.CustomCookbooksSource, ok); err != nil {
6114			return err
6115		}
6116	}
6117
6118	if v.CustomJson != nil {
6119		ok := object.Key("CustomJson")
6120		ok.String(*v.CustomJson)
6121	}
6122
6123	if v.DefaultAvailabilityZone != nil {
6124		ok := object.Key("DefaultAvailabilityZone")
6125		ok.String(*v.DefaultAvailabilityZone)
6126	}
6127
6128	if v.DefaultInstanceProfileArn != nil {
6129		ok := object.Key("DefaultInstanceProfileArn")
6130		ok.String(*v.DefaultInstanceProfileArn)
6131	}
6132
6133	if v.DefaultOs != nil {
6134		ok := object.Key("DefaultOs")
6135		ok.String(*v.DefaultOs)
6136	}
6137
6138	if len(v.DefaultRootDeviceType) > 0 {
6139		ok := object.Key("DefaultRootDeviceType")
6140		ok.String(string(v.DefaultRootDeviceType))
6141	}
6142
6143	if v.DefaultSshKeyName != nil {
6144		ok := object.Key("DefaultSshKeyName")
6145		ok.String(*v.DefaultSshKeyName)
6146	}
6147
6148	if v.DefaultSubnetId != nil {
6149		ok := object.Key("DefaultSubnetId")
6150		ok.String(*v.DefaultSubnetId)
6151	}
6152
6153	if v.HostnameTheme != nil {
6154		ok := object.Key("HostnameTheme")
6155		ok.String(*v.HostnameTheme)
6156	}
6157
6158	if v.Name != nil {
6159		ok := object.Key("Name")
6160		ok.String(*v.Name)
6161	}
6162
6163	if v.ServiceRoleArn != nil {
6164		ok := object.Key("ServiceRoleArn")
6165		ok.String(*v.ServiceRoleArn)
6166	}
6167
6168	if v.StackId != nil {
6169		ok := object.Key("StackId")
6170		ok.String(*v.StackId)
6171	}
6172
6173	if v.UseCustomCookbooks != nil {
6174		ok := object.Key("UseCustomCookbooks")
6175		ok.Boolean(*v.UseCustomCookbooks)
6176	}
6177
6178	if v.UseOpsworksSecurityGroups != nil {
6179		ok := object.Key("UseOpsworksSecurityGroups")
6180		ok.Boolean(*v.UseOpsworksSecurityGroups)
6181	}
6182
6183	return nil
6184}
6185
6186func awsAwsjson11_serializeOpDocumentUpdateUserProfileInput(v *UpdateUserProfileInput, value smithyjson.Value) error {
6187	object := value.Object()
6188	defer object.Close()
6189
6190	if v.AllowSelfManagement != nil {
6191		ok := object.Key("AllowSelfManagement")
6192		ok.Boolean(*v.AllowSelfManagement)
6193	}
6194
6195	if v.IamUserArn != nil {
6196		ok := object.Key("IamUserArn")
6197		ok.String(*v.IamUserArn)
6198	}
6199
6200	if v.SshPublicKey != nil {
6201		ok := object.Key("SshPublicKey")
6202		ok.String(*v.SshPublicKey)
6203	}
6204
6205	if v.SshUsername != nil {
6206		ok := object.Key("SshUsername")
6207		ok.String(*v.SshUsername)
6208	}
6209
6210	return nil
6211}
6212
6213func awsAwsjson11_serializeOpDocumentUpdateVolumeInput(v *UpdateVolumeInput, value smithyjson.Value) error {
6214	object := value.Object()
6215	defer object.Close()
6216
6217	if v.MountPoint != nil {
6218		ok := object.Key("MountPoint")
6219		ok.String(*v.MountPoint)
6220	}
6221
6222	if v.Name != nil {
6223		ok := object.Key("Name")
6224		ok.String(*v.Name)
6225	}
6226
6227	if v.VolumeId != nil {
6228		ok := object.Key("VolumeId")
6229		ok.String(*v.VolumeId)
6230	}
6231
6232	return nil
6233}
6234