1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package ecs
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/ecs/types"
10	smithy "github.com/aws/smithy-go"
11	"github.com/aws/smithy-go/encoding/httpbinding"
12	smithyjson "github.com/aws/smithy-go/encoding/json"
13	"github.com/aws/smithy-go/middleware"
14	smithytime "github.com/aws/smithy-go/time"
15	smithyhttp "github.com/aws/smithy-go/transport/http"
16)
17
18type awsAwsjson11_serializeOpCreateCapacityProvider struct {
19}
20
21func (*awsAwsjson11_serializeOpCreateCapacityProvider) ID() string {
22	return "OperationSerializer"
23}
24
25func (m *awsAwsjson11_serializeOpCreateCapacityProvider) 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.(*CreateCapacityProviderInput)
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("AmazonEC2ContainerServiceV20141113.CreateCapacityProvider")
47
48	jsonEncoder := smithyjson.NewEncoder()
49	if err := awsAwsjson11_serializeOpDocumentCreateCapacityProviderInput(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_serializeOpCreateCluster struct {
66}
67
68func (*awsAwsjson11_serializeOpCreateCluster) ID() string {
69	return "OperationSerializer"
70}
71
72func (m *awsAwsjson11_serializeOpCreateCluster) 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.(*CreateClusterInput)
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("AmazonEC2ContainerServiceV20141113.CreateCluster")
94
95	jsonEncoder := smithyjson.NewEncoder()
96	if err := awsAwsjson11_serializeOpDocumentCreateClusterInput(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_serializeOpCreateService struct {
113}
114
115func (*awsAwsjson11_serializeOpCreateService) ID() string {
116	return "OperationSerializer"
117}
118
119func (m *awsAwsjson11_serializeOpCreateService) 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.(*CreateServiceInput)
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("AmazonEC2ContainerServiceV20141113.CreateService")
141
142	jsonEncoder := smithyjson.NewEncoder()
143	if err := awsAwsjson11_serializeOpDocumentCreateServiceInput(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_serializeOpCreateTaskSet struct {
160}
161
162func (*awsAwsjson11_serializeOpCreateTaskSet) ID() string {
163	return "OperationSerializer"
164}
165
166func (m *awsAwsjson11_serializeOpCreateTaskSet) 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.(*CreateTaskSetInput)
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("AmazonEC2ContainerServiceV20141113.CreateTaskSet")
188
189	jsonEncoder := smithyjson.NewEncoder()
190	if err := awsAwsjson11_serializeOpDocumentCreateTaskSetInput(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_serializeOpDeleteAccountSetting struct {
207}
208
209func (*awsAwsjson11_serializeOpDeleteAccountSetting) ID() string {
210	return "OperationSerializer"
211}
212
213func (m *awsAwsjson11_serializeOpDeleteAccountSetting) 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.(*DeleteAccountSettingInput)
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("AmazonEC2ContainerServiceV20141113.DeleteAccountSetting")
235
236	jsonEncoder := smithyjson.NewEncoder()
237	if err := awsAwsjson11_serializeOpDocumentDeleteAccountSettingInput(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_serializeOpDeleteAttributes struct {
254}
255
256func (*awsAwsjson11_serializeOpDeleteAttributes) ID() string {
257	return "OperationSerializer"
258}
259
260func (m *awsAwsjson11_serializeOpDeleteAttributes) 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.(*DeleteAttributesInput)
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("AmazonEC2ContainerServiceV20141113.DeleteAttributes")
282
283	jsonEncoder := smithyjson.NewEncoder()
284	if err := awsAwsjson11_serializeOpDocumentDeleteAttributesInput(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_serializeOpDeleteCapacityProvider struct {
301}
302
303func (*awsAwsjson11_serializeOpDeleteCapacityProvider) ID() string {
304	return "OperationSerializer"
305}
306
307func (m *awsAwsjson11_serializeOpDeleteCapacityProvider) 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.(*DeleteCapacityProviderInput)
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("AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider")
329
330	jsonEncoder := smithyjson.NewEncoder()
331	if err := awsAwsjson11_serializeOpDocumentDeleteCapacityProviderInput(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_serializeOpDeleteCluster struct {
348}
349
350func (*awsAwsjson11_serializeOpDeleteCluster) ID() string {
351	return "OperationSerializer"
352}
353
354func (m *awsAwsjson11_serializeOpDeleteCluster) 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.(*DeleteClusterInput)
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("AmazonEC2ContainerServiceV20141113.DeleteCluster")
376
377	jsonEncoder := smithyjson.NewEncoder()
378	if err := awsAwsjson11_serializeOpDocumentDeleteClusterInput(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_serializeOpDeleteService struct {
395}
396
397func (*awsAwsjson11_serializeOpDeleteService) ID() string {
398	return "OperationSerializer"
399}
400
401func (m *awsAwsjson11_serializeOpDeleteService) 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.(*DeleteServiceInput)
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("AmazonEC2ContainerServiceV20141113.DeleteService")
423
424	jsonEncoder := smithyjson.NewEncoder()
425	if err := awsAwsjson11_serializeOpDocumentDeleteServiceInput(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_serializeOpDeleteTaskSet struct {
442}
443
444func (*awsAwsjson11_serializeOpDeleteTaskSet) ID() string {
445	return "OperationSerializer"
446}
447
448func (m *awsAwsjson11_serializeOpDeleteTaskSet) 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.(*DeleteTaskSetInput)
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("AmazonEC2ContainerServiceV20141113.DeleteTaskSet")
470
471	jsonEncoder := smithyjson.NewEncoder()
472	if err := awsAwsjson11_serializeOpDocumentDeleteTaskSetInput(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_serializeOpDeregisterContainerInstance struct {
489}
490
491func (*awsAwsjson11_serializeOpDeregisterContainerInstance) ID() string {
492	return "OperationSerializer"
493}
494
495func (m *awsAwsjson11_serializeOpDeregisterContainerInstance) 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.(*DeregisterContainerInstanceInput)
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("AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance")
517
518	jsonEncoder := smithyjson.NewEncoder()
519	if err := awsAwsjson11_serializeOpDocumentDeregisterContainerInstanceInput(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_serializeOpDeregisterTaskDefinition struct {
536}
537
538func (*awsAwsjson11_serializeOpDeregisterTaskDefinition) ID() string {
539	return "OperationSerializer"
540}
541
542func (m *awsAwsjson11_serializeOpDeregisterTaskDefinition) 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.(*DeregisterTaskDefinitionInput)
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("AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition")
564
565	jsonEncoder := smithyjson.NewEncoder()
566	if err := awsAwsjson11_serializeOpDocumentDeregisterTaskDefinitionInput(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_serializeOpDescribeCapacityProviders struct {
583}
584
585func (*awsAwsjson11_serializeOpDescribeCapacityProviders) ID() string {
586	return "OperationSerializer"
587}
588
589func (m *awsAwsjson11_serializeOpDescribeCapacityProviders) 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.(*DescribeCapacityProvidersInput)
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("AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders")
611
612	jsonEncoder := smithyjson.NewEncoder()
613	if err := awsAwsjson11_serializeOpDocumentDescribeCapacityProvidersInput(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_serializeOpDescribeClusters struct {
630}
631
632func (*awsAwsjson11_serializeOpDescribeClusters) ID() string {
633	return "OperationSerializer"
634}
635
636func (m *awsAwsjson11_serializeOpDescribeClusters) 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.(*DescribeClustersInput)
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("AmazonEC2ContainerServiceV20141113.DescribeClusters")
658
659	jsonEncoder := smithyjson.NewEncoder()
660	if err := awsAwsjson11_serializeOpDocumentDescribeClustersInput(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_serializeOpDescribeContainerInstances struct {
677}
678
679func (*awsAwsjson11_serializeOpDescribeContainerInstances) ID() string {
680	return "OperationSerializer"
681}
682
683func (m *awsAwsjson11_serializeOpDescribeContainerInstances) 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.(*DescribeContainerInstancesInput)
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("AmazonEC2ContainerServiceV20141113.DescribeContainerInstances")
705
706	jsonEncoder := smithyjson.NewEncoder()
707	if err := awsAwsjson11_serializeOpDocumentDescribeContainerInstancesInput(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_serializeOpDescribeServices struct {
724}
725
726func (*awsAwsjson11_serializeOpDescribeServices) ID() string {
727	return "OperationSerializer"
728}
729
730func (m *awsAwsjson11_serializeOpDescribeServices) 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.(*DescribeServicesInput)
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("AmazonEC2ContainerServiceV20141113.DescribeServices")
752
753	jsonEncoder := smithyjson.NewEncoder()
754	if err := awsAwsjson11_serializeOpDocumentDescribeServicesInput(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_serializeOpDescribeTaskDefinition struct {
771}
772
773func (*awsAwsjson11_serializeOpDescribeTaskDefinition) ID() string {
774	return "OperationSerializer"
775}
776
777func (m *awsAwsjson11_serializeOpDescribeTaskDefinition) 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.(*DescribeTaskDefinitionInput)
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("AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition")
799
800	jsonEncoder := smithyjson.NewEncoder()
801	if err := awsAwsjson11_serializeOpDocumentDescribeTaskDefinitionInput(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_serializeOpDescribeTasks struct {
818}
819
820func (*awsAwsjson11_serializeOpDescribeTasks) ID() string {
821	return "OperationSerializer"
822}
823
824func (m *awsAwsjson11_serializeOpDescribeTasks) 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.(*DescribeTasksInput)
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("AmazonEC2ContainerServiceV20141113.DescribeTasks")
846
847	jsonEncoder := smithyjson.NewEncoder()
848	if err := awsAwsjson11_serializeOpDocumentDescribeTasksInput(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_serializeOpDescribeTaskSets struct {
865}
866
867func (*awsAwsjson11_serializeOpDescribeTaskSets) ID() string {
868	return "OperationSerializer"
869}
870
871func (m *awsAwsjson11_serializeOpDescribeTaskSets) 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.(*DescribeTaskSetsInput)
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("AmazonEC2ContainerServiceV20141113.DescribeTaskSets")
893
894	jsonEncoder := smithyjson.NewEncoder()
895	if err := awsAwsjson11_serializeOpDocumentDescribeTaskSetsInput(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_serializeOpDiscoverPollEndpoint struct {
912}
913
914func (*awsAwsjson11_serializeOpDiscoverPollEndpoint) ID() string {
915	return "OperationSerializer"
916}
917
918func (m *awsAwsjson11_serializeOpDiscoverPollEndpoint) 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.(*DiscoverPollEndpointInput)
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("AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint")
940
941	jsonEncoder := smithyjson.NewEncoder()
942	if err := awsAwsjson11_serializeOpDocumentDiscoverPollEndpointInput(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_serializeOpListAccountSettings struct {
959}
960
961func (*awsAwsjson11_serializeOpListAccountSettings) ID() string {
962	return "OperationSerializer"
963}
964
965func (m *awsAwsjson11_serializeOpListAccountSettings) 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.(*ListAccountSettingsInput)
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("AmazonEC2ContainerServiceV20141113.ListAccountSettings")
987
988	jsonEncoder := smithyjson.NewEncoder()
989	if err := awsAwsjson11_serializeOpDocumentListAccountSettingsInput(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_serializeOpListAttributes struct {
1006}
1007
1008func (*awsAwsjson11_serializeOpListAttributes) ID() string {
1009	return "OperationSerializer"
1010}
1011
1012func (m *awsAwsjson11_serializeOpListAttributes) 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.(*ListAttributesInput)
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("AmazonEC2ContainerServiceV20141113.ListAttributes")
1034
1035	jsonEncoder := smithyjson.NewEncoder()
1036	if err := awsAwsjson11_serializeOpDocumentListAttributesInput(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_serializeOpListClusters struct {
1053}
1054
1055func (*awsAwsjson11_serializeOpListClusters) ID() string {
1056	return "OperationSerializer"
1057}
1058
1059func (m *awsAwsjson11_serializeOpListClusters) 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.(*ListClustersInput)
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("AmazonEC2ContainerServiceV20141113.ListClusters")
1081
1082	jsonEncoder := smithyjson.NewEncoder()
1083	if err := awsAwsjson11_serializeOpDocumentListClustersInput(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_serializeOpListContainerInstances struct {
1100}
1101
1102func (*awsAwsjson11_serializeOpListContainerInstances) ID() string {
1103	return "OperationSerializer"
1104}
1105
1106func (m *awsAwsjson11_serializeOpListContainerInstances) 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.(*ListContainerInstancesInput)
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("AmazonEC2ContainerServiceV20141113.ListContainerInstances")
1128
1129	jsonEncoder := smithyjson.NewEncoder()
1130	if err := awsAwsjson11_serializeOpDocumentListContainerInstancesInput(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_serializeOpListServices struct {
1147}
1148
1149func (*awsAwsjson11_serializeOpListServices) ID() string {
1150	return "OperationSerializer"
1151}
1152
1153func (m *awsAwsjson11_serializeOpListServices) 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.(*ListServicesInput)
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("AmazonEC2ContainerServiceV20141113.ListServices")
1175
1176	jsonEncoder := smithyjson.NewEncoder()
1177	if err := awsAwsjson11_serializeOpDocumentListServicesInput(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_serializeOpListTagsForResource struct {
1194}
1195
1196func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
1197	return "OperationSerializer"
1198}
1199
1200func (m *awsAwsjson11_serializeOpListTagsForResource) 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.(*ListTagsForResourceInput)
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("AmazonEC2ContainerServiceV20141113.ListTagsForResource")
1222
1223	jsonEncoder := smithyjson.NewEncoder()
1224	if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(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_serializeOpListTaskDefinitionFamilies struct {
1241}
1242
1243func (*awsAwsjson11_serializeOpListTaskDefinitionFamilies) ID() string {
1244	return "OperationSerializer"
1245}
1246
1247func (m *awsAwsjson11_serializeOpListTaskDefinitionFamilies) 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.(*ListTaskDefinitionFamiliesInput)
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("AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies")
1269
1270	jsonEncoder := smithyjson.NewEncoder()
1271	if err := awsAwsjson11_serializeOpDocumentListTaskDefinitionFamiliesInput(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_serializeOpListTaskDefinitions struct {
1288}
1289
1290func (*awsAwsjson11_serializeOpListTaskDefinitions) ID() string {
1291	return "OperationSerializer"
1292}
1293
1294func (m *awsAwsjson11_serializeOpListTaskDefinitions) 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.(*ListTaskDefinitionsInput)
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("AmazonEC2ContainerServiceV20141113.ListTaskDefinitions")
1316
1317	jsonEncoder := smithyjson.NewEncoder()
1318	if err := awsAwsjson11_serializeOpDocumentListTaskDefinitionsInput(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_serializeOpListTasks struct {
1335}
1336
1337func (*awsAwsjson11_serializeOpListTasks) ID() string {
1338	return "OperationSerializer"
1339}
1340
1341func (m *awsAwsjson11_serializeOpListTasks) 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.(*ListTasksInput)
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("AmazonEC2ContainerServiceV20141113.ListTasks")
1363
1364	jsonEncoder := smithyjson.NewEncoder()
1365	if err := awsAwsjson11_serializeOpDocumentListTasksInput(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_serializeOpPutAccountSetting struct {
1382}
1383
1384func (*awsAwsjson11_serializeOpPutAccountSetting) ID() string {
1385	return "OperationSerializer"
1386}
1387
1388func (m *awsAwsjson11_serializeOpPutAccountSetting) 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.(*PutAccountSettingInput)
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("AmazonEC2ContainerServiceV20141113.PutAccountSetting")
1410
1411	jsonEncoder := smithyjson.NewEncoder()
1412	if err := awsAwsjson11_serializeOpDocumentPutAccountSettingInput(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_serializeOpPutAccountSettingDefault struct {
1429}
1430
1431func (*awsAwsjson11_serializeOpPutAccountSettingDefault) ID() string {
1432	return "OperationSerializer"
1433}
1434
1435func (m *awsAwsjson11_serializeOpPutAccountSettingDefault) 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.(*PutAccountSettingDefaultInput)
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("AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault")
1457
1458	jsonEncoder := smithyjson.NewEncoder()
1459	if err := awsAwsjson11_serializeOpDocumentPutAccountSettingDefaultInput(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_serializeOpPutAttributes struct {
1476}
1477
1478func (*awsAwsjson11_serializeOpPutAttributes) ID() string {
1479	return "OperationSerializer"
1480}
1481
1482func (m *awsAwsjson11_serializeOpPutAttributes) 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.(*PutAttributesInput)
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("AmazonEC2ContainerServiceV20141113.PutAttributes")
1504
1505	jsonEncoder := smithyjson.NewEncoder()
1506	if err := awsAwsjson11_serializeOpDocumentPutAttributesInput(input, jsonEncoder.Value); err != nil {
1507		return out, metadata, &smithy.SerializationError{Err: err}
1508	}
1509
1510	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1511		return out, metadata, &smithy.SerializationError{Err: err}
1512	}
1513
1514	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1515		return out, metadata, &smithy.SerializationError{Err: err}
1516	}
1517	in.Request = request
1518
1519	return next.HandleSerialize(ctx, in)
1520}
1521
1522type awsAwsjson11_serializeOpPutClusterCapacityProviders struct {
1523}
1524
1525func (*awsAwsjson11_serializeOpPutClusterCapacityProviders) ID() string {
1526	return "OperationSerializer"
1527}
1528
1529func (m *awsAwsjson11_serializeOpPutClusterCapacityProviders) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1530	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1531) {
1532	request, ok := in.Request.(*smithyhttp.Request)
1533	if !ok {
1534		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1535	}
1536
1537	input, ok := in.Parameters.(*PutClusterCapacityProvidersInput)
1538	_ = input
1539	if !ok {
1540		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1541	}
1542
1543	request.Request.URL.Path = "/"
1544	request.Request.Method = "POST"
1545	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1546	if err != nil {
1547		return out, metadata, &smithy.SerializationError{Err: err}
1548	}
1549	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1550	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders")
1551
1552	jsonEncoder := smithyjson.NewEncoder()
1553	if err := awsAwsjson11_serializeOpDocumentPutClusterCapacityProvidersInput(input, jsonEncoder.Value); err != nil {
1554		return out, metadata, &smithy.SerializationError{Err: err}
1555	}
1556
1557	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1558		return out, metadata, &smithy.SerializationError{Err: err}
1559	}
1560
1561	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1562		return out, metadata, &smithy.SerializationError{Err: err}
1563	}
1564	in.Request = request
1565
1566	return next.HandleSerialize(ctx, in)
1567}
1568
1569type awsAwsjson11_serializeOpRegisterContainerInstance struct {
1570}
1571
1572func (*awsAwsjson11_serializeOpRegisterContainerInstance) ID() string {
1573	return "OperationSerializer"
1574}
1575
1576func (m *awsAwsjson11_serializeOpRegisterContainerInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1577	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1578) {
1579	request, ok := in.Request.(*smithyhttp.Request)
1580	if !ok {
1581		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1582	}
1583
1584	input, ok := in.Parameters.(*RegisterContainerInstanceInput)
1585	_ = input
1586	if !ok {
1587		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1588	}
1589
1590	request.Request.URL.Path = "/"
1591	request.Request.Method = "POST"
1592	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1593	if err != nil {
1594		return out, metadata, &smithy.SerializationError{Err: err}
1595	}
1596	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1597	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.RegisterContainerInstance")
1598
1599	jsonEncoder := smithyjson.NewEncoder()
1600	if err := awsAwsjson11_serializeOpDocumentRegisterContainerInstanceInput(input, jsonEncoder.Value); err != nil {
1601		return out, metadata, &smithy.SerializationError{Err: err}
1602	}
1603
1604	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1605		return out, metadata, &smithy.SerializationError{Err: err}
1606	}
1607
1608	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1609		return out, metadata, &smithy.SerializationError{Err: err}
1610	}
1611	in.Request = request
1612
1613	return next.HandleSerialize(ctx, in)
1614}
1615
1616type awsAwsjson11_serializeOpRegisterTaskDefinition struct {
1617}
1618
1619func (*awsAwsjson11_serializeOpRegisterTaskDefinition) ID() string {
1620	return "OperationSerializer"
1621}
1622
1623func (m *awsAwsjson11_serializeOpRegisterTaskDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1624	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1625) {
1626	request, ok := in.Request.(*smithyhttp.Request)
1627	if !ok {
1628		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1629	}
1630
1631	input, ok := in.Parameters.(*RegisterTaskDefinitionInput)
1632	_ = input
1633	if !ok {
1634		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1635	}
1636
1637	request.Request.URL.Path = "/"
1638	request.Request.Method = "POST"
1639	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1640	if err != nil {
1641		return out, metadata, &smithy.SerializationError{Err: err}
1642	}
1643	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1644	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition")
1645
1646	jsonEncoder := smithyjson.NewEncoder()
1647	if err := awsAwsjson11_serializeOpDocumentRegisterTaskDefinitionInput(input, jsonEncoder.Value); err != nil {
1648		return out, metadata, &smithy.SerializationError{Err: err}
1649	}
1650
1651	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1652		return out, metadata, &smithy.SerializationError{Err: err}
1653	}
1654
1655	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1656		return out, metadata, &smithy.SerializationError{Err: err}
1657	}
1658	in.Request = request
1659
1660	return next.HandleSerialize(ctx, in)
1661}
1662
1663type awsAwsjson11_serializeOpRunTask struct {
1664}
1665
1666func (*awsAwsjson11_serializeOpRunTask) ID() string {
1667	return "OperationSerializer"
1668}
1669
1670func (m *awsAwsjson11_serializeOpRunTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1671	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1672) {
1673	request, ok := in.Request.(*smithyhttp.Request)
1674	if !ok {
1675		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1676	}
1677
1678	input, ok := in.Parameters.(*RunTaskInput)
1679	_ = input
1680	if !ok {
1681		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1682	}
1683
1684	request.Request.URL.Path = "/"
1685	request.Request.Method = "POST"
1686	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1687	if err != nil {
1688		return out, metadata, &smithy.SerializationError{Err: err}
1689	}
1690	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1691	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.RunTask")
1692
1693	jsonEncoder := smithyjson.NewEncoder()
1694	if err := awsAwsjson11_serializeOpDocumentRunTaskInput(input, jsonEncoder.Value); err != nil {
1695		return out, metadata, &smithy.SerializationError{Err: err}
1696	}
1697
1698	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1699		return out, metadata, &smithy.SerializationError{Err: err}
1700	}
1701
1702	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1703		return out, metadata, &smithy.SerializationError{Err: err}
1704	}
1705	in.Request = request
1706
1707	return next.HandleSerialize(ctx, in)
1708}
1709
1710type awsAwsjson11_serializeOpStartTask struct {
1711}
1712
1713func (*awsAwsjson11_serializeOpStartTask) ID() string {
1714	return "OperationSerializer"
1715}
1716
1717func (m *awsAwsjson11_serializeOpStartTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1718	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1719) {
1720	request, ok := in.Request.(*smithyhttp.Request)
1721	if !ok {
1722		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1723	}
1724
1725	input, ok := in.Parameters.(*StartTaskInput)
1726	_ = input
1727	if !ok {
1728		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1729	}
1730
1731	request.Request.URL.Path = "/"
1732	request.Request.Method = "POST"
1733	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1734	if err != nil {
1735		return out, metadata, &smithy.SerializationError{Err: err}
1736	}
1737	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1738	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.StartTask")
1739
1740	jsonEncoder := smithyjson.NewEncoder()
1741	if err := awsAwsjson11_serializeOpDocumentStartTaskInput(input, jsonEncoder.Value); err != nil {
1742		return out, metadata, &smithy.SerializationError{Err: err}
1743	}
1744
1745	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1746		return out, metadata, &smithy.SerializationError{Err: err}
1747	}
1748
1749	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1750		return out, metadata, &smithy.SerializationError{Err: err}
1751	}
1752	in.Request = request
1753
1754	return next.HandleSerialize(ctx, in)
1755}
1756
1757type awsAwsjson11_serializeOpStopTask struct {
1758}
1759
1760func (*awsAwsjson11_serializeOpStopTask) ID() string {
1761	return "OperationSerializer"
1762}
1763
1764func (m *awsAwsjson11_serializeOpStopTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1765	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1766) {
1767	request, ok := in.Request.(*smithyhttp.Request)
1768	if !ok {
1769		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1770	}
1771
1772	input, ok := in.Parameters.(*StopTaskInput)
1773	_ = input
1774	if !ok {
1775		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1776	}
1777
1778	request.Request.URL.Path = "/"
1779	request.Request.Method = "POST"
1780	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1781	if err != nil {
1782		return out, metadata, &smithy.SerializationError{Err: err}
1783	}
1784	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1785	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.StopTask")
1786
1787	jsonEncoder := smithyjson.NewEncoder()
1788	if err := awsAwsjson11_serializeOpDocumentStopTaskInput(input, jsonEncoder.Value); err != nil {
1789		return out, metadata, &smithy.SerializationError{Err: err}
1790	}
1791
1792	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1793		return out, metadata, &smithy.SerializationError{Err: err}
1794	}
1795
1796	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1797		return out, metadata, &smithy.SerializationError{Err: err}
1798	}
1799	in.Request = request
1800
1801	return next.HandleSerialize(ctx, in)
1802}
1803
1804type awsAwsjson11_serializeOpSubmitAttachmentStateChanges struct {
1805}
1806
1807func (*awsAwsjson11_serializeOpSubmitAttachmentStateChanges) ID() string {
1808	return "OperationSerializer"
1809}
1810
1811func (m *awsAwsjson11_serializeOpSubmitAttachmentStateChanges) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1812	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1813) {
1814	request, ok := in.Request.(*smithyhttp.Request)
1815	if !ok {
1816		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1817	}
1818
1819	input, ok := in.Parameters.(*SubmitAttachmentStateChangesInput)
1820	_ = input
1821	if !ok {
1822		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1823	}
1824
1825	request.Request.URL.Path = "/"
1826	request.Request.Method = "POST"
1827	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1828	if err != nil {
1829		return out, metadata, &smithy.SerializationError{Err: err}
1830	}
1831	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1832	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges")
1833
1834	jsonEncoder := smithyjson.NewEncoder()
1835	if err := awsAwsjson11_serializeOpDocumentSubmitAttachmentStateChangesInput(input, jsonEncoder.Value); err != nil {
1836		return out, metadata, &smithy.SerializationError{Err: err}
1837	}
1838
1839	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1840		return out, metadata, &smithy.SerializationError{Err: err}
1841	}
1842
1843	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1844		return out, metadata, &smithy.SerializationError{Err: err}
1845	}
1846	in.Request = request
1847
1848	return next.HandleSerialize(ctx, in)
1849}
1850
1851type awsAwsjson11_serializeOpSubmitContainerStateChange struct {
1852}
1853
1854func (*awsAwsjson11_serializeOpSubmitContainerStateChange) ID() string {
1855	return "OperationSerializer"
1856}
1857
1858func (m *awsAwsjson11_serializeOpSubmitContainerStateChange) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1859	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1860) {
1861	request, ok := in.Request.(*smithyhttp.Request)
1862	if !ok {
1863		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1864	}
1865
1866	input, ok := in.Parameters.(*SubmitContainerStateChangeInput)
1867	_ = input
1868	if !ok {
1869		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1870	}
1871
1872	request.Request.URL.Path = "/"
1873	request.Request.Method = "POST"
1874	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1875	if err != nil {
1876		return out, metadata, &smithy.SerializationError{Err: err}
1877	}
1878	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1879	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange")
1880
1881	jsonEncoder := smithyjson.NewEncoder()
1882	if err := awsAwsjson11_serializeOpDocumentSubmitContainerStateChangeInput(input, jsonEncoder.Value); err != nil {
1883		return out, metadata, &smithy.SerializationError{Err: err}
1884	}
1885
1886	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1887		return out, metadata, &smithy.SerializationError{Err: err}
1888	}
1889
1890	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1891		return out, metadata, &smithy.SerializationError{Err: err}
1892	}
1893	in.Request = request
1894
1895	return next.HandleSerialize(ctx, in)
1896}
1897
1898type awsAwsjson11_serializeOpSubmitTaskStateChange struct {
1899}
1900
1901func (*awsAwsjson11_serializeOpSubmitTaskStateChange) ID() string {
1902	return "OperationSerializer"
1903}
1904
1905func (m *awsAwsjson11_serializeOpSubmitTaskStateChange) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1906	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1907) {
1908	request, ok := in.Request.(*smithyhttp.Request)
1909	if !ok {
1910		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1911	}
1912
1913	input, ok := in.Parameters.(*SubmitTaskStateChangeInput)
1914	_ = input
1915	if !ok {
1916		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1917	}
1918
1919	request.Request.URL.Path = "/"
1920	request.Request.Method = "POST"
1921	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1922	if err != nil {
1923		return out, metadata, &smithy.SerializationError{Err: err}
1924	}
1925	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1926	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange")
1927
1928	jsonEncoder := smithyjson.NewEncoder()
1929	if err := awsAwsjson11_serializeOpDocumentSubmitTaskStateChangeInput(input, jsonEncoder.Value); err != nil {
1930		return out, metadata, &smithy.SerializationError{Err: err}
1931	}
1932
1933	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1934		return out, metadata, &smithy.SerializationError{Err: err}
1935	}
1936
1937	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1938		return out, metadata, &smithy.SerializationError{Err: err}
1939	}
1940	in.Request = request
1941
1942	return next.HandleSerialize(ctx, in)
1943}
1944
1945type awsAwsjson11_serializeOpTagResource struct {
1946}
1947
1948func (*awsAwsjson11_serializeOpTagResource) ID() string {
1949	return "OperationSerializer"
1950}
1951
1952func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1953	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1954) {
1955	request, ok := in.Request.(*smithyhttp.Request)
1956	if !ok {
1957		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1958	}
1959
1960	input, ok := in.Parameters.(*TagResourceInput)
1961	_ = input
1962	if !ok {
1963		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1964	}
1965
1966	request.Request.URL.Path = "/"
1967	request.Request.Method = "POST"
1968	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1969	if err != nil {
1970		return out, metadata, &smithy.SerializationError{Err: err}
1971	}
1972	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1973	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.TagResource")
1974
1975	jsonEncoder := smithyjson.NewEncoder()
1976	if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
1977		return out, metadata, &smithy.SerializationError{Err: err}
1978	}
1979
1980	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1981		return out, metadata, &smithy.SerializationError{Err: err}
1982	}
1983
1984	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1985		return out, metadata, &smithy.SerializationError{Err: err}
1986	}
1987	in.Request = request
1988
1989	return next.HandleSerialize(ctx, in)
1990}
1991
1992type awsAwsjson11_serializeOpUntagResource struct {
1993}
1994
1995func (*awsAwsjson11_serializeOpUntagResource) ID() string {
1996	return "OperationSerializer"
1997}
1998
1999func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2000	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2001) {
2002	request, ok := in.Request.(*smithyhttp.Request)
2003	if !ok {
2004		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2005	}
2006
2007	input, ok := in.Parameters.(*UntagResourceInput)
2008	_ = input
2009	if !ok {
2010		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2011	}
2012
2013	request.Request.URL.Path = "/"
2014	request.Request.Method = "POST"
2015	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2016	if err != nil {
2017		return out, metadata, &smithy.SerializationError{Err: err}
2018	}
2019	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2020	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UntagResource")
2021
2022	jsonEncoder := smithyjson.NewEncoder()
2023	if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
2024		return out, metadata, &smithy.SerializationError{Err: err}
2025	}
2026
2027	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2028		return out, metadata, &smithy.SerializationError{Err: err}
2029	}
2030
2031	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2032		return out, metadata, &smithy.SerializationError{Err: err}
2033	}
2034	in.Request = request
2035
2036	return next.HandleSerialize(ctx, in)
2037}
2038
2039type awsAwsjson11_serializeOpUpdateCapacityProvider struct {
2040}
2041
2042func (*awsAwsjson11_serializeOpUpdateCapacityProvider) ID() string {
2043	return "OperationSerializer"
2044}
2045
2046func (m *awsAwsjson11_serializeOpUpdateCapacityProvider) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2047	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2048) {
2049	request, ok := in.Request.(*smithyhttp.Request)
2050	if !ok {
2051		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2052	}
2053
2054	input, ok := in.Parameters.(*UpdateCapacityProviderInput)
2055	_ = input
2056	if !ok {
2057		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2058	}
2059
2060	request.Request.URL.Path = "/"
2061	request.Request.Method = "POST"
2062	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2063	if err != nil {
2064		return out, metadata, &smithy.SerializationError{Err: err}
2065	}
2066	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2067	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider")
2068
2069	jsonEncoder := smithyjson.NewEncoder()
2070	if err := awsAwsjson11_serializeOpDocumentUpdateCapacityProviderInput(input, jsonEncoder.Value); err != nil {
2071		return out, metadata, &smithy.SerializationError{Err: err}
2072	}
2073
2074	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2075		return out, metadata, &smithy.SerializationError{Err: err}
2076	}
2077
2078	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2079		return out, metadata, &smithy.SerializationError{Err: err}
2080	}
2081	in.Request = request
2082
2083	return next.HandleSerialize(ctx, in)
2084}
2085
2086type awsAwsjson11_serializeOpUpdateClusterSettings struct {
2087}
2088
2089func (*awsAwsjson11_serializeOpUpdateClusterSettings) ID() string {
2090	return "OperationSerializer"
2091}
2092
2093func (m *awsAwsjson11_serializeOpUpdateClusterSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2094	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2095) {
2096	request, ok := in.Request.(*smithyhttp.Request)
2097	if !ok {
2098		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2099	}
2100
2101	input, ok := in.Parameters.(*UpdateClusterSettingsInput)
2102	_ = input
2103	if !ok {
2104		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2105	}
2106
2107	request.Request.URL.Path = "/"
2108	request.Request.Method = "POST"
2109	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2110	if err != nil {
2111		return out, metadata, &smithy.SerializationError{Err: err}
2112	}
2113	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2114	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateClusterSettings")
2115
2116	jsonEncoder := smithyjson.NewEncoder()
2117	if err := awsAwsjson11_serializeOpDocumentUpdateClusterSettingsInput(input, jsonEncoder.Value); err != nil {
2118		return out, metadata, &smithy.SerializationError{Err: err}
2119	}
2120
2121	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2122		return out, metadata, &smithy.SerializationError{Err: err}
2123	}
2124
2125	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2126		return out, metadata, &smithy.SerializationError{Err: err}
2127	}
2128	in.Request = request
2129
2130	return next.HandleSerialize(ctx, in)
2131}
2132
2133type awsAwsjson11_serializeOpUpdateContainerAgent struct {
2134}
2135
2136func (*awsAwsjson11_serializeOpUpdateContainerAgent) ID() string {
2137	return "OperationSerializer"
2138}
2139
2140func (m *awsAwsjson11_serializeOpUpdateContainerAgent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2141	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2142) {
2143	request, ok := in.Request.(*smithyhttp.Request)
2144	if !ok {
2145		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2146	}
2147
2148	input, ok := in.Parameters.(*UpdateContainerAgentInput)
2149	_ = input
2150	if !ok {
2151		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2152	}
2153
2154	request.Request.URL.Path = "/"
2155	request.Request.Method = "POST"
2156	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2157	if err != nil {
2158		return out, metadata, &smithy.SerializationError{Err: err}
2159	}
2160	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2161	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateContainerAgent")
2162
2163	jsonEncoder := smithyjson.NewEncoder()
2164	if err := awsAwsjson11_serializeOpDocumentUpdateContainerAgentInput(input, jsonEncoder.Value); err != nil {
2165		return out, metadata, &smithy.SerializationError{Err: err}
2166	}
2167
2168	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2169		return out, metadata, &smithy.SerializationError{Err: err}
2170	}
2171
2172	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2173		return out, metadata, &smithy.SerializationError{Err: err}
2174	}
2175	in.Request = request
2176
2177	return next.HandleSerialize(ctx, in)
2178}
2179
2180type awsAwsjson11_serializeOpUpdateContainerInstancesState struct {
2181}
2182
2183func (*awsAwsjson11_serializeOpUpdateContainerInstancesState) ID() string {
2184	return "OperationSerializer"
2185}
2186
2187func (m *awsAwsjson11_serializeOpUpdateContainerInstancesState) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2188	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2189) {
2190	request, ok := in.Request.(*smithyhttp.Request)
2191	if !ok {
2192		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2193	}
2194
2195	input, ok := in.Parameters.(*UpdateContainerInstancesStateInput)
2196	_ = input
2197	if !ok {
2198		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2199	}
2200
2201	request.Request.URL.Path = "/"
2202	request.Request.Method = "POST"
2203	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2204	if err != nil {
2205		return out, metadata, &smithy.SerializationError{Err: err}
2206	}
2207	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2208	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState")
2209
2210	jsonEncoder := smithyjson.NewEncoder()
2211	if err := awsAwsjson11_serializeOpDocumentUpdateContainerInstancesStateInput(input, jsonEncoder.Value); err != nil {
2212		return out, metadata, &smithy.SerializationError{Err: err}
2213	}
2214
2215	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2216		return out, metadata, &smithy.SerializationError{Err: err}
2217	}
2218
2219	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2220		return out, metadata, &smithy.SerializationError{Err: err}
2221	}
2222	in.Request = request
2223
2224	return next.HandleSerialize(ctx, in)
2225}
2226
2227type awsAwsjson11_serializeOpUpdateService struct {
2228}
2229
2230func (*awsAwsjson11_serializeOpUpdateService) ID() string {
2231	return "OperationSerializer"
2232}
2233
2234func (m *awsAwsjson11_serializeOpUpdateService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2235	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2236) {
2237	request, ok := in.Request.(*smithyhttp.Request)
2238	if !ok {
2239		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2240	}
2241
2242	input, ok := in.Parameters.(*UpdateServiceInput)
2243	_ = input
2244	if !ok {
2245		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2246	}
2247
2248	request.Request.URL.Path = "/"
2249	request.Request.Method = "POST"
2250	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2251	if err != nil {
2252		return out, metadata, &smithy.SerializationError{Err: err}
2253	}
2254	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2255	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateService")
2256
2257	jsonEncoder := smithyjson.NewEncoder()
2258	if err := awsAwsjson11_serializeOpDocumentUpdateServiceInput(input, jsonEncoder.Value); err != nil {
2259		return out, metadata, &smithy.SerializationError{Err: err}
2260	}
2261
2262	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2263		return out, metadata, &smithy.SerializationError{Err: err}
2264	}
2265
2266	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2267		return out, metadata, &smithy.SerializationError{Err: err}
2268	}
2269	in.Request = request
2270
2271	return next.HandleSerialize(ctx, in)
2272}
2273
2274type awsAwsjson11_serializeOpUpdateServicePrimaryTaskSet struct {
2275}
2276
2277func (*awsAwsjson11_serializeOpUpdateServicePrimaryTaskSet) ID() string {
2278	return "OperationSerializer"
2279}
2280
2281func (m *awsAwsjson11_serializeOpUpdateServicePrimaryTaskSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2282	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2283) {
2284	request, ok := in.Request.(*smithyhttp.Request)
2285	if !ok {
2286		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2287	}
2288
2289	input, ok := in.Parameters.(*UpdateServicePrimaryTaskSetInput)
2290	_ = input
2291	if !ok {
2292		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2293	}
2294
2295	request.Request.URL.Path = "/"
2296	request.Request.Method = "POST"
2297	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2298	if err != nil {
2299		return out, metadata, &smithy.SerializationError{Err: err}
2300	}
2301	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2302	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet")
2303
2304	jsonEncoder := smithyjson.NewEncoder()
2305	if err := awsAwsjson11_serializeOpDocumentUpdateServicePrimaryTaskSetInput(input, jsonEncoder.Value); err != nil {
2306		return out, metadata, &smithy.SerializationError{Err: err}
2307	}
2308
2309	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2310		return out, metadata, &smithy.SerializationError{Err: err}
2311	}
2312
2313	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2314		return out, metadata, &smithy.SerializationError{Err: err}
2315	}
2316	in.Request = request
2317
2318	return next.HandleSerialize(ctx, in)
2319}
2320
2321type awsAwsjson11_serializeOpUpdateTaskSet struct {
2322}
2323
2324func (*awsAwsjson11_serializeOpUpdateTaskSet) ID() string {
2325	return "OperationSerializer"
2326}
2327
2328func (m *awsAwsjson11_serializeOpUpdateTaskSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2329	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2330) {
2331	request, ok := in.Request.(*smithyhttp.Request)
2332	if !ok {
2333		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2334	}
2335
2336	input, ok := in.Parameters.(*UpdateTaskSetInput)
2337	_ = input
2338	if !ok {
2339		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2340	}
2341
2342	request.Request.URL.Path = "/"
2343	request.Request.Method = "POST"
2344	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2345	if err != nil {
2346		return out, metadata, &smithy.SerializationError{Err: err}
2347	}
2348	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2349	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateTaskSet")
2350
2351	jsonEncoder := smithyjson.NewEncoder()
2352	if err := awsAwsjson11_serializeOpDocumentUpdateTaskSetInput(input, jsonEncoder.Value); err != nil {
2353		return out, metadata, &smithy.SerializationError{Err: err}
2354	}
2355
2356	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2357		return out, metadata, &smithy.SerializationError{Err: err}
2358	}
2359
2360	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2361		return out, metadata, &smithy.SerializationError{Err: err}
2362	}
2363	in.Request = request
2364
2365	return next.HandleSerialize(ctx, in)
2366}
2367func awsAwsjson11_serializeDocumentAttachmentStateChange(v *types.AttachmentStateChange, value smithyjson.Value) error {
2368	object := value.Object()
2369	defer object.Close()
2370
2371	if v.AttachmentArn != nil {
2372		ok := object.Key("attachmentArn")
2373		ok.String(*v.AttachmentArn)
2374	}
2375
2376	if v.Status != nil {
2377		ok := object.Key("status")
2378		ok.String(*v.Status)
2379	}
2380
2381	return nil
2382}
2383
2384func awsAwsjson11_serializeDocumentAttachmentStateChanges(v []types.AttachmentStateChange, value smithyjson.Value) error {
2385	array := value.Array()
2386	defer array.Close()
2387
2388	for i := range v {
2389		av := array.Value()
2390		if err := awsAwsjson11_serializeDocumentAttachmentStateChange(&v[i], av); err != nil {
2391			return err
2392		}
2393	}
2394	return nil
2395}
2396
2397func awsAwsjson11_serializeDocumentAttribute(v *types.Attribute, value smithyjson.Value) error {
2398	object := value.Object()
2399	defer object.Close()
2400
2401	if v.Name != nil {
2402		ok := object.Key("name")
2403		ok.String(*v.Name)
2404	}
2405
2406	if v.TargetId != nil {
2407		ok := object.Key("targetId")
2408		ok.String(*v.TargetId)
2409	}
2410
2411	if len(v.TargetType) > 0 {
2412		ok := object.Key("targetType")
2413		ok.String(string(v.TargetType))
2414	}
2415
2416	if v.Value != nil {
2417		ok := object.Key("value")
2418		ok.String(*v.Value)
2419	}
2420
2421	return nil
2422}
2423
2424func awsAwsjson11_serializeDocumentAttributes(v []types.Attribute, value smithyjson.Value) error {
2425	array := value.Array()
2426	defer array.Close()
2427
2428	for i := range v {
2429		av := array.Value()
2430		if err := awsAwsjson11_serializeDocumentAttribute(&v[i], av); err != nil {
2431			return err
2432		}
2433	}
2434	return nil
2435}
2436
2437func awsAwsjson11_serializeDocumentAutoScalingGroupProvider(v *types.AutoScalingGroupProvider, value smithyjson.Value) error {
2438	object := value.Object()
2439	defer object.Close()
2440
2441	if v.AutoScalingGroupArn != nil {
2442		ok := object.Key("autoScalingGroupArn")
2443		ok.String(*v.AutoScalingGroupArn)
2444	}
2445
2446	if v.ManagedScaling != nil {
2447		ok := object.Key("managedScaling")
2448		if err := awsAwsjson11_serializeDocumentManagedScaling(v.ManagedScaling, ok); err != nil {
2449			return err
2450		}
2451	}
2452
2453	if len(v.ManagedTerminationProtection) > 0 {
2454		ok := object.Key("managedTerminationProtection")
2455		ok.String(string(v.ManagedTerminationProtection))
2456	}
2457
2458	return nil
2459}
2460
2461func awsAwsjson11_serializeDocumentAutoScalingGroupProviderUpdate(v *types.AutoScalingGroupProviderUpdate, value smithyjson.Value) error {
2462	object := value.Object()
2463	defer object.Close()
2464
2465	if v.ManagedScaling != nil {
2466		ok := object.Key("managedScaling")
2467		if err := awsAwsjson11_serializeDocumentManagedScaling(v.ManagedScaling, ok); err != nil {
2468			return err
2469		}
2470	}
2471
2472	if len(v.ManagedTerminationProtection) > 0 {
2473		ok := object.Key("managedTerminationProtection")
2474		ok.String(string(v.ManagedTerminationProtection))
2475	}
2476
2477	return nil
2478}
2479
2480func awsAwsjson11_serializeDocumentAwsVpcConfiguration(v *types.AwsVpcConfiguration, value smithyjson.Value) error {
2481	object := value.Object()
2482	defer object.Close()
2483
2484	if len(v.AssignPublicIp) > 0 {
2485		ok := object.Key("assignPublicIp")
2486		ok.String(string(v.AssignPublicIp))
2487	}
2488
2489	if v.SecurityGroups != nil {
2490		ok := object.Key("securityGroups")
2491		if err := awsAwsjson11_serializeDocumentStringList(v.SecurityGroups, ok); err != nil {
2492			return err
2493		}
2494	}
2495
2496	if v.Subnets != nil {
2497		ok := object.Key("subnets")
2498		if err := awsAwsjson11_serializeDocumentStringList(v.Subnets, ok); err != nil {
2499			return err
2500		}
2501	}
2502
2503	return nil
2504}
2505
2506func awsAwsjson11_serializeDocumentCapacityProviderFieldList(v []types.CapacityProviderField, value smithyjson.Value) error {
2507	array := value.Array()
2508	defer array.Close()
2509
2510	for i := range v {
2511		av := array.Value()
2512		av.String(string(v[i]))
2513	}
2514	return nil
2515}
2516
2517func awsAwsjson11_serializeDocumentCapacityProviderStrategy(v []types.CapacityProviderStrategyItem, value smithyjson.Value) error {
2518	array := value.Array()
2519	defer array.Close()
2520
2521	for i := range v {
2522		av := array.Value()
2523		if err := awsAwsjson11_serializeDocumentCapacityProviderStrategyItem(&v[i], av); err != nil {
2524			return err
2525		}
2526	}
2527	return nil
2528}
2529
2530func awsAwsjson11_serializeDocumentCapacityProviderStrategyItem(v *types.CapacityProviderStrategyItem, value smithyjson.Value) error {
2531	object := value.Object()
2532	defer object.Close()
2533
2534	if v.Base != 0 {
2535		ok := object.Key("base")
2536		ok.Integer(v.Base)
2537	}
2538
2539	if v.CapacityProvider != nil {
2540		ok := object.Key("capacityProvider")
2541		ok.String(*v.CapacityProvider)
2542	}
2543
2544	if v.Weight != 0 {
2545		ok := object.Key("weight")
2546		ok.Integer(v.Weight)
2547	}
2548
2549	return nil
2550}
2551
2552func awsAwsjson11_serializeDocumentClusterFieldList(v []types.ClusterField, value smithyjson.Value) error {
2553	array := value.Array()
2554	defer array.Close()
2555
2556	for i := range v {
2557		av := array.Value()
2558		av.String(string(v[i]))
2559	}
2560	return nil
2561}
2562
2563func awsAwsjson11_serializeDocumentClusterSetting(v *types.ClusterSetting, value smithyjson.Value) error {
2564	object := value.Object()
2565	defer object.Close()
2566
2567	if len(v.Name) > 0 {
2568		ok := object.Key("name")
2569		ok.String(string(v.Name))
2570	}
2571
2572	if v.Value != nil {
2573		ok := object.Key("value")
2574		ok.String(*v.Value)
2575	}
2576
2577	return nil
2578}
2579
2580func awsAwsjson11_serializeDocumentClusterSettings(v []types.ClusterSetting, value smithyjson.Value) error {
2581	array := value.Array()
2582	defer array.Close()
2583
2584	for i := range v {
2585		av := array.Value()
2586		if err := awsAwsjson11_serializeDocumentClusterSetting(&v[i], av); err != nil {
2587			return err
2588		}
2589	}
2590	return nil
2591}
2592
2593func awsAwsjson11_serializeDocumentCompatibilityList(v []types.Compatibility, value smithyjson.Value) error {
2594	array := value.Array()
2595	defer array.Close()
2596
2597	for i := range v {
2598		av := array.Value()
2599		av.String(string(v[i]))
2600	}
2601	return nil
2602}
2603
2604func awsAwsjson11_serializeDocumentContainerDefinition(v *types.ContainerDefinition, value smithyjson.Value) error {
2605	object := value.Object()
2606	defer object.Close()
2607
2608	if v.Command != nil {
2609		ok := object.Key("command")
2610		if err := awsAwsjson11_serializeDocumentStringList(v.Command, ok); err != nil {
2611			return err
2612		}
2613	}
2614
2615	if v.Cpu != 0 {
2616		ok := object.Key("cpu")
2617		ok.Integer(v.Cpu)
2618	}
2619
2620	if v.DependsOn != nil {
2621		ok := object.Key("dependsOn")
2622		if err := awsAwsjson11_serializeDocumentContainerDependencies(v.DependsOn, ok); err != nil {
2623			return err
2624		}
2625	}
2626
2627	if v.DisableNetworking != nil {
2628		ok := object.Key("disableNetworking")
2629		ok.Boolean(*v.DisableNetworking)
2630	}
2631
2632	if v.DnsSearchDomains != nil {
2633		ok := object.Key("dnsSearchDomains")
2634		if err := awsAwsjson11_serializeDocumentStringList(v.DnsSearchDomains, ok); err != nil {
2635			return err
2636		}
2637	}
2638
2639	if v.DnsServers != nil {
2640		ok := object.Key("dnsServers")
2641		if err := awsAwsjson11_serializeDocumentStringList(v.DnsServers, ok); err != nil {
2642			return err
2643		}
2644	}
2645
2646	if v.DockerLabels != nil {
2647		ok := object.Key("dockerLabels")
2648		if err := awsAwsjson11_serializeDocumentDockerLabelsMap(v.DockerLabels, ok); err != nil {
2649			return err
2650		}
2651	}
2652
2653	if v.DockerSecurityOptions != nil {
2654		ok := object.Key("dockerSecurityOptions")
2655		if err := awsAwsjson11_serializeDocumentStringList(v.DockerSecurityOptions, ok); err != nil {
2656			return err
2657		}
2658	}
2659
2660	if v.EntryPoint != nil {
2661		ok := object.Key("entryPoint")
2662		if err := awsAwsjson11_serializeDocumentStringList(v.EntryPoint, ok); err != nil {
2663			return err
2664		}
2665	}
2666
2667	if v.Environment != nil {
2668		ok := object.Key("environment")
2669		if err := awsAwsjson11_serializeDocumentEnvironmentVariables(v.Environment, ok); err != nil {
2670			return err
2671		}
2672	}
2673
2674	if v.EnvironmentFiles != nil {
2675		ok := object.Key("environmentFiles")
2676		if err := awsAwsjson11_serializeDocumentEnvironmentFiles(v.EnvironmentFiles, ok); err != nil {
2677			return err
2678		}
2679	}
2680
2681	if v.Essential != nil {
2682		ok := object.Key("essential")
2683		ok.Boolean(*v.Essential)
2684	}
2685
2686	if v.ExtraHosts != nil {
2687		ok := object.Key("extraHosts")
2688		if err := awsAwsjson11_serializeDocumentHostEntryList(v.ExtraHosts, ok); err != nil {
2689			return err
2690		}
2691	}
2692
2693	if v.FirelensConfiguration != nil {
2694		ok := object.Key("firelensConfiguration")
2695		if err := awsAwsjson11_serializeDocumentFirelensConfiguration(v.FirelensConfiguration, ok); err != nil {
2696			return err
2697		}
2698	}
2699
2700	if v.HealthCheck != nil {
2701		ok := object.Key("healthCheck")
2702		if err := awsAwsjson11_serializeDocumentHealthCheck(v.HealthCheck, ok); err != nil {
2703			return err
2704		}
2705	}
2706
2707	if v.Hostname != nil {
2708		ok := object.Key("hostname")
2709		ok.String(*v.Hostname)
2710	}
2711
2712	if v.Image != nil {
2713		ok := object.Key("image")
2714		ok.String(*v.Image)
2715	}
2716
2717	if v.Interactive != nil {
2718		ok := object.Key("interactive")
2719		ok.Boolean(*v.Interactive)
2720	}
2721
2722	if v.Links != nil {
2723		ok := object.Key("links")
2724		if err := awsAwsjson11_serializeDocumentStringList(v.Links, ok); err != nil {
2725			return err
2726		}
2727	}
2728
2729	if v.LinuxParameters != nil {
2730		ok := object.Key("linuxParameters")
2731		if err := awsAwsjson11_serializeDocumentLinuxParameters(v.LinuxParameters, ok); err != nil {
2732			return err
2733		}
2734	}
2735
2736	if v.LogConfiguration != nil {
2737		ok := object.Key("logConfiguration")
2738		if err := awsAwsjson11_serializeDocumentLogConfiguration(v.LogConfiguration, ok); err != nil {
2739			return err
2740		}
2741	}
2742
2743	if v.Memory != nil {
2744		ok := object.Key("memory")
2745		ok.Integer(*v.Memory)
2746	}
2747
2748	if v.MemoryReservation != nil {
2749		ok := object.Key("memoryReservation")
2750		ok.Integer(*v.MemoryReservation)
2751	}
2752
2753	if v.MountPoints != nil {
2754		ok := object.Key("mountPoints")
2755		if err := awsAwsjson11_serializeDocumentMountPointList(v.MountPoints, ok); err != nil {
2756			return err
2757		}
2758	}
2759
2760	if v.Name != nil {
2761		ok := object.Key("name")
2762		ok.String(*v.Name)
2763	}
2764
2765	if v.PortMappings != nil {
2766		ok := object.Key("portMappings")
2767		if err := awsAwsjson11_serializeDocumentPortMappingList(v.PortMappings, ok); err != nil {
2768			return err
2769		}
2770	}
2771
2772	if v.Privileged != nil {
2773		ok := object.Key("privileged")
2774		ok.Boolean(*v.Privileged)
2775	}
2776
2777	if v.PseudoTerminal != nil {
2778		ok := object.Key("pseudoTerminal")
2779		ok.Boolean(*v.PseudoTerminal)
2780	}
2781
2782	if v.ReadonlyRootFilesystem != nil {
2783		ok := object.Key("readonlyRootFilesystem")
2784		ok.Boolean(*v.ReadonlyRootFilesystem)
2785	}
2786
2787	if v.RepositoryCredentials != nil {
2788		ok := object.Key("repositoryCredentials")
2789		if err := awsAwsjson11_serializeDocumentRepositoryCredentials(v.RepositoryCredentials, ok); err != nil {
2790			return err
2791		}
2792	}
2793
2794	if v.ResourceRequirements != nil {
2795		ok := object.Key("resourceRequirements")
2796		if err := awsAwsjson11_serializeDocumentResourceRequirements(v.ResourceRequirements, ok); err != nil {
2797			return err
2798		}
2799	}
2800
2801	if v.Secrets != nil {
2802		ok := object.Key("secrets")
2803		if err := awsAwsjson11_serializeDocumentSecretList(v.Secrets, ok); err != nil {
2804			return err
2805		}
2806	}
2807
2808	if v.StartTimeout != nil {
2809		ok := object.Key("startTimeout")
2810		ok.Integer(*v.StartTimeout)
2811	}
2812
2813	if v.StopTimeout != nil {
2814		ok := object.Key("stopTimeout")
2815		ok.Integer(*v.StopTimeout)
2816	}
2817
2818	if v.SystemControls != nil {
2819		ok := object.Key("systemControls")
2820		if err := awsAwsjson11_serializeDocumentSystemControls(v.SystemControls, ok); err != nil {
2821			return err
2822		}
2823	}
2824
2825	if v.Ulimits != nil {
2826		ok := object.Key("ulimits")
2827		if err := awsAwsjson11_serializeDocumentUlimitList(v.Ulimits, ok); err != nil {
2828			return err
2829		}
2830	}
2831
2832	if v.User != nil {
2833		ok := object.Key("user")
2834		ok.String(*v.User)
2835	}
2836
2837	if v.VolumesFrom != nil {
2838		ok := object.Key("volumesFrom")
2839		if err := awsAwsjson11_serializeDocumentVolumeFromList(v.VolumesFrom, ok); err != nil {
2840			return err
2841		}
2842	}
2843
2844	if v.WorkingDirectory != nil {
2845		ok := object.Key("workingDirectory")
2846		ok.String(*v.WorkingDirectory)
2847	}
2848
2849	return nil
2850}
2851
2852func awsAwsjson11_serializeDocumentContainerDefinitions(v []types.ContainerDefinition, value smithyjson.Value) error {
2853	array := value.Array()
2854	defer array.Close()
2855
2856	for i := range v {
2857		av := array.Value()
2858		if err := awsAwsjson11_serializeDocumentContainerDefinition(&v[i], av); err != nil {
2859			return err
2860		}
2861	}
2862	return nil
2863}
2864
2865func awsAwsjson11_serializeDocumentContainerDependencies(v []types.ContainerDependency, value smithyjson.Value) error {
2866	array := value.Array()
2867	defer array.Close()
2868
2869	for i := range v {
2870		av := array.Value()
2871		if err := awsAwsjson11_serializeDocumentContainerDependency(&v[i], av); err != nil {
2872			return err
2873		}
2874	}
2875	return nil
2876}
2877
2878func awsAwsjson11_serializeDocumentContainerDependency(v *types.ContainerDependency, value smithyjson.Value) error {
2879	object := value.Object()
2880	defer object.Close()
2881
2882	if len(v.Condition) > 0 {
2883		ok := object.Key("condition")
2884		ok.String(string(v.Condition))
2885	}
2886
2887	if v.ContainerName != nil {
2888		ok := object.Key("containerName")
2889		ok.String(*v.ContainerName)
2890	}
2891
2892	return nil
2893}
2894
2895func awsAwsjson11_serializeDocumentContainerInstanceFieldList(v []types.ContainerInstanceField, value smithyjson.Value) error {
2896	array := value.Array()
2897	defer array.Close()
2898
2899	for i := range v {
2900		av := array.Value()
2901		av.String(string(v[i]))
2902	}
2903	return nil
2904}
2905
2906func awsAwsjson11_serializeDocumentContainerOverride(v *types.ContainerOverride, value smithyjson.Value) error {
2907	object := value.Object()
2908	defer object.Close()
2909
2910	if v.Command != nil {
2911		ok := object.Key("command")
2912		if err := awsAwsjson11_serializeDocumentStringList(v.Command, ok); err != nil {
2913			return err
2914		}
2915	}
2916
2917	if v.Cpu != nil {
2918		ok := object.Key("cpu")
2919		ok.Integer(*v.Cpu)
2920	}
2921
2922	if v.Environment != nil {
2923		ok := object.Key("environment")
2924		if err := awsAwsjson11_serializeDocumentEnvironmentVariables(v.Environment, ok); err != nil {
2925			return err
2926		}
2927	}
2928
2929	if v.EnvironmentFiles != nil {
2930		ok := object.Key("environmentFiles")
2931		if err := awsAwsjson11_serializeDocumentEnvironmentFiles(v.EnvironmentFiles, ok); err != nil {
2932			return err
2933		}
2934	}
2935
2936	if v.Memory != nil {
2937		ok := object.Key("memory")
2938		ok.Integer(*v.Memory)
2939	}
2940
2941	if v.MemoryReservation != nil {
2942		ok := object.Key("memoryReservation")
2943		ok.Integer(*v.MemoryReservation)
2944	}
2945
2946	if v.Name != nil {
2947		ok := object.Key("name")
2948		ok.String(*v.Name)
2949	}
2950
2951	if v.ResourceRequirements != nil {
2952		ok := object.Key("resourceRequirements")
2953		if err := awsAwsjson11_serializeDocumentResourceRequirements(v.ResourceRequirements, ok); err != nil {
2954			return err
2955		}
2956	}
2957
2958	return nil
2959}
2960
2961func awsAwsjson11_serializeDocumentContainerOverrides(v []types.ContainerOverride, value smithyjson.Value) error {
2962	array := value.Array()
2963	defer array.Close()
2964
2965	for i := range v {
2966		av := array.Value()
2967		if err := awsAwsjson11_serializeDocumentContainerOverride(&v[i], av); err != nil {
2968			return err
2969		}
2970	}
2971	return nil
2972}
2973
2974func awsAwsjson11_serializeDocumentContainerStateChange(v *types.ContainerStateChange, value smithyjson.Value) error {
2975	object := value.Object()
2976	defer object.Close()
2977
2978	if v.ContainerName != nil {
2979		ok := object.Key("containerName")
2980		ok.String(*v.ContainerName)
2981	}
2982
2983	if v.ExitCode != nil {
2984		ok := object.Key("exitCode")
2985		ok.Integer(*v.ExitCode)
2986	}
2987
2988	if v.ImageDigest != nil {
2989		ok := object.Key("imageDigest")
2990		ok.String(*v.ImageDigest)
2991	}
2992
2993	if v.NetworkBindings != nil {
2994		ok := object.Key("networkBindings")
2995		if err := awsAwsjson11_serializeDocumentNetworkBindings(v.NetworkBindings, ok); err != nil {
2996			return err
2997		}
2998	}
2999
3000	if v.Reason != nil {
3001		ok := object.Key("reason")
3002		ok.String(*v.Reason)
3003	}
3004
3005	if v.RuntimeId != nil {
3006		ok := object.Key("runtimeId")
3007		ok.String(*v.RuntimeId)
3008	}
3009
3010	if v.Status != nil {
3011		ok := object.Key("status")
3012		ok.String(*v.Status)
3013	}
3014
3015	return nil
3016}
3017
3018func awsAwsjson11_serializeDocumentContainerStateChanges(v []types.ContainerStateChange, value smithyjson.Value) error {
3019	array := value.Array()
3020	defer array.Close()
3021
3022	for i := range v {
3023		av := array.Value()
3024		if err := awsAwsjson11_serializeDocumentContainerStateChange(&v[i], av); err != nil {
3025			return err
3026		}
3027	}
3028	return nil
3029}
3030
3031func awsAwsjson11_serializeDocumentDeploymentCircuitBreaker(v *types.DeploymentCircuitBreaker, value smithyjson.Value) error {
3032	object := value.Object()
3033	defer object.Close()
3034
3035	if v.Enable {
3036		ok := object.Key("enable")
3037		ok.Boolean(v.Enable)
3038	}
3039
3040	if v.Rollback {
3041		ok := object.Key("rollback")
3042		ok.Boolean(v.Rollback)
3043	}
3044
3045	return nil
3046}
3047
3048func awsAwsjson11_serializeDocumentDeploymentConfiguration(v *types.DeploymentConfiguration, value smithyjson.Value) error {
3049	object := value.Object()
3050	defer object.Close()
3051
3052	if v.DeploymentCircuitBreaker != nil {
3053		ok := object.Key("deploymentCircuitBreaker")
3054		if err := awsAwsjson11_serializeDocumentDeploymentCircuitBreaker(v.DeploymentCircuitBreaker, ok); err != nil {
3055			return err
3056		}
3057	}
3058
3059	if v.MaximumPercent != nil {
3060		ok := object.Key("maximumPercent")
3061		ok.Integer(*v.MaximumPercent)
3062	}
3063
3064	if v.MinimumHealthyPercent != nil {
3065		ok := object.Key("minimumHealthyPercent")
3066		ok.Integer(*v.MinimumHealthyPercent)
3067	}
3068
3069	return nil
3070}
3071
3072func awsAwsjson11_serializeDocumentDeploymentController(v *types.DeploymentController, value smithyjson.Value) error {
3073	object := value.Object()
3074	defer object.Close()
3075
3076	if len(v.Type) > 0 {
3077		ok := object.Key("type")
3078		ok.String(string(v.Type))
3079	}
3080
3081	return nil
3082}
3083
3084func awsAwsjson11_serializeDocumentDevice(v *types.Device, value smithyjson.Value) error {
3085	object := value.Object()
3086	defer object.Close()
3087
3088	if v.ContainerPath != nil {
3089		ok := object.Key("containerPath")
3090		ok.String(*v.ContainerPath)
3091	}
3092
3093	if v.HostPath != nil {
3094		ok := object.Key("hostPath")
3095		ok.String(*v.HostPath)
3096	}
3097
3098	if v.Permissions != nil {
3099		ok := object.Key("permissions")
3100		if err := awsAwsjson11_serializeDocumentDeviceCgroupPermissions(v.Permissions, ok); err != nil {
3101			return err
3102		}
3103	}
3104
3105	return nil
3106}
3107
3108func awsAwsjson11_serializeDocumentDeviceCgroupPermissions(v []types.DeviceCgroupPermission, value smithyjson.Value) error {
3109	array := value.Array()
3110	defer array.Close()
3111
3112	for i := range v {
3113		av := array.Value()
3114		av.String(string(v[i]))
3115	}
3116	return nil
3117}
3118
3119func awsAwsjson11_serializeDocumentDevicesList(v []types.Device, value smithyjson.Value) error {
3120	array := value.Array()
3121	defer array.Close()
3122
3123	for i := range v {
3124		av := array.Value()
3125		if err := awsAwsjson11_serializeDocumentDevice(&v[i], av); err != nil {
3126			return err
3127		}
3128	}
3129	return nil
3130}
3131
3132func awsAwsjson11_serializeDocumentDockerLabelsMap(v map[string]string, value smithyjson.Value) error {
3133	object := value.Object()
3134	defer object.Close()
3135
3136	for key := range v {
3137		om := object.Key(key)
3138		om.String(v[key])
3139	}
3140	return nil
3141}
3142
3143func awsAwsjson11_serializeDocumentDockerVolumeConfiguration(v *types.DockerVolumeConfiguration, value smithyjson.Value) error {
3144	object := value.Object()
3145	defer object.Close()
3146
3147	if v.Autoprovision != nil {
3148		ok := object.Key("autoprovision")
3149		ok.Boolean(*v.Autoprovision)
3150	}
3151
3152	if v.Driver != nil {
3153		ok := object.Key("driver")
3154		ok.String(*v.Driver)
3155	}
3156
3157	if v.DriverOpts != nil {
3158		ok := object.Key("driverOpts")
3159		if err := awsAwsjson11_serializeDocumentStringMap(v.DriverOpts, ok); err != nil {
3160			return err
3161		}
3162	}
3163
3164	if v.Labels != nil {
3165		ok := object.Key("labels")
3166		if err := awsAwsjson11_serializeDocumentStringMap(v.Labels, ok); err != nil {
3167			return err
3168		}
3169	}
3170
3171	if len(v.Scope) > 0 {
3172		ok := object.Key("scope")
3173		ok.String(string(v.Scope))
3174	}
3175
3176	return nil
3177}
3178
3179func awsAwsjson11_serializeDocumentEFSAuthorizationConfig(v *types.EFSAuthorizationConfig, value smithyjson.Value) error {
3180	object := value.Object()
3181	defer object.Close()
3182
3183	if v.AccessPointId != nil {
3184		ok := object.Key("accessPointId")
3185		ok.String(*v.AccessPointId)
3186	}
3187
3188	if len(v.Iam) > 0 {
3189		ok := object.Key("iam")
3190		ok.String(string(v.Iam))
3191	}
3192
3193	return nil
3194}
3195
3196func awsAwsjson11_serializeDocumentEFSVolumeConfiguration(v *types.EFSVolumeConfiguration, value smithyjson.Value) error {
3197	object := value.Object()
3198	defer object.Close()
3199
3200	if v.AuthorizationConfig != nil {
3201		ok := object.Key("authorizationConfig")
3202		if err := awsAwsjson11_serializeDocumentEFSAuthorizationConfig(v.AuthorizationConfig, ok); err != nil {
3203			return err
3204		}
3205	}
3206
3207	if v.FileSystemId != nil {
3208		ok := object.Key("fileSystemId")
3209		ok.String(*v.FileSystemId)
3210	}
3211
3212	if v.RootDirectory != nil {
3213		ok := object.Key("rootDirectory")
3214		ok.String(*v.RootDirectory)
3215	}
3216
3217	if len(v.TransitEncryption) > 0 {
3218		ok := object.Key("transitEncryption")
3219		ok.String(string(v.TransitEncryption))
3220	}
3221
3222	if v.TransitEncryptionPort != nil {
3223		ok := object.Key("transitEncryptionPort")
3224		ok.Integer(*v.TransitEncryptionPort)
3225	}
3226
3227	return nil
3228}
3229
3230func awsAwsjson11_serializeDocumentEnvironmentFile(v *types.EnvironmentFile, value smithyjson.Value) error {
3231	object := value.Object()
3232	defer object.Close()
3233
3234	if len(v.Type) > 0 {
3235		ok := object.Key("type")
3236		ok.String(string(v.Type))
3237	}
3238
3239	if v.Value != nil {
3240		ok := object.Key("value")
3241		ok.String(*v.Value)
3242	}
3243
3244	return nil
3245}
3246
3247func awsAwsjson11_serializeDocumentEnvironmentFiles(v []types.EnvironmentFile, value smithyjson.Value) error {
3248	array := value.Array()
3249	defer array.Close()
3250
3251	for i := range v {
3252		av := array.Value()
3253		if err := awsAwsjson11_serializeDocumentEnvironmentFile(&v[i], av); err != nil {
3254			return err
3255		}
3256	}
3257	return nil
3258}
3259
3260func awsAwsjson11_serializeDocumentEnvironmentVariables(v []types.KeyValuePair, value smithyjson.Value) error {
3261	array := value.Array()
3262	defer array.Close()
3263
3264	for i := range v {
3265		av := array.Value()
3266		if err := awsAwsjson11_serializeDocumentKeyValuePair(&v[i], av); err != nil {
3267			return err
3268		}
3269	}
3270	return nil
3271}
3272
3273func awsAwsjson11_serializeDocumentFirelensConfiguration(v *types.FirelensConfiguration, value smithyjson.Value) error {
3274	object := value.Object()
3275	defer object.Close()
3276
3277	if v.Options != nil {
3278		ok := object.Key("options")
3279		if err := awsAwsjson11_serializeDocumentFirelensConfigurationOptionsMap(v.Options, ok); err != nil {
3280			return err
3281		}
3282	}
3283
3284	if len(v.Type) > 0 {
3285		ok := object.Key("type")
3286		ok.String(string(v.Type))
3287	}
3288
3289	return nil
3290}
3291
3292func awsAwsjson11_serializeDocumentFirelensConfigurationOptionsMap(v map[string]string, value smithyjson.Value) error {
3293	object := value.Object()
3294	defer object.Close()
3295
3296	for key := range v {
3297		om := object.Key(key)
3298		om.String(v[key])
3299	}
3300	return nil
3301}
3302
3303func awsAwsjson11_serializeDocumentFSxWindowsFileServerAuthorizationConfig(v *types.FSxWindowsFileServerAuthorizationConfig, value smithyjson.Value) error {
3304	object := value.Object()
3305	defer object.Close()
3306
3307	if v.CredentialsParameter != nil {
3308		ok := object.Key("credentialsParameter")
3309		ok.String(*v.CredentialsParameter)
3310	}
3311
3312	if v.Domain != nil {
3313		ok := object.Key("domain")
3314		ok.String(*v.Domain)
3315	}
3316
3317	return nil
3318}
3319
3320func awsAwsjson11_serializeDocumentFSxWindowsFileServerVolumeConfiguration(v *types.FSxWindowsFileServerVolumeConfiguration, value smithyjson.Value) error {
3321	object := value.Object()
3322	defer object.Close()
3323
3324	if v.AuthorizationConfig != nil {
3325		ok := object.Key("authorizationConfig")
3326		if err := awsAwsjson11_serializeDocumentFSxWindowsFileServerAuthorizationConfig(v.AuthorizationConfig, ok); err != nil {
3327			return err
3328		}
3329	}
3330
3331	if v.FileSystemId != nil {
3332		ok := object.Key("fileSystemId")
3333		ok.String(*v.FileSystemId)
3334	}
3335
3336	if v.RootDirectory != nil {
3337		ok := object.Key("rootDirectory")
3338		ok.String(*v.RootDirectory)
3339	}
3340
3341	return nil
3342}
3343
3344func awsAwsjson11_serializeDocumentHealthCheck(v *types.HealthCheck, value smithyjson.Value) error {
3345	object := value.Object()
3346	defer object.Close()
3347
3348	if v.Command != nil {
3349		ok := object.Key("command")
3350		if err := awsAwsjson11_serializeDocumentStringList(v.Command, ok); err != nil {
3351			return err
3352		}
3353	}
3354
3355	if v.Interval != nil {
3356		ok := object.Key("interval")
3357		ok.Integer(*v.Interval)
3358	}
3359
3360	if v.Retries != nil {
3361		ok := object.Key("retries")
3362		ok.Integer(*v.Retries)
3363	}
3364
3365	if v.StartPeriod != nil {
3366		ok := object.Key("startPeriod")
3367		ok.Integer(*v.StartPeriod)
3368	}
3369
3370	if v.Timeout != nil {
3371		ok := object.Key("timeout")
3372		ok.Integer(*v.Timeout)
3373	}
3374
3375	return nil
3376}
3377
3378func awsAwsjson11_serializeDocumentHostEntry(v *types.HostEntry, value smithyjson.Value) error {
3379	object := value.Object()
3380	defer object.Close()
3381
3382	if v.Hostname != nil {
3383		ok := object.Key("hostname")
3384		ok.String(*v.Hostname)
3385	}
3386
3387	if v.IpAddress != nil {
3388		ok := object.Key("ipAddress")
3389		ok.String(*v.IpAddress)
3390	}
3391
3392	return nil
3393}
3394
3395func awsAwsjson11_serializeDocumentHostEntryList(v []types.HostEntry, value smithyjson.Value) error {
3396	array := value.Array()
3397	defer array.Close()
3398
3399	for i := range v {
3400		av := array.Value()
3401		if err := awsAwsjson11_serializeDocumentHostEntry(&v[i], av); err != nil {
3402			return err
3403		}
3404	}
3405	return nil
3406}
3407
3408func awsAwsjson11_serializeDocumentHostVolumeProperties(v *types.HostVolumeProperties, value smithyjson.Value) error {
3409	object := value.Object()
3410	defer object.Close()
3411
3412	if v.SourcePath != nil {
3413		ok := object.Key("sourcePath")
3414		ok.String(*v.SourcePath)
3415	}
3416
3417	return nil
3418}
3419
3420func awsAwsjson11_serializeDocumentInferenceAccelerator(v *types.InferenceAccelerator, value smithyjson.Value) error {
3421	object := value.Object()
3422	defer object.Close()
3423
3424	if v.DeviceName != nil {
3425		ok := object.Key("deviceName")
3426		ok.String(*v.DeviceName)
3427	}
3428
3429	if v.DeviceType != nil {
3430		ok := object.Key("deviceType")
3431		ok.String(*v.DeviceType)
3432	}
3433
3434	return nil
3435}
3436
3437func awsAwsjson11_serializeDocumentInferenceAcceleratorOverride(v *types.InferenceAcceleratorOverride, value smithyjson.Value) error {
3438	object := value.Object()
3439	defer object.Close()
3440
3441	if v.DeviceName != nil {
3442		ok := object.Key("deviceName")
3443		ok.String(*v.DeviceName)
3444	}
3445
3446	if v.DeviceType != nil {
3447		ok := object.Key("deviceType")
3448		ok.String(*v.DeviceType)
3449	}
3450
3451	return nil
3452}
3453
3454func awsAwsjson11_serializeDocumentInferenceAcceleratorOverrides(v []types.InferenceAcceleratorOverride, value smithyjson.Value) error {
3455	array := value.Array()
3456	defer array.Close()
3457
3458	for i := range v {
3459		av := array.Value()
3460		if err := awsAwsjson11_serializeDocumentInferenceAcceleratorOverride(&v[i], av); err != nil {
3461			return err
3462		}
3463	}
3464	return nil
3465}
3466
3467func awsAwsjson11_serializeDocumentInferenceAccelerators(v []types.InferenceAccelerator, value smithyjson.Value) error {
3468	array := value.Array()
3469	defer array.Close()
3470
3471	for i := range v {
3472		av := array.Value()
3473		if err := awsAwsjson11_serializeDocumentInferenceAccelerator(&v[i], av); err != nil {
3474			return err
3475		}
3476	}
3477	return nil
3478}
3479
3480func awsAwsjson11_serializeDocumentKernelCapabilities(v *types.KernelCapabilities, value smithyjson.Value) error {
3481	object := value.Object()
3482	defer object.Close()
3483
3484	if v.Add != nil {
3485		ok := object.Key("add")
3486		if err := awsAwsjson11_serializeDocumentStringList(v.Add, ok); err != nil {
3487			return err
3488		}
3489	}
3490
3491	if v.Drop != nil {
3492		ok := object.Key("drop")
3493		if err := awsAwsjson11_serializeDocumentStringList(v.Drop, ok); err != nil {
3494			return err
3495		}
3496	}
3497
3498	return nil
3499}
3500
3501func awsAwsjson11_serializeDocumentKeyValuePair(v *types.KeyValuePair, value smithyjson.Value) error {
3502	object := value.Object()
3503	defer object.Close()
3504
3505	if v.Name != nil {
3506		ok := object.Key("name")
3507		ok.String(*v.Name)
3508	}
3509
3510	if v.Value != nil {
3511		ok := object.Key("value")
3512		ok.String(*v.Value)
3513	}
3514
3515	return nil
3516}
3517
3518func awsAwsjson11_serializeDocumentLinuxParameters(v *types.LinuxParameters, value smithyjson.Value) error {
3519	object := value.Object()
3520	defer object.Close()
3521
3522	if v.Capabilities != nil {
3523		ok := object.Key("capabilities")
3524		if err := awsAwsjson11_serializeDocumentKernelCapabilities(v.Capabilities, ok); err != nil {
3525			return err
3526		}
3527	}
3528
3529	if v.Devices != nil {
3530		ok := object.Key("devices")
3531		if err := awsAwsjson11_serializeDocumentDevicesList(v.Devices, ok); err != nil {
3532			return err
3533		}
3534	}
3535
3536	if v.InitProcessEnabled != nil {
3537		ok := object.Key("initProcessEnabled")
3538		ok.Boolean(*v.InitProcessEnabled)
3539	}
3540
3541	if v.MaxSwap != nil {
3542		ok := object.Key("maxSwap")
3543		ok.Integer(*v.MaxSwap)
3544	}
3545
3546	if v.SharedMemorySize != nil {
3547		ok := object.Key("sharedMemorySize")
3548		ok.Integer(*v.SharedMemorySize)
3549	}
3550
3551	if v.Swappiness != nil {
3552		ok := object.Key("swappiness")
3553		ok.Integer(*v.Swappiness)
3554	}
3555
3556	if v.Tmpfs != nil {
3557		ok := object.Key("tmpfs")
3558		if err := awsAwsjson11_serializeDocumentTmpfsList(v.Tmpfs, ok); err != nil {
3559			return err
3560		}
3561	}
3562
3563	return nil
3564}
3565
3566func awsAwsjson11_serializeDocumentLoadBalancer(v *types.LoadBalancer, value smithyjson.Value) error {
3567	object := value.Object()
3568	defer object.Close()
3569
3570	if v.ContainerName != nil {
3571		ok := object.Key("containerName")
3572		ok.String(*v.ContainerName)
3573	}
3574
3575	if v.ContainerPort != nil {
3576		ok := object.Key("containerPort")
3577		ok.Integer(*v.ContainerPort)
3578	}
3579
3580	if v.LoadBalancerName != nil {
3581		ok := object.Key("loadBalancerName")
3582		ok.String(*v.LoadBalancerName)
3583	}
3584
3585	if v.TargetGroupArn != nil {
3586		ok := object.Key("targetGroupArn")
3587		ok.String(*v.TargetGroupArn)
3588	}
3589
3590	return nil
3591}
3592
3593func awsAwsjson11_serializeDocumentLoadBalancers(v []types.LoadBalancer, value smithyjson.Value) error {
3594	array := value.Array()
3595	defer array.Close()
3596
3597	for i := range v {
3598		av := array.Value()
3599		if err := awsAwsjson11_serializeDocumentLoadBalancer(&v[i], av); err != nil {
3600			return err
3601		}
3602	}
3603	return nil
3604}
3605
3606func awsAwsjson11_serializeDocumentLogConfiguration(v *types.LogConfiguration, value smithyjson.Value) error {
3607	object := value.Object()
3608	defer object.Close()
3609
3610	if len(v.LogDriver) > 0 {
3611		ok := object.Key("logDriver")
3612		ok.String(string(v.LogDriver))
3613	}
3614
3615	if v.Options != nil {
3616		ok := object.Key("options")
3617		if err := awsAwsjson11_serializeDocumentLogConfigurationOptionsMap(v.Options, ok); err != nil {
3618			return err
3619		}
3620	}
3621
3622	if v.SecretOptions != nil {
3623		ok := object.Key("secretOptions")
3624		if err := awsAwsjson11_serializeDocumentSecretList(v.SecretOptions, ok); err != nil {
3625			return err
3626		}
3627	}
3628
3629	return nil
3630}
3631
3632func awsAwsjson11_serializeDocumentLogConfigurationOptionsMap(v map[string]string, value smithyjson.Value) error {
3633	object := value.Object()
3634	defer object.Close()
3635
3636	for key := range v {
3637		om := object.Key(key)
3638		om.String(v[key])
3639	}
3640	return nil
3641}
3642
3643func awsAwsjson11_serializeDocumentManagedScaling(v *types.ManagedScaling, value smithyjson.Value) error {
3644	object := value.Object()
3645	defer object.Close()
3646
3647	if v.InstanceWarmupPeriod != nil {
3648		ok := object.Key("instanceWarmupPeriod")
3649		ok.Integer(*v.InstanceWarmupPeriod)
3650	}
3651
3652	if v.MaximumScalingStepSize != nil {
3653		ok := object.Key("maximumScalingStepSize")
3654		ok.Integer(*v.MaximumScalingStepSize)
3655	}
3656
3657	if v.MinimumScalingStepSize != nil {
3658		ok := object.Key("minimumScalingStepSize")
3659		ok.Integer(*v.MinimumScalingStepSize)
3660	}
3661
3662	if len(v.Status) > 0 {
3663		ok := object.Key("status")
3664		ok.String(string(v.Status))
3665	}
3666
3667	if v.TargetCapacity != nil {
3668		ok := object.Key("targetCapacity")
3669		ok.Integer(*v.TargetCapacity)
3670	}
3671
3672	return nil
3673}
3674
3675func awsAwsjson11_serializeDocumentMountPoint(v *types.MountPoint, value smithyjson.Value) error {
3676	object := value.Object()
3677	defer object.Close()
3678
3679	if v.ContainerPath != nil {
3680		ok := object.Key("containerPath")
3681		ok.String(*v.ContainerPath)
3682	}
3683
3684	if v.ReadOnly != nil {
3685		ok := object.Key("readOnly")
3686		ok.Boolean(*v.ReadOnly)
3687	}
3688
3689	if v.SourceVolume != nil {
3690		ok := object.Key("sourceVolume")
3691		ok.String(*v.SourceVolume)
3692	}
3693
3694	return nil
3695}
3696
3697func awsAwsjson11_serializeDocumentMountPointList(v []types.MountPoint, value smithyjson.Value) error {
3698	array := value.Array()
3699	defer array.Close()
3700
3701	for i := range v {
3702		av := array.Value()
3703		if err := awsAwsjson11_serializeDocumentMountPoint(&v[i], av); err != nil {
3704			return err
3705		}
3706	}
3707	return nil
3708}
3709
3710func awsAwsjson11_serializeDocumentNetworkBinding(v *types.NetworkBinding, value smithyjson.Value) error {
3711	object := value.Object()
3712	defer object.Close()
3713
3714	if v.BindIP != nil {
3715		ok := object.Key("bindIP")
3716		ok.String(*v.BindIP)
3717	}
3718
3719	if v.ContainerPort != nil {
3720		ok := object.Key("containerPort")
3721		ok.Integer(*v.ContainerPort)
3722	}
3723
3724	if v.HostPort != nil {
3725		ok := object.Key("hostPort")
3726		ok.Integer(*v.HostPort)
3727	}
3728
3729	if len(v.Protocol) > 0 {
3730		ok := object.Key("protocol")
3731		ok.String(string(v.Protocol))
3732	}
3733
3734	return nil
3735}
3736
3737func awsAwsjson11_serializeDocumentNetworkBindings(v []types.NetworkBinding, value smithyjson.Value) error {
3738	array := value.Array()
3739	defer array.Close()
3740
3741	for i := range v {
3742		av := array.Value()
3743		if err := awsAwsjson11_serializeDocumentNetworkBinding(&v[i], av); err != nil {
3744			return err
3745		}
3746	}
3747	return nil
3748}
3749
3750func awsAwsjson11_serializeDocumentNetworkConfiguration(v *types.NetworkConfiguration, value smithyjson.Value) error {
3751	object := value.Object()
3752	defer object.Close()
3753
3754	if v.AwsvpcConfiguration != nil {
3755		ok := object.Key("awsvpcConfiguration")
3756		if err := awsAwsjson11_serializeDocumentAwsVpcConfiguration(v.AwsvpcConfiguration, ok); err != nil {
3757			return err
3758		}
3759	}
3760
3761	return nil
3762}
3763
3764func awsAwsjson11_serializeDocumentPlacementConstraint(v *types.PlacementConstraint, value smithyjson.Value) error {
3765	object := value.Object()
3766	defer object.Close()
3767
3768	if v.Expression != nil {
3769		ok := object.Key("expression")
3770		ok.String(*v.Expression)
3771	}
3772
3773	if len(v.Type) > 0 {
3774		ok := object.Key("type")
3775		ok.String(string(v.Type))
3776	}
3777
3778	return nil
3779}
3780
3781func awsAwsjson11_serializeDocumentPlacementConstraints(v []types.PlacementConstraint, value smithyjson.Value) error {
3782	array := value.Array()
3783	defer array.Close()
3784
3785	for i := range v {
3786		av := array.Value()
3787		if err := awsAwsjson11_serializeDocumentPlacementConstraint(&v[i], av); err != nil {
3788			return err
3789		}
3790	}
3791	return nil
3792}
3793
3794func awsAwsjson11_serializeDocumentPlacementStrategies(v []types.PlacementStrategy, value smithyjson.Value) error {
3795	array := value.Array()
3796	defer array.Close()
3797
3798	for i := range v {
3799		av := array.Value()
3800		if err := awsAwsjson11_serializeDocumentPlacementStrategy(&v[i], av); err != nil {
3801			return err
3802		}
3803	}
3804	return nil
3805}
3806
3807func awsAwsjson11_serializeDocumentPlacementStrategy(v *types.PlacementStrategy, value smithyjson.Value) error {
3808	object := value.Object()
3809	defer object.Close()
3810
3811	if v.Field != nil {
3812		ok := object.Key("field")
3813		ok.String(*v.Field)
3814	}
3815
3816	if len(v.Type) > 0 {
3817		ok := object.Key("type")
3818		ok.String(string(v.Type))
3819	}
3820
3821	return nil
3822}
3823
3824func awsAwsjson11_serializeDocumentPlatformDevice(v *types.PlatformDevice, value smithyjson.Value) error {
3825	object := value.Object()
3826	defer object.Close()
3827
3828	if v.Id != nil {
3829		ok := object.Key("id")
3830		ok.String(*v.Id)
3831	}
3832
3833	if len(v.Type) > 0 {
3834		ok := object.Key("type")
3835		ok.String(string(v.Type))
3836	}
3837
3838	return nil
3839}
3840
3841func awsAwsjson11_serializeDocumentPlatformDevices(v []types.PlatformDevice, value smithyjson.Value) error {
3842	array := value.Array()
3843	defer array.Close()
3844
3845	for i := range v {
3846		av := array.Value()
3847		if err := awsAwsjson11_serializeDocumentPlatformDevice(&v[i], av); err != nil {
3848			return err
3849		}
3850	}
3851	return nil
3852}
3853
3854func awsAwsjson11_serializeDocumentPortMapping(v *types.PortMapping, value smithyjson.Value) error {
3855	object := value.Object()
3856	defer object.Close()
3857
3858	if v.ContainerPort != nil {
3859		ok := object.Key("containerPort")
3860		ok.Integer(*v.ContainerPort)
3861	}
3862
3863	if v.HostPort != nil {
3864		ok := object.Key("hostPort")
3865		ok.Integer(*v.HostPort)
3866	}
3867
3868	if len(v.Protocol) > 0 {
3869		ok := object.Key("protocol")
3870		ok.String(string(v.Protocol))
3871	}
3872
3873	return nil
3874}
3875
3876func awsAwsjson11_serializeDocumentPortMappingList(v []types.PortMapping, value smithyjson.Value) error {
3877	array := value.Array()
3878	defer array.Close()
3879
3880	for i := range v {
3881		av := array.Value()
3882		if err := awsAwsjson11_serializeDocumentPortMapping(&v[i], av); err != nil {
3883			return err
3884		}
3885	}
3886	return nil
3887}
3888
3889func awsAwsjson11_serializeDocumentProxyConfiguration(v *types.ProxyConfiguration, value smithyjson.Value) error {
3890	object := value.Object()
3891	defer object.Close()
3892
3893	if v.ContainerName != nil {
3894		ok := object.Key("containerName")
3895		ok.String(*v.ContainerName)
3896	}
3897
3898	if v.Properties != nil {
3899		ok := object.Key("properties")
3900		if err := awsAwsjson11_serializeDocumentProxyConfigurationProperties(v.Properties, ok); err != nil {
3901			return err
3902		}
3903	}
3904
3905	if len(v.Type) > 0 {
3906		ok := object.Key("type")
3907		ok.String(string(v.Type))
3908	}
3909
3910	return nil
3911}
3912
3913func awsAwsjson11_serializeDocumentProxyConfigurationProperties(v []types.KeyValuePair, value smithyjson.Value) error {
3914	array := value.Array()
3915	defer array.Close()
3916
3917	for i := range v {
3918		av := array.Value()
3919		if err := awsAwsjson11_serializeDocumentKeyValuePair(&v[i], av); err != nil {
3920			return err
3921		}
3922	}
3923	return nil
3924}
3925
3926func awsAwsjson11_serializeDocumentRepositoryCredentials(v *types.RepositoryCredentials, value smithyjson.Value) error {
3927	object := value.Object()
3928	defer object.Close()
3929
3930	if v.CredentialsParameter != nil {
3931		ok := object.Key("credentialsParameter")
3932		ok.String(*v.CredentialsParameter)
3933	}
3934
3935	return nil
3936}
3937
3938func awsAwsjson11_serializeDocumentResource(v *types.Resource, value smithyjson.Value) error {
3939	object := value.Object()
3940	defer object.Close()
3941
3942	if v.DoubleValue != 0 {
3943		ok := object.Key("doubleValue")
3944		ok.Double(v.DoubleValue)
3945	}
3946
3947	if v.IntegerValue != 0 {
3948		ok := object.Key("integerValue")
3949		ok.Integer(v.IntegerValue)
3950	}
3951
3952	if v.LongValue != 0 {
3953		ok := object.Key("longValue")
3954		ok.Long(v.LongValue)
3955	}
3956
3957	if v.Name != nil {
3958		ok := object.Key("name")
3959		ok.String(*v.Name)
3960	}
3961
3962	if v.StringSetValue != nil {
3963		ok := object.Key("stringSetValue")
3964		if err := awsAwsjson11_serializeDocumentStringList(v.StringSetValue, ok); err != nil {
3965			return err
3966		}
3967	}
3968
3969	if v.Type != nil {
3970		ok := object.Key("type")
3971		ok.String(*v.Type)
3972	}
3973
3974	return nil
3975}
3976
3977func awsAwsjson11_serializeDocumentResourceRequirement(v *types.ResourceRequirement, value smithyjson.Value) error {
3978	object := value.Object()
3979	defer object.Close()
3980
3981	if len(v.Type) > 0 {
3982		ok := object.Key("type")
3983		ok.String(string(v.Type))
3984	}
3985
3986	if v.Value != nil {
3987		ok := object.Key("value")
3988		ok.String(*v.Value)
3989	}
3990
3991	return nil
3992}
3993
3994func awsAwsjson11_serializeDocumentResourceRequirements(v []types.ResourceRequirement, value smithyjson.Value) error {
3995	array := value.Array()
3996	defer array.Close()
3997
3998	for i := range v {
3999		av := array.Value()
4000		if err := awsAwsjson11_serializeDocumentResourceRequirement(&v[i], av); err != nil {
4001			return err
4002		}
4003	}
4004	return nil
4005}
4006
4007func awsAwsjson11_serializeDocumentResources(v []types.Resource, value smithyjson.Value) error {
4008	array := value.Array()
4009	defer array.Close()
4010
4011	for i := range v {
4012		av := array.Value()
4013		if err := awsAwsjson11_serializeDocumentResource(&v[i], av); err != nil {
4014			return err
4015		}
4016	}
4017	return nil
4018}
4019
4020func awsAwsjson11_serializeDocumentScale(v *types.Scale, value smithyjson.Value) error {
4021	object := value.Object()
4022	defer object.Close()
4023
4024	if len(v.Unit) > 0 {
4025		ok := object.Key("unit")
4026		ok.String(string(v.Unit))
4027	}
4028
4029	if v.Value != 0 {
4030		ok := object.Key("value")
4031		ok.Double(v.Value)
4032	}
4033
4034	return nil
4035}
4036
4037func awsAwsjson11_serializeDocumentSecret(v *types.Secret, value smithyjson.Value) error {
4038	object := value.Object()
4039	defer object.Close()
4040
4041	if v.Name != nil {
4042		ok := object.Key("name")
4043		ok.String(*v.Name)
4044	}
4045
4046	if v.ValueFrom != nil {
4047		ok := object.Key("valueFrom")
4048		ok.String(*v.ValueFrom)
4049	}
4050
4051	return nil
4052}
4053
4054func awsAwsjson11_serializeDocumentSecretList(v []types.Secret, value smithyjson.Value) error {
4055	array := value.Array()
4056	defer array.Close()
4057
4058	for i := range v {
4059		av := array.Value()
4060		if err := awsAwsjson11_serializeDocumentSecret(&v[i], av); err != nil {
4061			return err
4062		}
4063	}
4064	return nil
4065}
4066
4067func awsAwsjson11_serializeDocumentServiceFieldList(v []types.ServiceField, value smithyjson.Value) error {
4068	array := value.Array()
4069	defer array.Close()
4070
4071	for i := range v {
4072		av := array.Value()
4073		av.String(string(v[i]))
4074	}
4075	return nil
4076}
4077
4078func awsAwsjson11_serializeDocumentServiceRegistries(v []types.ServiceRegistry, value smithyjson.Value) error {
4079	array := value.Array()
4080	defer array.Close()
4081
4082	for i := range v {
4083		av := array.Value()
4084		if err := awsAwsjson11_serializeDocumentServiceRegistry(&v[i], av); err != nil {
4085			return err
4086		}
4087	}
4088	return nil
4089}
4090
4091func awsAwsjson11_serializeDocumentServiceRegistry(v *types.ServiceRegistry, value smithyjson.Value) error {
4092	object := value.Object()
4093	defer object.Close()
4094
4095	if v.ContainerName != nil {
4096		ok := object.Key("containerName")
4097		ok.String(*v.ContainerName)
4098	}
4099
4100	if v.ContainerPort != nil {
4101		ok := object.Key("containerPort")
4102		ok.Integer(*v.ContainerPort)
4103	}
4104
4105	if v.Port != nil {
4106		ok := object.Key("port")
4107		ok.Integer(*v.Port)
4108	}
4109
4110	if v.RegistryArn != nil {
4111		ok := object.Key("registryArn")
4112		ok.String(*v.RegistryArn)
4113	}
4114
4115	return nil
4116}
4117
4118func awsAwsjson11_serializeDocumentStringList(v []string, value smithyjson.Value) error {
4119	array := value.Array()
4120	defer array.Close()
4121
4122	for i := range v {
4123		av := array.Value()
4124		av.String(v[i])
4125	}
4126	return nil
4127}
4128
4129func awsAwsjson11_serializeDocumentStringMap(v map[string]string, value smithyjson.Value) error {
4130	object := value.Object()
4131	defer object.Close()
4132
4133	for key := range v {
4134		om := object.Key(key)
4135		om.String(v[key])
4136	}
4137	return nil
4138}
4139
4140func awsAwsjson11_serializeDocumentSystemControl(v *types.SystemControl, value smithyjson.Value) error {
4141	object := value.Object()
4142	defer object.Close()
4143
4144	if v.Namespace != nil {
4145		ok := object.Key("namespace")
4146		ok.String(*v.Namespace)
4147	}
4148
4149	if v.Value != nil {
4150		ok := object.Key("value")
4151		ok.String(*v.Value)
4152	}
4153
4154	return nil
4155}
4156
4157func awsAwsjson11_serializeDocumentSystemControls(v []types.SystemControl, value smithyjson.Value) error {
4158	array := value.Array()
4159	defer array.Close()
4160
4161	for i := range v {
4162		av := array.Value()
4163		if err := awsAwsjson11_serializeDocumentSystemControl(&v[i], av); err != nil {
4164			return err
4165		}
4166	}
4167	return nil
4168}
4169
4170func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
4171	object := value.Object()
4172	defer object.Close()
4173
4174	if v.Key != nil {
4175		ok := object.Key("key")
4176		ok.String(*v.Key)
4177	}
4178
4179	if v.Value != nil {
4180		ok := object.Key("value")
4181		ok.String(*v.Value)
4182	}
4183
4184	return nil
4185}
4186
4187func awsAwsjson11_serializeDocumentTagKeys(v []string, value smithyjson.Value) error {
4188	array := value.Array()
4189	defer array.Close()
4190
4191	for i := range v {
4192		av := array.Value()
4193		av.String(v[i])
4194	}
4195	return nil
4196}
4197
4198func awsAwsjson11_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error {
4199	array := value.Array()
4200	defer array.Close()
4201
4202	for i := range v {
4203		av := array.Value()
4204		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
4205			return err
4206		}
4207	}
4208	return nil
4209}
4210
4211func awsAwsjson11_serializeDocumentTaskDefinitionFieldList(v []types.TaskDefinitionField, value smithyjson.Value) error {
4212	array := value.Array()
4213	defer array.Close()
4214
4215	for i := range v {
4216		av := array.Value()
4217		av.String(string(v[i]))
4218	}
4219	return nil
4220}
4221
4222func awsAwsjson11_serializeDocumentTaskDefinitionPlacementConstraint(v *types.TaskDefinitionPlacementConstraint, value smithyjson.Value) error {
4223	object := value.Object()
4224	defer object.Close()
4225
4226	if v.Expression != nil {
4227		ok := object.Key("expression")
4228		ok.String(*v.Expression)
4229	}
4230
4231	if len(v.Type) > 0 {
4232		ok := object.Key("type")
4233		ok.String(string(v.Type))
4234	}
4235
4236	return nil
4237}
4238
4239func awsAwsjson11_serializeDocumentTaskDefinitionPlacementConstraints(v []types.TaskDefinitionPlacementConstraint, value smithyjson.Value) error {
4240	array := value.Array()
4241	defer array.Close()
4242
4243	for i := range v {
4244		av := array.Value()
4245		if err := awsAwsjson11_serializeDocumentTaskDefinitionPlacementConstraint(&v[i], av); err != nil {
4246			return err
4247		}
4248	}
4249	return nil
4250}
4251
4252func awsAwsjson11_serializeDocumentTaskFieldList(v []types.TaskField, value smithyjson.Value) error {
4253	array := value.Array()
4254	defer array.Close()
4255
4256	for i := range v {
4257		av := array.Value()
4258		av.String(string(v[i]))
4259	}
4260	return nil
4261}
4262
4263func awsAwsjson11_serializeDocumentTaskOverride(v *types.TaskOverride, value smithyjson.Value) error {
4264	object := value.Object()
4265	defer object.Close()
4266
4267	if v.ContainerOverrides != nil {
4268		ok := object.Key("containerOverrides")
4269		if err := awsAwsjson11_serializeDocumentContainerOverrides(v.ContainerOverrides, ok); err != nil {
4270			return err
4271		}
4272	}
4273
4274	if v.Cpu != nil {
4275		ok := object.Key("cpu")
4276		ok.String(*v.Cpu)
4277	}
4278
4279	if v.ExecutionRoleArn != nil {
4280		ok := object.Key("executionRoleArn")
4281		ok.String(*v.ExecutionRoleArn)
4282	}
4283
4284	if v.InferenceAcceleratorOverrides != nil {
4285		ok := object.Key("inferenceAcceleratorOverrides")
4286		if err := awsAwsjson11_serializeDocumentInferenceAcceleratorOverrides(v.InferenceAcceleratorOverrides, ok); err != nil {
4287			return err
4288		}
4289	}
4290
4291	if v.Memory != nil {
4292		ok := object.Key("memory")
4293		ok.String(*v.Memory)
4294	}
4295
4296	if v.TaskRoleArn != nil {
4297		ok := object.Key("taskRoleArn")
4298		ok.String(*v.TaskRoleArn)
4299	}
4300
4301	return nil
4302}
4303
4304func awsAwsjson11_serializeDocumentTaskSetFieldList(v []types.TaskSetField, value smithyjson.Value) error {
4305	array := value.Array()
4306	defer array.Close()
4307
4308	for i := range v {
4309		av := array.Value()
4310		av.String(string(v[i]))
4311	}
4312	return nil
4313}
4314
4315func awsAwsjson11_serializeDocumentTmpfs(v *types.Tmpfs, value smithyjson.Value) error {
4316	object := value.Object()
4317	defer object.Close()
4318
4319	if v.ContainerPath != nil {
4320		ok := object.Key("containerPath")
4321		ok.String(*v.ContainerPath)
4322	}
4323
4324	if v.MountOptions != nil {
4325		ok := object.Key("mountOptions")
4326		if err := awsAwsjson11_serializeDocumentStringList(v.MountOptions, ok); err != nil {
4327			return err
4328		}
4329	}
4330
4331	if v.Size != 0 {
4332		ok := object.Key("size")
4333		ok.Integer(v.Size)
4334	}
4335
4336	return nil
4337}
4338
4339func awsAwsjson11_serializeDocumentTmpfsList(v []types.Tmpfs, value smithyjson.Value) error {
4340	array := value.Array()
4341	defer array.Close()
4342
4343	for i := range v {
4344		av := array.Value()
4345		if err := awsAwsjson11_serializeDocumentTmpfs(&v[i], av); err != nil {
4346			return err
4347		}
4348	}
4349	return nil
4350}
4351
4352func awsAwsjson11_serializeDocumentUlimit(v *types.Ulimit, value smithyjson.Value) error {
4353	object := value.Object()
4354	defer object.Close()
4355
4356	if v.HardLimit != 0 {
4357		ok := object.Key("hardLimit")
4358		ok.Integer(v.HardLimit)
4359	}
4360
4361	if len(v.Name) > 0 {
4362		ok := object.Key("name")
4363		ok.String(string(v.Name))
4364	}
4365
4366	if v.SoftLimit != 0 {
4367		ok := object.Key("softLimit")
4368		ok.Integer(v.SoftLimit)
4369	}
4370
4371	return nil
4372}
4373
4374func awsAwsjson11_serializeDocumentUlimitList(v []types.Ulimit, value smithyjson.Value) error {
4375	array := value.Array()
4376	defer array.Close()
4377
4378	for i := range v {
4379		av := array.Value()
4380		if err := awsAwsjson11_serializeDocumentUlimit(&v[i], av); err != nil {
4381			return err
4382		}
4383	}
4384	return nil
4385}
4386
4387func awsAwsjson11_serializeDocumentVersionInfo(v *types.VersionInfo, value smithyjson.Value) error {
4388	object := value.Object()
4389	defer object.Close()
4390
4391	if v.AgentHash != nil {
4392		ok := object.Key("agentHash")
4393		ok.String(*v.AgentHash)
4394	}
4395
4396	if v.AgentVersion != nil {
4397		ok := object.Key("agentVersion")
4398		ok.String(*v.AgentVersion)
4399	}
4400
4401	if v.DockerVersion != nil {
4402		ok := object.Key("dockerVersion")
4403		ok.String(*v.DockerVersion)
4404	}
4405
4406	return nil
4407}
4408
4409func awsAwsjson11_serializeDocumentVolume(v *types.Volume, value smithyjson.Value) error {
4410	object := value.Object()
4411	defer object.Close()
4412
4413	if v.DockerVolumeConfiguration != nil {
4414		ok := object.Key("dockerVolumeConfiguration")
4415		if err := awsAwsjson11_serializeDocumentDockerVolumeConfiguration(v.DockerVolumeConfiguration, ok); err != nil {
4416			return err
4417		}
4418	}
4419
4420	if v.EfsVolumeConfiguration != nil {
4421		ok := object.Key("efsVolumeConfiguration")
4422		if err := awsAwsjson11_serializeDocumentEFSVolumeConfiguration(v.EfsVolumeConfiguration, ok); err != nil {
4423			return err
4424		}
4425	}
4426
4427	if v.FsxWindowsFileServerVolumeConfiguration != nil {
4428		ok := object.Key("fsxWindowsFileServerVolumeConfiguration")
4429		if err := awsAwsjson11_serializeDocumentFSxWindowsFileServerVolumeConfiguration(v.FsxWindowsFileServerVolumeConfiguration, ok); err != nil {
4430			return err
4431		}
4432	}
4433
4434	if v.Host != nil {
4435		ok := object.Key("host")
4436		if err := awsAwsjson11_serializeDocumentHostVolumeProperties(v.Host, ok); err != nil {
4437			return err
4438		}
4439	}
4440
4441	if v.Name != nil {
4442		ok := object.Key("name")
4443		ok.String(*v.Name)
4444	}
4445
4446	return nil
4447}
4448
4449func awsAwsjson11_serializeDocumentVolumeFrom(v *types.VolumeFrom, value smithyjson.Value) error {
4450	object := value.Object()
4451	defer object.Close()
4452
4453	if v.ReadOnly != nil {
4454		ok := object.Key("readOnly")
4455		ok.Boolean(*v.ReadOnly)
4456	}
4457
4458	if v.SourceContainer != nil {
4459		ok := object.Key("sourceContainer")
4460		ok.String(*v.SourceContainer)
4461	}
4462
4463	return nil
4464}
4465
4466func awsAwsjson11_serializeDocumentVolumeFromList(v []types.VolumeFrom, value smithyjson.Value) error {
4467	array := value.Array()
4468	defer array.Close()
4469
4470	for i := range v {
4471		av := array.Value()
4472		if err := awsAwsjson11_serializeDocumentVolumeFrom(&v[i], av); err != nil {
4473			return err
4474		}
4475	}
4476	return nil
4477}
4478
4479func awsAwsjson11_serializeDocumentVolumeList(v []types.Volume, value smithyjson.Value) error {
4480	array := value.Array()
4481	defer array.Close()
4482
4483	for i := range v {
4484		av := array.Value()
4485		if err := awsAwsjson11_serializeDocumentVolume(&v[i], av); err != nil {
4486			return err
4487		}
4488	}
4489	return nil
4490}
4491
4492func awsAwsjson11_serializeOpDocumentCreateCapacityProviderInput(v *CreateCapacityProviderInput, value smithyjson.Value) error {
4493	object := value.Object()
4494	defer object.Close()
4495
4496	if v.AutoScalingGroupProvider != nil {
4497		ok := object.Key("autoScalingGroupProvider")
4498		if err := awsAwsjson11_serializeDocumentAutoScalingGroupProvider(v.AutoScalingGroupProvider, ok); err != nil {
4499			return err
4500		}
4501	}
4502
4503	if v.Name != nil {
4504		ok := object.Key("name")
4505		ok.String(*v.Name)
4506	}
4507
4508	if v.Tags != nil {
4509		ok := object.Key("tags")
4510		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
4511			return err
4512		}
4513	}
4514
4515	return nil
4516}
4517
4518func awsAwsjson11_serializeOpDocumentCreateClusterInput(v *CreateClusterInput, value smithyjson.Value) error {
4519	object := value.Object()
4520	defer object.Close()
4521
4522	if v.CapacityProviders != nil {
4523		ok := object.Key("capacityProviders")
4524		if err := awsAwsjson11_serializeDocumentStringList(v.CapacityProviders, ok); err != nil {
4525			return err
4526		}
4527	}
4528
4529	if v.ClusterName != nil {
4530		ok := object.Key("clusterName")
4531		ok.String(*v.ClusterName)
4532	}
4533
4534	if v.DefaultCapacityProviderStrategy != nil {
4535		ok := object.Key("defaultCapacityProviderStrategy")
4536		if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.DefaultCapacityProviderStrategy, ok); err != nil {
4537			return err
4538		}
4539	}
4540
4541	if v.Settings != nil {
4542		ok := object.Key("settings")
4543		if err := awsAwsjson11_serializeDocumentClusterSettings(v.Settings, ok); err != nil {
4544			return err
4545		}
4546	}
4547
4548	if v.Tags != nil {
4549		ok := object.Key("tags")
4550		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
4551			return err
4552		}
4553	}
4554
4555	return nil
4556}
4557
4558func awsAwsjson11_serializeOpDocumentCreateServiceInput(v *CreateServiceInput, value smithyjson.Value) error {
4559	object := value.Object()
4560	defer object.Close()
4561
4562	if v.CapacityProviderStrategy != nil {
4563		ok := object.Key("capacityProviderStrategy")
4564		if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.CapacityProviderStrategy, ok); err != nil {
4565			return err
4566		}
4567	}
4568
4569	if v.ClientToken != nil {
4570		ok := object.Key("clientToken")
4571		ok.String(*v.ClientToken)
4572	}
4573
4574	if v.Cluster != nil {
4575		ok := object.Key("cluster")
4576		ok.String(*v.Cluster)
4577	}
4578
4579	if v.DeploymentConfiguration != nil {
4580		ok := object.Key("deploymentConfiguration")
4581		if err := awsAwsjson11_serializeDocumentDeploymentConfiguration(v.DeploymentConfiguration, ok); err != nil {
4582			return err
4583		}
4584	}
4585
4586	if v.DeploymentController != nil {
4587		ok := object.Key("deploymentController")
4588		if err := awsAwsjson11_serializeDocumentDeploymentController(v.DeploymentController, ok); err != nil {
4589			return err
4590		}
4591	}
4592
4593	if v.DesiredCount != nil {
4594		ok := object.Key("desiredCount")
4595		ok.Integer(*v.DesiredCount)
4596	}
4597
4598	if v.EnableECSManagedTags {
4599		ok := object.Key("enableECSManagedTags")
4600		ok.Boolean(v.EnableECSManagedTags)
4601	}
4602
4603	if v.HealthCheckGracePeriodSeconds != nil {
4604		ok := object.Key("healthCheckGracePeriodSeconds")
4605		ok.Integer(*v.HealthCheckGracePeriodSeconds)
4606	}
4607
4608	if len(v.LaunchType) > 0 {
4609		ok := object.Key("launchType")
4610		ok.String(string(v.LaunchType))
4611	}
4612
4613	if v.LoadBalancers != nil {
4614		ok := object.Key("loadBalancers")
4615		if err := awsAwsjson11_serializeDocumentLoadBalancers(v.LoadBalancers, ok); err != nil {
4616			return err
4617		}
4618	}
4619
4620	if v.NetworkConfiguration != nil {
4621		ok := object.Key("networkConfiguration")
4622		if err := awsAwsjson11_serializeDocumentNetworkConfiguration(v.NetworkConfiguration, ok); err != nil {
4623			return err
4624		}
4625	}
4626
4627	if v.PlacementConstraints != nil {
4628		ok := object.Key("placementConstraints")
4629		if err := awsAwsjson11_serializeDocumentPlacementConstraints(v.PlacementConstraints, ok); err != nil {
4630			return err
4631		}
4632	}
4633
4634	if v.PlacementStrategy != nil {
4635		ok := object.Key("placementStrategy")
4636		if err := awsAwsjson11_serializeDocumentPlacementStrategies(v.PlacementStrategy, ok); err != nil {
4637			return err
4638		}
4639	}
4640
4641	if v.PlatformVersion != nil {
4642		ok := object.Key("platformVersion")
4643		ok.String(*v.PlatformVersion)
4644	}
4645
4646	if len(v.PropagateTags) > 0 {
4647		ok := object.Key("propagateTags")
4648		ok.String(string(v.PropagateTags))
4649	}
4650
4651	if v.Role != nil {
4652		ok := object.Key("role")
4653		ok.String(*v.Role)
4654	}
4655
4656	if len(v.SchedulingStrategy) > 0 {
4657		ok := object.Key("schedulingStrategy")
4658		ok.String(string(v.SchedulingStrategy))
4659	}
4660
4661	if v.ServiceName != nil {
4662		ok := object.Key("serviceName")
4663		ok.String(*v.ServiceName)
4664	}
4665
4666	if v.ServiceRegistries != nil {
4667		ok := object.Key("serviceRegistries")
4668		if err := awsAwsjson11_serializeDocumentServiceRegistries(v.ServiceRegistries, ok); err != nil {
4669			return err
4670		}
4671	}
4672
4673	if v.Tags != nil {
4674		ok := object.Key("tags")
4675		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
4676			return err
4677		}
4678	}
4679
4680	if v.TaskDefinition != nil {
4681		ok := object.Key("taskDefinition")
4682		ok.String(*v.TaskDefinition)
4683	}
4684
4685	return nil
4686}
4687
4688func awsAwsjson11_serializeOpDocumentCreateTaskSetInput(v *CreateTaskSetInput, value smithyjson.Value) error {
4689	object := value.Object()
4690	defer object.Close()
4691
4692	if v.CapacityProviderStrategy != nil {
4693		ok := object.Key("capacityProviderStrategy")
4694		if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.CapacityProviderStrategy, ok); err != nil {
4695			return err
4696		}
4697	}
4698
4699	if v.ClientToken != nil {
4700		ok := object.Key("clientToken")
4701		ok.String(*v.ClientToken)
4702	}
4703
4704	if v.Cluster != nil {
4705		ok := object.Key("cluster")
4706		ok.String(*v.Cluster)
4707	}
4708
4709	if v.ExternalId != nil {
4710		ok := object.Key("externalId")
4711		ok.String(*v.ExternalId)
4712	}
4713
4714	if len(v.LaunchType) > 0 {
4715		ok := object.Key("launchType")
4716		ok.String(string(v.LaunchType))
4717	}
4718
4719	if v.LoadBalancers != nil {
4720		ok := object.Key("loadBalancers")
4721		if err := awsAwsjson11_serializeDocumentLoadBalancers(v.LoadBalancers, ok); err != nil {
4722			return err
4723		}
4724	}
4725
4726	if v.NetworkConfiguration != nil {
4727		ok := object.Key("networkConfiguration")
4728		if err := awsAwsjson11_serializeDocumentNetworkConfiguration(v.NetworkConfiguration, ok); err != nil {
4729			return err
4730		}
4731	}
4732
4733	if v.PlatformVersion != nil {
4734		ok := object.Key("platformVersion")
4735		ok.String(*v.PlatformVersion)
4736	}
4737
4738	if v.Scale != nil {
4739		ok := object.Key("scale")
4740		if err := awsAwsjson11_serializeDocumentScale(v.Scale, ok); err != nil {
4741			return err
4742		}
4743	}
4744
4745	if v.Service != nil {
4746		ok := object.Key("service")
4747		ok.String(*v.Service)
4748	}
4749
4750	if v.ServiceRegistries != nil {
4751		ok := object.Key("serviceRegistries")
4752		if err := awsAwsjson11_serializeDocumentServiceRegistries(v.ServiceRegistries, ok); err != nil {
4753			return err
4754		}
4755	}
4756
4757	if v.Tags != nil {
4758		ok := object.Key("tags")
4759		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
4760			return err
4761		}
4762	}
4763
4764	if v.TaskDefinition != nil {
4765		ok := object.Key("taskDefinition")
4766		ok.String(*v.TaskDefinition)
4767	}
4768
4769	return nil
4770}
4771
4772func awsAwsjson11_serializeOpDocumentDeleteAccountSettingInput(v *DeleteAccountSettingInput, value smithyjson.Value) error {
4773	object := value.Object()
4774	defer object.Close()
4775
4776	if len(v.Name) > 0 {
4777		ok := object.Key("name")
4778		ok.String(string(v.Name))
4779	}
4780
4781	if v.PrincipalArn != nil {
4782		ok := object.Key("principalArn")
4783		ok.String(*v.PrincipalArn)
4784	}
4785
4786	return nil
4787}
4788
4789func awsAwsjson11_serializeOpDocumentDeleteAttributesInput(v *DeleteAttributesInput, value smithyjson.Value) error {
4790	object := value.Object()
4791	defer object.Close()
4792
4793	if v.Attributes != nil {
4794		ok := object.Key("attributes")
4795		if err := awsAwsjson11_serializeDocumentAttributes(v.Attributes, ok); err != nil {
4796			return err
4797		}
4798	}
4799
4800	if v.Cluster != nil {
4801		ok := object.Key("cluster")
4802		ok.String(*v.Cluster)
4803	}
4804
4805	return nil
4806}
4807
4808func awsAwsjson11_serializeOpDocumentDeleteCapacityProviderInput(v *DeleteCapacityProviderInput, value smithyjson.Value) error {
4809	object := value.Object()
4810	defer object.Close()
4811
4812	if v.CapacityProvider != nil {
4813		ok := object.Key("capacityProvider")
4814		ok.String(*v.CapacityProvider)
4815	}
4816
4817	return nil
4818}
4819
4820func awsAwsjson11_serializeOpDocumentDeleteClusterInput(v *DeleteClusterInput, value smithyjson.Value) error {
4821	object := value.Object()
4822	defer object.Close()
4823
4824	if v.Cluster != nil {
4825		ok := object.Key("cluster")
4826		ok.String(*v.Cluster)
4827	}
4828
4829	return nil
4830}
4831
4832func awsAwsjson11_serializeOpDocumentDeleteServiceInput(v *DeleteServiceInput, value smithyjson.Value) error {
4833	object := value.Object()
4834	defer object.Close()
4835
4836	if v.Cluster != nil {
4837		ok := object.Key("cluster")
4838		ok.String(*v.Cluster)
4839	}
4840
4841	if v.Force != nil {
4842		ok := object.Key("force")
4843		ok.Boolean(*v.Force)
4844	}
4845
4846	if v.Service != nil {
4847		ok := object.Key("service")
4848		ok.String(*v.Service)
4849	}
4850
4851	return nil
4852}
4853
4854func awsAwsjson11_serializeOpDocumentDeleteTaskSetInput(v *DeleteTaskSetInput, value smithyjson.Value) error {
4855	object := value.Object()
4856	defer object.Close()
4857
4858	if v.Cluster != nil {
4859		ok := object.Key("cluster")
4860		ok.String(*v.Cluster)
4861	}
4862
4863	if v.Force != nil {
4864		ok := object.Key("force")
4865		ok.Boolean(*v.Force)
4866	}
4867
4868	if v.Service != nil {
4869		ok := object.Key("service")
4870		ok.String(*v.Service)
4871	}
4872
4873	if v.TaskSet != nil {
4874		ok := object.Key("taskSet")
4875		ok.String(*v.TaskSet)
4876	}
4877
4878	return nil
4879}
4880
4881func awsAwsjson11_serializeOpDocumentDeregisterContainerInstanceInput(v *DeregisterContainerInstanceInput, value smithyjson.Value) error {
4882	object := value.Object()
4883	defer object.Close()
4884
4885	if v.Cluster != nil {
4886		ok := object.Key("cluster")
4887		ok.String(*v.Cluster)
4888	}
4889
4890	if v.ContainerInstance != nil {
4891		ok := object.Key("containerInstance")
4892		ok.String(*v.ContainerInstance)
4893	}
4894
4895	if v.Force != nil {
4896		ok := object.Key("force")
4897		ok.Boolean(*v.Force)
4898	}
4899
4900	return nil
4901}
4902
4903func awsAwsjson11_serializeOpDocumentDeregisterTaskDefinitionInput(v *DeregisterTaskDefinitionInput, value smithyjson.Value) error {
4904	object := value.Object()
4905	defer object.Close()
4906
4907	if v.TaskDefinition != nil {
4908		ok := object.Key("taskDefinition")
4909		ok.String(*v.TaskDefinition)
4910	}
4911
4912	return nil
4913}
4914
4915func awsAwsjson11_serializeOpDocumentDescribeCapacityProvidersInput(v *DescribeCapacityProvidersInput, value smithyjson.Value) error {
4916	object := value.Object()
4917	defer object.Close()
4918
4919	if v.CapacityProviders != nil {
4920		ok := object.Key("capacityProviders")
4921		if err := awsAwsjson11_serializeDocumentStringList(v.CapacityProviders, ok); err != nil {
4922			return err
4923		}
4924	}
4925
4926	if v.Include != nil {
4927		ok := object.Key("include")
4928		if err := awsAwsjson11_serializeDocumentCapacityProviderFieldList(v.Include, ok); err != nil {
4929			return err
4930		}
4931	}
4932
4933	if v.MaxResults != nil {
4934		ok := object.Key("maxResults")
4935		ok.Integer(*v.MaxResults)
4936	}
4937
4938	if v.NextToken != nil {
4939		ok := object.Key("nextToken")
4940		ok.String(*v.NextToken)
4941	}
4942
4943	return nil
4944}
4945
4946func awsAwsjson11_serializeOpDocumentDescribeClustersInput(v *DescribeClustersInput, value smithyjson.Value) error {
4947	object := value.Object()
4948	defer object.Close()
4949
4950	if v.Clusters != nil {
4951		ok := object.Key("clusters")
4952		if err := awsAwsjson11_serializeDocumentStringList(v.Clusters, ok); err != nil {
4953			return err
4954		}
4955	}
4956
4957	if v.Include != nil {
4958		ok := object.Key("include")
4959		if err := awsAwsjson11_serializeDocumentClusterFieldList(v.Include, ok); err != nil {
4960			return err
4961		}
4962	}
4963
4964	return nil
4965}
4966
4967func awsAwsjson11_serializeOpDocumentDescribeContainerInstancesInput(v *DescribeContainerInstancesInput, value smithyjson.Value) error {
4968	object := value.Object()
4969	defer object.Close()
4970
4971	if v.Cluster != nil {
4972		ok := object.Key("cluster")
4973		ok.String(*v.Cluster)
4974	}
4975
4976	if v.ContainerInstances != nil {
4977		ok := object.Key("containerInstances")
4978		if err := awsAwsjson11_serializeDocumentStringList(v.ContainerInstances, ok); err != nil {
4979			return err
4980		}
4981	}
4982
4983	if v.Include != nil {
4984		ok := object.Key("include")
4985		if err := awsAwsjson11_serializeDocumentContainerInstanceFieldList(v.Include, ok); err != nil {
4986			return err
4987		}
4988	}
4989
4990	return nil
4991}
4992
4993func awsAwsjson11_serializeOpDocumentDescribeServicesInput(v *DescribeServicesInput, value smithyjson.Value) error {
4994	object := value.Object()
4995	defer object.Close()
4996
4997	if v.Cluster != nil {
4998		ok := object.Key("cluster")
4999		ok.String(*v.Cluster)
5000	}
5001
5002	if v.Include != nil {
5003		ok := object.Key("include")
5004		if err := awsAwsjson11_serializeDocumentServiceFieldList(v.Include, ok); err != nil {
5005			return err
5006		}
5007	}
5008
5009	if v.Services != nil {
5010		ok := object.Key("services")
5011		if err := awsAwsjson11_serializeDocumentStringList(v.Services, ok); err != nil {
5012			return err
5013		}
5014	}
5015
5016	return nil
5017}
5018
5019func awsAwsjson11_serializeOpDocumentDescribeTaskDefinitionInput(v *DescribeTaskDefinitionInput, value smithyjson.Value) error {
5020	object := value.Object()
5021	defer object.Close()
5022
5023	if v.Include != nil {
5024		ok := object.Key("include")
5025		if err := awsAwsjson11_serializeDocumentTaskDefinitionFieldList(v.Include, ok); err != nil {
5026			return err
5027		}
5028	}
5029
5030	if v.TaskDefinition != nil {
5031		ok := object.Key("taskDefinition")
5032		ok.String(*v.TaskDefinition)
5033	}
5034
5035	return nil
5036}
5037
5038func awsAwsjson11_serializeOpDocumentDescribeTaskSetsInput(v *DescribeTaskSetsInput, value smithyjson.Value) error {
5039	object := value.Object()
5040	defer object.Close()
5041
5042	if v.Cluster != nil {
5043		ok := object.Key("cluster")
5044		ok.String(*v.Cluster)
5045	}
5046
5047	if v.Include != nil {
5048		ok := object.Key("include")
5049		if err := awsAwsjson11_serializeDocumentTaskSetFieldList(v.Include, ok); err != nil {
5050			return err
5051		}
5052	}
5053
5054	if v.Service != nil {
5055		ok := object.Key("service")
5056		ok.String(*v.Service)
5057	}
5058
5059	if v.TaskSets != nil {
5060		ok := object.Key("taskSets")
5061		if err := awsAwsjson11_serializeDocumentStringList(v.TaskSets, ok); err != nil {
5062			return err
5063		}
5064	}
5065
5066	return nil
5067}
5068
5069func awsAwsjson11_serializeOpDocumentDescribeTasksInput(v *DescribeTasksInput, value smithyjson.Value) error {
5070	object := value.Object()
5071	defer object.Close()
5072
5073	if v.Cluster != nil {
5074		ok := object.Key("cluster")
5075		ok.String(*v.Cluster)
5076	}
5077
5078	if v.Include != nil {
5079		ok := object.Key("include")
5080		if err := awsAwsjson11_serializeDocumentTaskFieldList(v.Include, ok); err != nil {
5081			return err
5082		}
5083	}
5084
5085	if v.Tasks != nil {
5086		ok := object.Key("tasks")
5087		if err := awsAwsjson11_serializeDocumentStringList(v.Tasks, ok); err != nil {
5088			return err
5089		}
5090	}
5091
5092	return nil
5093}
5094
5095func awsAwsjson11_serializeOpDocumentDiscoverPollEndpointInput(v *DiscoverPollEndpointInput, value smithyjson.Value) error {
5096	object := value.Object()
5097	defer object.Close()
5098
5099	if v.Cluster != nil {
5100		ok := object.Key("cluster")
5101		ok.String(*v.Cluster)
5102	}
5103
5104	if v.ContainerInstance != nil {
5105		ok := object.Key("containerInstance")
5106		ok.String(*v.ContainerInstance)
5107	}
5108
5109	return nil
5110}
5111
5112func awsAwsjson11_serializeOpDocumentListAccountSettingsInput(v *ListAccountSettingsInput, value smithyjson.Value) error {
5113	object := value.Object()
5114	defer object.Close()
5115
5116	if v.EffectiveSettings {
5117		ok := object.Key("effectiveSettings")
5118		ok.Boolean(v.EffectiveSettings)
5119	}
5120
5121	if v.MaxResults != 0 {
5122		ok := object.Key("maxResults")
5123		ok.Integer(v.MaxResults)
5124	}
5125
5126	if len(v.Name) > 0 {
5127		ok := object.Key("name")
5128		ok.String(string(v.Name))
5129	}
5130
5131	if v.NextToken != nil {
5132		ok := object.Key("nextToken")
5133		ok.String(*v.NextToken)
5134	}
5135
5136	if v.PrincipalArn != nil {
5137		ok := object.Key("principalArn")
5138		ok.String(*v.PrincipalArn)
5139	}
5140
5141	if v.Value != nil {
5142		ok := object.Key("value")
5143		ok.String(*v.Value)
5144	}
5145
5146	return nil
5147}
5148
5149func awsAwsjson11_serializeOpDocumentListAttributesInput(v *ListAttributesInput, value smithyjson.Value) error {
5150	object := value.Object()
5151	defer object.Close()
5152
5153	if v.AttributeName != nil {
5154		ok := object.Key("attributeName")
5155		ok.String(*v.AttributeName)
5156	}
5157
5158	if v.AttributeValue != nil {
5159		ok := object.Key("attributeValue")
5160		ok.String(*v.AttributeValue)
5161	}
5162
5163	if v.Cluster != nil {
5164		ok := object.Key("cluster")
5165		ok.String(*v.Cluster)
5166	}
5167
5168	if v.MaxResults != nil {
5169		ok := object.Key("maxResults")
5170		ok.Integer(*v.MaxResults)
5171	}
5172
5173	if v.NextToken != nil {
5174		ok := object.Key("nextToken")
5175		ok.String(*v.NextToken)
5176	}
5177
5178	if len(v.TargetType) > 0 {
5179		ok := object.Key("targetType")
5180		ok.String(string(v.TargetType))
5181	}
5182
5183	return nil
5184}
5185
5186func awsAwsjson11_serializeOpDocumentListClustersInput(v *ListClustersInput, value smithyjson.Value) error {
5187	object := value.Object()
5188	defer object.Close()
5189
5190	if v.MaxResults != nil {
5191		ok := object.Key("maxResults")
5192		ok.Integer(*v.MaxResults)
5193	}
5194
5195	if v.NextToken != nil {
5196		ok := object.Key("nextToken")
5197		ok.String(*v.NextToken)
5198	}
5199
5200	return nil
5201}
5202
5203func awsAwsjson11_serializeOpDocumentListContainerInstancesInput(v *ListContainerInstancesInput, value smithyjson.Value) error {
5204	object := value.Object()
5205	defer object.Close()
5206
5207	if v.Cluster != nil {
5208		ok := object.Key("cluster")
5209		ok.String(*v.Cluster)
5210	}
5211
5212	if v.Filter != nil {
5213		ok := object.Key("filter")
5214		ok.String(*v.Filter)
5215	}
5216
5217	if v.MaxResults != nil {
5218		ok := object.Key("maxResults")
5219		ok.Integer(*v.MaxResults)
5220	}
5221
5222	if v.NextToken != nil {
5223		ok := object.Key("nextToken")
5224		ok.String(*v.NextToken)
5225	}
5226
5227	if len(v.Status) > 0 {
5228		ok := object.Key("status")
5229		ok.String(string(v.Status))
5230	}
5231
5232	return nil
5233}
5234
5235func awsAwsjson11_serializeOpDocumentListServicesInput(v *ListServicesInput, value smithyjson.Value) error {
5236	object := value.Object()
5237	defer object.Close()
5238
5239	if v.Cluster != nil {
5240		ok := object.Key("cluster")
5241		ok.String(*v.Cluster)
5242	}
5243
5244	if len(v.LaunchType) > 0 {
5245		ok := object.Key("launchType")
5246		ok.String(string(v.LaunchType))
5247	}
5248
5249	if v.MaxResults != nil {
5250		ok := object.Key("maxResults")
5251		ok.Integer(*v.MaxResults)
5252	}
5253
5254	if v.NextToken != nil {
5255		ok := object.Key("nextToken")
5256		ok.String(*v.NextToken)
5257	}
5258
5259	if len(v.SchedulingStrategy) > 0 {
5260		ok := object.Key("schedulingStrategy")
5261		ok.String(string(v.SchedulingStrategy))
5262	}
5263
5264	return nil
5265}
5266
5267func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
5268	object := value.Object()
5269	defer object.Close()
5270
5271	if v.ResourceArn != nil {
5272		ok := object.Key("resourceArn")
5273		ok.String(*v.ResourceArn)
5274	}
5275
5276	return nil
5277}
5278
5279func awsAwsjson11_serializeOpDocumentListTaskDefinitionFamiliesInput(v *ListTaskDefinitionFamiliesInput, value smithyjson.Value) error {
5280	object := value.Object()
5281	defer object.Close()
5282
5283	if v.FamilyPrefix != nil {
5284		ok := object.Key("familyPrefix")
5285		ok.String(*v.FamilyPrefix)
5286	}
5287
5288	if v.MaxResults != nil {
5289		ok := object.Key("maxResults")
5290		ok.Integer(*v.MaxResults)
5291	}
5292
5293	if v.NextToken != nil {
5294		ok := object.Key("nextToken")
5295		ok.String(*v.NextToken)
5296	}
5297
5298	if len(v.Status) > 0 {
5299		ok := object.Key("status")
5300		ok.String(string(v.Status))
5301	}
5302
5303	return nil
5304}
5305
5306func awsAwsjson11_serializeOpDocumentListTaskDefinitionsInput(v *ListTaskDefinitionsInput, value smithyjson.Value) error {
5307	object := value.Object()
5308	defer object.Close()
5309
5310	if v.FamilyPrefix != nil {
5311		ok := object.Key("familyPrefix")
5312		ok.String(*v.FamilyPrefix)
5313	}
5314
5315	if v.MaxResults != nil {
5316		ok := object.Key("maxResults")
5317		ok.Integer(*v.MaxResults)
5318	}
5319
5320	if v.NextToken != nil {
5321		ok := object.Key("nextToken")
5322		ok.String(*v.NextToken)
5323	}
5324
5325	if len(v.Sort) > 0 {
5326		ok := object.Key("sort")
5327		ok.String(string(v.Sort))
5328	}
5329
5330	if len(v.Status) > 0 {
5331		ok := object.Key("status")
5332		ok.String(string(v.Status))
5333	}
5334
5335	return nil
5336}
5337
5338func awsAwsjson11_serializeOpDocumentListTasksInput(v *ListTasksInput, value smithyjson.Value) error {
5339	object := value.Object()
5340	defer object.Close()
5341
5342	if v.Cluster != nil {
5343		ok := object.Key("cluster")
5344		ok.String(*v.Cluster)
5345	}
5346
5347	if v.ContainerInstance != nil {
5348		ok := object.Key("containerInstance")
5349		ok.String(*v.ContainerInstance)
5350	}
5351
5352	if len(v.DesiredStatus) > 0 {
5353		ok := object.Key("desiredStatus")
5354		ok.String(string(v.DesiredStatus))
5355	}
5356
5357	if v.Family != nil {
5358		ok := object.Key("family")
5359		ok.String(*v.Family)
5360	}
5361
5362	if len(v.LaunchType) > 0 {
5363		ok := object.Key("launchType")
5364		ok.String(string(v.LaunchType))
5365	}
5366
5367	if v.MaxResults != nil {
5368		ok := object.Key("maxResults")
5369		ok.Integer(*v.MaxResults)
5370	}
5371
5372	if v.NextToken != nil {
5373		ok := object.Key("nextToken")
5374		ok.String(*v.NextToken)
5375	}
5376
5377	if v.ServiceName != nil {
5378		ok := object.Key("serviceName")
5379		ok.String(*v.ServiceName)
5380	}
5381
5382	if v.StartedBy != nil {
5383		ok := object.Key("startedBy")
5384		ok.String(*v.StartedBy)
5385	}
5386
5387	return nil
5388}
5389
5390func awsAwsjson11_serializeOpDocumentPutAccountSettingDefaultInput(v *PutAccountSettingDefaultInput, value smithyjson.Value) error {
5391	object := value.Object()
5392	defer object.Close()
5393
5394	if len(v.Name) > 0 {
5395		ok := object.Key("name")
5396		ok.String(string(v.Name))
5397	}
5398
5399	if v.Value != nil {
5400		ok := object.Key("value")
5401		ok.String(*v.Value)
5402	}
5403
5404	return nil
5405}
5406
5407func awsAwsjson11_serializeOpDocumentPutAccountSettingInput(v *PutAccountSettingInput, value smithyjson.Value) error {
5408	object := value.Object()
5409	defer object.Close()
5410
5411	if len(v.Name) > 0 {
5412		ok := object.Key("name")
5413		ok.String(string(v.Name))
5414	}
5415
5416	if v.PrincipalArn != nil {
5417		ok := object.Key("principalArn")
5418		ok.String(*v.PrincipalArn)
5419	}
5420
5421	if v.Value != nil {
5422		ok := object.Key("value")
5423		ok.String(*v.Value)
5424	}
5425
5426	return nil
5427}
5428
5429func awsAwsjson11_serializeOpDocumentPutAttributesInput(v *PutAttributesInput, value smithyjson.Value) error {
5430	object := value.Object()
5431	defer object.Close()
5432
5433	if v.Attributes != nil {
5434		ok := object.Key("attributes")
5435		if err := awsAwsjson11_serializeDocumentAttributes(v.Attributes, ok); err != nil {
5436			return err
5437		}
5438	}
5439
5440	if v.Cluster != nil {
5441		ok := object.Key("cluster")
5442		ok.String(*v.Cluster)
5443	}
5444
5445	return nil
5446}
5447
5448func awsAwsjson11_serializeOpDocumentPutClusterCapacityProvidersInput(v *PutClusterCapacityProvidersInput, value smithyjson.Value) error {
5449	object := value.Object()
5450	defer object.Close()
5451
5452	if v.CapacityProviders != nil {
5453		ok := object.Key("capacityProviders")
5454		if err := awsAwsjson11_serializeDocumentStringList(v.CapacityProviders, ok); err != nil {
5455			return err
5456		}
5457	}
5458
5459	if v.Cluster != nil {
5460		ok := object.Key("cluster")
5461		ok.String(*v.Cluster)
5462	}
5463
5464	if v.DefaultCapacityProviderStrategy != nil {
5465		ok := object.Key("defaultCapacityProviderStrategy")
5466		if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.DefaultCapacityProviderStrategy, ok); err != nil {
5467			return err
5468		}
5469	}
5470
5471	return nil
5472}
5473
5474func awsAwsjson11_serializeOpDocumentRegisterContainerInstanceInput(v *RegisterContainerInstanceInput, value smithyjson.Value) error {
5475	object := value.Object()
5476	defer object.Close()
5477
5478	if v.Attributes != nil {
5479		ok := object.Key("attributes")
5480		if err := awsAwsjson11_serializeDocumentAttributes(v.Attributes, ok); err != nil {
5481			return err
5482		}
5483	}
5484
5485	if v.Cluster != nil {
5486		ok := object.Key("cluster")
5487		ok.String(*v.Cluster)
5488	}
5489
5490	if v.ContainerInstanceArn != nil {
5491		ok := object.Key("containerInstanceArn")
5492		ok.String(*v.ContainerInstanceArn)
5493	}
5494
5495	if v.InstanceIdentityDocument != nil {
5496		ok := object.Key("instanceIdentityDocument")
5497		ok.String(*v.InstanceIdentityDocument)
5498	}
5499
5500	if v.InstanceIdentityDocumentSignature != nil {
5501		ok := object.Key("instanceIdentityDocumentSignature")
5502		ok.String(*v.InstanceIdentityDocumentSignature)
5503	}
5504
5505	if v.PlatformDevices != nil {
5506		ok := object.Key("platformDevices")
5507		if err := awsAwsjson11_serializeDocumentPlatformDevices(v.PlatformDevices, ok); err != nil {
5508			return err
5509		}
5510	}
5511
5512	if v.Tags != nil {
5513		ok := object.Key("tags")
5514		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5515			return err
5516		}
5517	}
5518
5519	if v.TotalResources != nil {
5520		ok := object.Key("totalResources")
5521		if err := awsAwsjson11_serializeDocumentResources(v.TotalResources, ok); err != nil {
5522			return err
5523		}
5524	}
5525
5526	if v.VersionInfo != nil {
5527		ok := object.Key("versionInfo")
5528		if err := awsAwsjson11_serializeDocumentVersionInfo(v.VersionInfo, ok); err != nil {
5529			return err
5530		}
5531	}
5532
5533	return nil
5534}
5535
5536func awsAwsjson11_serializeOpDocumentRegisterTaskDefinitionInput(v *RegisterTaskDefinitionInput, value smithyjson.Value) error {
5537	object := value.Object()
5538	defer object.Close()
5539
5540	if v.ContainerDefinitions != nil {
5541		ok := object.Key("containerDefinitions")
5542		if err := awsAwsjson11_serializeDocumentContainerDefinitions(v.ContainerDefinitions, ok); err != nil {
5543			return err
5544		}
5545	}
5546
5547	if v.Cpu != nil {
5548		ok := object.Key("cpu")
5549		ok.String(*v.Cpu)
5550	}
5551
5552	if v.ExecutionRoleArn != nil {
5553		ok := object.Key("executionRoleArn")
5554		ok.String(*v.ExecutionRoleArn)
5555	}
5556
5557	if v.Family != nil {
5558		ok := object.Key("family")
5559		ok.String(*v.Family)
5560	}
5561
5562	if v.InferenceAccelerators != nil {
5563		ok := object.Key("inferenceAccelerators")
5564		if err := awsAwsjson11_serializeDocumentInferenceAccelerators(v.InferenceAccelerators, ok); err != nil {
5565			return err
5566		}
5567	}
5568
5569	if len(v.IpcMode) > 0 {
5570		ok := object.Key("ipcMode")
5571		ok.String(string(v.IpcMode))
5572	}
5573
5574	if v.Memory != nil {
5575		ok := object.Key("memory")
5576		ok.String(*v.Memory)
5577	}
5578
5579	if len(v.NetworkMode) > 0 {
5580		ok := object.Key("networkMode")
5581		ok.String(string(v.NetworkMode))
5582	}
5583
5584	if len(v.PidMode) > 0 {
5585		ok := object.Key("pidMode")
5586		ok.String(string(v.PidMode))
5587	}
5588
5589	if v.PlacementConstraints != nil {
5590		ok := object.Key("placementConstraints")
5591		if err := awsAwsjson11_serializeDocumentTaskDefinitionPlacementConstraints(v.PlacementConstraints, ok); err != nil {
5592			return err
5593		}
5594	}
5595
5596	if v.ProxyConfiguration != nil {
5597		ok := object.Key("proxyConfiguration")
5598		if err := awsAwsjson11_serializeDocumentProxyConfiguration(v.ProxyConfiguration, ok); err != nil {
5599			return err
5600		}
5601	}
5602
5603	if v.RequiresCompatibilities != nil {
5604		ok := object.Key("requiresCompatibilities")
5605		if err := awsAwsjson11_serializeDocumentCompatibilityList(v.RequiresCompatibilities, ok); err != nil {
5606			return err
5607		}
5608	}
5609
5610	if v.Tags != nil {
5611		ok := object.Key("tags")
5612		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5613			return err
5614		}
5615	}
5616
5617	if v.TaskRoleArn != nil {
5618		ok := object.Key("taskRoleArn")
5619		ok.String(*v.TaskRoleArn)
5620	}
5621
5622	if v.Volumes != nil {
5623		ok := object.Key("volumes")
5624		if err := awsAwsjson11_serializeDocumentVolumeList(v.Volumes, ok); err != nil {
5625			return err
5626		}
5627	}
5628
5629	return nil
5630}
5631
5632func awsAwsjson11_serializeOpDocumentRunTaskInput(v *RunTaskInput, value smithyjson.Value) error {
5633	object := value.Object()
5634	defer object.Close()
5635
5636	if v.CapacityProviderStrategy != nil {
5637		ok := object.Key("capacityProviderStrategy")
5638		if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.CapacityProviderStrategy, ok); err != nil {
5639			return err
5640		}
5641	}
5642
5643	if v.Cluster != nil {
5644		ok := object.Key("cluster")
5645		ok.String(*v.Cluster)
5646	}
5647
5648	if v.Count != nil {
5649		ok := object.Key("count")
5650		ok.Integer(*v.Count)
5651	}
5652
5653	if v.EnableECSManagedTags {
5654		ok := object.Key("enableECSManagedTags")
5655		ok.Boolean(v.EnableECSManagedTags)
5656	}
5657
5658	if v.Group != nil {
5659		ok := object.Key("group")
5660		ok.String(*v.Group)
5661	}
5662
5663	if len(v.LaunchType) > 0 {
5664		ok := object.Key("launchType")
5665		ok.String(string(v.LaunchType))
5666	}
5667
5668	if v.NetworkConfiguration != nil {
5669		ok := object.Key("networkConfiguration")
5670		if err := awsAwsjson11_serializeDocumentNetworkConfiguration(v.NetworkConfiguration, ok); err != nil {
5671			return err
5672		}
5673	}
5674
5675	if v.Overrides != nil {
5676		ok := object.Key("overrides")
5677		if err := awsAwsjson11_serializeDocumentTaskOverride(v.Overrides, ok); err != nil {
5678			return err
5679		}
5680	}
5681
5682	if v.PlacementConstraints != nil {
5683		ok := object.Key("placementConstraints")
5684		if err := awsAwsjson11_serializeDocumentPlacementConstraints(v.PlacementConstraints, ok); err != nil {
5685			return err
5686		}
5687	}
5688
5689	if v.PlacementStrategy != nil {
5690		ok := object.Key("placementStrategy")
5691		if err := awsAwsjson11_serializeDocumentPlacementStrategies(v.PlacementStrategy, ok); err != nil {
5692			return err
5693		}
5694	}
5695
5696	if v.PlatformVersion != nil {
5697		ok := object.Key("platformVersion")
5698		ok.String(*v.PlatformVersion)
5699	}
5700
5701	if len(v.PropagateTags) > 0 {
5702		ok := object.Key("propagateTags")
5703		ok.String(string(v.PropagateTags))
5704	}
5705
5706	if v.ReferenceId != nil {
5707		ok := object.Key("referenceId")
5708		ok.String(*v.ReferenceId)
5709	}
5710
5711	if v.StartedBy != nil {
5712		ok := object.Key("startedBy")
5713		ok.String(*v.StartedBy)
5714	}
5715
5716	if v.Tags != nil {
5717		ok := object.Key("tags")
5718		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5719			return err
5720		}
5721	}
5722
5723	if v.TaskDefinition != nil {
5724		ok := object.Key("taskDefinition")
5725		ok.String(*v.TaskDefinition)
5726	}
5727
5728	return nil
5729}
5730
5731func awsAwsjson11_serializeOpDocumentStartTaskInput(v *StartTaskInput, value smithyjson.Value) error {
5732	object := value.Object()
5733	defer object.Close()
5734
5735	if v.Cluster != nil {
5736		ok := object.Key("cluster")
5737		ok.String(*v.Cluster)
5738	}
5739
5740	if v.ContainerInstances != nil {
5741		ok := object.Key("containerInstances")
5742		if err := awsAwsjson11_serializeDocumentStringList(v.ContainerInstances, ok); err != nil {
5743			return err
5744		}
5745	}
5746
5747	if v.EnableECSManagedTags {
5748		ok := object.Key("enableECSManagedTags")
5749		ok.Boolean(v.EnableECSManagedTags)
5750	}
5751
5752	if v.Group != nil {
5753		ok := object.Key("group")
5754		ok.String(*v.Group)
5755	}
5756
5757	if v.NetworkConfiguration != nil {
5758		ok := object.Key("networkConfiguration")
5759		if err := awsAwsjson11_serializeDocumentNetworkConfiguration(v.NetworkConfiguration, ok); err != nil {
5760			return err
5761		}
5762	}
5763
5764	if v.Overrides != nil {
5765		ok := object.Key("overrides")
5766		if err := awsAwsjson11_serializeDocumentTaskOverride(v.Overrides, ok); err != nil {
5767			return err
5768		}
5769	}
5770
5771	if len(v.PropagateTags) > 0 {
5772		ok := object.Key("propagateTags")
5773		ok.String(string(v.PropagateTags))
5774	}
5775
5776	if v.ReferenceId != nil {
5777		ok := object.Key("referenceId")
5778		ok.String(*v.ReferenceId)
5779	}
5780
5781	if v.StartedBy != nil {
5782		ok := object.Key("startedBy")
5783		ok.String(*v.StartedBy)
5784	}
5785
5786	if v.Tags != nil {
5787		ok := object.Key("tags")
5788		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5789			return err
5790		}
5791	}
5792
5793	if v.TaskDefinition != nil {
5794		ok := object.Key("taskDefinition")
5795		ok.String(*v.TaskDefinition)
5796	}
5797
5798	return nil
5799}
5800
5801func awsAwsjson11_serializeOpDocumentStopTaskInput(v *StopTaskInput, value smithyjson.Value) error {
5802	object := value.Object()
5803	defer object.Close()
5804
5805	if v.Cluster != nil {
5806		ok := object.Key("cluster")
5807		ok.String(*v.Cluster)
5808	}
5809
5810	if v.Reason != nil {
5811		ok := object.Key("reason")
5812		ok.String(*v.Reason)
5813	}
5814
5815	if v.Task != nil {
5816		ok := object.Key("task")
5817		ok.String(*v.Task)
5818	}
5819
5820	return nil
5821}
5822
5823func awsAwsjson11_serializeOpDocumentSubmitAttachmentStateChangesInput(v *SubmitAttachmentStateChangesInput, value smithyjson.Value) error {
5824	object := value.Object()
5825	defer object.Close()
5826
5827	if v.Attachments != nil {
5828		ok := object.Key("attachments")
5829		if err := awsAwsjson11_serializeDocumentAttachmentStateChanges(v.Attachments, ok); err != nil {
5830			return err
5831		}
5832	}
5833
5834	if v.Cluster != nil {
5835		ok := object.Key("cluster")
5836		ok.String(*v.Cluster)
5837	}
5838
5839	return nil
5840}
5841
5842func awsAwsjson11_serializeOpDocumentSubmitContainerStateChangeInput(v *SubmitContainerStateChangeInput, value smithyjson.Value) error {
5843	object := value.Object()
5844	defer object.Close()
5845
5846	if v.Cluster != nil {
5847		ok := object.Key("cluster")
5848		ok.String(*v.Cluster)
5849	}
5850
5851	if v.ContainerName != nil {
5852		ok := object.Key("containerName")
5853		ok.String(*v.ContainerName)
5854	}
5855
5856	if v.ExitCode != nil {
5857		ok := object.Key("exitCode")
5858		ok.Integer(*v.ExitCode)
5859	}
5860
5861	if v.NetworkBindings != nil {
5862		ok := object.Key("networkBindings")
5863		if err := awsAwsjson11_serializeDocumentNetworkBindings(v.NetworkBindings, ok); err != nil {
5864			return err
5865		}
5866	}
5867
5868	if v.Reason != nil {
5869		ok := object.Key("reason")
5870		ok.String(*v.Reason)
5871	}
5872
5873	if v.RuntimeId != nil {
5874		ok := object.Key("runtimeId")
5875		ok.String(*v.RuntimeId)
5876	}
5877
5878	if v.Status != nil {
5879		ok := object.Key("status")
5880		ok.String(*v.Status)
5881	}
5882
5883	if v.Task != nil {
5884		ok := object.Key("task")
5885		ok.String(*v.Task)
5886	}
5887
5888	return nil
5889}
5890
5891func awsAwsjson11_serializeOpDocumentSubmitTaskStateChangeInput(v *SubmitTaskStateChangeInput, value smithyjson.Value) error {
5892	object := value.Object()
5893	defer object.Close()
5894
5895	if v.Attachments != nil {
5896		ok := object.Key("attachments")
5897		if err := awsAwsjson11_serializeDocumentAttachmentStateChanges(v.Attachments, ok); err != nil {
5898			return err
5899		}
5900	}
5901
5902	if v.Cluster != nil {
5903		ok := object.Key("cluster")
5904		ok.String(*v.Cluster)
5905	}
5906
5907	if v.Containers != nil {
5908		ok := object.Key("containers")
5909		if err := awsAwsjson11_serializeDocumentContainerStateChanges(v.Containers, ok); err != nil {
5910			return err
5911		}
5912	}
5913
5914	if v.ExecutionStoppedAt != nil {
5915		ok := object.Key("executionStoppedAt")
5916		ok.Double(smithytime.FormatEpochSeconds(*v.ExecutionStoppedAt))
5917	}
5918
5919	if v.PullStartedAt != nil {
5920		ok := object.Key("pullStartedAt")
5921		ok.Double(smithytime.FormatEpochSeconds(*v.PullStartedAt))
5922	}
5923
5924	if v.PullStoppedAt != nil {
5925		ok := object.Key("pullStoppedAt")
5926		ok.Double(smithytime.FormatEpochSeconds(*v.PullStoppedAt))
5927	}
5928
5929	if v.Reason != nil {
5930		ok := object.Key("reason")
5931		ok.String(*v.Reason)
5932	}
5933
5934	if v.Status != nil {
5935		ok := object.Key("status")
5936		ok.String(*v.Status)
5937	}
5938
5939	if v.Task != nil {
5940		ok := object.Key("task")
5941		ok.String(*v.Task)
5942	}
5943
5944	return nil
5945}
5946
5947func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
5948	object := value.Object()
5949	defer object.Close()
5950
5951	if v.ResourceArn != nil {
5952		ok := object.Key("resourceArn")
5953		ok.String(*v.ResourceArn)
5954	}
5955
5956	if v.Tags != nil {
5957		ok := object.Key("tags")
5958		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5959			return err
5960		}
5961	}
5962
5963	return nil
5964}
5965
5966func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
5967	object := value.Object()
5968	defer object.Close()
5969
5970	if v.ResourceArn != nil {
5971		ok := object.Key("resourceArn")
5972		ok.String(*v.ResourceArn)
5973	}
5974
5975	if v.TagKeys != nil {
5976		ok := object.Key("tagKeys")
5977		if err := awsAwsjson11_serializeDocumentTagKeys(v.TagKeys, ok); err != nil {
5978			return err
5979		}
5980	}
5981
5982	return nil
5983}
5984
5985func awsAwsjson11_serializeOpDocumentUpdateCapacityProviderInput(v *UpdateCapacityProviderInput, value smithyjson.Value) error {
5986	object := value.Object()
5987	defer object.Close()
5988
5989	if v.AutoScalingGroupProvider != nil {
5990		ok := object.Key("autoScalingGroupProvider")
5991		if err := awsAwsjson11_serializeDocumentAutoScalingGroupProviderUpdate(v.AutoScalingGroupProvider, ok); err != nil {
5992			return err
5993		}
5994	}
5995
5996	if v.Name != nil {
5997		ok := object.Key("name")
5998		ok.String(*v.Name)
5999	}
6000
6001	return nil
6002}
6003
6004func awsAwsjson11_serializeOpDocumentUpdateClusterSettingsInput(v *UpdateClusterSettingsInput, value smithyjson.Value) error {
6005	object := value.Object()
6006	defer object.Close()
6007
6008	if v.Cluster != nil {
6009		ok := object.Key("cluster")
6010		ok.String(*v.Cluster)
6011	}
6012
6013	if v.Settings != nil {
6014		ok := object.Key("settings")
6015		if err := awsAwsjson11_serializeDocumentClusterSettings(v.Settings, ok); err != nil {
6016			return err
6017		}
6018	}
6019
6020	return nil
6021}
6022
6023func awsAwsjson11_serializeOpDocumentUpdateContainerAgentInput(v *UpdateContainerAgentInput, value smithyjson.Value) error {
6024	object := value.Object()
6025	defer object.Close()
6026
6027	if v.Cluster != nil {
6028		ok := object.Key("cluster")
6029		ok.String(*v.Cluster)
6030	}
6031
6032	if v.ContainerInstance != nil {
6033		ok := object.Key("containerInstance")
6034		ok.String(*v.ContainerInstance)
6035	}
6036
6037	return nil
6038}
6039
6040func awsAwsjson11_serializeOpDocumentUpdateContainerInstancesStateInput(v *UpdateContainerInstancesStateInput, value smithyjson.Value) error {
6041	object := value.Object()
6042	defer object.Close()
6043
6044	if v.Cluster != nil {
6045		ok := object.Key("cluster")
6046		ok.String(*v.Cluster)
6047	}
6048
6049	if v.ContainerInstances != nil {
6050		ok := object.Key("containerInstances")
6051		if err := awsAwsjson11_serializeDocumentStringList(v.ContainerInstances, ok); err != nil {
6052			return err
6053		}
6054	}
6055
6056	if len(v.Status) > 0 {
6057		ok := object.Key("status")
6058		ok.String(string(v.Status))
6059	}
6060
6061	return nil
6062}
6063
6064func awsAwsjson11_serializeOpDocumentUpdateServiceInput(v *UpdateServiceInput, value smithyjson.Value) error {
6065	object := value.Object()
6066	defer object.Close()
6067
6068	if v.CapacityProviderStrategy != nil {
6069		ok := object.Key("capacityProviderStrategy")
6070		if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.CapacityProviderStrategy, ok); err != nil {
6071			return err
6072		}
6073	}
6074
6075	if v.Cluster != nil {
6076		ok := object.Key("cluster")
6077		ok.String(*v.Cluster)
6078	}
6079
6080	if v.DeploymentConfiguration != nil {
6081		ok := object.Key("deploymentConfiguration")
6082		if err := awsAwsjson11_serializeDocumentDeploymentConfiguration(v.DeploymentConfiguration, ok); err != nil {
6083			return err
6084		}
6085	}
6086
6087	if v.DesiredCount != nil {
6088		ok := object.Key("desiredCount")
6089		ok.Integer(*v.DesiredCount)
6090	}
6091
6092	if v.ForceNewDeployment {
6093		ok := object.Key("forceNewDeployment")
6094		ok.Boolean(v.ForceNewDeployment)
6095	}
6096
6097	if v.HealthCheckGracePeriodSeconds != nil {
6098		ok := object.Key("healthCheckGracePeriodSeconds")
6099		ok.Integer(*v.HealthCheckGracePeriodSeconds)
6100	}
6101
6102	if v.NetworkConfiguration != nil {
6103		ok := object.Key("networkConfiguration")
6104		if err := awsAwsjson11_serializeDocumentNetworkConfiguration(v.NetworkConfiguration, ok); err != nil {
6105			return err
6106		}
6107	}
6108
6109	if v.PlacementConstraints != nil {
6110		ok := object.Key("placementConstraints")
6111		if err := awsAwsjson11_serializeDocumentPlacementConstraints(v.PlacementConstraints, ok); err != nil {
6112			return err
6113		}
6114	}
6115
6116	if v.PlacementStrategy != nil {
6117		ok := object.Key("placementStrategy")
6118		if err := awsAwsjson11_serializeDocumentPlacementStrategies(v.PlacementStrategy, ok); err != nil {
6119			return err
6120		}
6121	}
6122
6123	if v.PlatformVersion != nil {
6124		ok := object.Key("platformVersion")
6125		ok.String(*v.PlatformVersion)
6126	}
6127
6128	if v.Service != nil {
6129		ok := object.Key("service")
6130		ok.String(*v.Service)
6131	}
6132
6133	if v.TaskDefinition != nil {
6134		ok := object.Key("taskDefinition")
6135		ok.String(*v.TaskDefinition)
6136	}
6137
6138	return nil
6139}
6140
6141func awsAwsjson11_serializeOpDocumentUpdateServicePrimaryTaskSetInput(v *UpdateServicePrimaryTaskSetInput, value smithyjson.Value) error {
6142	object := value.Object()
6143	defer object.Close()
6144
6145	if v.Cluster != nil {
6146		ok := object.Key("cluster")
6147		ok.String(*v.Cluster)
6148	}
6149
6150	if v.PrimaryTaskSet != nil {
6151		ok := object.Key("primaryTaskSet")
6152		ok.String(*v.PrimaryTaskSet)
6153	}
6154
6155	if v.Service != nil {
6156		ok := object.Key("service")
6157		ok.String(*v.Service)
6158	}
6159
6160	return nil
6161}
6162
6163func awsAwsjson11_serializeOpDocumentUpdateTaskSetInput(v *UpdateTaskSetInput, value smithyjson.Value) error {
6164	object := value.Object()
6165	defer object.Close()
6166
6167	if v.Cluster != nil {
6168		ok := object.Key("cluster")
6169		ok.String(*v.Cluster)
6170	}
6171
6172	if v.Scale != nil {
6173		ok := object.Key("scale")
6174		if err := awsAwsjson11_serializeDocumentScale(v.Scale, ok); err != nil {
6175			return err
6176		}
6177	}
6178
6179	if v.Service != nil {
6180		ok := object.Key("service")
6181		ok.String(*v.Service)
6182	}
6183
6184	if v.TaskSet != nil {
6185		ok := object.Key("taskSet")
6186		ok.String(*v.TaskSet)
6187	}
6188
6189	return nil
6190}
6191