1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package robomaker
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/robomaker/types"
10	smithy "github.com/aws/smithy-go"
11	"github.com/aws/smithy-go/encoding/httpbinding"
12	smithyjson "github.com/aws/smithy-go/encoding/json"
13	"github.com/aws/smithy-go/middleware"
14	smithyhttp "github.com/aws/smithy-go/transport/http"
15)
16
17type awsRestjson1_serializeOpBatchDeleteWorlds struct {
18}
19
20func (*awsRestjson1_serializeOpBatchDeleteWorlds) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsRestjson1_serializeOpBatchDeleteWorlds) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
25	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
26) {
27	request, ok := in.Request.(*smithyhttp.Request)
28	if !ok {
29		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
30	}
31
32	input, ok := in.Parameters.(*BatchDeleteWorldsInput)
33	_ = input
34	if !ok {
35		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
36	}
37
38	opPath, opQuery := httpbinding.SplitURI("/batchDeleteWorlds")
39	request.URL.Path = opPath
40	if len(request.URL.RawQuery) > 0 {
41		request.URL.RawQuery = "&" + opQuery
42	} else {
43		request.URL.RawQuery = opQuery
44	}
45
46	request.Method = "POST"
47	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
48	if err != nil {
49		return out, metadata, &smithy.SerializationError{Err: err}
50	}
51
52	restEncoder.SetHeader("Content-Type").String("application/json")
53
54	jsonEncoder := smithyjson.NewEncoder()
55	if err := awsRestjson1_serializeOpDocumentBatchDeleteWorldsInput(input, jsonEncoder.Value); err != nil {
56		return out, metadata, &smithy.SerializationError{Err: err}
57	}
58
59	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
60		return out, metadata, &smithy.SerializationError{Err: err}
61	}
62
63	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
64		return out, metadata, &smithy.SerializationError{Err: err}
65	}
66	in.Request = request
67
68	return next.HandleSerialize(ctx, in)
69}
70func awsRestjson1_serializeOpHttpBindingsBatchDeleteWorldsInput(v *BatchDeleteWorldsInput, encoder *httpbinding.Encoder) error {
71	if v == nil {
72		return fmt.Errorf("unsupported serialization of nil %T", v)
73	}
74
75	return nil
76}
77
78func awsRestjson1_serializeOpDocumentBatchDeleteWorldsInput(v *BatchDeleteWorldsInput, value smithyjson.Value) error {
79	object := value.Object()
80	defer object.Close()
81
82	if v.Worlds != nil {
83		ok := object.Key("worlds")
84		if err := awsRestjson1_serializeDocumentArns(v.Worlds, ok); err != nil {
85			return err
86		}
87	}
88
89	return nil
90}
91
92type awsRestjson1_serializeOpBatchDescribeSimulationJob struct {
93}
94
95func (*awsRestjson1_serializeOpBatchDescribeSimulationJob) ID() string {
96	return "OperationSerializer"
97}
98
99func (m *awsRestjson1_serializeOpBatchDescribeSimulationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
100	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
101) {
102	request, ok := in.Request.(*smithyhttp.Request)
103	if !ok {
104		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
105	}
106
107	input, ok := in.Parameters.(*BatchDescribeSimulationJobInput)
108	_ = input
109	if !ok {
110		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
111	}
112
113	opPath, opQuery := httpbinding.SplitURI("/batchDescribeSimulationJob")
114	request.URL.Path = opPath
115	if len(request.URL.RawQuery) > 0 {
116		request.URL.RawQuery = "&" + opQuery
117	} else {
118		request.URL.RawQuery = opQuery
119	}
120
121	request.Method = "POST"
122	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
123	if err != nil {
124		return out, metadata, &smithy.SerializationError{Err: err}
125	}
126
127	restEncoder.SetHeader("Content-Type").String("application/json")
128
129	jsonEncoder := smithyjson.NewEncoder()
130	if err := awsRestjson1_serializeOpDocumentBatchDescribeSimulationJobInput(input, jsonEncoder.Value); err != nil {
131		return out, metadata, &smithy.SerializationError{Err: err}
132	}
133
134	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
135		return out, metadata, &smithy.SerializationError{Err: err}
136	}
137
138	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
139		return out, metadata, &smithy.SerializationError{Err: err}
140	}
141	in.Request = request
142
143	return next.HandleSerialize(ctx, in)
144}
145func awsRestjson1_serializeOpHttpBindingsBatchDescribeSimulationJobInput(v *BatchDescribeSimulationJobInput, encoder *httpbinding.Encoder) error {
146	if v == nil {
147		return fmt.Errorf("unsupported serialization of nil %T", v)
148	}
149
150	return nil
151}
152
153func awsRestjson1_serializeOpDocumentBatchDescribeSimulationJobInput(v *BatchDescribeSimulationJobInput, value smithyjson.Value) error {
154	object := value.Object()
155	defer object.Close()
156
157	if v.Jobs != nil {
158		ok := object.Key("jobs")
159		if err := awsRestjson1_serializeDocumentArns(v.Jobs, ok); err != nil {
160			return err
161		}
162	}
163
164	return nil
165}
166
167type awsRestjson1_serializeOpCancelDeploymentJob struct {
168}
169
170func (*awsRestjson1_serializeOpCancelDeploymentJob) ID() string {
171	return "OperationSerializer"
172}
173
174func (m *awsRestjson1_serializeOpCancelDeploymentJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
175	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
176) {
177	request, ok := in.Request.(*smithyhttp.Request)
178	if !ok {
179		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
180	}
181
182	input, ok := in.Parameters.(*CancelDeploymentJobInput)
183	_ = input
184	if !ok {
185		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
186	}
187
188	opPath, opQuery := httpbinding.SplitURI("/cancelDeploymentJob")
189	request.URL.Path = opPath
190	if len(request.URL.RawQuery) > 0 {
191		request.URL.RawQuery = "&" + opQuery
192	} else {
193		request.URL.RawQuery = opQuery
194	}
195
196	request.Method = "POST"
197	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
198	if err != nil {
199		return out, metadata, &smithy.SerializationError{Err: err}
200	}
201
202	restEncoder.SetHeader("Content-Type").String("application/json")
203
204	jsonEncoder := smithyjson.NewEncoder()
205	if err := awsRestjson1_serializeOpDocumentCancelDeploymentJobInput(input, jsonEncoder.Value); err != nil {
206		return out, metadata, &smithy.SerializationError{Err: err}
207	}
208
209	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
210		return out, metadata, &smithy.SerializationError{Err: err}
211	}
212
213	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
214		return out, metadata, &smithy.SerializationError{Err: err}
215	}
216	in.Request = request
217
218	return next.HandleSerialize(ctx, in)
219}
220func awsRestjson1_serializeOpHttpBindingsCancelDeploymentJobInput(v *CancelDeploymentJobInput, encoder *httpbinding.Encoder) error {
221	if v == nil {
222		return fmt.Errorf("unsupported serialization of nil %T", v)
223	}
224
225	return nil
226}
227
228func awsRestjson1_serializeOpDocumentCancelDeploymentJobInput(v *CancelDeploymentJobInput, value smithyjson.Value) error {
229	object := value.Object()
230	defer object.Close()
231
232	if v.Job != nil {
233		ok := object.Key("job")
234		ok.String(*v.Job)
235	}
236
237	return nil
238}
239
240type awsRestjson1_serializeOpCancelSimulationJob struct {
241}
242
243func (*awsRestjson1_serializeOpCancelSimulationJob) ID() string {
244	return "OperationSerializer"
245}
246
247func (m *awsRestjson1_serializeOpCancelSimulationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
248	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
249) {
250	request, ok := in.Request.(*smithyhttp.Request)
251	if !ok {
252		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
253	}
254
255	input, ok := in.Parameters.(*CancelSimulationJobInput)
256	_ = input
257	if !ok {
258		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
259	}
260
261	opPath, opQuery := httpbinding.SplitURI("/cancelSimulationJob")
262	request.URL.Path = opPath
263	if len(request.URL.RawQuery) > 0 {
264		request.URL.RawQuery = "&" + opQuery
265	} else {
266		request.URL.RawQuery = opQuery
267	}
268
269	request.Method = "POST"
270	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
271	if err != nil {
272		return out, metadata, &smithy.SerializationError{Err: err}
273	}
274
275	restEncoder.SetHeader("Content-Type").String("application/json")
276
277	jsonEncoder := smithyjson.NewEncoder()
278	if err := awsRestjson1_serializeOpDocumentCancelSimulationJobInput(input, jsonEncoder.Value); err != nil {
279		return out, metadata, &smithy.SerializationError{Err: err}
280	}
281
282	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
283		return out, metadata, &smithy.SerializationError{Err: err}
284	}
285
286	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
287		return out, metadata, &smithy.SerializationError{Err: err}
288	}
289	in.Request = request
290
291	return next.HandleSerialize(ctx, in)
292}
293func awsRestjson1_serializeOpHttpBindingsCancelSimulationJobInput(v *CancelSimulationJobInput, encoder *httpbinding.Encoder) error {
294	if v == nil {
295		return fmt.Errorf("unsupported serialization of nil %T", v)
296	}
297
298	return nil
299}
300
301func awsRestjson1_serializeOpDocumentCancelSimulationJobInput(v *CancelSimulationJobInput, value smithyjson.Value) error {
302	object := value.Object()
303	defer object.Close()
304
305	if v.Job != nil {
306		ok := object.Key("job")
307		ok.String(*v.Job)
308	}
309
310	return nil
311}
312
313type awsRestjson1_serializeOpCancelSimulationJobBatch struct {
314}
315
316func (*awsRestjson1_serializeOpCancelSimulationJobBatch) ID() string {
317	return "OperationSerializer"
318}
319
320func (m *awsRestjson1_serializeOpCancelSimulationJobBatch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
321	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
322) {
323	request, ok := in.Request.(*smithyhttp.Request)
324	if !ok {
325		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
326	}
327
328	input, ok := in.Parameters.(*CancelSimulationJobBatchInput)
329	_ = input
330	if !ok {
331		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
332	}
333
334	opPath, opQuery := httpbinding.SplitURI("/cancelSimulationJobBatch")
335	request.URL.Path = opPath
336	if len(request.URL.RawQuery) > 0 {
337		request.URL.RawQuery = "&" + opQuery
338	} else {
339		request.URL.RawQuery = opQuery
340	}
341
342	request.Method = "POST"
343	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
344	if err != nil {
345		return out, metadata, &smithy.SerializationError{Err: err}
346	}
347
348	restEncoder.SetHeader("Content-Type").String("application/json")
349
350	jsonEncoder := smithyjson.NewEncoder()
351	if err := awsRestjson1_serializeOpDocumentCancelSimulationJobBatchInput(input, jsonEncoder.Value); err != nil {
352		return out, metadata, &smithy.SerializationError{Err: err}
353	}
354
355	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
356		return out, metadata, &smithy.SerializationError{Err: err}
357	}
358
359	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
360		return out, metadata, &smithy.SerializationError{Err: err}
361	}
362	in.Request = request
363
364	return next.HandleSerialize(ctx, in)
365}
366func awsRestjson1_serializeOpHttpBindingsCancelSimulationJobBatchInput(v *CancelSimulationJobBatchInput, encoder *httpbinding.Encoder) error {
367	if v == nil {
368		return fmt.Errorf("unsupported serialization of nil %T", v)
369	}
370
371	return nil
372}
373
374func awsRestjson1_serializeOpDocumentCancelSimulationJobBatchInput(v *CancelSimulationJobBatchInput, value smithyjson.Value) error {
375	object := value.Object()
376	defer object.Close()
377
378	if v.Batch != nil {
379		ok := object.Key("batch")
380		ok.String(*v.Batch)
381	}
382
383	return nil
384}
385
386type awsRestjson1_serializeOpCancelWorldExportJob struct {
387}
388
389func (*awsRestjson1_serializeOpCancelWorldExportJob) ID() string {
390	return "OperationSerializer"
391}
392
393func (m *awsRestjson1_serializeOpCancelWorldExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
394	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
395) {
396	request, ok := in.Request.(*smithyhttp.Request)
397	if !ok {
398		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
399	}
400
401	input, ok := in.Parameters.(*CancelWorldExportJobInput)
402	_ = input
403	if !ok {
404		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
405	}
406
407	opPath, opQuery := httpbinding.SplitURI("/cancelWorldExportJob")
408	request.URL.Path = opPath
409	if len(request.URL.RawQuery) > 0 {
410		request.URL.RawQuery = "&" + opQuery
411	} else {
412		request.URL.RawQuery = opQuery
413	}
414
415	request.Method = "POST"
416	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
417	if err != nil {
418		return out, metadata, &smithy.SerializationError{Err: err}
419	}
420
421	restEncoder.SetHeader("Content-Type").String("application/json")
422
423	jsonEncoder := smithyjson.NewEncoder()
424	if err := awsRestjson1_serializeOpDocumentCancelWorldExportJobInput(input, jsonEncoder.Value); err != nil {
425		return out, metadata, &smithy.SerializationError{Err: err}
426	}
427
428	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
429		return out, metadata, &smithy.SerializationError{Err: err}
430	}
431
432	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
433		return out, metadata, &smithy.SerializationError{Err: err}
434	}
435	in.Request = request
436
437	return next.HandleSerialize(ctx, in)
438}
439func awsRestjson1_serializeOpHttpBindingsCancelWorldExportJobInput(v *CancelWorldExportJobInput, encoder *httpbinding.Encoder) error {
440	if v == nil {
441		return fmt.Errorf("unsupported serialization of nil %T", v)
442	}
443
444	return nil
445}
446
447func awsRestjson1_serializeOpDocumentCancelWorldExportJobInput(v *CancelWorldExportJobInput, value smithyjson.Value) error {
448	object := value.Object()
449	defer object.Close()
450
451	if v.Job != nil {
452		ok := object.Key("job")
453		ok.String(*v.Job)
454	}
455
456	return nil
457}
458
459type awsRestjson1_serializeOpCancelWorldGenerationJob struct {
460}
461
462func (*awsRestjson1_serializeOpCancelWorldGenerationJob) ID() string {
463	return "OperationSerializer"
464}
465
466func (m *awsRestjson1_serializeOpCancelWorldGenerationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
467	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
468) {
469	request, ok := in.Request.(*smithyhttp.Request)
470	if !ok {
471		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
472	}
473
474	input, ok := in.Parameters.(*CancelWorldGenerationJobInput)
475	_ = input
476	if !ok {
477		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
478	}
479
480	opPath, opQuery := httpbinding.SplitURI("/cancelWorldGenerationJob")
481	request.URL.Path = opPath
482	if len(request.URL.RawQuery) > 0 {
483		request.URL.RawQuery = "&" + opQuery
484	} else {
485		request.URL.RawQuery = opQuery
486	}
487
488	request.Method = "POST"
489	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
490	if err != nil {
491		return out, metadata, &smithy.SerializationError{Err: err}
492	}
493
494	restEncoder.SetHeader("Content-Type").String("application/json")
495
496	jsonEncoder := smithyjson.NewEncoder()
497	if err := awsRestjson1_serializeOpDocumentCancelWorldGenerationJobInput(input, jsonEncoder.Value); err != nil {
498		return out, metadata, &smithy.SerializationError{Err: err}
499	}
500
501	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
502		return out, metadata, &smithy.SerializationError{Err: err}
503	}
504
505	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
506		return out, metadata, &smithy.SerializationError{Err: err}
507	}
508	in.Request = request
509
510	return next.HandleSerialize(ctx, in)
511}
512func awsRestjson1_serializeOpHttpBindingsCancelWorldGenerationJobInput(v *CancelWorldGenerationJobInput, encoder *httpbinding.Encoder) error {
513	if v == nil {
514		return fmt.Errorf("unsupported serialization of nil %T", v)
515	}
516
517	return nil
518}
519
520func awsRestjson1_serializeOpDocumentCancelWorldGenerationJobInput(v *CancelWorldGenerationJobInput, value smithyjson.Value) error {
521	object := value.Object()
522	defer object.Close()
523
524	if v.Job != nil {
525		ok := object.Key("job")
526		ok.String(*v.Job)
527	}
528
529	return nil
530}
531
532type awsRestjson1_serializeOpCreateDeploymentJob struct {
533}
534
535func (*awsRestjson1_serializeOpCreateDeploymentJob) ID() string {
536	return "OperationSerializer"
537}
538
539func (m *awsRestjson1_serializeOpCreateDeploymentJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
540	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
541) {
542	request, ok := in.Request.(*smithyhttp.Request)
543	if !ok {
544		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
545	}
546
547	input, ok := in.Parameters.(*CreateDeploymentJobInput)
548	_ = input
549	if !ok {
550		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
551	}
552
553	opPath, opQuery := httpbinding.SplitURI("/createDeploymentJob")
554	request.URL.Path = opPath
555	if len(request.URL.RawQuery) > 0 {
556		request.URL.RawQuery = "&" + opQuery
557	} else {
558		request.URL.RawQuery = opQuery
559	}
560
561	request.Method = "POST"
562	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
563	if err != nil {
564		return out, metadata, &smithy.SerializationError{Err: err}
565	}
566
567	restEncoder.SetHeader("Content-Type").String("application/json")
568
569	jsonEncoder := smithyjson.NewEncoder()
570	if err := awsRestjson1_serializeOpDocumentCreateDeploymentJobInput(input, jsonEncoder.Value); err != nil {
571		return out, metadata, &smithy.SerializationError{Err: err}
572	}
573
574	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
575		return out, metadata, &smithy.SerializationError{Err: err}
576	}
577
578	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
579		return out, metadata, &smithy.SerializationError{Err: err}
580	}
581	in.Request = request
582
583	return next.HandleSerialize(ctx, in)
584}
585func awsRestjson1_serializeOpHttpBindingsCreateDeploymentJobInput(v *CreateDeploymentJobInput, encoder *httpbinding.Encoder) error {
586	if v == nil {
587		return fmt.Errorf("unsupported serialization of nil %T", v)
588	}
589
590	return nil
591}
592
593func awsRestjson1_serializeOpDocumentCreateDeploymentJobInput(v *CreateDeploymentJobInput, value smithyjson.Value) error {
594	object := value.Object()
595	defer object.Close()
596
597	if v.ClientRequestToken != nil {
598		ok := object.Key("clientRequestToken")
599		ok.String(*v.ClientRequestToken)
600	}
601
602	if v.DeploymentApplicationConfigs != nil {
603		ok := object.Key("deploymentApplicationConfigs")
604		if err := awsRestjson1_serializeDocumentDeploymentApplicationConfigs(v.DeploymentApplicationConfigs, ok); err != nil {
605			return err
606		}
607	}
608
609	if v.DeploymentConfig != nil {
610		ok := object.Key("deploymentConfig")
611		if err := awsRestjson1_serializeDocumentDeploymentConfig(v.DeploymentConfig, ok); err != nil {
612			return err
613		}
614	}
615
616	if v.Fleet != nil {
617		ok := object.Key("fleet")
618		ok.String(*v.Fleet)
619	}
620
621	if v.Tags != nil {
622		ok := object.Key("tags")
623		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
624			return err
625		}
626	}
627
628	return nil
629}
630
631type awsRestjson1_serializeOpCreateFleet struct {
632}
633
634func (*awsRestjson1_serializeOpCreateFleet) ID() string {
635	return "OperationSerializer"
636}
637
638func (m *awsRestjson1_serializeOpCreateFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
639	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
640) {
641	request, ok := in.Request.(*smithyhttp.Request)
642	if !ok {
643		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
644	}
645
646	input, ok := in.Parameters.(*CreateFleetInput)
647	_ = input
648	if !ok {
649		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
650	}
651
652	opPath, opQuery := httpbinding.SplitURI("/createFleet")
653	request.URL.Path = opPath
654	if len(request.URL.RawQuery) > 0 {
655		request.URL.RawQuery = "&" + opQuery
656	} else {
657		request.URL.RawQuery = opQuery
658	}
659
660	request.Method = "POST"
661	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
662	if err != nil {
663		return out, metadata, &smithy.SerializationError{Err: err}
664	}
665
666	restEncoder.SetHeader("Content-Type").String("application/json")
667
668	jsonEncoder := smithyjson.NewEncoder()
669	if err := awsRestjson1_serializeOpDocumentCreateFleetInput(input, jsonEncoder.Value); err != nil {
670		return out, metadata, &smithy.SerializationError{Err: err}
671	}
672
673	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
674		return out, metadata, &smithy.SerializationError{Err: err}
675	}
676
677	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
678		return out, metadata, &smithy.SerializationError{Err: err}
679	}
680	in.Request = request
681
682	return next.HandleSerialize(ctx, in)
683}
684func awsRestjson1_serializeOpHttpBindingsCreateFleetInput(v *CreateFleetInput, encoder *httpbinding.Encoder) error {
685	if v == nil {
686		return fmt.Errorf("unsupported serialization of nil %T", v)
687	}
688
689	return nil
690}
691
692func awsRestjson1_serializeOpDocumentCreateFleetInput(v *CreateFleetInput, value smithyjson.Value) error {
693	object := value.Object()
694	defer object.Close()
695
696	if v.Name != nil {
697		ok := object.Key("name")
698		ok.String(*v.Name)
699	}
700
701	if v.Tags != nil {
702		ok := object.Key("tags")
703		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
704			return err
705		}
706	}
707
708	return nil
709}
710
711type awsRestjson1_serializeOpCreateRobot struct {
712}
713
714func (*awsRestjson1_serializeOpCreateRobot) ID() string {
715	return "OperationSerializer"
716}
717
718func (m *awsRestjson1_serializeOpCreateRobot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
719	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
720) {
721	request, ok := in.Request.(*smithyhttp.Request)
722	if !ok {
723		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
724	}
725
726	input, ok := in.Parameters.(*CreateRobotInput)
727	_ = input
728	if !ok {
729		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
730	}
731
732	opPath, opQuery := httpbinding.SplitURI("/createRobot")
733	request.URL.Path = opPath
734	if len(request.URL.RawQuery) > 0 {
735		request.URL.RawQuery = "&" + opQuery
736	} else {
737		request.URL.RawQuery = opQuery
738	}
739
740	request.Method = "POST"
741	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
742	if err != nil {
743		return out, metadata, &smithy.SerializationError{Err: err}
744	}
745
746	restEncoder.SetHeader("Content-Type").String("application/json")
747
748	jsonEncoder := smithyjson.NewEncoder()
749	if err := awsRestjson1_serializeOpDocumentCreateRobotInput(input, jsonEncoder.Value); err != nil {
750		return out, metadata, &smithy.SerializationError{Err: err}
751	}
752
753	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
754		return out, metadata, &smithy.SerializationError{Err: err}
755	}
756
757	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
758		return out, metadata, &smithy.SerializationError{Err: err}
759	}
760	in.Request = request
761
762	return next.HandleSerialize(ctx, in)
763}
764func awsRestjson1_serializeOpHttpBindingsCreateRobotInput(v *CreateRobotInput, encoder *httpbinding.Encoder) error {
765	if v == nil {
766		return fmt.Errorf("unsupported serialization of nil %T", v)
767	}
768
769	return nil
770}
771
772func awsRestjson1_serializeOpDocumentCreateRobotInput(v *CreateRobotInput, value smithyjson.Value) error {
773	object := value.Object()
774	defer object.Close()
775
776	if len(v.Architecture) > 0 {
777		ok := object.Key("architecture")
778		ok.String(string(v.Architecture))
779	}
780
781	if v.GreengrassGroupId != nil {
782		ok := object.Key("greengrassGroupId")
783		ok.String(*v.GreengrassGroupId)
784	}
785
786	if v.Name != nil {
787		ok := object.Key("name")
788		ok.String(*v.Name)
789	}
790
791	if v.Tags != nil {
792		ok := object.Key("tags")
793		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
794			return err
795		}
796	}
797
798	return nil
799}
800
801type awsRestjson1_serializeOpCreateRobotApplication struct {
802}
803
804func (*awsRestjson1_serializeOpCreateRobotApplication) ID() string {
805	return "OperationSerializer"
806}
807
808func (m *awsRestjson1_serializeOpCreateRobotApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
809	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
810) {
811	request, ok := in.Request.(*smithyhttp.Request)
812	if !ok {
813		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
814	}
815
816	input, ok := in.Parameters.(*CreateRobotApplicationInput)
817	_ = input
818	if !ok {
819		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
820	}
821
822	opPath, opQuery := httpbinding.SplitURI("/createRobotApplication")
823	request.URL.Path = opPath
824	if len(request.URL.RawQuery) > 0 {
825		request.URL.RawQuery = "&" + opQuery
826	} else {
827		request.URL.RawQuery = opQuery
828	}
829
830	request.Method = "POST"
831	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
832	if err != nil {
833		return out, metadata, &smithy.SerializationError{Err: err}
834	}
835
836	restEncoder.SetHeader("Content-Type").String("application/json")
837
838	jsonEncoder := smithyjson.NewEncoder()
839	if err := awsRestjson1_serializeOpDocumentCreateRobotApplicationInput(input, jsonEncoder.Value); err != nil {
840		return out, metadata, &smithy.SerializationError{Err: err}
841	}
842
843	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
844		return out, metadata, &smithy.SerializationError{Err: err}
845	}
846
847	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
848		return out, metadata, &smithy.SerializationError{Err: err}
849	}
850	in.Request = request
851
852	return next.HandleSerialize(ctx, in)
853}
854func awsRestjson1_serializeOpHttpBindingsCreateRobotApplicationInput(v *CreateRobotApplicationInput, encoder *httpbinding.Encoder) error {
855	if v == nil {
856		return fmt.Errorf("unsupported serialization of nil %T", v)
857	}
858
859	return nil
860}
861
862func awsRestjson1_serializeOpDocumentCreateRobotApplicationInput(v *CreateRobotApplicationInput, value smithyjson.Value) error {
863	object := value.Object()
864	defer object.Close()
865
866	if v.Name != nil {
867		ok := object.Key("name")
868		ok.String(*v.Name)
869	}
870
871	if v.RobotSoftwareSuite != nil {
872		ok := object.Key("robotSoftwareSuite")
873		if err := awsRestjson1_serializeDocumentRobotSoftwareSuite(v.RobotSoftwareSuite, ok); err != nil {
874			return err
875		}
876	}
877
878	if v.Sources != nil {
879		ok := object.Key("sources")
880		if err := awsRestjson1_serializeDocumentSourceConfigs(v.Sources, ok); err != nil {
881			return err
882		}
883	}
884
885	if v.Tags != nil {
886		ok := object.Key("tags")
887		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
888			return err
889		}
890	}
891
892	return nil
893}
894
895type awsRestjson1_serializeOpCreateRobotApplicationVersion struct {
896}
897
898func (*awsRestjson1_serializeOpCreateRobotApplicationVersion) ID() string {
899	return "OperationSerializer"
900}
901
902func (m *awsRestjson1_serializeOpCreateRobotApplicationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
903	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
904) {
905	request, ok := in.Request.(*smithyhttp.Request)
906	if !ok {
907		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
908	}
909
910	input, ok := in.Parameters.(*CreateRobotApplicationVersionInput)
911	_ = input
912	if !ok {
913		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
914	}
915
916	opPath, opQuery := httpbinding.SplitURI("/createRobotApplicationVersion")
917	request.URL.Path = opPath
918	if len(request.URL.RawQuery) > 0 {
919		request.URL.RawQuery = "&" + opQuery
920	} else {
921		request.URL.RawQuery = opQuery
922	}
923
924	request.Method = "POST"
925	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
926	if err != nil {
927		return out, metadata, &smithy.SerializationError{Err: err}
928	}
929
930	restEncoder.SetHeader("Content-Type").String("application/json")
931
932	jsonEncoder := smithyjson.NewEncoder()
933	if err := awsRestjson1_serializeOpDocumentCreateRobotApplicationVersionInput(input, jsonEncoder.Value); err != nil {
934		return out, metadata, &smithy.SerializationError{Err: err}
935	}
936
937	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
938		return out, metadata, &smithy.SerializationError{Err: err}
939	}
940
941	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
942		return out, metadata, &smithy.SerializationError{Err: err}
943	}
944	in.Request = request
945
946	return next.HandleSerialize(ctx, in)
947}
948func awsRestjson1_serializeOpHttpBindingsCreateRobotApplicationVersionInput(v *CreateRobotApplicationVersionInput, encoder *httpbinding.Encoder) error {
949	if v == nil {
950		return fmt.Errorf("unsupported serialization of nil %T", v)
951	}
952
953	return nil
954}
955
956func awsRestjson1_serializeOpDocumentCreateRobotApplicationVersionInput(v *CreateRobotApplicationVersionInput, value smithyjson.Value) error {
957	object := value.Object()
958	defer object.Close()
959
960	if v.Application != nil {
961		ok := object.Key("application")
962		ok.String(*v.Application)
963	}
964
965	if v.CurrentRevisionId != nil {
966		ok := object.Key("currentRevisionId")
967		ok.String(*v.CurrentRevisionId)
968	}
969
970	return nil
971}
972
973type awsRestjson1_serializeOpCreateSimulationApplication struct {
974}
975
976func (*awsRestjson1_serializeOpCreateSimulationApplication) ID() string {
977	return "OperationSerializer"
978}
979
980func (m *awsRestjson1_serializeOpCreateSimulationApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
981	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
982) {
983	request, ok := in.Request.(*smithyhttp.Request)
984	if !ok {
985		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
986	}
987
988	input, ok := in.Parameters.(*CreateSimulationApplicationInput)
989	_ = input
990	if !ok {
991		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
992	}
993
994	opPath, opQuery := httpbinding.SplitURI("/createSimulationApplication")
995	request.URL.Path = opPath
996	if len(request.URL.RawQuery) > 0 {
997		request.URL.RawQuery = "&" + opQuery
998	} else {
999		request.URL.RawQuery = opQuery
1000	}
1001
1002	request.Method = "POST"
1003	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1004	if err != nil {
1005		return out, metadata, &smithy.SerializationError{Err: err}
1006	}
1007
1008	restEncoder.SetHeader("Content-Type").String("application/json")
1009
1010	jsonEncoder := smithyjson.NewEncoder()
1011	if err := awsRestjson1_serializeOpDocumentCreateSimulationApplicationInput(input, jsonEncoder.Value); err != nil {
1012		return out, metadata, &smithy.SerializationError{Err: err}
1013	}
1014
1015	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1016		return out, metadata, &smithy.SerializationError{Err: err}
1017	}
1018
1019	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1020		return out, metadata, &smithy.SerializationError{Err: err}
1021	}
1022	in.Request = request
1023
1024	return next.HandleSerialize(ctx, in)
1025}
1026func awsRestjson1_serializeOpHttpBindingsCreateSimulationApplicationInput(v *CreateSimulationApplicationInput, encoder *httpbinding.Encoder) error {
1027	if v == nil {
1028		return fmt.Errorf("unsupported serialization of nil %T", v)
1029	}
1030
1031	return nil
1032}
1033
1034func awsRestjson1_serializeOpDocumentCreateSimulationApplicationInput(v *CreateSimulationApplicationInput, value smithyjson.Value) error {
1035	object := value.Object()
1036	defer object.Close()
1037
1038	if v.Name != nil {
1039		ok := object.Key("name")
1040		ok.String(*v.Name)
1041	}
1042
1043	if v.RenderingEngine != nil {
1044		ok := object.Key("renderingEngine")
1045		if err := awsRestjson1_serializeDocumentRenderingEngine(v.RenderingEngine, ok); err != nil {
1046			return err
1047		}
1048	}
1049
1050	if v.RobotSoftwareSuite != nil {
1051		ok := object.Key("robotSoftwareSuite")
1052		if err := awsRestjson1_serializeDocumentRobotSoftwareSuite(v.RobotSoftwareSuite, ok); err != nil {
1053			return err
1054		}
1055	}
1056
1057	if v.SimulationSoftwareSuite != nil {
1058		ok := object.Key("simulationSoftwareSuite")
1059		if err := awsRestjson1_serializeDocumentSimulationSoftwareSuite(v.SimulationSoftwareSuite, ok); err != nil {
1060			return err
1061		}
1062	}
1063
1064	if v.Sources != nil {
1065		ok := object.Key("sources")
1066		if err := awsRestjson1_serializeDocumentSourceConfigs(v.Sources, ok); err != nil {
1067			return err
1068		}
1069	}
1070
1071	if v.Tags != nil {
1072		ok := object.Key("tags")
1073		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
1074			return err
1075		}
1076	}
1077
1078	return nil
1079}
1080
1081type awsRestjson1_serializeOpCreateSimulationApplicationVersion struct {
1082}
1083
1084func (*awsRestjson1_serializeOpCreateSimulationApplicationVersion) ID() string {
1085	return "OperationSerializer"
1086}
1087
1088func (m *awsRestjson1_serializeOpCreateSimulationApplicationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1089	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1090) {
1091	request, ok := in.Request.(*smithyhttp.Request)
1092	if !ok {
1093		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1094	}
1095
1096	input, ok := in.Parameters.(*CreateSimulationApplicationVersionInput)
1097	_ = input
1098	if !ok {
1099		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1100	}
1101
1102	opPath, opQuery := httpbinding.SplitURI("/createSimulationApplicationVersion")
1103	request.URL.Path = opPath
1104	if len(request.URL.RawQuery) > 0 {
1105		request.URL.RawQuery = "&" + opQuery
1106	} else {
1107		request.URL.RawQuery = opQuery
1108	}
1109
1110	request.Method = "POST"
1111	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1112	if err != nil {
1113		return out, metadata, &smithy.SerializationError{Err: err}
1114	}
1115
1116	restEncoder.SetHeader("Content-Type").String("application/json")
1117
1118	jsonEncoder := smithyjson.NewEncoder()
1119	if err := awsRestjson1_serializeOpDocumentCreateSimulationApplicationVersionInput(input, jsonEncoder.Value); err != nil {
1120		return out, metadata, &smithy.SerializationError{Err: err}
1121	}
1122
1123	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1124		return out, metadata, &smithy.SerializationError{Err: err}
1125	}
1126
1127	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1128		return out, metadata, &smithy.SerializationError{Err: err}
1129	}
1130	in.Request = request
1131
1132	return next.HandleSerialize(ctx, in)
1133}
1134func awsRestjson1_serializeOpHttpBindingsCreateSimulationApplicationVersionInput(v *CreateSimulationApplicationVersionInput, encoder *httpbinding.Encoder) error {
1135	if v == nil {
1136		return fmt.Errorf("unsupported serialization of nil %T", v)
1137	}
1138
1139	return nil
1140}
1141
1142func awsRestjson1_serializeOpDocumentCreateSimulationApplicationVersionInput(v *CreateSimulationApplicationVersionInput, value smithyjson.Value) error {
1143	object := value.Object()
1144	defer object.Close()
1145
1146	if v.Application != nil {
1147		ok := object.Key("application")
1148		ok.String(*v.Application)
1149	}
1150
1151	if v.CurrentRevisionId != nil {
1152		ok := object.Key("currentRevisionId")
1153		ok.String(*v.CurrentRevisionId)
1154	}
1155
1156	return nil
1157}
1158
1159type awsRestjson1_serializeOpCreateSimulationJob struct {
1160}
1161
1162func (*awsRestjson1_serializeOpCreateSimulationJob) ID() string {
1163	return "OperationSerializer"
1164}
1165
1166func (m *awsRestjson1_serializeOpCreateSimulationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1167	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1168) {
1169	request, ok := in.Request.(*smithyhttp.Request)
1170	if !ok {
1171		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1172	}
1173
1174	input, ok := in.Parameters.(*CreateSimulationJobInput)
1175	_ = input
1176	if !ok {
1177		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1178	}
1179
1180	opPath, opQuery := httpbinding.SplitURI("/createSimulationJob")
1181	request.URL.Path = opPath
1182	if len(request.URL.RawQuery) > 0 {
1183		request.URL.RawQuery = "&" + opQuery
1184	} else {
1185		request.URL.RawQuery = opQuery
1186	}
1187
1188	request.Method = "POST"
1189	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1190	if err != nil {
1191		return out, metadata, &smithy.SerializationError{Err: err}
1192	}
1193
1194	restEncoder.SetHeader("Content-Type").String("application/json")
1195
1196	jsonEncoder := smithyjson.NewEncoder()
1197	if err := awsRestjson1_serializeOpDocumentCreateSimulationJobInput(input, jsonEncoder.Value); err != nil {
1198		return out, metadata, &smithy.SerializationError{Err: err}
1199	}
1200
1201	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1202		return out, metadata, &smithy.SerializationError{Err: err}
1203	}
1204
1205	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1206		return out, metadata, &smithy.SerializationError{Err: err}
1207	}
1208	in.Request = request
1209
1210	return next.HandleSerialize(ctx, in)
1211}
1212func awsRestjson1_serializeOpHttpBindingsCreateSimulationJobInput(v *CreateSimulationJobInput, encoder *httpbinding.Encoder) error {
1213	if v == nil {
1214		return fmt.Errorf("unsupported serialization of nil %T", v)
1215	}
1216
1217	return nil
1218}
1219
1220func awsRestjson1_serializeOpDocumentCreateSimulationJobInput(v *CreateSimulationJobInput, value smithyjson.Value) error {
1221	object := value.Object()
1222	defer object.Close()
1223
1224	if v.ClientRequestToken != nil {
1225		ok := object.Key("clientRequestToken")
1226		ok.String(*v.ClientRequestToken)
1227	}
1228
1229	if v.Compute != nil {
1230		ok := object.Key("compute")
1231		if err := awsRestjson1_serializeDocumentCompute(v.Compute, ok); err != nil {
1232			return err
1233		}
1234	}
1235
1236	if v.DataSources != nil {
1237		ok := object.Key("dataSources")
1238		if err := awsRestjson1_serializeDocumentDataSourceConfigs(v.DataSources, ok); err != nil {
1239			return err
1240		}
1241	}
1242
1243	if len(v.FailureBehavior) > 0 {
1244		ok := object.Key("failureBehavior")
1245		ok.String(string(v.FailureBehavior))
1246	}
1247
1248	if v.IamRole != nil {
1249		ok := object.Key("iamRole")
1250		ok.String(*v.IamRole)
1251	}
1252
1253	if v.LoggingConfig != nil {
1254		ok := object.Key("loggingConfig")
1255		if err := awsRestjson1_serializeDocumentLoggingConfig(v.LoggingConfig, ok); err != nil {
1256			return err
1257		}
1258	}
1259
1260	if v.MaxJobDurationInSeconds != 0 {
1261		ok := object.Key("maxJobDurationInSeconds")
1262		ok.Long(v.MaxJobDurationInSeconds)
1263	}
1264
1265	if v.OutputLocation != nil {
1266		ok := object.Key("outputLocation")
1267		if err := awsRestjson1_serializeDocumentOutputLocation(v.OutputLocation, ok); err != nil {
1268			return err
1269		}
1270	}
1271
1272	if v.RobotApplications != nil {
1273		ok := object.Key("robotApplications")
1274		if err := awsRestjson1_serializeDocumentRobotApplicationConfigs(v.RobotApplications, ok); err != nil {
1275			return err
1276		}
1277	}
1278
1279	if v.SimulationApplications != nil {
1280		ok := object.Key("simulationApplications")
1281		if err := awsRestjson1_serializeDocumentSimulationApplicationConfigs(v.SimulationApplications, ok); err != nil {
1282			return err
1283		}
1284	}
1285
1286	if v.Tags != nil {
1287		ok := object.Key("tags")
1288		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
1289			return err
1290		}
1291	}
1292
1293	if v.VpcConfig != nil {
1294		ok := object.Key("vpcConfig")
1295		if err := awsRestjson1_serializeDocumentVPCConfig(v.VpcConfig, ok); err != nil {
1296			return err
1297		}
1298	}
1299
1300	return nil
1301}
1302
1303type awsRestjson1_serializeOpCreateWorldExportJob struct {
1304}
1305
1306func (*awsRestjson1_serializeOpCreateWorldExportJob) ID() string {
1307	return "OperationSerializer"
1308}
1309
1310func (m *awsRestjson1_serializeOpCreateWorldExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1311	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1312) {
1313	request, ok := in.Request.(*smithyhttp.Request)
1314	if !ok {
1315		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1316	}
1317
1318	input, ok := in.Parameters.(*CreateWorldExportJobInput)
1319	_ = input
1320	if !ok {
1321		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1322	}
1323
1324	opPath, opQuery := httpbinding.SplitURI("/createWorldExportJob")
1325	request.URL.Path = opPath
1326	if len(request.URL.RawQuery) > 0 {
1327		request.URL.RawQuery = "&" + opQuery
1328	} else {
1329		request.URL.RawQuery = opQuery
1330	}
1331
1332	request.Method = "POST"
1333	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1334	if err != nil {
1335		return out, metadata, &smithy.SerializationError{Err: err}
1336	}
1337
1338	restEncoder.SetHeader("Content-Type").String("application/json")
1339
1340	jsonEncoder := smithyjson.NewEncoder()
1341	if err := awsRestjson1_serializeOpDocumentCreateWorldExportJobInput(input, jsonEncoder.Value); err != nil {
1342		return out, metadata, &smithy.SerializationError{Err: err}
1343	}
1344
1345	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1346		return out, metadata, &smithy.SerializationError{Err: err}
1347	}
1348
1349	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1350		return out, metadata, &smithy.SerializationError{Err: err}
1351	}
1352	in.Request = request
1353
1354	return next.HandleSerialize(ctx, in)
1355}
1356func awsRestjson1_serializeOpHttpBindingsCreateWorldExportJobInput(v *CreateWorldExportJobInput, encoder *httpbinding.Encoder) error {
1357	if v == nil {
1358		return fmt.Errorf("unsupported serialization of nil %T", v)
1359	}
1360
1361	return nil
1362}
1363
1364func awsRestjson1_serializeOpDocumentCreateWorldExportJobInput(v *CreateWorldExportJobInput, value smithyjson.Value) error {
1365	object := value.Object()
1366	defer object.Close()
1367
1368	if v.ClientRequestToken != nil {
1369		ok := object.Key("clientRequestToken")
1370		ok.String(*v.ClientRequestToken)
1371	}
1372
1373	if v.IamRole != nil {
1374		ok := object.Key("iamRole")
1375		ok.String(*v.IamRole)
1376	}
1377
1378	if v.OutputLocation != nil {
1379		ok := object.Key("outputLocation")
1380		if err := awsRestjson1_serializeDocumentOutputLocation(v.OutputLocation, ok); err != nil {
1381			return err
1382		}
1383	}
1384
1385	if v.Tags != nil {
1386		ok := object.Key("tags")
1387		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
1388			return err
1389		}
1390	}
1391
1392	if v.Worlds != nil {
1393		ok := object.Key("worlds")
1394		if err := awsRestjson1_serializeDocumentArns(v.Worlds, ok); err != nil {
1395			return err
1396		}
1397	}
1398
1399	return nil
1400}
1401
1402type awsRestjson1_serializeOpCreateWorldGenerationJob struct {
1403}
1404
1405func (*awsRestjson1_serializeOpCreateWorldGenerationJob) ID() string {
1406	return "OperationSerializer"
1407}
1408
1409func (m *awsRestjson1_serializeOpCreateWorldGenerationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1410	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1411) {
1412	request, ok := in.Request.(*smithyhttp.Request)
1413	if !ok {
1414		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1415	}
1416
1417	input, ok := in.Parameters.(*CreateWorldGenerationJobInput)
1418	_ = input
1419	if !ok {
1420		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1421	}
1422
1423	opPath, opQuery := httpbinding.SplitURI("/createWorldGenerationJob")
1424	request.URL.Path = opPath
1425	if len(request.URL.RawQuery) > 0 {
1426		request.URL.RawQuery = "&" + opQuery
1427	} else {
1428		request.URL.RawQuery = opQuery
1429	}
1430
1431	request.Method = "POST"
1432	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1433	if err != nil {
1434		return out, metadata, &smithy.SerializationError{Err: err}
1435	}
1436
1437	restEncoder.SetHeader("Content-Type").String("application/json")
1438
1439	jsonEncoder := smithyjson.NewEncoder()
1440	if err := awsRestjson1_serializeOpDocumentCreateWorldGenerationJobInput(input, jsonEncoder.Value); err != nil {
1441		return out, metadata, &smithy.SerializationError{Err: err}
1442	}
1443
1444	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1445		return out, metadata, &smithy.SerializationError{Err: err}
1446	}
1447
1448	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1449		return out, metadata, &smithy.SerializationError{Err: err}
1450	}
1451	in.Request = request
1452
1453	return next.HandleSerialize(ctx, in)
1454}
1455func awsRestjson1_serializeOpHttpBindingsCreateWorldGenerationJobInput(v *CreateWorldGenerationJobInput, encoder *httpbinding.Encoder) error {
1456	if v == nil {
1457		return fmt.Errorf("unsupported serialization of nil %T", v)
1458	}
1459
1460	return nil
1461}
1462
1463func awsRestjson1_serializeOpDocumentCreateWorldGenerationJobInput(v *CreateWorldGenerationJobInput, value smithyjson.Value) error {
1464	object := value.Object()
1465	defer object.Close()
1466
1467	if v.ClientRequestToken != nil {
1468		ok := object.Key("clientRequestToken")
1469		ok.String(*v.ClientRequestToken)
1470	}
1471
1472	if v.Tags != nil {
1473		ok := object.Key("tags")
1474		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
1475			return err
1476		}
1477	}
1478
1479	if v.Template != nil {
1480		ok := object.Key("template")
1481		ok.String(*v.Template)
1482	}
1483
1484	if v.WorldCount != nil {
1485		ok := object.Key("worldCount")
1486		if err := awsRestjson1_serializeDocumentWorldCount(v.WorldCount, ok); err != nil {
1487			return err
1488		}
1489	}
1490
1491	if v.WorldTags != nil {
1492		ok := object.Key("worldTags")
1493		if err := awsRestjson1_serializeDocumentTagMap(v.WorldTags, ok); err != nil {
1494			return err
1495		}
1496	}
1497
1498	return nil
1499}
1500
1501type awsRestjson1_serializeOpCreateWorldTemplate struct {
1502}
1503
1504func (*awsRestjson1_serializeOpCreateWorldTemplate) ID() string {
1505	return "OperationSerializer"
1506}
1507
1508func (m *awsRestjson1_serializeOpCreateWorldTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1509	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1510) {
1511	request, ok := in.Request.(*smithyhttp.Request)
1512	if !ok {
1513		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1514	}
1515
1516	input, ok := in.Parameters.(*CreateWorldTemplateInput)
1517	_ = input
1518	if !ok {
1519		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1520	}
1521
1522	opPath, opQuery := httpbinding.SplitURI("/createWorldTemplate")
1523	request.URL.Path = opPath
1524	if len(request.URL.RawQuery) > 0 {
1525		request.URL.RawQuery = "&" + opQuery
1526	} else {
1527		request.URL.RawQuery = opQuery
1528	}
1529
1530	request.Method = "POST"
1531	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1532	if err != nil {
1533		return out, metadata, &smithy.SerializationError{Err: err}
1534	}
1535
1536	restEncoder.SetHeader("Content-Type").String("application/json")
1537
1538	jsonEncoder := smithyjson.NewEncoder()
1539	if err := awsRestjson1_serializeOpDocumentCreateWorldTemplateInput(input, jsonEncoder.Value); err != nil {
1540		return out, metadata, &smithy.SerializationError{Err: err}
1541	}
1542
1543	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1544		return out, metadata, &smithy.SerializationError{Err: err}
1545	}
1546
1547	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1548		return out, metadata, &smithy.SerializationError{Err: err}
1549	}
1550	in.Request = request
1551
1552	return next.HandleSerialize(ctx, in)
1553}
1554func awsRestjson1_serializeOpHttpBindingsCreateWorldTemplateInput(v *CreateWorldTemplateInput, encoder *httpbinding.Encoder) error {
1555	if v == nil {
1556		return fmt.Errorf("unsupported serialization of nil %T", v)
1557	}
1558
1559	return nil
1560}
1561
1562func awsRestjson1_serializeOpDocumentCreateWorldTemplateInput(v *CreateWorldTemplateInput, value smithyjson.Value) error {
1563	object := value.Object()
1564	defer object.Close()
1565
1566	if v.ClientRequestToken != nil {
1567		ok := object.Key("clientRequestToken")
1568		ok.String(*v.ClientRequestToken)
1569	}
1570
1571	if v.Name != nil {
1572		ok := object.Key("name")
1573		ok.String(*v.Name)
1574	}
1575
1576	if v.Tags != nil {
1577		ok := object.Key("tags")
1578		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
1579			return err
1580		}
1581	}
1582
1583	if v.TemplateBody != nil {
1584		ok := object.Key("templateBody")
1585		ok.String(*v.TemplateBody)
1586	}
1587
1588	if v.TemplateLocation != nil {
1589		ok := object.Key("templateLocation")
1590		if err := awsRestjson1_serializeDocumentTemplateLocation(v.TemplateLocation, ok); err != nil {
1591			return err
1592		}
1593	}
1594
1595	return nil
1596}
1597
1598type awsRestjson1_serializeOpDeleteFleet struct {
1599}
1600
1601func (*awsRestjson1_serializeOpDeleteFleet) ID() string {
1602	return "OperationSerializer"
1603}
1604
1605func (m *awsRestjson1_serializeOpDeleteFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1606	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1607) {
1608	request, ok := in.Request.(*smithyhttp.Request)
1609	if !ok {
1610		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1611	}
1612
1613	input, ok := in.Parameters.(*DeleteFleetInput)
1614	_ = input
1615	if !ok {
1616		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1617	}
1618
1619	opPath, opQuery := httpbinding.SplitURI("/deleteFleet")
1620	request.URL.Path = opPath
1621	if len(request.URL.RawQuery) > 0 {
1622		request.URL.RawQuery = "&" + opQuery
1623	} else {
1624		request.URL.RawQuery = opQuery
1625	}
1626
1627	request.Method = "POST"
1628	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1629	if err != nil {
1630		return out, metadata, &smithy.SerializationError{Err: err}
1631	}
1632
1633	restEncoder.SetHeader("Content-Type").String("application/json")
1634
1635	jsonEncoder := smithyjson.NewEncoder()
1636	if err := awsRestjson1_serializeOpDocumentDeleteFleetInput(input, jsonEncoder.Value); err != nil {
1637		return out, metadata, &smithy.SerializationError{Err: err}
1638	}
1639
1640	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1641		return out, metadata, &smithy.SerializationError{Err: err}
1642	}
1643
1644	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1645		return out, metadata, &smithy.SerializationError{Err: err}
1646	}
1647	in.Request = request
1648
1649	return next.HandleSerialize(ctx, in)
1650}
1651func awsRestjson1_serializeOpHttpBindingsDeleteFleetInput(v *DeleteFleetInput, encoder *httpbinding.Encoder) error {
1652	if v == nil {
1653		return fmt.Errorf("unsupported serialization of nil %T", v)
1654	}
1655
1656	return nil
1657}
1658
1659func awsRestjson1_serializeOpDocumentDeleteFleetInput(v *DeleteFleetInput, value smithyjson.Value) error {
1660	object := value.Object()
1661	defer object.Close()
1662
1663	if v.Fleet != nil {
1664		ok := object.Key("fleet")
1665		ok.String(*v.Fleet)
1666	}
1667
1668	return nil
1669}
1670
1671type awsRestjson1_serializeOpDeleteRobot struct {
1672}
1673
1674func (*awsRestjson1_serializeOpDeleteRobot) ID() string {
1675	return "OperationSerializer"
1676}
1677
1678func (m *awsRestjson1_serializeOpDeleteRobot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1679	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1680) {
1681	request, ok := in.Request.(*smithyhttp.Request)
1682	if !ok {
1683		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1684	}
1685
1686	input, ok := in.Parameters.(*DeleteRobotInput)
1687	_ = input
1688	if !ok {
1689		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1690	}
1691
1692	opPath, opQuery := httpbinding.SplitURI("/deleteRobot")
1693	request.URL.Path = opPath
1694	if len(request.URL.RawQuery) > 0 {
1695		request.URL.RawQuery = "&" + opQuery
1696	} else {
1697		request.URL.RawQuery = opQuery
1698	}
1699
1700	request.Method = "POST"
1701	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1702	if err != nil {
1703		return out, metadata, &smithy.SerializationError{Err: err}
1704	}
1705
1706	restEncoder.SetHeader("Content-Type").String("application/json")
1707
1708	jsonEncoder := smithyjson.NewEncoder()
1709	if err := awsRestjson1_serializeOpDocumentDeleteRobotInput(input, jsonEncoder.Value); err != nil {
1710		return out, metadata, &smithy.SerializationError{Err: err}
1711	}
1712
1713	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1714		return out, metadata, &smithy.SerializationError{Err: err}
1715	}
1716
1717	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1718		return out, metadata, &smithy.SerializationError{Err: err}
1719	}
1720	in.Request = request
1721
1722	return next.HandleSerialize(ctx, in)
1723}
1724func awsRestjson1_serializeOpHttpBindingsDeleteRobotInput(v *DeleteRobotInput, encoder *httpbinding.Encoder) error {
1725	if v == nil {
1726		return fmt.Errorf("unsupported serialization of nil %T", v)
1727	}
1728
1729	return nil
1730}
1731
1732func awsRestjson1_serializeOpDocumentDeleteRobotInput(v *DeleteRobotInput, value smithyjson.Value) error {
1733	object := value.Object()
1734	defer object.Close()
1735
1736	if v.Robot != nil {
1737		ok := object.Key("robot")
1738		ok.String(*v.Robot)
1739	}
1740
1741	return nil
1742}
1743
1744type awsRestjson1_serializeOpDeleteRobotApplication struct {
1745}
1746
1747func (*awsRestjson1_serializeOpDeleteRobotApplication) ID() string {
1748	return "OperationSerializer"
1749}
1750
1751func (m *awsRestjson1_serializeOpDeleteRobotApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1752	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1753) {
1754	request, ok := in.Request.(*smithyhttp.Request)
1755	if !ok {
1756		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1757	}
1758
1759	input, ok := in.Parameters.(*DeleteRobotApplicationInput)
1760	_ = input
1761	if !ok {
1762		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1763	}
1764
1765	opPath, opQuery := httpbinding.SplitURI("/deleteRobotApplication")
1766	request.URL.Path = opPath
1767	if len(request.URL.RawQuery) > 0 {
1768		request.URL.RawQuery = "&" + opQuery
1769	} else {
1770		request.URL.RawQuery = opQuery
1771	}
1772
1773	request.Method = "POST"
1774	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1775	if err != nil {
1776		return out, metadata, &smithy.SerializationError{Err: err}
1777	}
1778
1779	restEncoder.SetHeader("Content-Type").String("application/json")
1780
1781	jsonEncoder := smithyjson.NewEncoder()
1782	if err := awsRestjson1_serializeOpDocumentDeleteRobotApplicationInput(input, jsonEncoder.Value); err != nil {
1783		return out, metadata, &smithy.SerializationError{Err: err}
1784	}
1785
1786	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1787		return out, metadata, &smithy.SerializationError{Err: err}
1788	}
1789
1790	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1791		return out, metadata, &smithy.SerializationError{Err: err}
1792	}
1793	in.Request = request
1794
1795	return next.HandleSerialize(ctx, in)
1796}
1797func awsRestjson1_serializeOpHttpBindingsDeleteRobotApplicationInput(v *DeleteRobotApplicationInput, encoder *httpbinding.Encoder) error {
1798	if v == nil {
1799		return fmt.Errorf("unsupported serialization of nil %T", v)
1800	}
1801
1802	return nil
1803}
1804
1805func awsRestjson1_serializeOpDocumentDeleteRobotApplicationInput(v *DeleteRobotApplicationInput, value smithyjson.Value) error {
1806	object := value.Object()
1807	defer object.Close()
1808
1809	if v.Application != nil {
1810		ok := object.Key("application")
1811		ok.String(*v.Application)
1812	}
1813
1814	if v.ApplicationVersion != nil {
1815		ok := object.Key("applicationVersion")
1816		ok.String(*v.ApplicationVersion)
1817	}
1818
1819	return nil
1820}
1821
1822type awsRestjson1_serializeOpDeleteSimulationApplication struct {
1823}
1824
1825func (*awsRestjson1_serializeOpDeleteSimulationApplication) ID() string {
1826	return "OperationSerializer"
1827}
1828
1829func (m *awsRestjson1_serializeOpDeleteSimulationApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1830	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1831) {
1832	request, ok := in.Request.(*smithyhttp.Request)
1833	if !ok {
1834		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1835	}
1836
1837	input, ok := in.Parameters.(*DeleteSimulationApplicationInput)
1838	_ = input
1839	if !ok {
1840		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1841	}
1842
1843	opPath, opQuery := httpbinding.SplitURI("/deleteSimulationApplication")
1844	request.URL.Path = opPath
1845	if len(request.URL.RawQuery) > 0 {
1846		request.URL.RawQuery = "&" + opQuery
1847	} else {
1848		request.URL.RawQuery = opQuery
1849	}
1850
1851	request.Method = "POST"
1852	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1853	if err != nil {
1854		return out, metadata, &smithy.SerializationError{Err: err}
1855	}
1856
1857	restEncoder.SetHeader("Content-Type").String("application/json")
1858
1859	jsonEncoder := smithyjson.NewEncoder()
1860	if err := awsRestjson1_serializeOpDocumentDeleteSimulationApplicationInput(input, jsonEncoder.Value); err != nil {
1861		return out, metadata, &smithy.SerializationError{Err: err}
1862	}
1863
1864	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1865		return out, metadata, &smithy.SerializationError{Err: err}
1866	}
1867
1868	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1869		return out, metadata, &smithy.SerializationError{Err: err}
1870	}
1871	in.Request = request
1872
1873	return next.HandleSerialize(ctx, in)
1874}
1875func awsRestjson1_serializeOpHttpBindingsDeleteSimulationApplicationInput(v *DeleteSimulationApplicationInput, encoder *httpbinding.Encoder) error {
1876	if v == nil {
1877		return fmt.Errorf("unsupported serialization of nil %T", v)
1878	}
1879
1880	return nil
1881}
1882
1883func awsRestjson1_serializeOpDocumentDeleteSimulationApplicationInput(v *DeleteSimulationApplicationInput, value smithyjson.Value) error {
1884	object := value.Object()
1885	defer object.Close()
1886
1887	if v.Application != nil {
1888		ok := object.Key("application")
1889		ok.String(*v.Application)
1890	}
1891
1892	if v.ApplicationVersion != nil {
1893		ok := object.Key("applicationVersion")
1894		ok.String(*v.ApplicationVersion)
1895	}
1896
1897	return nil
1898}
1899
1900type awsRestjson1_serializeOpDeleteWorldTemplate struct {
1901}
1902
1903func (*awsRestjson1_serializeOpDeleteWorldTemplate) ID() string {
1904	return "OperationSerializer"
1905}
1906
1907func (m *awsRestjson1_serializeOpDeleteWorldTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1908	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1909) {
1910	request, ok := in.Request.(*smithyhttp.Request)
1911	if !ok {
1912		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1913	}
1914
1915	input, ok := in.Parameters.(*DeleteWorldTemplateInput)
1916	_ = input
1917	if !ok {
1918		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1919	}
1920
1921	opPath, opQuery := httpbinding.SplitURI("/deleteWorldTemplate")
1922	request.URL.Path = opPath
1923	if len(request.URL.RawQuery) > 0 {
1924		request.URL.RawQuery = "&" + opQuery
1925	} else {
1926		request.URL.RawQuery = opQuery
1927	}
1928
1929	request.Method = "POST"
1930	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1931	if err != nil {
1932		return out, metadata, &smithy.SerializationError{Err: err}
1933	}
1934
1935	restEncoder.SetHeader("Content-Type").String("application/json")
1936
1937	jsonEncoder := smithyjson.NewEncoder()
1938	if err := awsRestjson1_serializeOpDocumentDeleteWorldTemplateInput(input, jsonEncoder.Value); err != nil {
1939		return out, metadata, &smithy.SerializationError{Err: err}
1940	}
1941
1942	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1943		return out, metadata, &smithy.SerializationError{Err: err}
1944	}
1945
1946	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1947		return out, metadata, &smithy.SerializationError{Err: err}
1948	}
1949	in.Request = request
1950
1951	return next.HandleSerialize(ctx, in)
1952}
1953func awsRestjson1_serializeOpHttpBindingsDeleteWorldTemplateInput(v *DeleteWorldTemplateInput, encoder *httpbinding.Encoder) error {
1954	if v == nil {
1955		return fmt.Errorf("unsupported serialization of nil %T", v)
1956	}
1957
1958	return nil
1959}
1960
1961func awsRestjson1_serializeOpDocumentDeleteWorldTemplateInput(v *DeleteWorldTemplateInput, value smithyjson.Value) error {
1962	object := value.Object()
1963	defer object.Close()
1964
1965	if v.Template != nil {
1966		ok := object.Key("template")
1967		ok.String(*v.Template)
1968	}
1969
1970	return nil
1971}
1972
1973type awsRestjson1_serializeOpDeregisterRobot struct {
1974}
1975
1976func (*awsRestjson1_serializeOpDeregisterRobot) ID() string {
1977	return "OperationSerializer"
1978}
1979
1980func (m *awsRestjson1_serializeOpDeregisterRobot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1981	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1982) {
1983	request, ok := in.Request.(*smithyhttp.Request)
1984	if !ok {
1985		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1986	}
1987
1988	input, ok := in.Parameters.(*DeregisterRobotInput)
1989	_ = input
1990	if !ok {
1991		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1992	}
1993
1994	opPath, opQuery := httpbinding.SplitURI("/deregisterRobot")
1995	request.URL.Path = opPath
1996	if len(request.URL.RawQuery) > 0 {
1997		request.URL.RawQuery = "&" + opQuery
1998	} else {
1999		request.URL.RawQuery = opQuery
2000	}
2001
2002	request.Method = "POST"
2003	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2004	if err != nil {
2005		return out, metadata, &smithy.SerializationError{Err: err}
2006	}
2007
2008	restEncoder.SetHeader("Content-Type").String("application/json")
2009
2010	jsonEncoder := smithyjson.NewEncoder()
2011	if err := awsRestjson1_serializeOpDocumentDeregisterRobotInput(input, jsonEncoder.Value); err != nil {
2012		return out, metadata, &smithy.SerializationError{Err: err}
2013	}
2014
2015	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2016		return out, metadata, &smithy.SerializationError{Err: err}
2017	}
2018
2019	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2020		return out, metadata, &smithy.SerializationError{Err: err}
2021	}
2022	in.Request = request
2023
2024	return next.HandleSerialize(ctx, in)
2025}
2026func awsRestjson1_serializeOpHttpBindingsDeregisterRobotInput(v *DeregisterRobotInput, encoder *httpbinding.Encoder) error {
2027	if v == nil {
2028		return fmt.Errorf("unsupported serialization of nil %T", v)
2029	}
2030
2031	return nil
2032}
2033
2034func awsRestjson1_serializeOpDocumentDeregisterRobotInput(v *DeregisterRobotInput, value smithyjson.Value) error {
2035	object := value.Object()
2036	defer object.Close()
2037
2038	if v.Fleet != nil {
2039		ok := object.Key("fleet")
2040		ok.String(*v.Fleet)
2041	}
2042
2043	if v.Robot != nil {
2044		ok := object.Key("robot")
2045		ok.String(*v.Robot)
2046	}
2047
2048	return nil
2049}
2050
2051type awsRestjson1_serializeOpDescribeDeploymentJob struct {
2052}
2053
2054func (*awsRestjson1_serializeOpDescribeDeploymentJob) ID() string {
2055	return "OperationSerializer"
2056}
2057
2058func (m *awsRestjson1_serializeOpDescribeDeploymentJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2059	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2060) {
2061	request, ok := in.Request.(*smithyhttp.Request)
2062	if !ok {
2063		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2064	}
2065
2066	input, ok := in.Parameters.(*DescribeDeploymentJobInput)
2067	_ = input
2068	if !ok {
2069		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2070	}
2071
2072	opPath, opQuery := httpbinding.SplitURI("/describeDeploymentJob")
2073	request.URL.Path = opPath
2074	if len(request.URL.RawQuery) > 0 {
2075		request.URL.RawQuery = "&" + opQuery
2076	} else {
2077		request.URL.RawQuery = opQuery
2078	}
2079
2080	request.Method = "POST"
2081	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2082	if err != nil {
2083		return out, metadata, &smithy.SerializationError{Err: err}
2084	}
2085
2086	restEncoder.SetHeader("Content-Type").String("application/json")
2087
2088	jsonEncoder := smithyjson.NewEncoder()
2089	if err := awsRestjson1_serializeOpDocumentDescribeDeploymentJobInput(input, jsonEncoder.Value); err != nil {
2090		return out, metadata, &smithy.SerializationError{Err: err}
2091	}
2092
2093	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2094		return out, metadata, &smithy.SerializationError{Err: err}
2095	}
2096
2097	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2098		return out, metadata, &smithy.SerializationError{Err: err}
2099	}
2100	in.Request = request
2101
2102	return next.HandleSerialize(ctx, in)
2103}
2104func awsRestjson1_serializeOpHttpBindingsDescribeDeploymentJobInput(v *DescribeDeploymentJobInput, encoder *httpbinding.Encoder) error {
2105	if v == nil {
2106		return fmt.Errorf("unsupported serialization of nil %T", v)
2107	}
2108
2109	return nil
2110}
2111
2112func awsRestjson1_serializeOpDocumentDescribeDeploymentJobInput(v *DescribeDeploymentJobInput, value smithyjson.Value) error {
2113	object := value.Object()
2114	defer object.Close()
2115
2116	if v.Job != nil {
2117		ok := object.Key("job")
2118		ok.String(*v.Job)
2119	}
2120
2121	return nil
2122}
2123
2124type awsRestjson1_serializeOpDescribeFleet struct {
2125}
2126
2127func (*awsRestjson1_serializeOpDescribeFleet) ID() string {
2128	return "OperationSerializer"
2129}
2130
2131func (m *awsRestjson1_serializeOpDescribeFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2132	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2133) {
2134	request, ok := in.Request.(*smithyhttp.Request)
2135	if !ok {
2136		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2137	}
2138
2139	input, ok := in.Parameters.(*DescribeFleetInput)
2140	_ = input
2141	if !ok {
2142		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2143	}
2144
2145	opPath, opQuery := httpbinding.SplitURI("/describeFleet")
2146	request.URL.Path = opPath
2147	if len(request.URL.RawQuery) > 0 {
2148		request.URL.RawQuery = "&" + opQuery
2149	} else {
2150		request.URL.RawQuery = opQuery
2151	}
2152
2153	request.Method = "POST"
2154	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2155	if err != nil {
2156		return out, metadata, &smithy.SerializationError{Err: err}
2157	}
2158
2159	restEncoder.SetHeader("Content-Type").String("application/json")
2160
2161	jsonEncoder := smithyjson.NewEncoder()
2162	if err := awsRestjson1_serializeOpDocumentDescribeFleetInput(input, jsonEncoder.Value); err != nil {
2163		return out, metadata, &smithy.SerializationError{Err: err}
2164	}
2165
2166	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2167		return out, metadata, &smithy.SerializationError{Err: err}
2168	}
2169
2170	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2171		return out, metadata, &smithy.SerializationError{Err: err}
2172	}
2173	in.Request = request
2174
2175	return next.HandleSerialize(ctx, in)
2176}
2177func awsRestjson1_serializeOpHttpBindingsDescribeFleetInput(v *DescribeFleetInput, encoder *httpbinding.Encoder) error {
2178	if v == nil {
2179		return fmt.Errorf("unsupported serialization of nil %T", v)
2180	}
2181
2182	return nil
2183}
2184
2185func awsRestjson1_serializeOpDocumentDescribeFleetInput(v *DescribeFleetInput, value smithyjson.Value) error {
2186	object := value.Object()
2187	defer object.Close()
2188
2189	if v.Fleet != nil {
2190		ok := object.Key("fleet")
2191		ok.String(*v.Fleet)
2192	}
2193
2194	return nil
2195}
2196
2197type awsRestjson1_serializeOpDescribeRobot struct {
2198}
2199
2200func (*awsRestjson1_serializeOpDescribeRobot) ID() string {
2201	return "OperationSerializer"
2202}
2203
2204func (m *awsRestjson1_serializeOpDescribeRobot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2205	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2206) {
2207	request, ok := in.Request.(*smithyhttp.Request)
2208	if !ok {
2209		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2210	}
2211
2212	input, ok := in.Parameters.(*DescribeRobotInput)
2213	_ = input
2214	if !ok {
2215		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2216	}
2217
2218	opPath, opQuery := httpbinding.SplitURI("/describeRobot")
2219	request.URL.Path = opPath
2220	if len(request.URL.RawQuery) > 0 {
2221		request.URL.RawQuery = "&" + opQuery
2222	} else {
2223		request.URL.RawQuery = opQuery
2224	}
2225
2226	request.Method = "POST"
2227	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2228	if err != nil {
2229		return out, metadata, &smithy.SerializationError{Err: err}
2230	}
2231
2232	restEncoder.SetHeader("Content-Type").String("application/json")
2233
2234	jsonEncoder := smithyjson.NewEncoder()
2235	if err := awsRestjson1_serializeOpDocumentDescribeRobotInput(input, jsonEncoder.Value); err != nil {
2236		return out, metadata, &smithy.SerializationError{Err: err}
2237	}
2238
2239	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2240		return out, metadata, &smithy.SerializationError{Err: err}
2241	}
2242
2243	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2244		return out, metadata, &smithy.SerializationError{Err: err}
2245	}
2246	in.Request = request
2247
2248	return next.HandleSerialize(ctx, in)
2249}
2250func awsRestjson1_serializeOpHttpBindingsDescribeRobotInput(v *DescribeRobotInput, encoder *httpbinding.Encoder) error {
2251	if v == nil {
2252		return fmt.Errorf("unsupported serialization of nil %T", v)
2253	}
2254
2255	return nil
2256}
2257
2258func awsRestjson1_serializeOpDocumentDescribeRobotInput(v *DescribeRobotInput, value smithyjson.Value) error {
2259	object := value.Object()
2260	defer object.Close()
2261
2262	if v.Robot != nil {
2263		ok := object.Key("robot")
2264		ok.String(*v.Robot)
2265	}
2266
2267	return nil
2268}
2269
2270type awsRestjson1_serializeOpDescribeRobotApplication struct {
2271}
2272
2273func (*awsRestjson1_serializeOpDescribeRobotApplication) ID() string {
2274	return "OperationSerializer"
2275}
2276
2277func (m *awsRestjson1_serializeOpDescribeRobotApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2278	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2279) {
2280	request, ok := in.Request.(*smithyhttp.Request)
2281	if !ok {
2282		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2283	}
2284
2285	input, ok := in.Parameters.(*DescribeRobotApplicationInput)
2286	_ = input
2287	if !ok {
2288		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2289	}
2290
2291	opPath, opQuery := httpbinding.SplitURI("/describeRobotApplication")
2292	request.URL.Path = opPath
2293	if len(request.URL.RawQuery) > 0 {
2294		request.URL.RawQuery = "&" + opQuery
2295	} else {
2296		request.URL.RawQuery = opQuery
2297	}
2298
2299	request.Method = "POST"
2300	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2301	if err != nil {
2302		return out, metadata, &smithy.SerializationError{Err: err}
2303	}
2304
2305	restEncoder.SetHeader("Content-Type").String("application/json")
2306
2307	jsonEncoder := smithyjson.NewEncoder()
2308	if err := awsRestjson1_serializeOpDocumentDescribeRobotApplicationInput(input, jsonEncoder.Value); err != nil {
2309		return out, metadata, &smithy.SerializationError{Err: err}
2310	}
2311
2312	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2313		return out, metadata, &smithy.SerializationError{Err: err}
2314	}
2315
2316	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2317		return out, metadata, &smithy.SerializationError{Err: err}
2318	}
2319	in.Request = request
2320
2321	return next.HandleSerialize(ctx, in)
2322}
2323func awsRestjson1_serializeOpHttpBindingsDescribeRobotApplicationInput(v *DescribeRobotApplicationInput, encoder *httpbinding.Encoder) error {
2324	if v == nil {
2325		return fmt.Errorf("unsupported serialization of nil %T", v)
2326	}
2327
2328	return nil
2329}
2330
2331func awsRestjson1_serializeOpDocumentDescribeRobotApplicationInput(v *DescribeRobotApplicationInput, value smithyjson.Value) error {
2332	object := value.Object()
2333	defer object.Close()
2334
2335	if v.Application != nil {
2336		ok := object.Key("application")
2337		ok.String(*v.Application)
2338	}
2339
2340	if v.ApplicationVersion != nil {
2341		ok := object.Key("applicationVersion")
2342		ok.String(*v.ApplicationVersion)
2343	}
2344
2345	return nil
2346}
2347
2348type awsRestjson1_serializeOpDescribeSimulationApplication struct {
2349}
2350
2351func (*awsRestjson1_serializeOpDescribeSimulationApplication) ID() string {
2352	return "OperationSerializer"
2353}
2354
2355func (m *awsRestjson1_serializeOpDescribeSimulationApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2356	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2357) {
2358	request, ok := in.Request.(*smithyhttp.Request)
2359	if !ok {
2360		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2361	}
2362
2363	input, ok := in.Parameters.(*DescribeSimulationApplicationInput)
2364	_ = input
2365	if !ok {
2366		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2367	}
2368
2369	opPath, opQuery := httpbinding.SplitURI("/describeSimulationApplication")
2370	request.URL.Path = opPath
2371	if len(request.URL.RawQuery) > 0 {
2372		request.URL.RawQuery = "&" + opQuery
2373	} else {
2374		request.URL.RawQuery = opQuery
2375	}
2376
2377	request.Method = "POST"
2378	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2379	if err != nil {
2380		return out, metadata, &smithy.SerializationError{Err: err}
2381	}
2382
2383	restEncoder.SetHeader("Content-Type").String("application/json")
2384
2385	jsonEncoder := smithyjson.NewEncoder()
2386	if err := awsRestjson1_serializeOpDocumentDescribeSimulationApplicationInput(input, jsonEncoder.Value); err != nil {
2387		return out, metadata, &smithy.SerializationError{Err: err}
2388	}
2389
2390	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2391		return out, metadata, &smithy.SerializationError{Err: err}
2392	}
2393
2394	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2395		return out, metadata, &smithy.SerializationError{Err: err}
2396	}
2397	in.Request = request
2398
2399	return next.HandleSerialize(ctx, in)
2400}
2401func awsRestjson1_serializeOpHttpBindingsDescribeSimulationApplicationInput(v *DescribeSimulationApplicationInput, encoder *httpbinding.Encoder) error {
2402	if v == nil {
2403		return fmt.Errorf("unsupported serialization of nil %T", v)
2404	}
2405
2406	return nil
2407}
2408
2409func awsRestjson1_serializeOpDocumentDescribeSimulationApplicationInput(v *DescribeSimulationApplicationInput, value smithyjson.Value) error {
2410	object := value.Object()
2411	defer object.Close()
2412
2413	if v.Application != nil {
2414		ok := object.Key("application")
2415		ok.String(*v.Application)
2416	}
2417
2418	if v.ApplicationVersion != nil {
2419		ok := object.Key("applicationVersion")
2420		ok.String(*v.ApplicationVersion)
2421	}
2422
2423	return nil
2424}
2425
2426type awsRestjson1_serializeOpDescribeSimulationJob struct {
2427}
2428
2429func (*awsRestjson1_serializeOpDescribeSimulationJob) ID() string {
2430	return "OperationSerializer"
2431}
2432
2433func (m *awsRestjson1_serializeOpDescribeSimulationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2434	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2435) {
2436	request, ok := in.Request.(*smithyhttp.Request)
2437	if !ok {
2438		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2439	}
2440
2441	input, ok := in.Parameters.(*DescribeSimulationJobInput)
2442	_ = input
2443	if !ok {
2444		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2445	}
2446
2447	opPath, opQuery := httpbinding.SplitURI("/describeSimulationJob")
2448	request.URL.Path = opPath
2449	if len(request.URL.RawQuery) > 0 {
2450		request.URL.RawQuery = "&" + opQuery
2451	} else {
2452		request.URL.RawQuery = opQuery
2453	}
2454
2455	request.Method = "POST"
2456	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2457	if err != nil {
2458		return out, metadata, &smithy.SerializationError{Err: err}
2459	}
2460
2461	restEncoder.SetHeader("Content-Type").String("application/json")
2462
2463	jsonEncoder := smithyjson.NewEncoder()
2464	if err := awsRestjson1_serializeOpDocumentDescribeSimulationJobInput(input, jsonEncoder.Value); err != nil {
2465		return out, metadata, &smithy.SerializationError{Err: err}
2466	}
2467
2468	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2469		return out, metadata, &smithy.SerializationError{Err: err}
2470	}
2471
2472	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2473		return out, metadata, &smithy.SerializationError{Err: err}
2474	}
2475	in.Request = request
2476
2477	return next.HandleSerialize(ctx, in)
2478}
2479func awsRestjson1_serializeOpHttpBindingsDescribeSimulationJobInput(v *DescribeSimulationJobInput, encoder *httpbinding.Encoder) error {
2480	if v == nil {
2481		return fmt.Errorf("unsupported serialization of nil %T", v)
2482	}
2483
2484	return nil
2485}
2486
2487func awsRestjson1_serializeOpDocumentDescribeSimulationJobInput(v *DescribeSimulationJobInput, value smithyjson.Value) error {
2488	object := value.Object()
2489	defer object.Close()
2490
2491	if v.Job != nil {
2492		ok := object.Key("job")
2493		ok.String(*v.Job)
2494	}
2495
2496	return nil
2497}
2498
2499type awsRestjson1_serializeOpDescribeSimulationJobBatch struct {
2500}
2501
2502func (*awsRestjson1_serializeOpDescribeSimulationJobBatch) ID() string {
2503	return "OperationSerializer"
2504}
2505
2506func (m *awsRestjson1_serializeOpDescribeSimulationJobBatch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2507	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2508) {
2509	request, ok := in.Request.(*smithyhttp.Request)
2510	if !ok {
2511		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2512	}
2513
2514	input, ok := in.Parameters.(*DescribeSimulationJobBatchInput)
2515	_ = input
2516	if !ok {
2517		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2518	}
2519
2520	opPath, opQuery := httpbinding.SplitURI("/describeSimulationJobBatch")
2521	request.URL.Path = opPath
2522	if len(request.URL.RawQuery) > 0 {
2523		request.URL.RawQuery = "&" + opQuery
2524	} else {
2525		request.URL.RawQuery = opQuery
2526	}
2527
2528	request.Method = "POST"
2529	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2530	if err != nil {
2531		return out, metadata, &smithy.SerializationError{Err: err}
2532	}
2533
2534	restEncoder.SetHeader("Content-Type").String("application/json")
2535
2536	jsonEncoder := smithyjson.NewEncoder()
2537	if err := awsRestjson1_serializeOpDocumentDescribeSimulationJobBatchInput(input, jsonEncoder.Value); err != nil {
2538		return out, metadata, &smithy.SerializationError{Err: err}
2539	}
2540
2541	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2542		return out, metadata, &smithy.SerializationError{Err: err}
2543	}
2544
2545	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2546		return out, metadata, &smithy.SerializationError{Err: err}
2547	}
2548	in.Request = request
2549
2550	return next.HandleSerialize(ctx, in)
2551}
2552func awsRestjson1_serializeOpHttpBindingsDescribeSimulationJobBatchInput(v *DescribeSimulationJobBatchInput, encoder *httpbinding.Encoder) error {
2553	if v == nil {
2554		return fmt.Errorf("unsupported serialization of nil %T", v)
2555	}
2556
2557	return nil
2558}
2559
2560func awsRestjson1_serializeOpDocumentDescribeSimulationJobBatchInput(v *DescribeSimulationJobBatchInput, value smithyjson.Value) error {
2561	object := value.Object()
2562	defer object.Close()
2563
2564	if v.Batch != nil {
2565		ok := object.Key("batch")
2566		ok.String(*v.Batch)
2567	}
2568
2569	return nil
2570}
2571
2572type awsRestjson1_serializeOpDescribeWorld struct {
2573}
2574
2575func (*awsRestjson1_serializeOpDescribeWorld) ID() string {
2576	return "OperationSerializer"
2577}
2578
2579func (m *awsRestjson1_serializeOpDescribeWorld) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2580	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2581) {
2582	request, ok := in.Request.(*smithyhttp.Request)
2583	if !ok {
2584		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2585	}
2586
2587	input, ok := in.Parameters.(*DescribeWorldInput)
2588	_ = input
2589	if !ok {
2590		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2591	}
2592
2593	opPath, opQuery := httpbinding.SplitURI("/describeWorld")
2594	request.URL.Path = opPath
2595	if len(request.URL.RawQuery) > 0 {
2596		request.URL.RawQuery = "&" + opQuery
2597	} else {
2598		request.URL.RawQuery = opQuery
2599	}
2600
2601	request.Method = "POST"
2602	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2603	if err != nil {
2604		return out, metadata, &smithy.SerializationError{Err: err}
2605	}
2606
2607	restEncoder.SetHeader("Content-Type").String("application/json")
2608
2609	jsonEncoder := smithyjson.NewEncoder()
2610	if err := awsRestjson1_serializeOpDocumentDescribeWorldInput(input, jsonEncoder.Value); err != nil {
2611		return out, metadata, &smithy.SerializationError{Err: err}
2612	}
2613
2614	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2615		return out, metadata, &smithy.SerializationError{Err: err}
2616	}
2617
2618	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2619		return out, metadata, &smithy.SerializationError{Err: err}
2620	}
2621	in.Request = request
2622
2623	return next.HandleSerialize(ctx, in)
2624}
2625func awsRestjson1_serializeOpHttpBindingsDescribeWorldInput(v *DescribeWorldInput, encoder *httpbinding.Encoder) error {
2626	if v == nil {
2627		return fmt.Errorf("unsupported serialization of nil %T", v)
2628	}
2629
2630	return nil
2631}
2632
2633func awsRestjson1_serializeOpDocumentDescribeWorldInput(v *DescribeWorldInput, value smithyjson.Value) error {
2634	object := value.Object()
2635	defer object.Close()
2636
2637	if v.World != nil {
2638		ok := object.Key("world")
2639		ok.String(*v.World)
2640	}
2641
2642	return nil
2643}
2644
2645type awsRestjson1_serializeOpDescribeWorldExportJob struct {
2646}
2647
2648func (*awsRestjson1_serializeOpDescribeWorldExportJob) ID() string {
2649	return "OperationSerializer"
2650}
2651
2652func (m *awsRestjson1_serializeOpDescribeWorldExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2653	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2654) {
2655	request, ok := in.Request.(*smithyhttp.Request)
2656	if !ok {
2657		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2658	}
2659
2660	input, ok := in.Parameters.(*DescribeWorldExportJobInput)
2661	_ = input
2662	if !ok {
2663		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2664	}
2665
2666	opPath, opQuery := httpbinding.SplitURI("/describeWorldExportJob")
2667	request.URL.Path = opPath
2668	if len(request.URL.RawQuery) > 0 {
2669		request.URL.RawQuery = "&" + opQuery
2670	} else {
2671		request.URL.RawQuery = opQuery
2672	}
2673
2674	request.Method = "POST"
2675	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2676	if err != nil {
2677		return out, metadata, &smithy.SerializationError{Err: err}
2678	}
2679
2680	restEncoder.SetHeader("Content-Type").String("application/json")
2681
2682	jsonEncoder := smithyjson.NewEncoder()
2683	if err := awsRestjson1_serializeOpDocumentDescribeWorldExportJobInput(input, jsonEncoder.Value); err != nil {
2684		return out, metadata, &smithy.SerializationError{Err: err}
2685	}
2686
2687	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2688		return out, metadata, &smithy.SerializationError{Err: err}
2689	}
2690
2691	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2692		return out, metadata, &smithy.SerializationError{Err: err}
2693	}
2694	in.Request = request
2695
2696	return next.HandleSerialize(ctx, in)
2697}
2698func awsRestjson1_serializeOpHttpBindingsDescribeWorldExportJobInput(v *DescribeWorldExportJobInput, encoder *httpbinding.Encoder) error {
2699	if v == nil {
2700		return fmt.Errorf("unsupported serialization of nil %T", v)
2701	}
2702
2703	return nil
2704}
2705
2706func awsRestjson1_serializeOpDocumentDescribeWorldExportJobInput(v *DescribeWorldExportJobInput, value smithyjson.Value) error {
2707	object := value.Object()
2708	defer object.Close()
2709
2710	if v.Job != nil {
2711		ok := object.Key("job")
2712		ok.String(*v.Job)
2713	}
2714
2715	return nil
2716}
2717
2718type awsRestjson1_serializeOpDescribeWorldGenerationJob struct {
2719}
2720
2721func (*awsRestjson1_serializeOpDescribeWorldGenerationJob) ID() string {
2722	return "OperationSerializer"
2723}
2724
2725func (m *awsRestjson1_serializeOpDescribeWorldGenerationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2726	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2727) {
2728	request, ok := in.Request.(*smithyhttp.Request)
2729	if !ok {
2730		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2731	}
2732
2733	input, ok := in.Parameters.(*DescribeWorldGenerationJobInput)
2734	_ = input
2735	if !ok {
2736		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2737	}
2738
2739	opPath, opQuery := httpbinding.SplitURI("/describeWorldGenerationJob")
2740	request.URL.Path = opPath
2741	if len(request.URL.RawQuery) > 0 {
2742		request.URL.RawQuery = "&" + opQuery
2743	} else {
2744		request.URL.RawQuery = opQuery
2745	}
2746
2747	request.Method = "POST"
2748	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2749	if err != nil {
2750		return out, metadata, &smithy.SerializationError{Err: err}
2751	}
2752
2753	restEncoder.SetHeader("Content-Type").String("application/json")
2754
2755	jsonEncoder := smithyjson.NewEncoder()
2756	if err := awsRestjson1_serializeOpDocumentDescribeWorldGenerationJobInput(input, jsonEncoder.Value); err != nil {
2757		return out, metadata, &smithy.SerializationError{Err: err}
2758	}
2759
2760	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2761		return out, metadata, &smithy.SerializationError{Err: err}
2762	}
2763
2764	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2765		return out, metadata, &smithy.SerializationError{Err: err}
2766	}
2767	in.Request = request
2768
2769	return next.HandleSerialize(ctx, in)
2770}
2771func awsRestjson1_serializeOpHttpBindingsDescribeWorldGenerationJobInput(v *DescribeWorldGenerationJobInput, encoder *httpbinding.Encoder) error {
2772	if v == nil {
2773		return fmt.Errorf("unsupported serialization of nil %T", v)
2774	}
2775
2776	return nil
2777}
2778
2779func awsRestjson1_serializeOpDocumentDescribeWorldGenerationJobInput(v *DescribeWorldGenerationJobInput, value smithyjson.Value) error {
2780	object := value.Object()
2781	defer object.Close()
2782
2783	if v.Job != nil {
2784		ok := object.Key("job")
2785		ok.String(*v.Job)
2786	}
2787
2788	return nil
2789}
2790
2791type awsRestjson1_serializeOpDescribeWorldTemplate struct {
2792}
2793
2794func (*awsRestjson1_serializeOpDescribeWorldTemplate) ID() string {
2795	return "OperationSerializer"
2796}
2797
2798func (m *awsRestjson1_serializeOpDescribeWorldTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2799	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2800) {
2801	request, ok := in.Request.(*smithyhttp.Request)
2802	if !ok {
2803		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2804	}
2805
2806	input, ok := in.Parameters.(*DescribeWorldTemplateInput)
2807	_ = input
2808	if !ok {
2809		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2810	}
2811
2812	opPath, opQuery := httpbinding.SplitURI("/describeWorldTemplate")
2813	request.URL.Path = opPath
2814	if len(request.URL.RawQuery) > 0 {
2815		request.URL.RawQuery = "&" + opQuery
2816	} else {
2817		request.URL.RawQuery = opQuery
2818	}
2819
2820	request.Method = "POST"
2821	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2822	if err != nil {
2823		return out, metadata, &smithy.SerializationError{Err: err}
2824	}
2825
2826	restEncoder.SetHeader("Content-Type").String("application/json")
2827
2828	jsonEncoder := smithyjson.NewEncoder()
2829	if err := awsRestjson1_serializeOpDocumentDescribeWorldTemplateInput(input, jsonEncoder.Value); err != nil {
2830		return out, metadata, &smithy.SerializationError{Err: err}
2831	}
2832
2833	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2834		return out, metadata, &smithy.SerializationError{Err: err}
2835	}
2836
2837	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2838		return out, metadata, &smithy.SerializationError{Err: err}
2839	}
2840	in.Request = request
2841
2842	return next.HandleSerialize(ctx, in)
2843}
2844func awsRestjson1_serializeOpHttpBindingsDescribeWorldTemplateInput(v *DescribeWorldTemplateInput, encoder *httpbinding.Encoder) error {
2845	if v == nil {
2846		return fmt.Errorf("unsupported serialization of nil %T", v)
2847	}
2848
2849	return nil
2850}
2851
2852func awsRestjson1_serializeOpDocumentDescribeWorldTemplateInput(v *DescribeWorldTemplateInput, value smithyjson.Value) error {
2853	object := value.Object()
2854	defer object.Close()
2855
2856	if v.Template != nil {
2857		ok := object.Key("template")
2858		ok.String(*v.Template)
2859	}
2860
2861	return nil
2862}
2863
2864type awsRestjson1_serializeOpGetWorldTemplateBody struct {
2865}
2866
2867func (*awsRestjson1_serializeOpGetWorldTemplateBody) ID() string {
2868	return "OperationSerializer"
2869}
2870
2871func (m *awsRestjson1_serializeOpGetWorldTemplateBody) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2872	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2873) {
2874	request, ok := in.Request.(*smithyhttp.Request)
2875	if !ok {
2876		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2877	}
2878
2879	input, ok := in.Parameters.(*GetWorldTemplateBodyInput)
2880	_ = input
2881	if !ok {
2882		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2883	}
2884
2885	opPath, opQuery := httpbinding.SplitURI("/getWorldTemplateBody")
2886	request.URL.Path = opPath
2887	if len(request.URL.RawQuery) > 0 {
2888		request.URL.RawQuery = "&" + opQuery
2889	} else {
2890		request.URL.RawQuery = opQuery
2891	}
2892
2893	request.Method = "POST"
2894	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2895	if err != nil {
2896		return out, metadata, &smithy.SerializationError{Err: err}
2897	}
2898
2899	restEncoder.SetHeader("Content-Type").String("application/json")
2900
2901	jsonEncoder := smithyjson.NewEncoder()
2902	if err := awsRestjson1_serializeOpDocumentGetWorldTemplateBodyInput(input, jsonEncoder.Value); err != nil {
2903		return out, metadata, &smithy.SerializationError{Err: err}
2904	}
2905
2906	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2907		return out, metadata, &smithy.SerializationError{Err: err}
2908	}
2909
2910	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2911		return out, metadata, &smithy.SerializationError{Err: err}
2912	}
2913	in.Request = request
2914
2915	return next.HandleSerialize(ctx, in)
2916}
2917func awsRestjson1_serializeOpHttpBindingsGetWorldTemplateBodyInput(v *GetWorldTemplateBodyInput, encoder *httpbinding.Encoder) error {
2918	if v == nil {
2919		return fmt.Errorf("unsupported serialization of nil %T", v)
2920	}
2921
2922	return nil
2923}
2924
2925func awsRestjson1_serializeOpDocumentGetWorldTemplateBodyInput(v *GetWorldTemplateBodyInput, value smithyjson.Value) error {
2926	object := value.Object()
2927	defer object.Close()
2928
2929	if v.GenerationJob != nil {
2930		ok := object.Key("generationJob")
2931		ok.String(*v.GenerationJob)
2932	}
2933
2934	if v.Template != nil {
2935		ok := object.Key("template")
2936		ok.String(*v.Template)
2937	}
2938
2939	return nil
2940}
2941
2942type awsRestjson1_serializeOpListDeploymentJobs struct {
2943}
2944
2945func (*awsRestjson1_serializeOpListDeploymentJobs) ID() string {
2946	return "OperationSerializer"
2947}
2948
2949func (m *awsRestjson1_serializeOpListDeploymentJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2950	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2951) {
2952	request, ok := in.Request.(*smithyhttp.Request)
2953	if !ok {
2954		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2955	}
2956
2957	input, ok := in.Parameters.(*ListDeploymentJobsInput)
2958	_ = input
2959	if !ok {
2960		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2961	}
2962
2963	opPath, opQuery := httpbinding.SplitURI("/listDeploymentJobs")
2964	request.URL.Path = opPath
2965	if len(request.URL.RawQuery) > 0 {
2966		request.URL.RawQuery = "&" + opQuery
2967	} else {
2968		request.URL.RawQuery = opQuery
2969	}
2970
2971	request.Method = "POST"
2972	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2973	if err != nil {
2974		return out, metadata, &smithy.SerializationError{Err: err}
2975	}
2976
2977	restEncoder.SetHeader("Content-Type").String("application/json")
2978
2979	jsonEncoder := smithyjson.NewEncoder()
2980	if err := awsRestjson1_serializeOpDocumentListDeploymentJobsInput(input, jsonEncoder.Value); err != nil {
2981		return out, metadata, &smithy.SerializationError{Err: err}
2982	}
2983
2984	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2985		return out, metadata, &smithy.SerializationError{Err: err}
2986	}
2987
2988	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2989		return out, metadata, &smithy.SerializationError{Err: err}
2990	}
2991	in.Request = request
2992
2993	return next.HandleSerialize(ctx, in)
2994}
2995func awsRestjson1_serializeOpHttpBindingsListDeploymentJobsInput(v *ListDeploymentJobsInput, encoder *httpbinding.Encoder) error {
2996	if v == nil {
2997		return fmt.Errorf("unsupported serialization of nil %T", v)
2998	}
2999
3000	return nil
3001}
3002
3003func awsRestjson1_serializeOpDocumentListDeploymentJobsInput(v *ListDeploymentJobsInput, value smithyjson.Value) error {
3004	object := value.Object()
3005	defer object.Close()
3006
3007	if v.Filters != nil {
3008		ok := object.Key("filters")
3009		if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil {
3010			return err
3011		}
3012	}
3013
3014	if v.MaxResults != nil {
3015		ok := object.Key("maxResults")
3016		ok.Integer(*v.MaxResults)
3017	}
3018
3019	if v.NextToken != nil {
3020		ok := object.Key("nextToken")
3021		ok.String(*v.NextToken)
3022	}
3023
3024	return nil
3025}
3026
3027type awsRestjson1_serializeOpListFleets struct {
3028}
3029
3030func (*awsRestjson1_serializeOpListFleets) ID() string {
3031	return "OperationSerializer"
3032}
3033
3034func (m *awsRestjson1_serializeOpListFleets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3035	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3036) {
3037	request, ok := in.Request.(*smithyhttp.Request)
3038	if !ok {
3039		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3040	}
3041
3042	input, ok := in.Parameters.(*ListFleetsInput)
3043	_ = input
3044	if !ok {
3045		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3046	}
3047
3048	opPath, opQuery := httpbinding.SplitURI("/listFleets")
3049	request.URL.Path = opPath
3050	if len(request.URL.RawQuery) > 0 {
3051		request.URL.RawQuery = "&" + opQuery
3052	} else {
3053		request.URL.RawQuery = opQuery
3054	}
3055
3056	request.Method = "POST"
3057	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3058	if err != nil {
3059		return out, metadata, &smithy.SerializationError{Err: err}
3060	}
3061
3062	restEncoder.SetHeader("Content-Type").String("application/json")
3063
3064	jsonEncoder := smithyjson.NewEncoder()
3065	if err := awsRestjson1_serializeOpDocumentListFleetsInput(input, jsonEncoder.Value); err != nil {
3066		return out, metadata, &smithy.SerializationError{Err: err}
3067	}
3068
3069	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3070		return out, metadata, &smithy.SerializationError{Err: err}
3071	}
3072
3073	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3074		return out, metadata, &smithy.SerializationError{Err: err}
3075	}
3076	in.Request = request
3077
3078	return next.HandleSerialize(ctx, in)
3079}
3080func awsRestjson1_serializeOpHttpBindingsListFleetsInput(v *ListFleetsInput, encoder *httpbinding.Encoder) error {
3081	if v == nil {
3082		return fmt.Errorf("unsupported serialization of nil %T", v)
3083	}
3084
3085	return nil
3086}
3087
3088func awsRestjson1_serializeOpDocumentListFleetsInput(v *ListFleetsInput, value smithyjson.Value) error {
3089	object := value.Object()
3090	defer object.Close()
3091
3092	if v.Filters != nil {
3093		ok := object.Key("filters")
3094		if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil {
3095			return err
3096		}
3097	}
3098
3099	if v.MaxResults != nil {
3100		ok := object.Key("maxResults")
3101		ok.Integer(*v.MaxResults)
3102	}
3103
3104	if v.NextToken != nil {
3105		ok := object.Key("nextToken")
3106		ok.String(*v.NextToken)
3107	}
3108
3109	return nil
3110}
3111
3112type awsRestjson1_serializeOpListRobotApplications struct {
3113}
3114
3115func (*awsRestjson1_serializeOpListRobotApplications) ID() string {
3116	return "OperationSerializer"
3117}
3118
3119func (m *awsRestjson1_serializeOpListRobotApplications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3120	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3121) {
3122	request, ok := in.Request.(*smithyhttp.Request)
3123	if !ok {
3124		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3125	}
3126
3127	input, ok := in.Parameters.(*ListRobotApplicationsInput)
3128	_ = input
3129	if !ok {
3130		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3131	}
3132
3133	opPath, opQuery := httpbinding.SplitURI("/listRobotApplications")
3134	request.URL.Path = opPath
3135	if len(request.URL.RawQuery) > 0 {
3136		request.URL.RawQuery = "&" + opQuery
3137	} else {
3138		request.URL.RawQuery = opQuery
3139	}
3140
3141	request.Method = "POST"
3142	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3143	if err != nil {
3144		return out, metadata, &smithy.SerializationError{Err: err}
3145	}
3146
3147	restEncoder.SetHeader("Content-Type").String("application/json")
3148
3149	jsonEncoder := smithyjson.NewEncoder()
3150	if err := awsRestjson1_serializeOpDocumentListRobotApplicationsInput(input, jsonEncoder.Value); err != nil {
3151		return out, metadata, &smithy.SerializationError{Err: err}
3152	}
3153
3154	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3155		return out, metadata, &smithy.SerializationError{Err: err}
3156	}
3157
3158	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3159		return out, metadata, &smithy.SerializationError{Err: err}
3160	}
3161	in.Request = request
3162
3163	return next.HandleSerialize(ctx, in)
3164}
3165func awsRestjson1_serializeOpHttpBindingsListRobotApplicationsInput(v *ListRobotApplicationsInput, encoder *httpbinding.Encoder) error {
3166	if v == nil {
3167		return fmt.Errorf("unsupported serialization of nil %T", v)
3168	}
3169
3170	return nil
3171}
3172
3173func awsRestjson1_serializeOpDocumentListRobotApplicationsInput(v *ListRobotApplicationsInput, value smithyjson.Value) error {
3174	object := value.Object()
3175	defer object.Close()
3176
3177	if v.Filters != nil {
3178		ok := object.Key("filters")
3179		if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil {
3180			return err
3181		}
3182	}
3183
3184	if v.MaxResults != nil {
3185		ok := object.Key("maxResults")
3186		ok.Integer(*v.MaxResults)
3187	}
3188
3189	if v.NextToken != nil {
3190		ok := object.Key("nextToken")
3191		ok.String(*v.NextToken)
3192	}
3193
3194	if v.VersionQualifier != nil {
3195		ok := object.Key("versionQualifier")
3196		ok.String(*v.VersionQualifier)
3197	}
3198
3199	return nil
3200}
3201
3202type awsRestjson1_serializeOpListRobots struct {
3203}
3204
3205func (*awsRestjson1_serializeOpListRobots) ID() string {
3206	return "OperationSerializer"
3207}
3208
3209func (m *awsRestjson1_serializeOpListRobots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3210	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3211) {
3212	request, ok := in.Request.(*smithyhttp.Request)
3213	if !ok {
3214		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3215	}
3216
3217	input, ok := in.Parameters.(*ListRobotsInput)
3218	_ = input
3219	if !ok {
3220		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3221	}
3222
3223	opPath, opQuery := httpbinding.SplitURI("/listRobots")
3224	request.URL.Path = opPath
3225	if len(request.URL.RawQuery) > 0 {
3226		request.URL.RawQuery = "&" + opQuery
3227	} else {
3228		request.URL.RawQuery = opQuery
3229	}
3230
3231	request.Method = "POST"
3232	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3233	if err != nil {
3234		return out, metadata, &smithy.SerializationError{Err: err}
3235	}
3236
3237	restEncoder.SetHeader("Content-Type").String("application/json")
3238
3239	jsonEncoder := smithyjson.NewEncoder()
3240	if err := awsRestjson1_serializeOpDocumentListRobotsInput(input, jsonEncoder.Value); err != nil {
3241		return out, metadata, &smithy.SerializationError{Err: err}
3242	}
3243
3244	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3245		return out, metadata, &smithy.SerializationError{Err: err}
3246	}
3247
3248	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3249		return out, metadata, &smithy.SerializationError{Err: err}
3250	}
3251	in.Request = request
3252
3253	return next.HandleSerialize(ctx, in)
3254}
3255func awsRestjson1_serializeOpHttpBindingsListRobotsInput(v *ListRobotsInput, encoder *httpbinding.Encoder) error {
3256	if v == nil {
3257		return fmt.Errorf("unsupported serialization of nil %T", v)
3258	}
3259
3260	return nil
3261}
3262
3263func awsRestjson1_serializeOpDocumentListRobotsInput(v *ListRobotsInput, value smithyjson.Value) error {
3264	object := value.Object()
3265	defer object.Close()
3266
3267	if v.Filters != nil {
3268		ok := object.Key("filters")
3269		if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil {
3270			return err
3271		}
3272	}
3273
3274	if v.MaxResults != nil {
3275		ok := object.Key("maxResults")
3276		ok.Integer(*v.MaxResults)
3277	}
3278
3279	if v.NextToken != nil {
3280		ok := object.Key("nextToken")
3281		ok.String(*v.NextToken)
3282	}
3283
3284	return nil
3285}
3286
3287type awsRestjson1_serializeOpListSimulationApplications struct {
3288}
3289
3290func (*awsRestjson1_serializeOpListSimulationApplications) ID() string {
3291	return "OperationSerializer"
3292}
3293
3294func (m *awsRestjson1_serializeOpListSimulationApplications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3295	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3296) {
3297	request, ok := in.Request.(*smithyhttp.Request)
3298	if !ok {
3299		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3300	}
3301
3302	input, ok := in.Parameters.(*ListSimulationApplicationsInput)
3303	_ = input
3304	if !ok {
3305		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3306	}
3307
3308	opPath, opQuery := httpbinding.SplitURI("/listSimulationApplications")
3309	request.URL.Path = opPath
3310	if len(request.URL.RawQuery) > 0 {
3311		request.URL.RawQuery = "&" + opQuery
3312	} else {
3313		request.URL.RawQuery = opQuery
3314	}
3315
3316	request.Method = "POST"
3317	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3318	if err != nil {
3319		return out, metadata, &smithy.SerializationError{Err: err}
3320	}
3321
3322	restEncoder.SetHeader("Content-Type").String("application/json")
3323
3324	jsonEncoder := smithyjson.NewEncoder()
3325	if err := awsRestjson1_serializeOpDocumentListSimulationApplicationsInput(input, jsonEncoder.Value); err != nil {
3326		return out, metadata, &smithy.SerializationError{Err: err}
3327	}
3328
3329	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3330		return out, metadata, &smithy.SerializationError{Err: err}
3331	}
3332
3333	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3334		return out, metadata, &smithy.SerializationError{Err: err}
3335	}
3336	in.Request = request
3337
3338	return next.HandleSerialize(ctx, in)
3339}
3340func awsRestjson1_serializeOpHttpBindingsListSimulationApplicationsInput(v *ListSimulationApplicationsInput, encoder *httpbinding.Encoder) error {
3341	if v == nil {
3342		return fmt.Errorf("unsupported serialization of nil %T", v)
3343	}
3344
3345	return nil
3346}
3347
3348func awsRestjson1_serializeOpDocumentListSimulationApplicationsInput(v *ListSimulationApplicationsInput, value smithyjson.Value) error {
3349	object := value.Object()
3350	defer object.Close()
3351
3352	if v.Filters != nil {
3353		ok := object.Key("filters")
3354		if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil {
3355			return err
3356		}
3357	}
3358
3359	if v.MaxResults != nil {
3360		ok := object.Key("maxResults")
3361		ok.Integer(*v.MaxResults)
3362	}
3363
3364	if v.NextToken != nil {
3365		ok := object.Key("nextToken")
3366		ok.String(*v.NextToken)
3367	}
3368
3369	if v.VersionQualifier != nil {
3370		ok := object.Key("versionQualifier")
3371		ok.String(*v.VersionQualifier)
3372	}
3373
3374	return nil
3375}
3376
3377type awsRestjson1_serializeOpListSimulationJobBatches struct {
3378}
3379
3380func (*awsRestjson1_serializeOpListSimulationJobBatches) ID() string {
3381	return "OperationSerializer"
3382}
3383
3384func (m *awsRestjson1_serializeOpListSimulationJobBatches) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3385	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3386) {
3387	request, ok := in.Request.(*smithyhttp.Request)
3388	if !ok {
3389		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3390	}
3391
3392	input, ok := in.Parameters.(*ListSimulationJobBatchesInput)
3393	_ = input
3394	if !ok {
3395		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3396	}
3397
3398	opPath, opQuery := httpbinding.SplitURI("/listSimulationJobBatches")
3399	request.URL.Path = opPath
3400	if len(request.URL.RawQuery) > 0 {
3401		request.URL.RawQuery = "&" + opQuery
3402	} else {
3403		request.URL.RawQuery = opQuery
3404	}
3405
3406	request.Method = "POST"
3407	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3408	if err != nil {
3409		return out, metadata, &smithy.SerializationError{Err: err}
3410	}
3411
3412	restEncoder.SetHeader("Content-Type").String("application/json")
3413
3414	jsonEncoder := smithyjson.NewEncoder()
3415	if err := awsRestjson1_serializeOpDocumentListSimulationJobBatchesInput(input, jsonEncoder.Value); err != nil {
3416		return out, metadata, &smithy.SerializationError{Err: err}
3417	}
3418
3419	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3420		return out, metadata, &smithy.SerializationError{Err: err}
3421	}
3422
3423	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3424		return out, metadata, &smithy.SerializationError{Err: err}
3425	}
3426	in.Request = request
3427
3428	return next.HandleSerialize(ctx, in)
3429}
3430func awsRestjson1_serializeOpHttpBindingsListSimulationJobBatchesInput(v *ListSimulationJobBatchesInput, encoder *httpbinding.Encoder) error {
3431	if v == nil {
3432		return fmt.Errorf("unsupported serialization of nil %T", v)
3433	}
3434
3435	return nil
3436}
3437
3438func awsRestjson1_serializeOpDocumentListSimulationJobBatchesInput(v *ListSimulationJobBatchesInput, value smithyjson.Value) error {
3439	object := value.Object()
3440	defer object.Close()
3441
3442	if v.Filters != nil {
3443		ok := object.Key("filters")
3444		if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil {
3445			return err
3446		}
3447	}
3448
3449	if v.MaxResults != nil {
3450		ok := object.Key("maxResults")
3451		ok.Integer(*v.MaxResults)
3452	}
3453
3454	if v.NextToken != nil {
3455		ok := object.Key("nextToken")
3456		ok.String(*v.NextToken)
3457	}
3458
3459	return nil
3460}
3461
3462type awsRestjson1_serializeOpListSimulationJobs struct {
3463}
3464
3465func (*awsRestjson1_serializeOpListSimulationJobs) ID() string {
3466	return "OperationSerializer"
3467}
3468
3469func (m *awsRestjson1_serializeOpListSimulationJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3470	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3471) {
3472	request, ok := in.Request.(*smithyhttp.Request)
3473	if !ok {
3474		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3475	}
3476
3477	input, ok := in.Parameters.(*ListSimulationJobsInput)
3478	_ = input
3479	if !ok {
3480		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3481	}
3482
3483	opPath, opQuery := httpbinding.SplitURI("/listSimulationJobs")
3484	request.URL.Path = opPath
3485	if len(request.URL.RawQuery) > 0 {
3486		request.URL.RawQuery = "&" + opQuery
3487	} else {
3488		request.URL.RawQuery = opQuery
3489	}
3490
3491	request.Method = "POST"
3492	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3493	if err != nil {
3494		return out, metadata, &smithy.SerializationError{Err: err}
3495	}
3496
3497	restEncoder.SetHeader("Content-Type").String("application/json")
3498
3499	jsonEncoder := smithyjson.NewEncoder()
3500	if err := awsRestjson1_serializeOpDocumentListSimulationJobsInput(input, jsonEncoder.Value); err != nil {
3501		return out, metadata, &smithy.SerializationError{Err: err}
3502	}
3503
3504	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3505		return out, metadata, &smithy.SerializationError{Err: err}
3506	}
3507
3508	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3509		return out, metadata, &smithy.SerializationError{Err: err}
3510	}
3511	in.Request = request
3512
3513	return next.HandleSerialize(ctx, in)
3514}
3515func awsRestjson1_serializeOpHttpBindingsListSimulationJobsInput(v *ListSimulationJobsInput, encoder *httpbinding.Encoder) error {
3516	if v == nil {
3517		return fmt.Errorf("unsupported serialization of nil %T", v)
3518	}
3519
3520	return nil
3521}
3522
3523func awsRestjson1_serializeOpDocumentListSimulationJobsInput(v *ListSimulationJobsInput, value smithyjson.Value) error {
3524	object := value.Object()
3525	defer object.Close()
3526
3527	if v.Filters != nil {
3528		ok := object.Key("filters")
3529		if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil {
3530			return err
3531		}
3532	}
3533
3534	if v.MaxResults != nil {
3535		ok := object.Key("maxResults")
3536		ok.Integer(*v.MaxResults)
3537	}
3538
3539	if v.NextToken != nil {
3540		ok := object.Key("nextToken")
3541		ok.String(*v.NextToken)
3542	}
3543
3544	return nil
3545}
3546
3547type awsRestjson1_serializeOpListTagsForResource struct {
3548}
3549
3550func (*awsRestjson1_serializeOpListTagsForResource) ID() string {
3551	return "OperationSerializer"
3552}
3553
3554func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3555	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3556) {
3557	request, ok := in.Request.(*smithyhttp.Request)
3558	if !ok {
3559		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3560	}
3561
3562	input, ok := in.Parameters.(*ListTagsForResourceInput)
3563	_ = input
3564	if !ok {
3565		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3566	}
3567
3568	opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
3569	request.URL.Path = opPath
3570	if len(request.URL.RawQuery) > 0 {
3571		request.URL.RawQuery = "&" + opQuery
3572	} else {
3573		request.URL.RawQuery = opQuery
3574	}
3575
3576	request.Method = "GET"
3577	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3578	if err != nil {
3579		return out, metadata, &smithy.SerializationError{Err: err}
3580	}
3581
3582	if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil {
3583		return out, metadata, &smithy.SerializationError{Err: err}
3584	}
3585
3586	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3587		return out, metadata, &smithy.SerializationError{Err: err}
3588	}
3589	in.Request = request
3590
3591	return next.HandleSerialize(ctx, in)
3592}
3593func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error {
3594	if v == nil {
3595		return fmt.Errorf("unsupported serialization of nil %T", v)
3596	}
3597
3598	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
3599		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
3600	}
3601	if v.ResourceArn != nil {
3602		if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
3603			return err
3604		}
3605	}
3606
3607	return nil
3608}
3609
3610type awsRestjson1_serializeOpListWorldExportJobs struct {
3611}
3612
3613func (*awsRestjson1_serializeOpListWorldExportJobs) ID() string {
3614	return "OperationSerializer"
3615}
3616
3617func (m *awsRestjson1_serializeOpListWorldExportJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3618	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3619) {
3620	request, ok := in.Request.(*smithyhttp.Request)
3621	if !ok {
3622		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3623	}
3624
3625	input, ok := in.Parameters.(*ListWorldExportJobsInput)
3626	_ = input
3627	if !ok {
3628		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3629	}
3630
3631	opPath, opQuery := httpbinding.SplitURI("/listWorldExportJobs")
3632	request.URL.Path = opPath
3633	if len(request.URL.RawQuery) > 0 {
3634		request.URL.RawQuery = "&" + opQuery
3635	} else {
3636		request.URL.RawQuery = opQuery
3637	}
3638
3639	request.Method = "POST"
3640	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3641	if err != nil {
3642		return out, metadata, &smithy.SerializationError{Err: err}
3643	}
3644
3645	restEncoder.SetHeader("Content-Type").String("application/json")
3646
3647	jsonEncoder := smithyjson.NewEncoder()
3648	if err := awsRestjson1_serializeOpDocumentListWorldExportJobsInput(input, jsonEncoder.Value); err != nil {
3649		return out, metadata, &smithy.SerializationError{Err: err}
3650	}
3651
3652	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3653		return out, metadata, &smithy.SerializationError{Err: err}
3654	}
3655
3656	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3657		return out, metadata, &smithy.SerializationError{Err: err}
3658	}
3659	in.Request = request
3660
3661	return next.HandleSerialize(ctx, in)
3662}
3663func awsRestjson1_serializeOpHttpBindingsListWorldExportJobsInput(v *ListWorldExportJobsInput, encoder *httpbinding.Encoder) error {
3664	if v == nil {
3665		return fmt.Errorf("unsupported serialization of nil %T", v)
3666	}
3667
3668	return nil
3669}
3670
3671func awsRestjson1_serializeOpDocumentListWorldExportJobsInput(v *ListWorldExportJobsInput, value smithyjson.Value) error {
3672	object := value.Object()
3673	defer object.Close()
3674
3675	if v.Filters != nil {
3676		ok := object.Key("filters")
3677		if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil {
3678			return err
3679		}
3680	}
3681
3682	if v.MaxResults != nil {
3683		ok := object.Key("maxResults")
3684		ok.Integer(*v.MaxResults)
3685	}
3686
3687	if v.NextToken != nil {
3688		ok := object.Key("nextToken")
3689		ok.String(*v.NextToken)
3690	}
3691
3692	return nil
3693}
3694
3695type awsRestjson1_serializeOpListWorldGenerationJobs struct {
3696}
3697
3698func (*awsRestjson1_serializeOpListWorldGenerationJobs) ID() string {
3699	return "OperationSerializer"
3700}
3701
3702func (m *awsRestjson1_serializeOpListWorldGenerationJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3703	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3704) {
3705	request, ok := in.Request.(*smithyhttp.Request)
3706	if !ok {
3707		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3708	}
3709
3710	input, ok := in.Parameters.(*ListWorldGenerationJobsInput)
3711	_ = input
3712	if !ok {
3713		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3714	}
3715
3716	opPath, opQuery := httpbinding.SplitURI("/listWorldGenerationJobs")
3717	request.URL.Path = opPath
3718	if len(request.URL.RawQuery) > 0 {
3719		request.URL.RawQuery = "&" + opQuery
3720	} else {
3721		request.URL.RawQuery = opQuery
3722	}
3723
3724	request.Method = "POST"
3725	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3726	if err != nil {
3727		return out, metadata, &smithy.SerializationError{Err: err}
3728	}
3729
3730	restEncoder.SetHeader("Content-Type").String("application/json")
3731
3732	jsonEncoder := smithyjson.NewEncoder()
3733	if err := awsRestjson1_serializeOpDocumentListWorldGenerationJobsInput(input, jsonEncoder.Value); err != nil {
3734		return out, metadata, &smithy.SerializationError{Err: err}
3735	}
3736
3737	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3738		return out, metadata, &smithy.SerializationError{Err: err}
3739	}
3740
3741	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3742		return out, metadata, &smithy.SerializationError{Err: err}
3743	}
3744	in.Request = request
3745
3746	return next.HandleSerialize(ctx, in)
3747}
3748func awsRestjson1_serializeOpHttpBindingsListWorldGenerationJobsInput(v *ListWorldGenerationJobsInput, encoder *httpbinding.Encoder) error {
3749	if v == nil {
3750		return fmt.Errorf("unsupported serialization of nil %T", v)
3751	}
3752
3753	return nil
3754}
3755
3756func awsRestjson1_serializeOpDocumentListWorldGenerationJobsInput(v *ListWorldGenerationJobsInput, value smithyjson.Value) error {
3757	object := value.Object()
3758	defer object.Close()
3759
3760	if v.Filters != nil {
3761		ok := object.Key("filters")
3762		if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil {
3763			return err
3764		}
3765	}
3766
3767	if v.MaxResults != nil {
3768		ok := object.Key("maxResults")
3769		ok.Integer(*v.MaxResults)
3770	}
3771
3772	if v.NextToken != nil {
3773		ok := object.Key("nextToken")
3774		ok.String(*v.NextToken)
3775	}
3776
3777	return nil
3778}
3779
3780type awsRestjson1_serializeOpListWorlds struct {
3781}
3782
3783func (*awsRestjson1_serializeOpListWorlds) ID() string {
3784	return "OperationSerializer"
3785}
3786
3787func (m *awsRestjson1_serializeOpListWorlds) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3788	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3789) {
3790	request, ok := in.Request.(*smithyhttp.Request)
3791	if !ok {
3792		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3793	}
3794
3795	input, ok := in.Parameters.(*ListWorldsInput)
3796	_ = input
3797	if !ok {
3798		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3799	}
3800
3801	opPath, opQuery := httpbinding.SplitURI("/listWorlds")
3802	request.URL.Path = opPath
3803	if len(request.URL.RawQuery) > 0 {
3804		request.URL.RawQuery = "&" + opQuery
3805	} else {
3806		request.URL.RawQuery = opQuery
3807	}
3808
3809	request.Method = "POST"
3810	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3811	if err != nil {
3812		return out, metadata, &smithy.SerializationError{Err: err}
3813	}
3814
3815	restEncoder.SetHeader("Content-Type").String("application/json")
3816
3817	jsonEncoder := smithyjson.NewEncoder()
3818	if err := awsRestjson1_serializeOpDocumentListWorldsInput(input, jsonEncoder.Value); err != nil {
3819		return out, metadata, &smithy.SerializationError{Err: err}
3820	}
3821
3822	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3823		return out, metadata, &smithy.SerializationError{Err: err}
3824	}
3825
3826	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3827		return out, metadata, &smithy.SerializationError{Err: err}
3828	}
3829	in.Request = request
3830
3831	return next.HandleSerialize(ctx, in)
3832}
3833func awsRestjson1_serializeOpHttpBindingsListWorldsInput(v *ListWorldsInput, encoder *httpbinding.Encoder) error {
3834	if v == nil {
3835		return fmt.Errorf("unsupported serialization of nil %T", v)
3836	}
3837
3838	return nil
3839}
3840
3841func awsRestjson1_serializeOpDocumentListWorldsInput(v *ListWorldsInput, value smithyjson.Value) error {
3842	object := value.Object()
3843	defer object.Close()
3844
3845	if v.Filters != nil {
3846		ok := object.Key("filters")
3847		if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil {
3848			return err
3849		}
3850	}
3851
3852	if v.MaxResults != nil {
3853		ok := object.Key("maxResults")
3854		ok.Integer(*v.MaxResults)
3855	}
3856
3857	if v.NextToken != nil {
3858		ok := object.Key("nextToken")
3859		ok.String(*v.NextToken)
3860	}
3861
3862	return nil
3863}
3864
3865type awsRestjson1_serializeOpListWorldTemplates struct {
3866}
3867
3868func (*awsRestjson1_serializeOpListWorldTemplates) ID() string {
3869	return "OperationSerializer"
3870}
3871
3872func (m *awsRestjson1_serializeOpListWorldTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3873	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3874) {
3875	request, ok := in.Request.(*smithyhttp.Request)
3876	if !ok {
3877		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3878	}
3879
3880	input, ok := in.Parameters.(*ListWorldTemplatesInput)
3881	_ = input
3882	if !ok {
3883		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3884	}
3885
3886	opPath, opQuery := httpbinding.SplitURI("/listWorldTemplates")
3887	request.URL.Path = opPath
3888	if len(request.URL.RawQuery) > 0 {
3889		request.URL.RawQuery = "&" + opQuery
3890	} else {
3891		request.URL.RawQuery = opQuery
3892	}
3893
3894	request.Method = "POST"
3895	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3896	if err != nil {
3897		return out, metadata, &smithy.SerializationError{Err: err}
3898	}
3899
3900	restEncoder.SetHeader("Content-Type").String("application/json")
3901
3902	jsonEncoder := smithyjson.NewEncoder()
3903	if err := awsRestjson1_serializeOpDocumentListWorldTemplatesInput(input, jsonEncoder.Value); err != nil {
3904		return out, metadata, &smithy.SerializationError{Err: err}
3905	}
3906
3907	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3908		return out, metadata, &smithy.SerializationError{Err: err}
3909	}
3910
3911	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3912		return out, metadata, &smithy.SerializationError{Err: err}
3913	}
3914	in.Request = request
3915
3916	return next.HandleSerialize(ctx, in)
3917}
3918func awsRestjson1_serializeOpHttpBindingsListWorldTemplatesInput(v *ListWorldTemplatesInput, encoder *httpbinding.Encoder) error {
3919	if v == nil {
3920		return fmt.Errorf("unsupported serialization of nil %T", v)
3921	}
3922
3923	return nil
3924}
3925
3926func awsRestjson1_serializeOpDocumentListWorldTemplatesInput(v *ListWorldTemplatesInput, value smithyjson.Value) error {
3927	object := value.Object()
3928	defer object.Close()
3929
3930	if v.MaxResults != nil {
3931		ok := object.Key("maxResults")
3932		ok.Integer(*v.MaxResults)
3933	}
3934
3935	if v.NextToken != nil {
3936		ok := object.Key("nextToken")
3937		ok.String(*v.NextToken)
3938	}
3939
3940	return nil
3941}
3942
3943type awsRestjson1_serializeOpRegisterRobot struct {
3944}
3945
3946func (*awsRestjson1_serializeOpRegisterRobot) ID() string {
3947	return "OperationSerializer"
3948}
3949
3950func (m *awsRestjson1_serializeOpRegisterRobot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3951	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3952) {
3953	request, ok := in.Request.(*smithyhttp.Request)
3954	if !ok {
3955		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3956	}
3957
3958	input, ok := in.Parameters.(*RegisterRobotInput)
3959	_ = input
3960	if !ok {
3961		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3962	}
3963
3964	opPath, opQuery := httpbinding.SplitURI("/registerRobot")
3965	request.URL.Path = opPath
3966	if len(request.URL.RawQuery) > 0 {
3967		request.URL.RawQuery = "&" + opQuery
3968	} else {
3969		request.URL.RawQuery = opQuery
3970	}
3971
3972	request.Method = "POST"
3973	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3974	if err != nil {
3975		return out, metadata, &smithy.SerializationError{Err: err}
3976	}
3977
3978	restEncoder.SetHeader("Content-Type").String("application/json")
3979
3980	jsonEncoder := smithyjson.NewEncoder()
3981	if err := awsRestjson1_serializeOpDocumentRegisterRobotInput(input, jsonEncoder.Value); err != nil {
3982		return out, metadata, &smithy.SerializationError{Err: err}
3983	}
3984
3985	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3986		return out, metadata, &smithy.SerializationError{Err: err}
3987	}
3988
3989	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3990		return out, metadata, &smithy.SerializationError{Err: err}
3991	}
3992	in.Request = request
3993
3994	return next.HandleSerialize(ctx, in)
3995}
3996func awsRestjson1_serializeOpHttpBindingsRegisterRobotInput(v *RegisterRobotInput, encoder *httpbinding.Encoder) error {
3997	if v == nil {
3998		return fmt.Errorf("unsupported serialization of nil %T", v)
3999	}
4000
4001	return nil
4002}
4003
4004func awsRestjson1_serializeOpDocumentRegisterRobotInput(v *RegisterRobotInput, value smithyjson.Value) error {
4005	object := value.Object()
4006	defer object.Close()
4007
4008	if v.Fleet != nil {
4009		ok := object.Key("fleet")
4010		ok.String(*v.Fleet)
4011	}
4012
4013	if v.Robot != nil {
4014		ok := object.Key("robot")
4015		ok.String(*v.Robot)
4016	}
4017
4018	return nil
4019}
4020
4021type awsRestjson1_serializeOpRestartSimulationJob struct {
4022}
4023
4024func (*awsRestjson1_serializeOpRestartSimulationJob) ID() string {
4025	return "OperationSerializer"
4026}
4027
4028func (m *awsRestjson1_serializeOpRestartSimulationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4029	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4030) {
4031	request, ok := in.Request.(*smithyhttp.Request)
4032	if !ok {
4033		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4034	}
4035
4036	input, ok := in.Parameters.(*RestartSimulationJobInput)
4037	_ = input
4038	if !ok {
4039		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4040	}
4041
4042	opPath, opQuery := httpbinding.SplitURI("/restartSimulationJob")
4043	request.URL.Path = opPath
4044	if len(request.URL.RawQuery) > 0 {
4045		request.URL.RawQuery = "&" + opQuery
4046	} else {
4047		request.URL.RawQuery = opQuery
4048	}
4049
4050	request.Method = "POST"
4051	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4052	if err != nil {
4053		return out, metadata, &smithy.SerializationError{Err: err}
4054	}
4055
4056	restEncoder.SetHeader("Content-Type").String("application/json")
4057
4058	jsonEncoder := smithyjson.NewEncoder()
4059	if err := awsRestjson1_serializeOpDocumentRestartSimulationJobInput(input, jsonEncoder.Value); err != nil {
4060		return out, metadata, &smithy.SerializationError{Err: err}
4061	}
4062
4063	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4064		return out, metadata, &smithy.SerializationError{Err: err}
4065	}
4066
4067	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4068		return out, metadata, &smithy.SerializationError{Err: err}
4069	}
4070	in.Request = request
4071
4072	return next.HandleSerialize(ctx, in)
4073}
4074func awsRestjson1_serializeOpHttpBindingsRestartSimulationJobInput(v *RestartSimulationJobInput, encoder *httpbinding.Encoder) error {
4075	if v == nil {
4076		return fmt.Errorf("unsupported serialization of nil %T", v)
4077	}
4078
4079	return nil
4080}
4081
4082func awsRestjson1_serializeOpDocumentRestartSimulationJobInput(v *RestartSimulationJobInput, value smithyjson.Value) error {
4083	object := value.Object()
4084	defer object.Close()
4085
4086	if v.Job != nil {
4087		ok := object.Key("job")
4088		ok.String(*v.Job)
4089	}
4090
4091	return nil
4092}
4093
4094type awsRestjson1_serializeOpStartSimulationJobBatch struct {
4095}
4096
4097func (*awsRestjson1_serializeOpStartSimulationJobBatch) ID() string {
4098	return "OperationSerializer"
4099}
4100
4101func (m *awsRestjson1_serializeOpStartSimulationJobBatch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4102	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4103) {
4104	request, ok := in.Request.(*smithyhttp.Request)
4105	if !ok {
4106		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4107	}
4108
4109	input, ok := in.Parameters.(*StartSimulationJobBatchInput)
4110	_ = input
4111	if !ok {
4112		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4113	}
4114
4115	opPath, opQuery := httpbinding.SplitURI("/startSimulationJobBatch")
4116	request.URL.Path = opPath
4117	if len(request.URL.RawQuery) > 0 {
4118		request.URL.RawQuery = "&" + opQuery
4119	} else {
4120		request.URL.RawQuery = opQuery
4121	}
4122
4123	request.Method = "POST"
4124	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4125	if err != nil {
4126		return out, metadata, &smithy.SerializationError{Err: err}
4127	}
4128
4129	restEncoder.SetHeader("Content-Type").String("application/json")
4130
4131	jsonEncoder := smithyjson.NewEncoder()
4132	if err := awsRestjson1_serializeOpDocumentStartSimulationJobBatchInput(input, jsonEncoder.Value); err != nil {
4133		return out, metadata, &smithy.SerializationError{Err: err}
4134	}
4135
4136	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4137		return out, metadata, &smithy.SerializationError{Err: err}
4138	}
4139
4140	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4141		return out, metadata, &smithy.SerializationError{Err: err}
4142	}
4143	in.Request = request
4144
4145	return next.HandleSerialize(ctx, in)
4146}
4147func awsRestjson1_serializeOpHttpBindingsStartSimulationJobBatchInput(v *StartSimulationJobBatchInput, encoder *httpbinding.Encoder) error {
4148	if v == nil {
4149		return fmt.Errorf("unsupported serialization of nil %T", v)
4150	}
4151
4152	return nil
4153}
4154
4155func awsRestjson1_serializeOpDocumentStartSimulationJobBatchInput(v *StartSimulationJobBatchInput, value smithyjson.Value) error {
4156	object := value.Object()
4157	defer object.Close()
4158
4159	if v.BatchPolicy != nil {
4160		ok := object.Key("batchPolicy")
4161		if err := awsRestjson1_serializeDocumentBatchPolicy(v.BatchPolicy, ok); err != nil {
4162			return err
4163		}
4164	}
4165
4166	if v.ClientRequestToken != nil {
4167		ok := object.Key("clientRequestToken")
4168		ok.String(*v.ClientRequestToken)
4169	}
4170
4171	if v.CreateSimulationJobRequests != nil {
4172		ok := object.Key("createSimulationJobRequests")
4173		if err := awsRestjson1_serializeDocumentCreateSimulationJobRequests(v.CreateSimulationJobRequests, ok); err != nil {
4174			return err
4175		}
4176	}
4177
4178	if v.Tags != nil {
4179		ok := object.Key("tags")
4180		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
4181			return err
4182		}
4183	}
4184
4185	return nil
4186}
4187
4188type awsRestjson1_serializeOpSyncDeploymentJob struct {
4189}
4190
4191func (*awsRestjson1_serializeOpSyncDeploymentJob) ID() string {
4192	return "OperationSerializer"
4193}
4194
4195func (m *awsRestjson1_serializeOpSyncDeploymentJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4196	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4197) {
4198	request, ok := in.Request.(*smithyhttp.Request)
4199	if !ok {
4200		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4201	}
4202
4203	input, ok := in.Parameters.(*SyncDeploymentJobInput)
4204	_ = input
4205	if !ok {
4206		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4207	}
4208
4209	opPath, opQuery := httpbinding.SplitURI("/syncDeploymentJob")
4210	request.URL.Path = opPath
4211	if len(request.URL.RawQuery) > 0 {
4212		request.URL.RawQuery = "&" + opQuery
4213	} else {
4214		request.URL.RawQuery = opQuery
4215	}
4216
4217	request.Method = "POST"
4218	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4219	if err != nil {
4220		return out, metadata, &smithy.SerializationError{Err: err}
4221	}
4222
4223	restEncoder.SetHeader("Content-Type").String("application/json")
4224
4225	jsonEncoder := smithyjson.NewEncoder()
4226	if err := awsRestjson1_serializeOpDocumentSyncDeploymentJobInput(input, jsonEncoder.Value); err != nil {
4227		return out, metadata, &smithy.SerializationError{Err: err}
4228	}
4229
4230	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4231		return out, metadata, &smithy.SerializationError{Err: err}
4232	}
4233
4234	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4235		return out, metadata, &smithy.SerializationError{Err: err}
4236	}
4237	in.Request = request
4238
4239	return next.HandleSerialize(ctx, in)
4240}
4241func awsRestjson1_serializeOpHttpBindingsSyncDeploymentJobInput(v *SyncDeploymentJobInput, encoder *httpbinding.Encoder) error {
4242	if v == nil {
4243		return fmt.Errorf("unsupported serialization of nil %T", v)
4244	}
4245
4246	return nil
4247}
4248
4249func awsRestjson1_serializeOpDocumentSyncDeploymentJobInput(v *SyncDeploymentJobInput, value smithyjson.Value) error {
4250	object := value.Object()
4251	defer object.Close()
4252
4253	if v.ClientRequestToken != nil {
4254		ok := object.Key("clientRequestToken")
4255		ok.String(*v.ClientRequestToken)
4256	}
4257
4258	if v.Fleet != nil {
4259		ok := object.Key("fleet")
4260		ok.String(*v.Fleet)
4261	}
4262
4263	return nil
4264}
4265
4266type awsRestjson1_serializeOpTagResource struct {
4267}
4268
4269func (*awsRestjson1_serializeOpTagResource) ID() string {
4270	return "OperationSerializer"
4271}
4272
4273func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4274	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4275) {
4276	request, ok := in.Request.(*smithyhttp.Request)
4277	if !ok {
4278		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4279	}
4280
4281	input, ok := in.Parameters.(*TagResourceInput)
4282	_ = input
4283	if !ok {
4284		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4285	}
4286
4287	opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
4288	request.URL.Path = opPath
4289	if len(request.URL.RawQuery) > 0 {
4290		request.URL.RawQuery = "&" + opQuery
4291	} else {
4292		request.URL.RawQuery = opQuery
4293	}
4294
4295	request.Method = "POST"
4296	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4297	if err != nil {
4298		return out, metadata, &smithy.SerializationError{Err: err}
4299	}
4300
4301	if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
4302		return out, metadata, &smithy.SerializationError{Err: err}
4303	}
4304
4305	restEncoder.SetHeader("Content-Type").String("application/json")
4306
4307	jsonEncoder := smithyjson.NewEncoder()
4308	if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
4309		return out, metadata, &smithy.SerializationError{Err: err}
4310	}
4311
4312	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4313		return out, metadata, &smithy.SerializationError{Err: err}
4314	}
4315
4316	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4317		return out, metadata, &smithy.SerializationError{Err: err}
4318	}
4319	in.Request = request
4320
4321	return next.HandleSerialize(ctx, in)
4322}
4323func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
4324	if v == nil {
4325		return fmt.Errorf("unsupported serialization of nil %T", v)
4326	}
4327
4328	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
4329		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
4330	}
4331	if v.ResourceArn != nil {
4332		if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
4333			return err
4334		}
4335	}
4336
4337	return nil
4338}
4339
4340func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
4341	object := value.Object()
4342	defer object.Close()
4343
4344	if v.Tags != nil {
4345		ok := object.Key("tags")
4346		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
4347			return err
4348		}
4349	}
4350
4351	return nil
4352}
4353
4354type awsRestjson1_serializeOpUntagResource struct {
4355}
4356
4357func (*awsRestjson1_serializeOpUntagResource) ID() string {
4358	return "OperationSerializer"
4359}
4360
4361func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4362	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4363) {
4364	request, ok := in.Request.(*smithyhttp.Request)
4365	if !ok {
4366		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4367	}
4368
4369	input, ok := in.Parameters.(*UntagResourceInput)
4370	_ = input
4371	if !ok {
4372		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4373	}
4374
4375	opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
4376	request.URL.Path = opPath
4377	if len(request.URL.RawQuery) > 0 {
4378		request.URL.RawQuery = "&" + opQuery
4379	} else {
4380		request.URL.RawQuery = opQuery
4381	}
4382
4383	request.Method = "DELETE"
4384	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4385	if err != nil {
4386		return out, metadata, &smithy.SerializationError{Err: err}
4387	}
4388
4389	if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil {
4390		return out, metadata, &smithy.SerializationError{Err: err}
4391	}
4392
4393	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4394		return out, metadata, &smithy.SerializationError{Err: err}
4395	}
4396	in.Request = request
4397
4398	return next.HandleSerialize(ctx, in)
4399}
4400func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
4401	if v == nil {
4402		return fmt.Errorf("unsupported serialization of nil %T", v)
4403	}
4404
4405	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
4406		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
4407	}
4408	if v.ResourceArn != nil {
4409		if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
4410			return err
4411		}
4412	}
4413
4414	if v.TagKeys != nil {
4415		for i := range v.TagKeys {
4416			encoder.AddQuery("tagKeys").String(v.TagKeys[i])
4417		}
4418	}
4419
4420	return nil
4421}
4422
4423type awsRestjson1_serializeOpUpdateRobotApplication struct {
4424}
4425
4426func (*awsRestjson1_serializeOpUpdateRobotApplication) ID() string {
4427	return "OperationSerializer"
4428}
4429
4430func (m *awsRestjson1_serializeOpUpdateRobotApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4431	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4432) {
4433	request, ok := in.Request.(*smithyhttp.Request)
4434	if !ok {
4435		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4436	}
4437
4438	input, ok := in.Parameters.(*UpdateRobotApplicationInput)
4439	_ = input
4440	if !ok {
4441		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4442	}
4443
4444	opPath, opQuery := httpbinding.SplitURI("/updateRobotApplication")
4445	request.URL.Path = opPath
4446	if len(request.URL.RawQuery) > 0 {
4447		request.URL.RawQuery = "&" + opQuery
4448	} else {
4449		request.URL.RawQuery = opQuery
4450	}
4451
4452	request.Method = "POST"
4453	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4454	if err != nil {
4455		return out, metadata, &smithy.SerializationError{Err: err}
4456	}
4457
4458	restEncoder.SetHeader("Content-Type").String("application/json")
4459
4460	jsonEncoder := smithyjson.NewEncoder()
4461	if err := awsRestjson1_serializeOpDocumentUpdateRobotApplicationInput(input, jsonEncoder.Value); err != nil {
4462		return out, metadata, &smithy.SerializationError{Err: err}
4463	}
4464
4465	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4466		return out, metadata, &smithy.SerializationError{Err: err}
4467	}
4468
4469	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4470		return out, metadata, &smithy.SerializationError{Err: err}
4471	}
4472	in.Request = request
4473
4474	return next.HandleSerialize(ctx, in)
4475}
4476func awsRestjson1_serializeOpHttpBindingsUpdateRobotApplicationInput(v *UpdateRobotApplicationInput, encoder *httpbinding.Encoder) error {
4477	if v == nil {
4478		return fmt.Errorf("unsupported serialization of nil %T", v)
4479	}
4480
4481	return nil
4482}
4483
4484func awsRestjson1_serializeOpDocumentUpdateRobotApplicationInput(v *UpdateRobotApplicationInput, value smithyjson.Value) error {
4485	object := value.Object()
4486	defer object.Close()
4487
4488	if v.Application != nil {
4489		ok := object.Key("application")
4490		ok.String(*v.Application)
4491	}
4492
4493	if v.CurrentRevisionId != nil {
4494		ok := object.Key("currentRevisionId")
4495		ok.String(*v.CurrentRevisionId)
4496	}
4497
4498	if v.RobotSoftwareSuite != nil {
4499		ok := object.Key("robotSoftwareSuite")
4500		if err := awsRestjson1_serializeDocumentRobotSoftwareSuite(v.RobotSoftwareSuite, ok); err != nil {
4501			return err
4502		}
4503	}
4504
4505	if v.Sources != nil {
4506		ok := object.Key("sources")
4507		if err := awsRestjson1_serializeDocumentSourceConfigs(v.Sources, ok); err != nil {
4508			return err
4509		}
4510	}
4511
4512	return nil
4513}
4514
4515type awsRestjson1_serializeOpUpdateSimulationApplication struct {
4516}
4517
4518func (*awsRestjson1_serializeOpUpdateSimulationApplication) ID() string {
4519	return "OperationSerializer"
4520}
4521
4522func (m *awsRestjson1_serializeOpUpdateSimulationApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4523	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4524) {
4525	request, ok := in.Request.(*smithyhttp.Request)
4526	if !ok {
4527		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4528	}
4529
4530	input, ok := in.Parameters.(*UpdateSimulationApplicationInput)
4531	_ = input
4532	if !ok {
4533		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4534	}
4535
4536	opPath, opQuery := httpbinding.SplitURI("/updateSimulationApplication")
4537	request.URL.Path = opPath
4538	if len(request.URL.RawQuery) > 0 {
4539		request.URL.RawQuery = "&" + opQuery
4540	} else {
4541		request.URL.RawQuery = opQuery
4542	}
4543
4544	request.Method = "POST"
4545	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4546	if err != nil {
4547		return out, metadata, &smithy.SerializationError{Err: err}
4548	}
4549
4550	restEncoder.SetHeader("Content-Type").String("application/json")
4551
4552	jsonEncoder := smithyjson.NewEncoder()
4553	if err := awsRestjson1_serializeOpDocumentUpdateSimulationApplicationInput(input, jsonEncoder.Value); err != nil {
4554		return out, metadata, &smithy.SerializationError{Err: err}
4555	}
4556
4557	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4558		return out, metadata, &smithy.SerializationError{Err: err}
4559	}
4560
4561	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4562		return out, metadata, &smithy.SerializationError{Err: err}
4563	}
4564	in.Request = request
4565
4566	return next.HandleSerialize(ctx, in)
4567}
4568func awsRestjson1_serializeOpHttpBindingsUpdateSimulationApplicationInput(v *UpdateSimulationApplicationInput, encoder *httpbinding.Encoder) error {
4569	if v == nil {
4570		return fmt.Errorf("unsupported serialization of nil %T", v)
4571	}
4572
4573	return nil
4574}
4575
4576func awsRestjson1_serializeOpDocumentUpdateSimulationApplicationInput(v *UpdateSimulationApplicationInput, value smithyjson.Value) error {
4577	object := value.Object()
4578	defer object.Close()
4579
4580	if v.Application != nil {
4581		ok := object.Key("application")
4582		ok.String(*v.Application)
4583	}
4584
4585	if v.CurrentRevisionId != nil {
4586		ok := object.Key("currentRevisionId")
4587		ok.String(*v.CurrentRevisionId)
4588	}
4589
4590	if v.RenderingEngine != nil {
4591		ok := object.Key("renderingEngine")
4592		if err := awsRestjson1_serializeDocumentRenderingEngine(v.RenderingEngine, ok); err != nil {
4593			return err
4594		}
4595	}
4596
4597	if v.RobotSoftwareSuite != nil {
4598		ok := object.Key("robotSoftwareSuite")
4599		if err := awsRestjson1_serializeDocumentRobotSoftwareSuite(v.RobotSoftwareSuite, ok); err != nil {
4600			return err
4601		}
4602	}
4603
4604	if v.SimulationSoftwareSuite != nil {
4605		ok := object.Key("simulationSoftwareSuite")
4606		if err := awsRestjson1_serializeDocumentSimulationSoftwareSuite(v.SimulationSoftwareSuite, ok); err != nil {
4607			return err
4608		}
4609	}
4610
4611	if v.Sources != nil {
4612		ok := object.Key("sources")
4613		if err := awsRestjson1_serializeDocumentSourceConfigs(v.Sources, ok); err != nil {
4614			return err
4615		}
4616	}
4617
4618	return nil
4619}
4620
4621type awsRestjson1_serializeOpUpdateWorldTemplate struct {
4622}
4623
4624func (*awsRestjson1_serializeOpUpdateWorldTemplate) ID() string {
4625	return "OperationSerializer"
4626}
4627
4628func (m *awsRestjson1_serializeOpUpdateWorldTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4629	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4630) {
4631	request, ok := in.Request.(*smithyhttp.Request)
4632	if !ok {
4633		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4634	}
4635
4636	input, ok := in.Parameters.(*UpdateWorldTemplateInput)
4637	_ = input
4638	if !ok {
4639		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4640	}
4641
4642	opPath, opQuery := httpbinding.SplitURI("/updateWorldTemplate")
4643	request.URL.Path = opPath
4644	if len(request.URL.RawQuery) > 0 {
4645		request.URL.RawQuery = "&" + opQuery
4646	} else {
4647		request.URL.RawQuery = opQuery
4648	}
4649
4650	request.Method = "POST"
4651	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4652	if err != nil {
4653		return out, metadata, &smithy.SerializationError{Err: err}
4654	}
4655
4656	restEncoder.SetHeader("Content-Type").String("application/json")
4657
4658	jsonEncoder := smithyjson.NewEncoder()
4659	if err := awsRestjson1_serializeOpDocumentUpdateWorldTemplateInput(input, jsonEncoder.Value); err != nil {
4660		return out, metadata, &smithy.SerializationError{Err: err}
4661	}
4662
4663	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4664		return out, metadata, &smithy.SerializationError{Err: err}
4665	}
4666
4667	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4668		return out, metadata, &smithy.SerializationError{Err: err}
4669	}
4670	in.Request = request
4671
4672	return next.HandleSerialize(ctx, in)
4673}
4674func awsRestjson1_serializeOpHttpBindingsUpdateWorldTemplateInput(v *UpdateWorldTemplateInput, encoder *httpbinding.Encoder) error {
4675	if v == nil {
4676		return fmt.Errorf("unsupported serialization of nil %T", v)
4677	}
4678
4679	return nil
4680}
4681
4682func awsRestjson1_serializeOpDocumentUpdateWorldTemplateInput(v *UpdateWorldTemplateInput, value smithyjson.Value) error {
4683	object := value.Object()
4684	defer object.Close()
4685
4686	if v.Name != nil {
4687		ok := object.Key("name")
4688		ok.String(*v.Name)
4689	}
4690
4691	if v.Template != nil {
4692		ok := object.Key("template")
4693		ok.String(*v.Template)
4694	}
4695
4696	if v.TemplateBody != nil {
4697		ok := object.Key("templateBody")
4698		ok.String(*v.TemplateBody)
4699	}
4700
4701	if v.TemplateLocation != nil {
4702		ok := object.Key("templateLocation")
4703		if err := awsRestjson1_serializeDocumentTemplateLocation(v.TemplateLocation, ok); err != nil {
4704			return err
4705		}
4706	}
4707
4708	return nil
4709}
4710
4711func awsRestjson1_serializeDocumentArns(v []string, value smithyjson.Value) error {
4712	array := value.Array()
4713	defer array.Close()
4714
4715	for i := range v {
4716		av := array.Value()
4717		av.String(v[i])
4718	}
4719	return nil
4720}
4721
4722func awsRestjson1_serializeDocumentBatchPolicy(v *types.BatchPolicy, value smithyjson.Value) error {
4723	object := value.Object()
4724	defer object.Close()
4725
4726	if v.MaxConcurrency != nil {
4727		ok := object.Key("maxConcurrency")
4728		ok.Integer(*v.MaxConcurrency)
4729	}
4730
4731	if v.TimeoutInSeconds != nil {
4732		ok := object.Key("timeoutInSeconds")
4733		ok.Long(*v.TimeoutInSeconds)
4734	}
4735
4736	return nil
4737}
4738
4739func awsRestjson1_serializeDocumentCompute(v *types.Compute, value smithyjson.Value) error {
4740	object := value.Object()
4741	defer object.Close()
4742
4743	if v.SimulationUnitLimit != nil {
4744		ok := object.Key("simulationUnitLimit")
4745		ok.Integer(*v.SimulationUnitLimit)
4746	}
4747
4748	return nil
4749}
4750
4751func awsRestjson1_serializeDocumentCreateSimulationJobRequests(v []types.SimulationJobRequest, value smithyjson.Value) error {
4752	array := value.Array()
4753	defer array.Close()
4754
4755	for i := range v {
4756		av := array.Value()
4757		if err := awsRestjson1_serializeDocumentSimulationJobRequest(&v[i], av); err != nil {
4758			return err
4759		}
4760	}
4761	return nil
4762}
4763
4764func awsRestjson1_serializeDocumentDataSourceConfig(v *types.DataSourceConfig, value smithyjson.Value) error {
4765	object := value.Object()
4766	defer object.Close()
4767
4768	if v.Name != nil {
4769		ok := object.Key("name")
4770		ok.String(*v.Name)
4771	}
4772
4773	if v.S3Bucket != nil {
4774		ok := object.Key("s3Bucket")
4775		ok.String(*v.S3Bucket)
4776	}
4777
4778	if v.S3Keys != nil {
4779		ok := object.Key("s3Keys")
4780		if err := awsRestjson1_serializeDocumentS3Keys(v.S3Keys, ok); err != nil {
4781			return err
4782		}
4783	}
4784
4785	return nil
4786}
4787
4788func awsRestjson1_serializeDocumentDataSourceConfigs(v []types.DataSourceConfig, value smithyjson.Value) error {
4789	array := value.Array()
4790	defer array.Close()
4791
4792	for i := range v {
4793		av := array.Value()
4794		if err := awsRestjson1_serializeDocumentDataSourceConfig(&v[i], av); err != nil {
4795			return err
4796		}
4797	}
4798	return nil
4799}
4800
4801func awsRestjson1_serializeDocumentDeploymentApplicationConfig(v *types.DeploymentApplicationConfig, value smithyjson.Value) error {
4802	object := value.Object()
4803	defer object.Close()
4804
4805	if v.Application != nil {
4806		ok := object.Key("application")
4807		ok.String(*v.Application)
4808	}
4809
4810	if v.ApplicationVersion != nil {
4811		ok := object.Key("applicationVersion")
4812		ok.String(*v.ApplicationVersion)
4813	}
4814
4815	if v.LaunchConfig != nil {
4816		ok := object.Key("launchConfig")
4817		if err := awsRestjson1_serializeDocumentDeploymentLaunchConfig(v.LaunchConfig, ok); err != nil {
4818			return err
4819		}
4820	}
4821
4822	return nil
4823}
4824
4825func awsRestjson1_serializeDocumentDeploymentApplicationConfigs(v []types.DeploymentApplicationConfig, value smithyjson.Value) error {
4826	array := value.Array()
4827	defer array.Close()
4828
4829	for i := range v {
4830		av := array.Value()
4831		if err := awsRestjson1_serializeDocumentDeploymentApplicationConfig(&v[i], av); err != nil {
4832			return err
4833		}
4834	}
4835	return nil
4836}
4837
4838func awsRestjson1_serializeDocumentDeploymentConfig(v *types.DeploymentConfig, value smithyjson.Value) error {
4839	object := value.Object()
4840	defer object.Close()
4841
4842	if v.ConcurrentDeploymentPercentage != nil {
4843		ok := object.Key("concurrentDeploymentPercentage")
4844		ok.Integer(*v.ConcurrentDeploymentPercentage)
4845	}
4846
4847	if v.DownloadConditionFile != nil {
4848		ok := object.Key("downloadConditionFile")
4849		if err := awsRestjson1_serializeDocumentS3Object(v.DownloadConditionFile, ok); err != nil {
4850			return err
4851		}
4852	}
4853
4854	if v.FailureThresholdPercentage != nil {
4855		ok := object.Key("failureThresholdPercentage")
4856		ok.Integer(*v.FailureThresholdPercentage)
4857	}
4858
4859	if v.RobotDeploymentTimeoutInSeconds != nil {
4860		ok := object.Key("robotDeploymentTimeoutInSeconds")
4861		ok.Long(*v.RobotDeploymentTimeoutInSeconds)
4862	}
4863
4864	return nil
4865}
4866
4867func awsRestjson1_serializeDocumentDeploymentLaunchConfig(v *types.DeploymentLaunchConfig, value smithyjson.Value) error {
4868	object := value.Object()
4869	defer object.Close()
4870
4871	if v.EnvironmentVariables != nil {
4872		ok := object.Key("environmentVariables")
4873		if err := awsRestjson1_serializeDocumentEnvironmentVariableMap(v.EnvironmentVariables, ok); err != nil {
4874			return err
4875		}
4876	}
4877
4878	if v.LaunchFile != nil {
4879		ok := object.Key("launchFile")
4880		ok.String(*v.LaunchFile)
4881	}
4882
4883	if v.PackageName != nil {
4884		ok := object.Key("packageName")
4885		ok.String(*v.PackageName)
4886	}
4887
4888	if v.PostLaunchFile != nil {
4889		ok := object.Key("postLaunchFile")
4890		ok.String(*v.PostLaunchFile)
4891	}
4892
4893	if v.PreLaunchFile != nil {
4894		ok := object.Key("preLaunchFile")
4895		ok.String(*v.PreLaunchFile)
4896	}
4897
4898	return nil
4899}
4900
4901func awsRestjson1_serializeDocumentEnvironmentVariableMap(v map[string]string, value smithyjson.Value) error {
4902	object := value.Object()
4903	defer object.Close()
4904
4905	for key := range v {
4906		om := object.Key(key)
4907		om.String(v[key])
4908	}
4909	return nil
4910}
4911
4912func awsRestjson1_serializeDocumentFilter(v *types.Filter, value smithyjson.Value) error {
4913	object := value.Object()
4914	defer object.Close()
4915
4916	if v.Name != nil {
4917		ok := object.Key("name")
4918		ok.String(*v.Name)
4919	}
4920
4921	if v.Values != nil {
4922		ok := object.Key("values")
4923		if err := awsRestjson1_serializeDocumentFilterValues(v.Values, ok); err != nil {
4924			return err
4925		}
4926	}
4927
4928	return nil
4929}
4930
4931func awsRestjson1_serializeDocumentFilters(v []types.Filter, value smithyjson.Value) error {
4932	array := value.Array()
4933	defer array.Close()
4934
4935	for i := range v {
4936		av := array.Value()
4937		if err := awsRestjson1_serializeDocumentFilter(&v[i], av); err != nil {
4938			return err
4939		}
4940	}
4941	return nil
4942}
4943
4944func awsRestjson1_serializeDocumentFilterValues(v []string, value smithyjson.Value) error {
4945	array := value.Array()
4946	defer array.Close()
4947
4948	for i := range v {
4949		av := array.Value()
4950		av.String(v[i])
4951	}
4952	return nil
4953}
4954
4955func awsRestjson1_serializeDocumentLaunchConfig(v *types.LaunchConfig, value smithyjson.Value) error {
4956	object := value.Object()
4957	defer object.Close()
4958
4959	if v.EnvironmentVariables != nil {
4960		ok := object.Key("environmentVariables")
4961		if err := awsRestjson1_serializeDocumentEnvironmentVariableMap(v.EnvironmentVariables, ok); err != nil {
4962			return err
4963		}
4964	}
4965
4966	if v.LaunchFile != nil {
4967		ok := object.Key("launchFile")
4968		ok.String(*v.LaunchFile)
4969	}
4970
4971	if v.PackageName != nil {
4972		ok := object.Key("packageName")
4973		ok.String(*v.PackageName)
4974	}
4975
4976	if v.PortForwardingConfig != nil {
4977		ok := object.Key("portForwardingConfig")
4978		if err := awsRestjson1_serializeDocumentPortForwardingConfig(v.PortForwardingConfig, ok); err != nil {
4979			return err
4980		}
4981	}
4982
4983	if v.StreamUI {
4984		ok := object.Key("streamUI")
4985		ok.Boolean(v.StreamUI)
4986	}
4987
4988	return nil
4989}
4990
4991func awsRestjson1_serializeDocumentLoggingConfig(v *types.LoggingConfig, value smithyjson.Value) error {
4992	object := value.Object()
4993	defer object.Close()
4994
4995	if v.RecordAllRosTopics != nil {
4996		ok := object.Key("recordAllRosTopics")
4997		ok.Boolean(*v.RecordAllRosTopics)
4998	}
4999
5000	return nil
5001}
5002
5003func awsRestjson1_serializeDocumentOutputLocation(v *types.OutputLocation, value smithyjson.Value) error {
5004	object := value.Object()
5005	defer object.Close()
5006
5007	if v.S3Bucket != nil {
5008		ok := object.Key("s3Bucket")
5009		ok.String(*v.S3Bucket)
5010	}
5011
5012	if v.S3Prefix != nil {
5013		ok := object.Key("s3Prefix")
5014		ok.String(*v.S3Prefix)
5015	}
5016
5017	return nil
5018}
5019
5020func awsRestjson1_serializeDocumentPortForwardingConfig(v *types.PortForwardingConfig, value smithyjson.Value) error {
5021	object := value.Object()
5022	defer object.Close()
5023
5024	if v.PortMappings != nil {
5025		ok := object.Key("portMappings")
5026		if err := awsRestjson1_serializeDocumentPortMappingList(v.PortMappings, ok); err != nil {
5027			return err
5028		}
5029	}
5030
5031	return nil
5032}
5033
5034func awsRestjson1_serializeDocumentPortMapping(v *types.PortMapping, value smithyjson.Value) error {
5035	object := value.Object()
5036	defer object.Close()
5037
5038	if v.ApplicationPort != 0 {
5039		ok := object.Key("applicationPort")
5040		ok.Integer(v.ApplicationPort)
5041	}
5042
5043	if v.EnableOnPublicIp {
5044		ok := object.Key("enableOnPublicIp")
5045		ok.Boolean(v.EnableOnPublicIp)
5046	}
5047
5048	if v.JobPort != 0 {
5049		ok := object.Key("jobPort")
5050		ok.Integer(v.JobPort)
5051	}
5052
5053	return nil
5054}
5055
5056func awsRestjson1_serializeDocumentPortMappingList(v []types.PortMapping, value smithyjson.Value) error {
5057	array := value.Array()
5058	defer array.Close()
5059
5060	for i := range v {
5061		av := array.Value()
5062		if err := awsRestjson1_serializeDocumentPortMapping(&v[i], av); err != nil {
5063			return err
5064		}
5065	}
5066	return nil
5067}
5068
5069func awsRestjson1_serializeDocumentRenderingEngine(v *types.RenderingEngine, value smithyjson.Value) error {
5070	object := value.Object()
5071	defer object.Close()
5072
5073	if len(v.Name) > 0 {
5074		ok := object.Key("name")
5075		ok.String(string(v.Name))
5076	}
5077
5078	if v.Version != nil {
5079		ok := object.Key("version")
5080		ok.String(*v.Version)
5081	}
5082
5083	return nil
5084}
5085
5086func awsRestjson1_serializeDocumentRobotApplicationConfig(v *types.RobotApplicationConfig, value smithyjson.Value) error {
5087	object := value.Object()
5088	defer object.Close()
5089
5090	if v.Application != nil {
5091		ok := object.Key("application")
5092		ok.String(*v.Application)
5093	}
5094
5095	if v.ApplicationVersion != nil {
5096		ok := object.Key("applicationVersion")
5097		ok.String(*v.ApplicationVersion)
5098	}
5099
5100	if v.LaunchConfig != nil {
5101		ok := object.Key("launchConfig")
5102		if err := awsRestjson1_serializeDocumentLaunchConfig(v.LaunchConfig, ok); err != nil {
5103			return err
5104		}
5105	}
5106
5107	return nil
5108}
5109
5110func awsRestjson1_serializeDocumentRobotApplicationConfigs(v []types.RobotApplicationConfig, value smithyjson.Value) error {
5111	array := value.Array()
5112	defer array.Close()
5113
5114	for i := range v {
5115		av := array.Value()
5116		if err := awsRestjson1_serializeDocumentRobotApplicationConfig(&v[i], av); err != nil {
5117			return err
5118		}
5119	}
5120	return nil
5121}
5122
5123func awsRestjson1_serializeDocumentRobotSoftwareSuite(v *types.RobotSoftwareSuite, value smithyjson.Value) error {
5124	object := value.Object()
5125	defer object.Close()
5126
5127	if len(v.Name) > 0 {
5128		ok := object.Key("name")
5129		ok.String(string(v.Name))
5130	}
5131
5132	if len(v.Version) > 0 {
5133		ok := object.Key("version")
5134		ok.String(string(v.Version))
5135	}
5136
5137	return nil
5138}
5139
5140func awsRestjson1_serializeDocumentS3Keys(v []string, value smithyjson.Value) error {
5141	array := value.Array()
5142	defer array.Close()
5143
5144	for i := range v {
5145		av := array.Value()
5146		av.String(v[i])
5147	}
5148	return nil
5149}
5150
5151func awsRestjson1_serializeDocumentS3Object(v *types.S3Object, value smithyjson.Value) error {
5152	object := value.Object()
5153	defer object.Close()
5154
5155	if v.Bucket != nil {
5156		ok := object.Key("bucket")
5157		ok.String(*v.Bucket)
5158	}
5159
5160	if v.Etag != nil {
5161		ok := object.Key("etag")
5162		ok.String(*v.Etag)
5163	}
5164
5165	if v.Key != nil {
5166		ok := object.Key("key")
5167		ok.String(*v.Key)
5168	}
5169
5170	return nil
5171}
5172
5173func awsRestjson1_serializeDocumentSecurityGroups(v []string, value smithyjson.Value) error {
5174	array := value.Array()
5175	defer array.Close()
5176
5177	for i := range v {
5178		av := array.Value()
5179		av.String(v[i])
5180	}
5181	return nil
5182}
5183
5184func awsRestjson1_serializeDocumentSimulationApplicationConfig(v *types.SimulationApplicationConfig, value smithyjson.Value) error {
5185	object := value.Object()
5186	defer object.Close()
5187
5188	if v.Application != nil {
5189		ok := object.Key("application")
5190		ok.String(*v.Application)
5191	}
5192
5193	if v.ApplicationVersion != nil {
5194		ok := object.Key("applicationVersion")
5195		ok.String(*v.ApplicationVersion)
5196	}
5197
5198	if v.LaunchConfig != nil {
5199		ok := object.Key("launchConfig")
5200		if err := awsRestjson1_serializeDocumentLaunchConfig(v.LaunchConfig, ok); err != nil {
5201			return err
5202		}
5203	}
5204
5205	if v.WorldConfigs != nil {
5206		ok := object.Key("worldConfigs")
5207		if err := awsRestjson1_serializeDocumentWorldConfigs(v.WorldConfigs, ok); err != nil {
5208			return err
5209		}
5210	}
5211
5212	return nil
5213}
5214
5215func awsRestjson1_serializeDocumentSimulationApplicationConfigs(v []types.SimulationApplicationConfig, value smithyjson.Value) error {
5216	array := value.Array()
5217	defer array.Close()
5218
5219	for i := range v {
5220		av := array.Value()
5221		if err := awsRestjson1_serializeDocumentSimulationApplicationConfig(&v[i], av); err != nil {
5222			return err
5223		}
5224	}
5225	return nil
5226}
5227
5228func awsRestjson1_serializeDocumentSimulationJobRequest(v *types.SimulationJobRequest, value smithyjson.Value) error {
5229	object := value.Object()
5230	defer object.Close()
5231
5232	if v.Compute != nil {
5233		ok := object.Key("compute")
5234		if err := awsRestjson1_serializeDocumentCompute(v.Compute, ok); err != nil {
5235			return err
5236		}
5237	}
5238
5239	if v.DataSources != nil {
5240		ok := object.Key("dataSources")
5241		if err := awsRestjson1_serializeDocumentDataSourceConfigs(v.DataSources, ok); err != nil {
5242			return err
5243		}
5244	}
5245
5246	if len(v.FailureBehavior) > 0 {
5247		ok := object.Key("failureBehavior")
5248		ok.String(string(v.FailureBehavior))
5249	}
5250
5251	if v.IamRole != nil {
5252		ok := object.Key("iamRole")
5253		ok.String(*v.IamRole)
5254	}
5255
5256	if v.LoggingConfig != nil {
5257		ok := object.Key("loggingConfig")
5258		if err := awsRestjson1_serializeDocumentLoggingConfig(v.LoggingConfig, ok); err != nil {
5259			return err
5260		}
5261	}
5262
5263	if v.MaxJobDurationInSeconds != 0 {
5264		ok := object.Key("maxJobDurationInSeconds")
5265		ok.Long(v.MaxJobDurationInSeconds)
5266	}
5267
5268	if v.OutputLocation != nil {
5269		ok := object.Key("outputLocation")
5270		if err := awsRestjson1_serializeDocumentOutputLocation(v.OutputLocation, ok); err != nil {
5271			return err
5272		}
5273	}
5274
5275	if v.RobotApplications != nil {
5276		ok := object.Key("robotApplications")
5277		if err := awsRestjson1_serializeDocumentRobotApplicationConfigs(v.RobotApplications, ok); err != nil {
5278			return err
5279		}
5280	}
5281
5282	if v.SimulationApplications != nil {
5283		ok := object.Key("simulationApplications")
5284		if err := awsRestjson1_serializeDocumentSimulationApplicationConfigs(v.SimulationApplications, ok); err != nil {
5285			return err
5286		}
5287	}
5288
5289	if v.Tags != nil {
5290		ok := object.Key("tags")
5291		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
5292			return err
5293		}
5294	}
5295
5296	if v.UseDefaultApplications != nil {
5297		ok := object.Key("useDefaultApplications")
5298		ok.Boolean(*v.UseDefaultApplications)
5299	}
5300
5301	if v.VpcConfig != nil {
5302		ok := object.Key("vpcConfig")
5303		if err := awsRestjson1_serializeDocumentVPCConfig(v.VpcConfig, ok); err != nil {
5304			return err
5305		}
5306	}
5307
5308	return nil
5309}
5310
5311func awsRestjson1_serializeDocumentSimulationSoftwareSuite(v *types.SimulationSoftwareSuite, value smithyjson.Value) error {
5312	object := value.Object()
5313	defer object.Close()
5314
5315	if len(v.Name) > 0 {
5316		ok := object.Key("name")
5317		ok.String(string(v.Name))
5318	}
5319
5320	if v.Version != nil {
5321		ok := object.Key("version")
5322		ok.String(*v.Version)
5323	}
5324
5325	return nil
5326}
5327
5328func awsRestjson1_serializeDocumentSourceConfig(v *types.SourceConfig, value smithyjson.Value) error {
5329	object := value.Object()
5330	defer object.Close()
5331
5332	if len(v.Architecture) > 0 {
5333		ok := object.Key("architecture")
5334		ok.String(string(v.Architecture))
5335	}
5336
5337	if v.S3Bucket != nil {
5338		ok := object.Key("s3Bucket")
5339		ok.String(*v.S3Bucket)
5340	}
5341
5342	if v.S3Key != nil {
5343		ok := object.Key("s3Key")
5344		ok.String(*v.S3Key)
5345	}
5346
5347	return nil
5348}
5349
5350func awsRestjson1_serializeDocumentSourceConfigs(v []types.SourceConfig, value smithyjson.Value) error {
5351	array := value.Array()
5352	defer array.Close()
5353
5354	for i := range v {
5355		av := array.Value()
5356		if err := awsRestjson1_serializeDocumentSourceConfig(&v[i], av); err != nil {
5357			return err
5358		}
5359	}
5360	return nil
5361}
5362
5363func awsRestjson1_serializeDocumentSubnets(v []string, value smithyjson.Value) error {
5364	array := value.Array()
5365	defer array.Close()
5366
5367	for i := range v {
5368		av := array.Value()
5369		av.String(v[i])
5370	}
5371	return nil
5372}
5373
5374func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error {
5375	object := value.Object()
5376	defer object.Close()
5377
5378	for key := range v {
5379		om := object.Key(key)
5380		om.String(v[key])
5381	}
5382	return nil
5383}
5384
5385func awsRestjson1_serializeDocumentTemplateLocation(v *types.TemplateLocation, value smithyjson.Value) error {
5386	object := value.Object()
5387	defer object.Close()
5388
5389	if v.S3Bucket != nil {
5390		ok := object.Key("s3Bucket")
5391		ok.String(*v.S3Bucket)
5392	}
5393
5394	if v.S3Key != nil {
5395		ok := object.Key("s3Key")
5396		ok.String(*v.S3Key)
5397	}
5398
5399	return nil
5400}
5401
5402func awsRestjson1_serializeDocumentVPCConfig(v *types.VPCConfig, value smithyjson.Value) error {
5403	object := value.Object()
5404	defer object.Close()
5405
5406	if v.AssignPublicIp {
5407		ok := object.Key("assignPublicIp")
5408		ok.Boolean(v.AssignPublicIp)
5409	}
5410
5411	if v.SecurityGroups != nil {
5412		ok := object.Key("securityGroups")
5413		if err := awsRestjson1_serializeDocumentSecurityGroups(v.SecurityGroups, ok); err != nil {
5414			return err
5415		}
5416	}
5417
5418	if v.Subnets != nil {
5419		ok := object.Key("subnets")
5420		if err := awsRestjson1_serializeDocumentSubnets(v.Subnets, ok); err != nil {
5421			return err
5422		}
5423	}
5424
5425	return nil
5426}
5427
5428func awsRestjson1_serializeDocumentWorldConfig(v *types.WorldConfig, value smithyjson.Value) error {
5429	object := value.Object()
5430	defer object.Close()
5431
5432	if v.World != nil {
5433		ok := object.Key("world")
5434		ok.String(*v.World)
5435	}
5436
5437	return nil
5438}
5439
5440func awsRestjson1_serializeDocumentWorldConfigs(v []types.WorldConfig, value smithyjson.Value) error {
5441	array := value.Array()
5442	defer array.Close()
5443
5444	for i := range v {
5445		av := array.Value()
5446		if err := awsRestjson1_serializeDocumentWorldConfig(&v[i], av); err != nil {
5447			return err
5448		}
5449	}
5450	return nil
5451}
5452
5453func awsRestjson1_serializeDocumentWorldCount(v *types.WorldCount, value smithyjson.Value) error {
5454	object := value.Object()
5455	defer object.Close()
5456
5457	if v.FloorplanCount != nil {
5458		ok := object.Key("floorplanCount")
5459		ok.Integer(*v.FloorplanCount)
5460	}
5461
5462	if v.InteriorCountPerFloorplan != nil {
5463		ok := object.Key("interiorCountPerFloorplan")
5464		ok.Integer(*v.InteriorCountPerFloorplan)
5465	}
5466
5467	return nil
5468}
5469