1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package greengrass
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/greengrass/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_serializeOpAssociateRoleToGroup struct {
18}
19
20func (*awsRestjson1_serializeOpAssociateRoleToGroup) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsRestjson1_serializeOpAssociateRoleToGroup) 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.(*AssociateRoleToGroupInput)
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("/greengrass/groups/{GroupId}/role")
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 = "PUT"
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	if err := awsRestjson1_serializeOpHttpBindingsAssociateRoleToGroupInput(input, restEncoder); err != nil {
53		return out, metadata, &smithy.SerializationError{Err: err}
54	}
55
56	restEncoder.SetHeader("Content-Type").String("application/json")
57
58	jsonEncoder := smithyjson.NewEncoder()
59	if err := awsRestjson1_serializeOpDocumentAssociateRoleToGroupInput(input, jsonEncoder.Value); err != nil {
60		return out, metadata, &smithy.SerializationError{Err: err}
61	}
62
63	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
64		return out, metadata, &smithy.SerializationError{Err: err}
65	}
66
67	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
68		return out, metadata, &smithy.SerializationError{Err: err}
69	}
70	in.Request = request
71
72	return next.HandleSerialize(ctx, in)
73}
74func awsRestjson1_serializeOpHttpBindingsAssociateRoleToGroupInput(v *AssociateRoleToGroupInput, encoder *httpbinding.Encoder) error {
75	if v == nil {
76		return fmt.Errorf("unsupported serialization of nil %T", v)
77	}
78
79	if v.GroupId == nil || len(*v.GroupId) == 0 {
80		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
81	}
82	if v.GroupId != nil {
83		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
84			return err
85		}
86	}
87
88	return nil
89}
90
91func awsRestjson1_serializeOpDocumentAssociateRoleToGroupInput(v *AssociateRoleToGroupInput, value smithyjson.Value) error {
92	object := value.Object()
93	defer object.Close()
94
95	if v.RoleArn != nil {
96		ok := object.Key("RoleArn")
97		ok.String(*v.RoleArn)
98	}
99
100	return nil
101}
102
103type awsRestjson1_serializeOpAssociateServiceRoleToAccount struct {
104}
105
106func (*awsRestjson1_serializeOpAssociateServiceRoleToAccount) ID() string {
107	return "OperationSerializer"
108}
109
110func (m *awsRestjson1_serializeOpAssociateServiceRoleToAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
111	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
112) {
113	request, ok := in.Request.(*smithyhttp.Request)
114	if !ok {
115		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
116	}
117
118	input, ok := in.Parameters.(*AssociateServiceRoleToAccountInput)
119	_ = input
120	if !ok {
121		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
122	}
123
124	opPath, opQuery := httpbinding.SplitURI("/greengrass/servicerole")
125	request.URL.Path = opPath
126	if len(request.URL.RawQuery) > 0 {
127		request.URL.RawQuery = "&" + opQuery
128	} else {
129		request.URL.RawQuery = opQuery
130	}
131
132	request.Method = "PUT"
133	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
134	if err != nil {
135		return out, metadata, &smithy.SerializationError{Err: err}
136	}
137
138	restEncoder.SetHeader("Content-Type").String("application/json")
139
140	jsonEncoder := smithyjson.NewEncoder()
141	if err := awsRestjson1_serializeOpDocumentAssociateServiceRoleToAccountInput(input, jsonEncoder.Value); err != nil {
142		return out, metadata, &smithy.SerializationError{Err: err}
143	}
144
145	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
146		return out, metadata, &smithy.SerializationError{Err: err}
147	}
148
149	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
150		return out, metadata, &smithy.SerializationError{Err: err}
151	}
152	in.Request = request
153
154	return next.HandleSerialize(ctx, in)
155}
156func awsRestjson1_serializeOpHttpBindingsAssociateServiceRoleToAccountInput(v *AssociateServiceRoleToAccountInput, encoder *httpbinding.Encoder) error {
157	if v == nil {
158		return fmt.Errorf("unsupported serialization of nil %T", v)
159	}
160
161	return nil
162}
163
164func awsRestjson1_serializeOpDocumentAssociateServiceRoleToAccountInput(v *AssociateServiceRoleToAccountInput, value smithyjson.Value) error {
165	object := value.Object()
166	defer object.Close()
167
168	if v.RoleArn != nil {
169		ok := object.Key("RoleArn")
170		ok.String(*v.RoleArn)
171	}
172
173	return nil
174}
175
176type awsRestjson1_serializeOpCreateConnectorDefinition struct {
177}
178
179func (*awsRestjson1_serializeOpCreateConnectorDefinition) ID() string {
180	return "OperationSerializer"
181}
182
183func (m *awsRestjson1_serializeOpCreateConnectorDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
184	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
185) {
186	request, ok := in.Request.(*smithyhttp.Request)
187	if !ok {
188		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
189	}
190
191	input, ok := in.Parameters.(*CreateConnectorDefinitionInput)
192	_ = input
193	if !ok {
194		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
195	}
196
197	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors")
198	request.URL.Path = opPath
199	if len(request.URL.RawQuery) > 0 {
200		request.URL.RawQuery = "&" + opQuery
201	} else {
202		request.URL.RawQuery = opQuery
203	}
204
205	request.Method = "POST"
206	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
207	if err != nil {
208		return out, metadata, &smithy.SerializationError{Err: err}
209	}
210
211	if err := awsRestjson1_serializeOpHttpBindingsCreateConnectorDefinitionInput(input, restEncoder); err != nil {
212		return out, metadata, &smithy.SerializationError{Err: err}
213	}
214
215	restEncoder.SetHeader("Content-Type").String("application/json")
216
217	jsonEncoder := smithyjson.NewEncoder()
218	if err := awsRestjson1_serializeOpDocumentCreateConnectorDefinitionInput(input, jsonEncoder.Value); err != nil {
219		return out, metadata, &smithy.SerializationError{Err: err}
220	}
221
222	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
223		return out, metadata, &smithy.SerializationError{Err: err}
224	}
225
226	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
227		return out, metadata, &smithy.SerializationError{Err: err}
228	}
229	in.Request = request
230
231	return next.HandleSerialize(ctx, in)
232}
233func awsRestjson1_serializeOpHttpBindingsCreateConnectorDefinitionInput(v *CreateConnectorDefinitionInput, encoder *httpbinding.Encoder) error {
234	if v == nil {
235		return fmt.Errorf("unsupported serialization of nil %T", v)
236	}
237
238	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
239		locationName := "X-Amzn-Client-Token"
240		encoder.SetHeader(locationName).String(*v.AmznClientToken)
241	}
242
243	return nil
244}
245
246func awsRestjson1_serializeOpDocumentCreateConnectorDefinitionInput(v *CreateConnectorDefinitionInput, value smithyjson.Value) error {
247	object := value.Object()
248	defer object.Close()
249
250	if v.InitialVersion != nil {
251		ok := object.Key("InitialVersion")
252		if err := awsRestjson1_serializeDocumentConnectorDefinitionVersion(v.InitialVersion, ok); err != nil {
253			return err
254		}
255	}
256
257	if v.Name != nil {
258		ok := object.Key("Name")
259		ok.String(*v.Name)
260	}
261
262	if v.Tags != nil {
263		ok := object.Key("tags")
264		if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
265			return err
266		}
267	}
268
269	return nil
270}
271
272type awsRestjson1_serializeOpCreateConnectorDefinitionVersion struct {
273}
274
275func (*awsRestjson1_serializeOpCreateConnectorDefinitionVersion) ID() string {
276	return "OperationSerializer"
277}
278
279func (m *awsRestjson1_serializeOpCreateConnectorDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
280	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
281) {
282	request, ok := in.Request.(*smithyhttp.Request)
283	if !ok {
284		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
285	}
286
287	input, ok := in.Parameters.(*CreateConnectorDefinitionVersionInput)
288	_ = input
289	if !ok {
290		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
291	}
292
293	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}/versions")
294	request.URL.Path = opPath
295	if len(request.URL.RawQuery) > 0 {
296		request.URL.RawQuery = "&" + opQuery
297	} else {
298		request.URL.RawQuery = opQuery
299	}
300
301	request.Method = "POST"
302	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
303	if err != nil {
304		return out, metadata, &smithy.SerializationError{Err: err}
305	}
306
307	if err := awsRestjson1_serializeOpHttpBindingsCreateConnectorDefinitionVersionInput(input, restEncoder); err != nil {
308		return out, metadata, &smithy.SerializationError{Err: err}
309	}
310
311	restEncoder.SetHeader("Content-Type").String("application/json")
312
313	jsonEncoder := smithyjson.NewEncoder()
314	if err := awsRestjson1_serializeOpDocumentCreateConnectorDefinitionVersionInput(input, jsonEncoder.Value); err != nil {
315		return out, metadata, &smithy.SerializationError{Err: err}
316	}
317
318	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
319		return out, metadata, &smithy.SerializationError{Err: err}
320	}
321
322	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
323		return out, metadata, &smithy.SerializationError{Err: err}
324	}
325	in.Request = request
326
327	return next.HandleSerialize(ctx, in)
328}
329func awsRestjson1_serializeOpHttpBindingsCreateConnectorDefinitionVersionInput(v *CreateConnectorDefinitionVersionInput, encoder *httpbinding.Encoder) error {
330	if v == nil {
331		return fmt.Errorf("unsupported serialization of nil %T", v)
332	}
333
334	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
335		locationName := "X-Amzn-Client-Token"
336		encoder.SetHeader(locationName).String(*v.AmznClientToken)
337	}
338
339	if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 {
340		return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")}
341	}
342	if v.ConnectorDefinitionId != nil {
343		if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil {
344			return err
345		}
346	}
347
348	return nil
349}
350
351func awsRestjson1_serializeOpDocumentCreateConnectorDefinitionVersionInput(v *CreateConnectorDefinitionVersionInput, value smithyjson.Value) error {
352	object := value.Object()
353	defer object.Close()
354
355	if v.Connectors != nil {
356		ok := object.Key("Connectors")
357		if err := awsRestjson1_serializeDocument__listOfConnector(v.Connectors, ok); err != nil {
358			return err
359		}
360	}
361
362	return nil
363}
364
365type awsRestjson1_serializeOpCreateCoreDefinition struct {
366}
367
368func (*awsRestjson1_serializeOpCreateCoreDefinition) ID() string {
369	return "OperationSerializer"
370}
371
372func (m *awsRestjson1_serializeOpCreateCoreDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
373	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
374) {
375	request, ok := in.Request.(*smithyhttp.Request)
376	if !ok {
377		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
378	}
379
380	input, ok := in.Parameters.(*CreateCoreDefinitionInput)
381	_ = input
382	if !ok {
383		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
384	}
385
386	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores")
387	request.URL.Path = opPath
388	if len(request.URL.RawQuery) > 0 {
389		request.URL.RawQuery = "&" + opQuery
390	} else {
391		request.URL.RawQuery = opQuery
392	}
393
394	request.Method = "POST"
395	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
396	if err != nil {
397		return out, metadata, &smithy.SerializationError{Err: err}
398	}
399
400	if err := awsRestjson1_serializeOpHttpBindingsCreateCoreDefinitionInput(input, restEncoder); err != nil {
401		return out, metadata, &smithy.SerializationError{Err: err}
402	}
403
404	restEncoder.SetHeader("Content-Type").String("application/json")
405
406	jsonEncoder := smithyjson.NewEncoder()
407	if err := awsRestjson1_serializeOpDocumentCreateCoreDefinitionInput(input, jsonEncoder.Value); err != nil {
408		return out, metadata, &smithy.SerializationError{Err: err}
409	}
410
411	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
412		return out, metadata, &smithy.SerializationError{Err: err}
413	}
414
415	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
416		return out, metadata, &smithy.SerializationError{Err: err}
417	}
418	in.Request = request
419
420	return next.HandleSerialize(ctx, in)
421}
422func awsRestjson1_serializeOpHttpBindingsCreateCoreDefinitionInput(v *CreateCoreDefinitionInput, encoder *httpbinding.Encoder) error {
423	if v == nil {
424		return fmt.Errorf("unsupported serialization of nil %T", v)
425	}
426
427	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
428		locationName := "X-Amzn-Client-Token"
429		encoder.SetHeader(locationName).String(*v.AmznClientToken)
430	}
431
432	return nil
433}
434
435func awsRestjson1_serializeOpDocumentCreateCoreDefinitionInput(v *CreateCoreDefinitionInput, value smithyjson.Value) error {
436	object := value.Object()
437	defer object.Close()
438
439	if v.InitialVersion != nil {
440		ok := object.Key("InitialVersion")
441		if err := awsRestjson1_serializeDocumentCoreDefinitionVersion(v.InitialVersion, ok); err != nil {
442			return err
443		}
444	}
445
446	if v.Name != nil {
447		ok := object.Key("Name")
448		ok.String(*v.Name)
449	}
450
451	if v.Tags != nil {
452		ok := object.Key("tags")
453		if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
454			return err
455		}
456	}
457
458	return nil
459}
460
461type awsRestjson1_serializeOpCreateCoreDefinitionVersion struct {
462}
463
464func (*awsRestjson1_serializeOpCreateCoreDefinitionVersion) ID() string {
465	return "OperationSerializer"
466}
467
468func (m *awsRestjson1_serializeOpCreateCoreDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
469	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
470) {
471	request, ok := in.Request.(*smithyhttp.Request)
472	if !ok {
473		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
474	}
475
476	input, ok := in.Parameters.(*CreateCoreDefinitionVersionInput)
477	_ = input
478	if !ok {
479		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
480	}
481
482	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}/versions")
483	request.URL.Path = opPath
484	if len(request.URL.RawQuery) > 0 {
485		request.URL.RawQuery = "&" + opQuery
486	} else {
487		request.URL.RawQuery = opQuery
488	}
489
490	request.Method = "POST"
491	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
492	if err != nil {
493		return out, metadata, &smithy.SerializationError{Err: err}
494	}
495
496	if err := awsRestjson1_serializeOpHttpBindingsCreateCoreDefinitionVersionInput(input, restEncoder); err != nil {
497		return out, metadata, &smithy.SerializationError{Err: err}
498	}
499
500	restEncoder.SetHeader("Content-Type").String("application/json")
501
502	jsonEncoder := smithyjson.NewEncoder()
503	if err := awsRestjson1_serializeOpDocumentCreateCoreDefinitionVersionInput(input, jsonEncoder.Value); err != nil {
504		return out, metadata, &smithy.SerializationError{Err: err}
505	}
506
507	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
508		return out, metadata, &smithy.SerializationError{Err: err}
509	}
510
511	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
512		return out, metadata, &smithy.SerializationError{Err: err}
513	}
514	in.Request = request
515
516	return next.HandleSerialize(ctx, in)
517}
518func awsRestjson1_serializeOpHttpBindingsCreateCoreDefinitionVersionInput(v *CreateCoreDefinitionVersionInput, encoder *httpbinding.Encoder) error {
519	if v == nil {
520		return fmt.Errorf("unsupported serialization of nil %T", v)
521	}
522
523	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
524		locationName := "X-Amzn-Client-Token"
525		encoder.SetHeader(locationName).String(*v.AmznClientToken)
526	}
527
528	if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 {
529		return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")}
530	}
531	if v.CoreDefinitionId != nil {
532		if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil {
533			return err
534		}
535	}
536
537	return nil
538}
539
540func awsRestjson1_serializeOpDocumentCreateCoreDefinitionVersionInput(v *CreateCoreDefinitionVersionInput, value smithyjson.Value) error {
541	object := value.Object()
542	defer object.Close()
543
544	if v.Cores != nil {
545		ok := object.Key("Cores")
546		if err := awsRestjson1_serializeDocument__listOfCore(v.Cores, ok); err != nil {
547			return err
548		}
549	}
550
551	return nil
552}
553
554type awsRestjson1_serializeOpCreateDeployment struct {
555}
556
557func (*awsRestjson1_serializeOpCreateDeployment) ID() string {
558	return "OperationSerializer"
559}
560
561func (m *awsRestjson1_serializeOpCreateDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
562	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
563) {
564	request, ok := in.Request.(*smithyhttp.Request)
565	if !ok {
566		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
567	}
568
569	input, ok := in.Parameters.(*CreateDeploymentInput)
570	_ = input
571	if !ok {
572		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
573	}
574
575	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/deployments")
576	request.URL.Path = opPath
577	if len(request.URL.RawQuery) > 0 {
578		request.URL.RawQuery = "&" + opQuery
579	} else {
580		request.URL.RawQuery = opQuery
581	}
582
583	request.Method = "POST"
584	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
585	if err != nil {
586		return out, metadata, &smithy.SerializationError{Err: err}
587	}
588
589	if err := awsRestjson1_serializeOpHttpBindingsCreateDeploymentInput(input, restEncoder); err != nil {
590		return out, metadata, &smithy.SerializationError{Err: err}
591	}
592
593	restEncoder.SetHeader("Content-Type").String("application/json")
594
595	jsonEncoder := smithyjson.NewEncoder()
596	if err := awsRestjson1_serializeOpDocumentCreateDeploymentInput(input, jsonEncoder.Value); err != nil {
597		return out, metadata, &smithy.SerializationError{Err: err}
598	}
599
600	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
601		return out, metadata, &smithy.SerializationError{Err: err}
602	}
603
604	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
605		return out, metadata, &smithy.SerializationError{Err: err}
606	}
607	in.Request = request
608
609	return next.HandleSerialize(ctx, in)
610}
611func awsRestjson1_serializeOpHttpBindingsCreateDeploymentInput(v *CreateDeploymentInput, encoder *httpbinding.Encoder) error {
612	if v == nil {
613		return fmt.Errorf("unsupported serialization of nil %T", v)
614	}
615
616	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
617		locationName := "X-Amzn-Client-Token"
618		encoder.SetHeader(locationName).String(*v.AmznClientToken)
619	}
620
621	if v.GroupId == nil || len(*v.GroupId) == 0 {
622		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
623	}
624	if v.GroupId != nil {
625		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
626			return err
627		}
628	}
629
630	return nil
631}
632
633func awsRestjson1_serializeOpDocumentCreateDeploymentInput(v *CreateDeploymentInput, value smithyjson.Value) error {
634	object := value.Object()
635	defer object.Close()
636
637	if v.DeploymentId != nil {
638		ok := object.Key("DeploymentId")
639		ok.String(*v.DeploymentId)
640	}
641
642	if len(v.DeploymentType) > 0 {
643		ok := object.Key("DeploymentType")
644		ok.String(string(v.DeploymentType))
645	}
646
647	if v.GroupVersionId != nil {
648		ok := object.Key("GroupVersionId")
649		ok.String(*v.GroupVersionId)
650	}
651
652	return nil
653}
654
655type awsRestjson1_serializeOpCreateDeviceDefinition struct {
656}
657
658func (*awsRestjson1_serializeOpCreateDeviceDefinition) ID() string {
659	return "OperationSerializer"
660}
661
662func (m *awsRestjson1_serializeOpCreateDeviceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
663	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
664) {
665	request, ok := in.Request.(*smithyhttp.Request)
666	if !ok {
667		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
668	}
669
670	input, ok := in.Parameters.(*CreateDeviceDefinitionInput)
671	_ = input
672	if !ok {
673		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
674	}
675
676	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices")
677	request.URL.Path = opPath
678	if len(request.URL.RawQuery) > 0 {
679		request.URL.RawQuery = "&" + opQuery
680	} else {
681		request.URL.RawQuery = opQuery
682	}
683
684	request.Method = "POST"
685	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
686	if err != nil {
687		return out, metadata, &smithy.SerializationError{Err: err}
688	}
689
690	if err := awsRestjson1_serializeOpHttpBindingsCreateDeviceDefinitionInput(input, restEncoder); err != nil {
691		return out, metadata, &smithy.SerializationError{Err: err}
692	}
693
694	restEncoder.SetHeader("Content-Type").String("application/json")
695
696	jsonEncoder := smithyjson.NewEncoder()
697	if err := awsRestjson1_serializeOpDocumentCreateDeviceDefinitionInput(input, jsonEncoder.Value); err != nil {
698		return out, metadata, &smithy.SerializationError{Err: err}
699	}
700
701	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
702		return out, metadata, &smithy.SerializationError{Err: err}
703	}
704
705	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
706		return out, metadata, &smithy.SerializationError{Err: err}
707	}
708	in.Request = request
709
710	return next.HandleSerialize(ctx, in)
711}
712func awsRestjson1_serializeOpHttpBindingsCreateDeviceDefinitionInput(v *CreateDeviceDefinitionInput, encoder *httpbinding.Encoder) error {
713	if v == nil {
714		return fmt.Errorf("unsupported serialization of nil %T", v)
715	}
716
717	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
718		locationName := "X-Amzn-Client-Token"
719		encoder.SetHeader(locationName).String(*v.AmznClientToken)
720	}
721
722	return nil
723}
724
725func awsRestjson1_serializeOpDocumentCreateDeviceDefinitionInput(v *CreateDeviceDefinitionInput, value smithyjson.Value) error {
726	object := value.Object()
727	defer object.Close()
728
729	if v.InitialVersion != nil {
730		ok := object.Key("InitialVersion")
731		if err := awsRestjson1_serializeDocumentDeviceDefinitionVersion(v.InitialVersion, ok); err != nil {
732			return err
733		}
734	}
735
736	if v.Name != nil {
737		ok := object.Key("Name")
738		ok.String(*v.Name)
739	}
740
741	if v.Tags != nil {
742		ok := object.Key("tags")
743		if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
744			return err
745		}
746	}
747
748	return nil
749}
750
751type awsRestjson1_serializeOpCreateDeviceDefinitionVersion struct {
752}
753
754func (*awsRestjson1_serializeOpCreateDeviceDefinitionVersion) ID() string {
755	return "OperationSerializer"
756}
757
758func (m *awsRestjson1_serializeOpCreateDeviceDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
759	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
760) {
761	request, ok := in.Request.(*smithyhttp.Request)
762	if !ok {
763		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
764	}
765
766	input, ok := in.Parameters.(*CreateDeviceDefinitionVersionInput)
767	_ = input
768	if !ok {
769		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
770	}
771
772	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}/versions")
773	request.URL.Path = opPath
774	if len(request.URL.RawQuery) > 0 {
775		request.URL.RawQuery = "&" + opQuery
776	} else {
777		request.URL.RawQuery = opQuery
778	}
779
780	request.Method = "POST"
781	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
782	if err != nil {
783		return out, metadata, &smithy.SerializationError{Err: err}
784	}
785
786	if err := awsRestjson1_serializeOpHttpBindingsCreateDeviceDefinitionVersionInput(input, restEncoder); err != nil {
787		return out, metadata, &smithy.SerializationError{Err: err}
788	}
789
790	restEncoder.SetHeader("Content-Type").String("application/json")
791
792	jsonEncoder := smithyjson.NewEncoder()
793	if err := awsRestjson1_serializeOpDocumentCreateDeviceDefinitionVersionInput(input, jsonEncoder.Value); err != nil {
794		return out, metadata, &smithy.SerializationError{Err: err}
795	}
796
797	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
798		return out, metadata, &smithy.SerializationError{Err: err}
799	}
800
801	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
802		return out, metadata, &smithy.SerializationError{Err: err}
803	}
804	in.Request = request
805
806	return next.HandleSerialize(ctx, in)
807}
808func awsRestjson1_serializeOpHttpBindingsCreateDeviceDefinitionVersionInput(v *CreateDeviceDefinitionVersionInput, encoder *httpbinding.Encoder) error {
809	if v == nil {
810		return fmt.Errorf("unsupported serialization of nil %T", v)
811	}
812
813	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
814		locationName := "X-Amzn-Client-Token"
815		encoder.SetHeader(locationName).String(*v.AmznClientToken)
816	}
817
818	if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 {
819		return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")}
820	}
821	if v.DeviceDefinitionId != nil {
822		if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil {
823			return err
824		}
825	}
826
827	return nil
828}
829
830func awsRestjson1_serializeOpDocumentCreateDeviceDefinitionVersionInput(v *CreateDeviceDefinitionVersionInput, value smithyjson.Value) error {
831	object := value.Object()
832	defer object.Close()
833
834	if v.Devices != nil {
835		ok := object.Key("Devices")
836		if err := awsRestjson1_serializeDocument__listOfDevice(v.Devices, ok); err != nil {
837			return err
838		}
839	}
840
841	return nil
842}
843
844type awsRestjson1_serializeOpCreateFunctionDefinition struct {
845}
846
847func (*awsRestjson1_serializeOpCreateFunctionDefinition) ID() string {
848	return "OperationSerializer"
849}
850
851func (m *awsRestjson1_serializeOpCreateFunctionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
852	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
853) {
854	request, ok := in.Request.(*smithyhttp.Request)
855	if !ok {
856		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
857	}
858
859	input, ok := in.Parameters.(*CreateFunctionDefinitionInput)
860	_ = input
861	if !ok {
862		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
863	}
864
865	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions")
866	request.URL.Path = opPath
867	if len(request.URL.RawQuery) > 0 {
868		request.URL.RawQuery = "&" + opQuery
869	} else {
870		request.URL.RawQuery = opQuery
871	}
872
873	request.Method = "POST"
874	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
875	if err != nil {
876		return out, metadata, &smithy.SerializationError{Err: err}
877	}
878
879	if err := awsRestjson1_serializeOpHttpBindingsCreateFunctionDefinitionInput(input, restEncoder); err != nil {
880		return out, metadata, &smithy.SerializationError{Err: err}
881	}
882
883	restEncoder.SetHeader("Content-Type").String("application/json")
884
885	jsonEncoder := smithyjson.NewEncoder()
886	if err := awsRestjson1_serializeOpDocumentCreateFunctionDefinitionInput(input, jsonEncoder.Value); err != nil {
887		return out, metadata, &smithy.SerializationError{Err: err}
888	}
889
890	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
891		return out, metadata, &smithy.SerializationError{Err: err}
892	}
893
894	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
895		return out, metadata, &smithy.SerializationError{Err: err}
896	}
897	in.Request = request
898
899	return next.HandleSerialize(ctx, in)
900}
901func awsRestjson1_serializeOpHttpBindingsCreateFunctionDefinitionInput(v *CreateFunctionDefinitionInput, encoder *httpbinding.Encoder) error {
902	if v == nil {
903		return fmt.Errorf("unsupported serialization of nil %T", v)
904	}
905
906	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
907		locationName := "X-Amzn-Client-Token"
908		encoder.SetHeader(locationName).String(*v.AmznClientToken)
909	}
910
911	return nil
912}
913
914func awsRestjson1_serializeOpDocumentCreateFunctionDefinitionInput(v *CreateFunctionDefinitionInput, value smithyjson.Value) error {
915	object := value.Object()
916	defer object.Close()
917
918	if v.InitialVersion != nil {
919		ok := object.Key("InitialVersion")
920		if err := awsRestjson1_serializeDocumentFunctionDefinitionVersion(v.InitialVersion, ok); err != nil {
921			return err
922		}
923	}
924
925	if v.Name != nil {
926		ok := object.Key("Name")
927		ok.String(*v.Name)
928	}
929
930	if v.Tags != nil {
931		ok := object.Key("tags")
932		if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
933			return err
934		}
935	}
936
937	return nil
938}
939
940type awsRestjson1_serializeOpCreateFunctionDefinitionVersion struct {
941}
942
943func (*awsRestjson1_serializeOpCreateFunctionDefinitionVersion) ID() string {
944	return "OperationSerializer"
945}
946
947func (m *awsRestjson1_serializeOpCreateFunctionDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
948	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
949) {
950	request, ok := in.Request.(*smithyhttp.Request)
951	if !ok {
952		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
953	}
954
955	input, ok := in.Parameters.(*CreateFunctionDefinitionVersionInput)
956	_ = input
957	if !ok {
958		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
959	}
960
961	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}/versions")
962	request.URL.Path = opPath
963	if len(request.URL.RawQuery) > 0 {
964		request.URL.RawQuery = "&" + opQuery
965	} else {
966		request.URL.RawQuery = opQuery
967	}
968
969	request.Method = "POST"
970	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
971	if err != nil {
972		return out, metadata, &smithy.SerializationError{Err: err}
973	}
974
975	if err := awsRestjson1_serializeOpHttpBindingsCreateFunctionDefinitionVersionInput(input, restEncoder); err != nil {
976		return out, metadata, &smithy.SerializationError{Err: err}
977	}
978
979	restEncoder.SetHeader("Content-Type").String("application/json")
980
981	jsonEncoder := smithyjson.NewEncoder()
982	if err := awsRestjson1_serializeOpDocumentCreateFunctionDefinitionVersionInput(input, jsonEncoder.Value); err != nil {
983		return out, metadata, &smithy.SerializationError{Err: err}
984	}
985
986	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
987		return out, metadata, &smithy.SerializationError{Err: err}
988	}
989
990	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
991		return out, metadata, &smithy.SerializationError{Err: err}
992	}
993	in.Request = request
994
995	return next.HandleSerialize(ctx, in)
996}
997func awsRestjson1_serializeOpHttpBindingsCreateFunctionDefinitionVersionInput(v *CreateFunctionDefinitionVersionInput, encoder *httpbinding.Encoder) error {
998	if v == nil {
999		return fmt.Errorf("unsupported serialization of nil %T", v)
1000	}
1001
1002	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1003		locationName := "X-Amzn-Client-Token"
1004		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1005	}
1006
1007	if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 {
1008		return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")}
1009	}
1010	if v.FunctionDefinitionId != nil {
1011		if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil {
1012			return err
1013		}
1014	}
1015
1016	return nil
1017}
1018
1019func awsRestjson1_serializeOpDocumentCreateFunctionDefinitionVersionInput(v *CreateFunctionDefinitionVersionInput, value smithyjson.Value) error {
1020	object := value.Object()
1021	defer object.Close()
1022
1023	if v.DefaultConfig != nil {
1024		ok := object.Key("DefaultConfig")
1025		if err := awsRestjson1_serializeDocumentFunctionDefaultConfig(v.DefaultConfig, ok); err != nil {
1026			return err
1027		}
1028	}
1029
1030	if v.Functions != nil {
1031		ok := object.Key("Functions")
1032		if err := awsRestjson1_serializeDocument__listOfFunction(v.Functions, ok); err != nil {
1033			return err
1034		}
1035	}
1036
1037	return nil
1038}
1039
1040type awsRestjson1_serializeOpCreateGroup struct {
1041}
1042
1043func (*awsRestjson1_serializeOpCreateGroup) ID() string {
1044	return "OperationSerializer"
1045}
1046
1047func (m *awsRestjson1_serializeOpCreateGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1048	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1049) {
1050	request, ok := in.Request.(*smithyhttp.Request)
1051	if !ok {
1052		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1053	}
1054
1055	input, ok := in.Parameters.(*CreateGroupInput)
1056	_ = input
1057	if !ok {
1058		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1059	}
1060
1061	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups")
1062	request.URL.Path = opPath
1063	if len(request.URL.RawQuery) > 0 {
1064		request.URL.RawQuery = "&" + opQuery
1065	} else {
1066		request.URL.RawQuery = opQuery
1067	}
1068
1069	request.Method = "POST"
1070	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1071	if err != nil {
1072		return out, metadata, &smithy.SerializationError{Err: err}
1073	}
1074
1075	if err := awsRestjson1_serializeOpHttpBindingsCreateGroupInput(input, restEncoder); err != nil {
1076		return out, metadata, &smithy.SerializationError{Err: err}
1077	}
1078
1079	restEncoder.SetHeader("Content-Type").String("application/json")
1080
1081	jsonEncoder := smithyjson.NewEncoder()
1082	if err := awsRestjson1_serializeOpDocumentCreateGroupInput(input, jsonEncoder.Value); err != nil {
1083		return out, metadata, &smithy.SerializationError{Err: err}
1084	}
1085
1086	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1087		return out, metadata, &smithy.SerializationError{Err: err}
1088	}
1089
1090	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1091		return out, metadata, &smithy.SerializationError{Err: err}
1092	}
1093	in.Request = request
1094
1095	return next.HandleSerialize(ctx, in)
1096}
1097func awsRestjson1_serializeOpHttpBindingsCreateGroupInput(v *CreateGroupInput, encoder *httpbinding.Encoder) error {
1098	if v == nil {
1099		return fmt.Errorf("unsupported serialization of nil %T", v)
1100	}
1101
1102	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1103		locationName := "X-Amzn-Client-Token"
1104		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1105	}
1106
1107	return nil
1108}
1109
1110func awsRestjson1_serializeOpDocumentCreateGroupInput(v *CreateGroupInput, value smithyjson.Value) error {
1111	object := value.Object()
1112	defer object.Close()
1113
1114	if v.InitialVersion != nil {
1115		ok := object.Key("InitialVersion")
1116		if err := awsRestjson1_serializeDocumentGroupVersion(v.InitialVersion, ok); err != nil {
1117			return err
1118		}
1119	}
1120
1121	if v.Name != nil {
1122		ok := object.Key("Name")
1123		ok.String(*v.Name)
1124	}
1125
1126	if v.Tags != nil {
1127		ok := object.Key("tags")
1128		if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
1129			return err
1130		}
1131	}
1132
1133	return nil
1134}
1135
1136type awsRestjson1_serializeOpCreateGroupCertificateAuthority struct {
1137}
1138
1139func (*awsRestjson1_serializeOpCreateGroupCertificateAuthority) ID() string {
1140	return "OperationSerializer"
1141}
1142
1143func (m *awsRestjson1_serializeOpCreateGroupCertificateAuthority) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1144	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1145) {
1146	request, ok := in.Request.(*smithyhttp.Request)
1147	if !ok {
1148		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1149	}
1150
1151	input, ok := in.Parameters.(*CreateGroupCertificateAuthorityInput)
1152	_ = input
1153	if !ok {
1154		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1155	}
1156
1157	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/certificateauthorities")
1158	request.URL.Path = opPath
1159	if len(request.URL.RawQuery) > 0 {
1160		request.URL.RawQuery = "&" + opQuery
1161	} else {
1162		request.URL.RawQuery = opQuery
1163	}
1164
1165	request.Method = "POST"
1166	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1167	if err != nil {
1168		return out, metadata, &smithy.SerializationError{Err: err}
1169	}
1170
1171	if err := awsRestjson1_serializeOpHttpBindingsCreateGroupCertificateAuthorityInput(input, restEncoder); err != nil {
1172		return out, metadata, &smithy.SerializationError{Err: err}
1173	}
1174
1175	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1176		return out, metadata, &smithy.SerializationError{Err: err}
1177	}
1178	in.Request = request
1179
1180	return next.HandleSerialize(ctx, in)
1181}
1182func awsRestjson1_serializeOpHttpBindingsCreateGroupCertificateAuthorityInput(v *CreateGroupCertificateAuthorityInput, encoder *httpbinding.Encoder) error {
1183	if v == nil {
1184		return fmt.Errorf("unsupported serialization of nil %T", v)
1185	}
1186
1187	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1188		locationName := "X-Amzn-Client-Token"
1189		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1190	}
1191
1192	if v.GroupId == nil || len(*v.GroupId) == 0 {
1193		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
1194	}
1195	if v.GroupId != nil {
1196		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
1197			return err
1198		}
1199	}
1200
1201	return nil
1202}
1203
1204type awsRestjson1_serializeOpCreateGroupVersion struct {
1205}
1206
1207func (*awsRestjson1_serializeOpCreateGroupVersion) ID() string {
1208	return "OperationSerializer"
1209}
1210
1211func (m *awsRestjson1_serializeOpCreateGroupVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1212	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1213) {
1214	request, ok := in.Request.(*smithyhttp.Request)
1215	if !ok {
1216		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1217	}
1218
1219	input, ok := in.Parameters.(*CreateGroupVersionInput)
1220	_ = input
1221	if !ok {
1222		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1223	}
1224
1225	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/versions")
1226	request.URL.Path = opPath
1227	if len(request.URL.RawQuery) > 0 {
1228		request.URL.RawQuery = "&" + opQuery
1229	} else {
1230		request.URL.RawQuery = opQuery
1231	}
1232
1233	request.Method = "POST"
1234	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1235	if err != nil {
1236		return out, metadata, &smithy.SerializationError{Err: err}
1237	}
1238
1239	if err := awsRestjson1_serializeOpHttpBindingsCreateGroupVersionInput(input, restEncoder); err != nil {
1240		return out, metadata, &smithy.SerializationError{Err: err}
1241	}
1242
1243	restEncoder.SetHeader("Content-Type").String("application/json")
1244
1245	jsonEncoder := smithyjson.NewEncoder()
1246	if err := awsRestjson1_serializeOpDocumentCreateGroupVersionInput(input, jsonEncoder.Value); err != nil {
1247		return out, metadata, &smithy.SerializationError{Err: err}
1248	}
1249
1250	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1251		return out, metadata, &smithy.SerializationError{Err: err}
1252	}
1253
1254	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1255		return out, metadata, &smithy.SerializationError{Err: err}
1256	}
1257	in.Request = request
1258
1259	return next.HandleSerialize(ctx, in)
1260}
1261func awsRestjson1_serializeOpHttpBindingsCreateGroupVersionInput(v *CreateGroupVersionInput, encoder *httpbinding.Encoder) error {
1262	if v == nil {
1263		return fmt.Errorf("unsupported serialization of nil %T", v)
1264	}
1265
1266	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1267		locationName := "X-Amzn-Client-Token"
1268		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1269	}
1270
1271	if v.GroupId == nil || len(*v.GroupId) == 0 {
1272		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
1273	}
1274	if v.GroupId != nil {
1275		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
1276			return err
1277		}
1278	}
1279
1280	return nil
1281}
1282
1283func awsRestjson1_serializeOpDocumentCreateGroupVersionInput(v *CreateGroupVersionInput, value smithyjson.Value) error {
1284	object := value.Object()
1285	defer object.Close()
1286
1287	if v.ConnectorDefinitionVersionArn != nil {
1288		ok := object.Key("ConnectorDefinitionVersionArn")
1289		ok.String(*v.ConnectorDefinitionVersionArn)
1290	}
1291
1292	if v.CoreDefinitionVersionArn != nil {
1293		ok := object.Key("CoreDefinitionVersionArn")
1294		ok.String(*v.CoreDefinitionVersionArn)
1295	}
1296
1297	if v.DeviceDefinitionVersionArn != nil {
1298		ok := object.Key("DeviceDefinitionVersionArn")
1299		ok.String(*v.DeviceDefinitionVersionArn)
1300	}
1301
1302	if v.FunctionDefinitionVersionArn != nil {
1303		ok := object.Key("FunctionDefinitionVersionArn")
1304		ok.String(*v.FunctionDefinitionVersionArn)
1305	}
1306
1307	if v.LoggerDefinitionVersionArn != nil {
1308		ok := object.Key("LoggerDefinitionVersionArn")
1309		ok.String(*v.LoggerDefinitionVersionArn)
1310	}
1311
1312	if v.ResourceDefinitionVersionArn != nil {
1313		ok := object.Key("ResourceDefinitionVersionArn")
1314		ok.String(*v.ResourceDefinitionVersionArn)
1315	}
1316
1317	if v.SubscriptionDefinitionVersionArn != nil {
1318		ok := object.Key("SubscriptionDefinitionVersionArn")
1319		ok.String(*v.SubscriptionDefinitionVersionArn)
1320	}
1321
1322	return nil
1323}
1324
1325type awsRestjson1_serializeOpCreateLoggerDefinition struct {
1326}
1327
1328func (*awsRestjson1_serializeOpCreateLoggerDefinition) ID() string {
1329	return "OperationSerializer"
1330}
1331
1332func (m *awsRestjson1_serializeOpCreateLoggerDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1333	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1334) {
1335	request, ok := in.Request.(*smithyhttp.Request)
1336	if !ok {
1337		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1338	}
1339
1340	input, ok := in.Parameters.(*CreateLoggerDefinitionInput)
1341	_ = input
1342	if !ok {
1343		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1344	}
1345
1346	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers")
1347	request.URL.Path = opPath
1348	if len(request.URL.RawQuery) > 0 {
1349		request.URL.RawQuery = "&" + opQuery
1350	} else {
1351		request.URL.RawQuery = opQuery
1352	}
1353
1354	request.Method = "POST"
1355	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1356	if err != nil {
1357		return out, metadata, &smithy.SerializationError{Err: err}
1358	}
1359
1360	if err := awsRestjson1_serializeOpHttpBindingsCreateLoggerDefinitionInput(input, restEncoder); err != nil {
1361		return out, metadata, &smithy.SerializationError{Err: err}
1362	}
1363
1364	restEncoder.SetHeader("Content-Type").String("application/json")
1365
1366	jsonEncoder := smithyjson.NewEncoder()
1367	if err := awsRestjson1_serializeOpDocumentCreateLoggerDefinitionInput(input, jsonEncoder.Value); err != nil {
1368		return out, metadata, &smithy.SerializationError{Err: err}
1369	}
1370
1371	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1372		return out, metadata, &smithy.SerializationError{Err: err}
1373	}
1374
1375	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1376		return out, metadata, &smithy.SerializationError{Err: err}
1377	}
1378	in.Request = request
1379
1380	return next.HandleSerialize(ctx, in)
1381}
1382func awsRestjson1_serializeOpHttpBindingsCreateLoggerDefinitionInput(v *CreateLoggerDefinitionInput, encoder *httpbinding.Encoder) error {
1383	if v == nil {
1384		return fmt.Errorf("unsupported serialization of nil %T", v)
1385	}
1386
1387	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1388		locationName := "X-Amzn-Client-Token"
1389		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1390	}
1391
1392	return nil
1393}
1394
1395func awsRestjson1_serializeOpDocumentCreateLoggerDefinitionInput(v *CreateLoggerDefinitionInput, value smithyjson.Value) error {
1396	object := value.Object()
1397	defer object.Close()
1398
1399	if v.InitialVersion != nil {
1400		ok := object.Key("InitialVersion")
1401		if err := awsRestjson1_serializeDocumentLoggerDefinitionVersion(v.InitialVersion, ok); err != nil {
1402			return err
1403		}
1404	}
1405
1406	if v.Name != nil {
1407		ok := object.Key("Name")
1408		ok.String(*v.Name)
1409	}
1410
1411	if v.Tags != nil {
1412		ok := object.Key("tags")
1413		if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
1414			return err
1415		}
1416	}
1417
1418	return nil
1419}
1420
1421type awsRestjson1_serializeOpCreateLoggerDefinitionVersion struct {
1422}
1423
1424func (*awsRestjson1_serializeOpCreateLoggerDefinitionVersion) ID() string {
1425	return "OperationSerializer"
1426}
1427
1428func (m *awsRestjson1_serializeOpCreateLoggerDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1429	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1430) {
1431	request, ok := in.Request.(*smithyhttp.Request)
1432	if !ok {
1433		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1434	}
1435
1436	input, ok := in.Parameters.(*CreateLoggerDefinitionVersionInput)
1437	_ = input
1438	if !ok {
1439		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1440	}
1441
1442	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}/versions")
1443	request.URL.Path = opPath
1444	if len(request.URL.RawQuery) > 0 {
1445		request.URL.RawQuery = "&" + opQuery
1446	} else {
1447		request.URL.RawQuery = opQuery
1448	}
1449
1450	request.Method = "POST"
1451	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1452	if err != nil {
1453		return out, metadata, &smithy.SerializationError{Err: err}
1454	}
1455
1456	if err := awsRestjson1_serializeOpHttpBindingsCreateLoggerDefinitionVersionInput(input, restEncoder); err != nil {
1457		return out, metadata, &smithy.SerializationError{Err: err}
1458	}
1459
1460	restEncoder.SetHeader("Content-Type").String("application/json")
1461
1462	jsonEncoder := smithyjson.NewEncoder()
1463	if err := awsRestjson1_serializeOpDocumentCreateLoggerDefinitionVersionInput(input, jsonEncoder.Value); err != nil {
1464		return out, metadata, &smithy.SerializationError{Err: err}
1465	}
1466
1467	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1468		return out, metadata, &smithy.SerializationError{Err: err}
1469	}
1470
1471	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1472		return out, metadata, &smithy.SerializationError{Err: err}
1473	}
1474	in.Request = request
1475
1476	return next.HandleSerialize(ctx, in)
1477}
1478func awsRestjson1_serializeOpHttpBindingsCreateLoggerDefinitionVersionInput(v *CreateLoggerDefinitionVersionInput, encoder *httpbinding.Encoder) error {
1479	if v == nil {
1480		return fmt.Errorf("unsupported serialization of nil %T", v)
1481	}
1482
1483	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1484		locationName := "X-Amzn-Client-Token"
1485		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1486	}
1487
1488	if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 {
1489		return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")}
1490	}
1491	if v.LoggerDefinitionId != nil {
1492		if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil {
1493			return err
1494		}
1495	}
1496
1497	return nil
1498}
1499
1500func awsRestjson1_serializeOpDocumentCreateLoggerDefinitionVersionInput(v *CreateLoggerDefinitionVersionInput, value smithyjson.Value) error {
1501	object := value.Object()
1502	defer object.Close()
1503
1504	if v.Loggers != nil {
1505		ok := object.Key("Loggers")
1506		if err := awsRestjson1_serializeDocument__listOfLogger(v.Loggers, ok); err != nil {
1507			return err
1508		}
1509	}
1510
1511	return nil
1512}
1513
1514type awsRestjson1_serializeOpCreateResourceDefinition struct {
1515}
1516
1517func (*awsRestjson1_serializeOpCreateResourceDefinition) ID() string {
1518	return "OperationSerializer"
1519}
1520
1521func (m *awsRestjson1_serializeOpCreateResourceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1522	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1523) {
1524	request, ok := in.Request.(*smithyhttp.Request)
1525	if !ok {
1526		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1527	}
1528
1529	input, ok := in.Parameters.(*CreateResourceDefinitionInput)
1530	_ = input
1531	if !ok {
1532		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1533	}
1534
1535	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources")
1536	request.URL.Path = opPath
1537	if len(request.URL.RawQuery) > 0 {
1538		request.URL.RawQuery = "&" + opQuery
1539	} else {
1540		request.URL.RawQuery = opQuery
1541	}
1542
1543	request.Method = "POST"
1544	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1545	if err != nil {
1546		return out, metadata, &smithy.SerializationError{Err: err}
1547	}
1548
1549	if err := awsRestjson1_serializeOpHttpBindingsCreateResourceDefinitionInput(input, restEncoder); err != nil {
1550		return out, metadata, &smithy.SerializationError{Err: err}
1551	}
1552
1553	restEncoder.SetHeader("Content-Type").String("application/json")
1554
1555	jsonEncoder := smithyjson.NewEncoder()
1556	if err := awsRestjson1_serializeOpDocumentCreateResourceDefinitionInput(input, jsonEncoder.Value); err != nil {
1557		return out, metadata, &smithy.SerializationError{Err: err}
1558	}
1559
1560	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1561		return out, metadata, &smithy.SerializationError{Err: err}
1562	}
1563
1564	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1565		return out, metadata, &smithy.SerializationError{Err: err}
1566	}
1567	in.Request = request
1568
1569	return next.HandleSerialize(ctx, in)
1570}
1571func awsRestjson1_serializeOpHttpBindingsCreateResourceDefinitionInput(v *CreateResourceDefinitionInput, encoder *httpbinding.Encoder) error {
1572	if v == nil {
1573		return fmt.Errorf("unsupported serialization of nil %T", v)
1574	}
1575
1576	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1577		locationName := "X-Amzn-Client-Token"
1578		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1579	}
1580
1581	return nil
1582}
1583
1584func awsRestjson1_serializeOpDocumentCreateResourceDefinitionInput(v *CreateResourceDefinitionInput, value smithyjson.Value) error {
1585	object := value.Object()
1586	defer object.Close()
1587
1588	if v.InitialVersion != nil {
1589		ok := object.Key("InitialVersion")
1590		if err := awsRestjson1_serializeDocumentResourceDefinitionVersion(v.InitialVersion, ok); err != nil {
1591			return err
1592		}
1593	}
1594
1595	if v.Name != nil {
1596		ok := object.Key("Name")
1597		ok.String(*v.Name)
1598	}
1599
1600	if v.Tags != nil {
1601		ok := object.Key("tags")
1602		if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
1603			return err
1604		}
1605	}
1606
1607	return nil
1608}
1609
1610type awsRestjson1_serializeOpCreateResourceDefinitionVersion struct {
1611}
1612
1613func (*awsRestjson1_serializeOpCreateResourceDefinitionVersion) ID() string {
1614	return "OperationSerializer"
1615}
1616
1617func (m *awsRestjson1_serializeOpCreateResourceDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1618	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1619) {
1620	request, ok := in.Request.(*smithyhttp.Request)
1621	if !ok {
1622		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1623	}
1624
1625	input, ok := in.Parameters.(*CreateResourceDefinitionVersionInput)
1626	_ = input
1627	if !ok {
1628		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1629	}
1630
1631	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}/versions")
1632	request.URL.Path = opPath
1633	if len(request.URL.RawQuery) > 0 {
1634		request.URL.RawQuery = "&" + opQuery
1635	} else {
1636		request.URL.RawQuery = opQuery
1637	}
1638
1639	request.Method = "POST"
1640	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1641	if err != nil {
1642		return out, metadata, &smithy.SerializationError{Err: err}
1643	}
1644
1645	if err := awsRestjson1_serializeOpHttpBindingsCreateResourceDefinitionVersionInput(input, restEncoder); err != nil {
1646		return out, metadata, &smithy.SerializationError{Err: err}
1647	}
1648
1649	restEncoder.SetHeader("Content-Type").String("application/json")
1650
1651	jsonEncoder := smithyjson.NewEncoder()
1652	if err := awsRestjson1_serializeOpDocumentCreateResourceDefinitionVersionInput(input, jsonEncoder.Value); err != nil {
1653		return out, metadata, &smithy.SerializationError{Err: err}
1654	}
1655
1656	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1657		return out, metadata, &smithy.SerializationError{Err: err}
1658	}
1659
1660	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1661		return out, metadata, &smithy.SerializationError{Err: err}
1662	}
1663	in.Request = request
1664
1665	return next.HandleSerialize(ctx, in)
1666}
1667func awsRestjson1_serializeOpHttpBindingsCreateResourceDefinitionVersionInput(v *CreateResourceDefinitionVersionInput, encoder *httpbinding.Encoder) error {
1668	if v == nil {
1669		return fmt.Errorf("unsupported serialization of nil %T", v)
1670	}
1671
1672	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1673		locationName := "X-Amzn-Client-Token"
1674		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1675	}
1676
1677	if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 {
1678		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")}
1679	}
1680	if v.ResourceDefinitionId != nil {
1681		if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil {
1682			return err
1683		}
1684	}
1685
1686	return nil
1687}
1688
1689func awsRestjson1_serializeOpDocumentCreateResourceDefinitionVersionInput(v *CreateResourceDefinitionVersionInput, value smithyjson.Value) error {
1690	object := value.Object()
1691	defer object.Close()
1692
1693	if v.Resources != nil {
1694		ok := object.Key("Resources")
1695		if err := awsRestjson1_serializeDocument__listOfResource(v.Resources, ok); err != nil {
1696			return err
1697		}
1698	}
1699
1700	return nil
1701}
1702
1703type awsRestjson1_serializeOpCreateSoftwareUpdateJob struct {
1704}
1705
1706func (*awsRestjson1_serializeOpCreateSoftwareUpdateJob) ID() string {
1707	return "OperationSerializer"
1708}
1709
1710func (m *awsRestjson1_serializeOpCreateSoftwareUpdateJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1711	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1712) {
1713	request, ok := in.Request.(*smithyhttp.Request)
1714	if !ok {
1715		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1716	}
1717
1718	input, ok := in.Parameters.(*CreateSoftwareUpdateJobInput)
1719	_ = input
1720	if !ok {
1721		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1722	}
1723
1724	opPath, opQuery := httpbinding.SplitURI("/greengrass/updates")
1725	request.URL.Path = opPath
1726	if len(request.URL.RawQuery) > 0 {
1727		request.URL.RawQuery = "&" + opQuery
1728	} else {
1729		request.URL.RawQuery = opQuery
1730	}
1731
1732	request.Method = "POST"
1733	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1734	if err != nil {
1735		return out, metadata, &smithy.SerializationError{Err: err}
1736	}
1737
1738	if err := awsRestjson1_serializeOpHttpBindingsCreateSoftwareUpdateJobInput(input, restEncoder); err != nil {
1739		return out, metadata, &smithy.SerializationError{Err: err}
1740	}
1741
1742	restEncoder.SetHeader("Content-Type").String("application/json")
1743
1744	jsonEncoder := smithyjson.NewEncoder()
1745	if err := awsRestjson1_serializeOpDocumentCreateSoftwareUpdateJobInput(input, jsonEncoder.Value); err != nil {
1746		return out, metadata, &smithy.SerializationError{Err: err}
1747	}
1748
1749	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1750		return out, metadata, &smithy.SerializationError{Err: err}
1751	}
1752
1753	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1754		return out, metadata, &smithy.SerializationError{Err: err}
1755	}
1756	in.Request = request
1757
1758	return next.HandleSerialize(ctx, in)
1759}
1760func awsRestjson1_serializeOpHttpBindingsCreateSoftwareUpdateJobInput(v *CreateSoftwareUpdateJobInput, encoder *httpbinding.Encoder) error {
1761	if v == nil {
1762		return fmt.Errorf("unsupported serialization of nil %T", v)
1763	}
1764
1765	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1766		locationName := "X-Amzn-Client-Token"
1767		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1768	}
1769
1770	return nil
1771}
1772
1773func awsRestjson1_serializeOpDocumentCreateSoftwareUpdateJobInput(v *CreateSoftwareUpdateJobInput, value smithyjson.Value) error {
1774	object := value.Object()
1775	defer object.Close()
1776
1777	if v.S3UrlSignerRole != nil {
1778		ok := object.Key("S3UrlSignerRole")
1779		ok.String(*v.S3UrlSignerRole)
1780	}
1781
1782	if len(v.SoftwareToUpdate) > 0 {
1783		ok := object.Key("SoftwareToUpdate")
1784		ok.String(string(v.SoftwareToUpdate))
1785	}
1786
1787	if len(v.UpdateAgentLogLevel) > 0 {
1788		ok := object.Key("UpdateAgentLogLevel")
1789		ok.String(string(v.UpdateAgentLogLevel))
1790	}
1791
1792	if v.UpdateTargets != nil {
1793		ok := object.Key("UpdateTargets")
1794		if err := awsRestjson1_serializeDocumentUpdateTargets(v.UpdateTargets, ok); err != nil {
1795			return err
1796		}
1797	}
1798
1799	if len(v.UpdateTargetsArchitecture) > 0 {
1800		ok := object.Key("UpdateTargetsArchitecture")
1801		ok.String(string(v.UpdateTargetsArchitecture))
1802	}
1803
1804	if len(v.UpdateTargetsOperatingSystem) > 0 {
1805		ok := object.Key("UpdateTargetsOperatingSystem")
1806		ok.String(string(v.UpdateTargetsOperatingSystem))
1807	}
1808
1809	return nil
1810}
1811
1812type awsRestjson1_serializeOpCreateSubscriptionDefinition struct {
1813}
1814
1815func (*awsRestjson1_serializeOpCreateSubscriptionDefinition) ID() string {
1816	return "OperationSerializer"
1817}
1818
1819func (m *awsRestjson1_serializeOpCreateSubscriptionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1820	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1821) {
1822	request, ok := in.Request.(*smithyhttp.Request)
1823	if !ok {
1824		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1825	}
1826
1827	input, ok := in.Parameters.(*CreateSubscriptionDefinitionInput)
1828	_ = input
1829	if !ok {
1830		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1831	}
1832
1833	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions")
1834	request.URL.Path = opPath
1835	if len(request.URL.RawQuery) > 0 {
1836		request.URL.RawQuery = "&" + opQuery
1837	} else {
1838		request.URL.RawQuery = opQuery
1839	}
1840
1841	request.Method = "POST"
1842	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1843	if err != nil {
1844		return out, metadata, &smithy.SerializationError{Err: err}
1845	}
1846
1847	if err := awsRestjson1_serializeOpHttpBindingsCreateSubscriptionDefinitionInput(input, restEncoder); err != nil {
1848		return out, metadata, &smithy.SerializationError{Err: err}
1849	}
1850
1851	restEncoder.SetHeader("Content-Type").String("application/json")
1852
1853	jsonEncoder := smithyjson.NewEncoder()
1854	if err := awsRestjson1_serializeOpDocumentCreateSubscriptionDefinitionInput(input, jsonEncoder.Value); err != nil {
1855		return out, metadata, &smithy.SerializationError{Err: err}
1856	}
1857
1858	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1859		return out, metadata, &smithy.SerializationError{Err: err}
1860	}
1861
1862	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1863		return out, metadata, &smithy.SerializationError{Err: err}
1864	}
1865	in.Request = request
1866
1867	return next.HandleSerialize(ctx, in)
1868}
1869func awsRestjson1_serializeOpHttpBindingsCreateSubscriptionDefinitionInput(v *CreateSubscriptionDefinitionInput, encoder *httpbinding.Encoder) error {
1870	if v == nil {
1871		return fmt.Errorf("unsupported serialization of nil %T", v)
1872	}
1873
1874	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1875		locationName := "X-Amzn-Client-Token"
1876		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1877	}
1878
1879	return nil
1880}
1881
1882func awsRestjson1_serializeOpDocumentCreateSubscriptionDefinitionInput(v *CreateSubscriptionDefinitionInput, value smithyjson.Value) error {
1883	object := value.Object()
1884	defer object.Close()
1885
1886	if v.InitialVersion != nil {
1887		ok := object.Key("InitialVersion")
1888		if err := awsRestjson1_serializeDocumentSubscriptionDefinitionVersion(v.InitialVersion, ok); err != nil {
1889			return err
1890		}
1891	}
1892
1893	if v.Name != nil {
1894		ok := object.Key("Name")
1895		ok.String(*v.Name)
1896	}
1897
1898	if v.Tags != nil {
1899		ok := object.Key("tags")
1900		if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
1901			return err
1902		}
1903	}
1904
1905	return nil
1906}
1907
1908type awsRestjson1_serializeOpCreateSubscriptionDefinitionVersion struct {
1909}
1910
1911func (*awsRestjson1_serializeOpCreateSubscriptionDefinitionVersion) ID() string {
1912	return "OperationSerializer"
1913}
1914
1915func (m *awsRestjson1_serializeOpCreateSubscriptionDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1916	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1917) {
1918	request, ok := in.Request.(*smithyhttp.Request)
1919	if !ok {
1920		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1921	}
1922
1923	input, ok := in.Parameters.(*CreateSubscriptionDefinitionVersionInput)
1924	_ = input
1925	if !ok {
1926		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1927	}
1928
1929	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions")
1930	request.URL.Path = opPath
1931	if len(request.URL.RawQuery) > 0 {
1932		request.URL.RawQuery = "&" + opQuery
1933	} else {
1934		request.URL.RawQuery = opQuery
1935	}
1936
1937	request.Method = "POST"
1938	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1939	if err != nil {
1940		return out, metadata, &smithy.SerializationError{Err: err}
1941	}
1942
1943	if err := awsRestjson1_serializeOpHttpBindingsCreateSubscriptionDefinitionVersionInput(input, restEncoder); err != nil {
1944		return out, metadata, &smithy.SerializationError{Err: err}
1945	}
1946
1947	restEncoder.SetHeader("Content-Type").String("application/json")
1948
1949	jsonEncoder := smithyjson.NewEncoder()
1950	if err := awsRestjson1_serializeOpDocumentCreateSubscriptionDefinitionVersionInput(input, jsonEncoder.Value); err != nil {
1951		return out, metadata, &smithy.SerializationError{Err: err}
1952	}
1953
1954	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1955		return out, metadata, &smithy.SerializationError{Err: err}
1956	}
1957
1958	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1959		return out, metadata, &smithy.SerializationError{Err: err}
1960	}
1961	in.Request = request
1962
1963	return next.HandleSerialize(ctx, in)
1964}
1965func awsRestjson1_serializeOpHttpBindingsCreateSubscriptionDefinitionVersionInput(v *CreateSubscriptionDefinitionVersionInput, encoder *httpbinding.Encoder) error {
1966	if v == nil {
1967		return fmt.Errorf("unsupported serialization of nil %T", v)
1968	}
1969
1970	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
1971		locationName := "X-Amzn-Client-Token"
1972		encoder.SetHeader(locationName).String(*v.AmznClientToken)
1973	}
1974
1975	if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 {
1976		return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")}
1977	}
1978	if v.SubscriptionDefinitionId != nil {
1979		if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil {
1980			return err
1981		}
1982	}
1983
1984	return nil
1985}
1986
1987func awsRestjson1_serializeOpDocumentCreateSubscriptionDefinitionVersionInput(v *CreateSubscriptionDefinitionVersionInput, value smithyjson.Value) error {
1988	object := value.Object()
1989	defer object.Close()
1990
1991	if v.Subscriptions != nil {
1992		ok := object.Key("Subscriptions")
1993		if err := awsRestjson1_serializeDocument__listOfSubscription(v.Subscriptions, ok); err != nil {
1994			return err
1995		}
1996	}
1997
1998	return nil
1999}
2000
2001type awsRestjson1_serializeOpDeleteConnectorDefinition struct {
2002}
2003
2004func (*awsRestjson1_serializeOpDeleteConnectorDefinition) ID() string {
2005	return "OperationSerializer"
2006}
2007
2008func (m *awsRestjson1_serializeOpDeleteConnectorDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2009	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2010) {
2011	request, ok := in.Request.(*smithyhttp.Request)
2012	if !ok {
2013		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2014	}
2015
2016	input, ok := in.Parameters.(*DeleteConnectorDefinitionInput)
2017	_ = input
2018	if !ok {
2019		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2020	}
2021
2022	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}")
2023	request.URL.Path = opPath
2024	if len(request.URL.RawQuery) > 0 {
2025		request.URL.RawQuery = "&" + opQuery
2026	} else {
2027		request.URL.RawQuery = opQuery
2028	}
2029
2030	request.Method = "DELETE"
2031	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2032	if err != nil {
2033		return out, metadata, &smithy.SerializationError{Err: err}
2034	}
2035
2036	if err := awsRestjson1_serializeOpHttpBindingsDeleteConnectorDefinitionInput(input, restEncoder); err != nil {
2037		return out, metadata, &smithy.SerializationError{Err: err}
2038	}
2039
2040	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2041		return out, metadata, &smithy.SerializationError{Err: err}
2042	}
2043	in.Request = request
2044
2045	return next.HandleSerialize(ctx, in)
2046}
2047func awsRestjson1_serializeOpHttpBindingsDeleteConnectorDefinitionInput(v *DeleteConnectorDefinitionInput, encoder *httpbinding.Encoder) error {
2048	if v == nil {
2049		return fmt.Errorf("unsupported serialization of nil %T", v)
2050	}
2051
2052	if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 {
2053		return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")}
2054	}
2055	if v.ConnectorDefinitionId != nil {
2056		if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil {
2057			return err
2058		}
2059	}
2060
2061	return nil
2062}
2063
2064type awsRestjson1_serializeOpDeleteCoreDefinition struct {
2065}
2066
2067func (*awsRestjson1_serializeOpDeleteCoreDefinition) ID() string {
2068	return "OperationSerializer"
2069}
2070
2071func (m *awsRestjson1_serializeOpDeleteCoreDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2072	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2073) {
2074	request, ok := in.Request.(*smithyhttp.Request)
2075	if !ok {
2076		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2077	}
2078
2079	input, ok := in.Parameters.(*DeleteCoreDefinitionInput)
2080	_ = input
2081	if !ok {
2082		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2083	}
2084
2085	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}")
2086	request.URL.Path = opPath
2087	if len(request.URL.RawQuery) > 0 {
2088		request.URL.RawQuery = "&" + opQuery
2089	} else {
2090		request.URL.RawQuery = opQuery
2091	}
2092
2093	request.Method = "DELETE"
2094	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2095	if err != nil {
2096		return out, metadata, &smithy.SerializationError{Err: err}
2097	}
2098
2099	if err := awsRestjson1_serializeOpHttpBindingsDeleteCoreDefinitionInput(input, restEncoder); err != nil {
2100		return out, metadata, &smithy.SerializationError{Err: err}
2101	}
2102
2103	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2104		return out, metadata, &smithy.SerializationError{Err: err}
2105	}
2106	in.Request = request
2107
2108	return next.HandleSerialize(ctx, in)
2109}
2110func awsRestjson1_serializeOpHttpBindingsDeleteCoreDefinitionInput(v *DeleteCoreDefinitionInput, encoder *httpbinding.Encoder) error {
2111	if v == nil {
2112		return fmt.Errorf("unsupported serialization of nil %T", v)
2113	}
2114
2115	if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 {
2116		return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")}
2117	}
2118	if v.CoreDefinitionId != nil {
2119		if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil {
2120			return err
2121		}
2122	}
2123
2124	return nil
2125}
2126
2127type awsRestjson1_serializeOpDeleteDeviceDefinition struct {
2128}
2129
2130func (*awsRestjson1_serializeOpDeleteDeviceDefinition) ID() string {
2131	return "OperationSerializer"
2132}
2133
2134func (m *awsRestjson1_serializeOpDeleteDeviceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2135	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2136) {
2137	request, ok := in.Request.(*smithyhttp.Request)
2138	if !ok {
2139		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2140	}
2141
2142	input, ok := in.Parameters.(*DeleteDeviceDefinitionInput)
2143	_ = input
2144	if !ok {
2145		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2146	}
2147
2148	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}")
2149	request.URL.Path = opPath
2150	if len(request.URL.RawQuery) > 0 {
2151		request.URL.RawQuery = "&" + opQuery
2152	} else {
2153		request.URL.RawQuery = opQuery
2154	}
2155
2156	request.Method = "DELETE"
2157	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2158	if err != nil {
2159		return out, metadata, &smithy.SerializationError{Err: err}
2160	}
2161
2162	if err := awsRestjson1_serializeOpHttpBindingsDeleteDeviceDefinitionInput(input, restEncoder); err != nil {
2163		return out, metadata, &smithy.SerializationError{Err: err}
2164	}
2165
2166	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2167		return out, metadata, &smithy.SerializationError{Err: err}
2168	}
2169	in.Request = request
2170
2171	return next.HandleSerialize(ctx, in)
2172}
2173func awsRestjson1_serializeOpHttpBindingsDeleteDeviceDefinitionInput(v *DeleteDeviceDefinitionInput, encoder *httpbinding.Encoder) error {
2174	if v == nil {
2175		return fmt.Errorf("unsupported serialization of nil %T", v)
2176	}
2177
2178	if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 {
2179		return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")}
2180	}
2181	if v.DeviceDefinitionId != nil {
2182		if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil {
2183			return err
2184		}
2185	}
2186
2187	return nil
2188}
2189
2190type awsRestjson1_serializeOpDeleteFunctionDefinition struct {
2191}
2192
2193func (*awsRestjson1_serializeOpDeleteFunctionDefinition) ID() string {
2194	return "OperationSerializer"
2195}
2196
2197func (m *awsRestjson1_serializeOpDeleteFunctionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2198	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2199) {
2200	request, ok := in.Request.(*smithyhttp.Request)
2201	if !ok {
2202		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2203	}
2204
2205	input, ok := in.Parameters.(*DeleteFunctionDefinitionInput)
2206	_ = input
2207	if !ok {
2208		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2209	}
2210
2211	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}")
2212	request.URL.Path = opPath
2213	if len(request.URL.RawQuery) > 0 {
2214		request.URL.RawQuery = "&" + opQuery
2215	} else {
2216		request.URL.RawQuery = opQuery
2217	}
2218
2219	request.Method = "DELETE"
2220	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2221	if err != nil {
2222		return out, metadata, &smithy.SerializationError{Err: err}
2223	}
2224
2225	if err := awsRestjson1_serializeOpHttpBindingsDeleteFunctionDefinitionInput(input, restEncoder); err != nil {
2226		return out, metadata, &smithy.SerializationError{Err: err}
2227	}
2228
2229	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2230		return out, metadata, &smithy.SerializationError{Err: err}
2231	}
2232	in.Request = request
2233
2234	return next.HandleSerialize(ctx, in)
2235}
2236func awsRestjson1_serializeOpHttpBindingsDeleteFunctionDefinitionInput(v *DeleteFunctionDefinitionInput, encoder *httpbinding.Encoder) error {
2237	if v == nil {
2238		return fmt.Errorf("unsupported serialization of nil %T", v)
2239	}
2240
2241	if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 {
2242		return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")}
2243	}
2244	if v.FunctionDefinitionId != nil {
2245		if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil {
2246			return err
2247		}
2248	}
2249
2250	return nil
2251}
2252
2253type awsRestjson1_serializeOpDeleteGroup struct {
2254}
2255
2256func (*awsRestjson1_serializeOpDeleteGroup) ID() string {
2257	return "OperationSerializer"
2258}
2259
2260func (m *awsRestjson1_serializeOpDeleteGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2261	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2262) {
2263	request, ok := in.Request.(*smithyhttp.Request)
2264	if !ok {
2265		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2266	}
2267
2268	input, ok := in.Parameters.(*DeleteGroupInput)
2269	_ = input
2270	if !ok {
2271		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2272	}
2273
2274	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}")
2275	request.URL.Path = opPath
2276	if len(request.URL.RawQuery) > 0 {
2277		request.URL.RawQuery = "&" + opQuery
2278	} else {
2279		request.URL.RawQuery = opQuery
2280	}
2281
2282	request.Method = "DELETE"
2283	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2284	if err != nil {
2285		return out, metadata, &smithy.SerializationError{Err: err}
2286	}
2287
2288	if err := awsRestjson1_serializeOpHttpBindingsDeleteGroupInput(input, restEncoder); err != nil {
2289		return out, metadata, &smithy.SerializationError{Err: err}
2290	}
2291
2292	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2293		return out, metadata, &smithy.SerializationError{Err: err}
2294	}
2295	in.Request = request
2296
2297	return next.HandleSerialize(ctx, in)
2298}
2299func awsRestjson1_serializeOpHttpBindingsDeleteGroupInput(v *DeleteGroupInput, encoder *httpbinding.Encoder) error {
2300	if v == nil {
2301		return fmt.Errorf("unsupported serialization of nil %T", v)
2302	}
2303
2304	if v.GroupId == nil || len(*v.GroupId) == 0 {
2305		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
2306	}
2307	if v.GroupId != nil {
2308		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
2309			return err
2310		}
2311	}
2312
2313	return nil
2314}
2315
2316type awsRestjson1_serializeOpDeleteLoggerDefinition struct {
2317}
2318
2319func (*awsRestjson1_serializeOpDeleteLoggerDefinition) ID() string {
2320	return "OperationSerializer"
2321}
2322
2323func (m *awsRestjson1_serializeOpDeleteLoggerDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2324	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2325) {
2326	request, ok := in.Request.(*smithyhttp.Request)
2327	if !ok {
2328		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2329	}
2330
2331	input, ok := in.Parameters.(*DeleteLoggerDefinitionInput)
2332	_ = input
2333	if !ok {
2334		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2335	}
2336
2337	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}")
2338	request.URL.Path = opPath
2339	if len(request.URL.RawQuery) > 0 {
2340		request.URL.RawQuery = "&" + opQuery
2341	} else {
2342		request.URL.RawQuery = opQuery
2343	}
2344
2345	request.Method = "DELETE"
2346	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2347	if err != nil {
2348		return out, metadata, &smithy.SerializationError{Err: err}
2349	}
2350
2351	if err := awsRestjson1_serializeOpHttpBindingsDeleteLoggerDefinitionInput(input, restEncoder); err != nil {
2352		return out, metadata, &smithy.SerializationError{Err: err}
2353	}
2354
2355	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2356		return out, metadata, &smithy.SerializationError{Err: err}
2357	}
2358	in.Request = request
2359
2360	return next.HandleSerialize(ctx, in)
2361}
2362func awsRestjson1_serializeOpHttpBindingsDeleteLoggerDefinitionInput(v *DeleteLoggerDefinitionInput, encoder *httpbinding.Encoder) error {
2363	if v == nil {
2364		return fmt.Errorf("unsupported serialization of nil %T", v)
2365	}
2366
2367	if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 {
2368		return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")}
2369	}
2370	if v.LoggerDefinitionId != nil {
2371		if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil {
2372			return err
2373		}
2374	}
2375
2376	return nil
2377}
2378
2379type awsRestjson1_serializeOpDeleteResourceDefinition struct {
2380}
2381
2382func (*awsRestjson1_serializeOpDeleteResourceDefinition) ID() string {
2383	return "OperationSerializer"
2384}
2385
2386func (m *awsRestjson1_serializeOpDeleteResourceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2387	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2388) {
2389	request, ok := in.Request.(*smithyhttp.Request)
2390	if !ok {
2391		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2392	}
2393
2394	input, ok := in.Parameters.(*DeleteResourceDefinitionInput)
2395	_ = input
2396	if !ok {
2397		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2398	}
2399
2400	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}")
2401	request.URL.Path = opPath
2402	if len(request.URL.RawQuery) > 0 {
2403		request.URL.RawQuery = "&" + opQuery
2404	} else {
2405		request.URL.RawQuery = opQuery
2406	}
2407
2408	request.Method = "DELETE"
2409	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2410	if err != nil {
2411		return out, metadata, &smithy.SerializationError{Err: err}
2412	}
2413
2414	if err := awsRestjson1_serializeOpHttpBindingsDeleteResourceDefinitionInput(input, restEncoder); err != nil {
2415		return out, metadata, &smithy.SerializationError{Err: err}
2416	}
2417
2418	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2419		return out, metadata, &smithy.SerializationError{Err: err}
2420	}
2421	in.Request = request
2422
2423	return next.HandleSerialize(ctx, in)
2424}
2425func awsRestjson1_serializeOpHttpBindingsDeleteResourceDefinitionInput(v *DeleteResourceDefinitionInput, encoder *httpbinding.Encoder) error {
2426	if v == nil {
2427		return fmt.Errorf("unsupported serialization of nil %T", v)
2428	}
2429
2430	if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 {
2431		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")}
2432	}
2433	if v.ResourceDefinitionId != nil {
2434		if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil {
2435			return err
2436		}
2437	}
2438
2439	return nil
2440}
2441
2442type awsRestjson1_serializeOpDeleteSubscriptionDefinition struct {
2443}
2444
2445func (*awsRestjson1_serializeOpDeleteSubscriptionDefinition) ID() string {
2446	return "OperationSerializer"
2447}
2448
2449func (m *awsRestjson1_serializeOpDeleteSubscriptionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2450	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2451) {
2452	request, ok := in.Request.(*smithyhttp.Request)
2453	if !ok {
2454		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2455	}
2456
2457	input, ok := in.Parameters.(*DeleteSubscriptionDefinitionInput)
2458	_ = input
2459	if !ok {
2460		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2461	}
2462
2463	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}")
2464	request.URL.Path = opPath
2465	if len(request.URL.RawQuery) > 0 {
2466		request.URL.RawQuery = "&" + opQuery
2467	} else {
2468		request.URL.RawQuery = opQuery
2469	}
2470
2471	request.Method = "DELETE"
2472	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2473	if err != nil {
2474		return out, metadata, &smithy.SerializationError{Err: err}
2475	}
2476
2477	if err := awsRestjson1_serializeOpHttpBindingsDeleteSubscriptionDefinitionInput(input, restEncoder); err != nil {
2478		return out, metadata, &smithy.SerializationError{Err: err}
2479	}
2480
2481	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2482		return out, metadata, &smithy.SerializationError{Err: err}
2483	}
2484	in.Request = request
2485
2486	return next.HandleSerialize(ctx, in)
2487}
2488func awsRestjson1_serializeOpHttpBindingsDeleteSubscriptionDefinitionInput(v *DeleteSubscriptionDefinitionInput, encoder *httpbinding.Encoder) error {
2489	if v == nil {
2490		return fmt.Errorf("unsupported serialization of nil %T", v)
2491	}
2492
2493	if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 {
2494		return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")}
2495	}
2496	if v.SubscriptionDefinitionId != nil {
2497		if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil {
2498			return err
2499		}
2500	}
2501
2502	return nil
2503}
2504
2505type awsRestjson1_serializeOpDisassociateRoleFromGroup struct {
2506}
2507
2508func (*awsRestjson1_serializeOpDisassociateRoleFromGroup) ID() string {
2509	return "OperationSerializer"
2510}
2511
2512func (m *awsRestjson1_serializeOpDisassociateRoleFromGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2513	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2514) {
2515	request, ok := in.Request.(*smithyhttp.Request)
2516	if !ok {
2517		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2518	}
2519
2520	input, ok := in.Parameters.(*DisassociateRoleFromGroupInput)
2521	_ = input
2522	if !ok {
2523		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2524	}
2525
2526	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/role")
2527	request.URL.Path = opPath
2528	if len(request.URL.RawQuery) > 0 {
2529		request.URL.RawQuery = "&" + opQuery
2530	} else {
2531		request.URL.RawQuery = opQuery
2532	}
2533
2534	request.Method = "DELETE"
2535	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2536	if err != nil {
2537		return out, metadata, &smithy.SerializationError{Err: err}
2538	}
2539
2540	if err := awsRestjson1_serializeOpHttpBindingsDisassociateRoleFromGroupInput(input, restEncoder); err != nil {
2541		return out, metadata, &smithy.SerializationError{Err: err}
2542	}
2543
2544	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2545		return out, metadata, &smithy.SerializationError{Err: err}
2546	}
2547	in.Request = request
2548
2549	return next.HandleSerialize(ctx, in)
2550}
2551func awsRestjson1_serializeOpHttpBindingsDisassociateRoleFromGroupInput(v *DisassociateRoleFromGroupInput, encoder *httpbinding.Encoder) error {
2552	if v == nil {
2553		return fmt.Errorf("unsupported serialization of nil %T", v)
2554	}
2555
2556	if v.GroupId == nil || len(*v.GroupId) == 0 {
2557		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
2558	}
2559	if v.GroupId != nil {
2560		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
2561			return err
2562		}
2563	}
2564
2565	return nil
2566}
2567
2568type awsRestjson1_serializeOpDisassociateServiceRoleFromAccount struct {
2569}
2570
2571func (*awsRestjson1_serializeOpDisassociateServiceRoleFromAccount) ID() string {
2572	return "OperationSerializer"
2573}
2574
2575func (m *awsRestjson1_serializeOpDisassociateServiceRoleFromAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2576	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2577) {
2578	request, ok := in.Request.(*smithyhttp.Request)
2579	if !ok {
2580		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2581	}
2582
2583	input, ok := in.Parameters.(*DisassociateServiceRoleFromAccountInput)
2584	_ = input
2585	if !ok {
2586		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2587	}
2588
2589	opPath, opQuery := httpbinding.SplitURI("/greengrass/servicerole")
2590	request.URL.Path = opPath
2591	if len(request.URL.RawQuery) > 0 {
2592		request.URL.RawQuery = "&" + opQuery
2593	} else {
2594		request.URL.RawQuery = opQuery
2595	}
2596
2597	request.Method = "DELETE"
2598	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2599	if err != nil {
2600		return out, metadata, &smithy.SerializationError{Err: err}
2601	}
2602
2603	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2604		return out, metadata, &smithy.SerializationError{Err: err}
2605	}
2606	in.Request = request
2607
2608	return next.HandleSerialize(ctx, in)
2609}
2610func awsRestjson1_serializeOpHttpBindingsDisassociateServiceRoleFromAccountInput(v *DisassociateServiceRoleFromAccountInput, encoder *httpbinding.Encoder) error {
2611	if v == nil {
2612		return fmt.Errorf("unsupported serialization of nil %T", v)
2613	}
2614
2615	return nil
2616}
2617
2618type awsRestjson1_serializeOpGetAssociatedRole struct {
2619}
2620
2621func (*awsRestjson1_serializeOpGetAssociatedRole) ID() string {
2622	return "OperationSerializer"
2623}
2624
2625func (m *awsRestjson1_serializeOpGetAssociatedRole) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2626	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2627) {
2628	request, ok := in.Request.(*smithyhttp.Request)
2629	if !ok {
2630		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2631	}
2632
2633	input, ok := in.Parameters.(*GetAssociatedRoleInput)
2634	_ = input
2635	if !ok {
2636		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2637	}
2638
2639	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/role")
2640	request.URL.Path = opPath
2641	if len(request.URL.RawQuery) > 0 {
2642		request.URL.RawQuery = "&" + opQuery
2643	} else {
2644		request.URL.RawQuery = opQuery
2645	}
2646
2647	request.Method = "GET"
2648	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2649	if err != nil {
2650		return out, metadata, &smithy.SerializationError{Err: err}
2651	}
2652
2653	if err := awsRestjson1_serializeOpHttpBindingsGetAssociatedRoleInput(input, restEncoder); err != nil {
2654		return out, metadata, &smithy.SerializationError{Err: err}
2655	}
2656
2657	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2658		return out, metadata, &smithy.SerializationError{Err: err}
2659	}
2660	in.Request = request
2661
2662	return next.HandleSerialize(ctx, in)
2663}
2664func awsRestjson1_serializeOpHttpBindingsGetAssociatedRoleInput(v *GetAssociatedRoleInput, encoder *httpbinding.Encoder) error {
2665	if v == nil {
2666		return fmt.Errorf("unsupported serialization of nil %T", v)
2667	}
2668
2669	if v.GroupId == nil || len(*v.GroupId) == 0 {
2670		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
2671	}
2672	if v.GroupId != nil {
2673		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
2674			return err
2675		}
2676	}
2677
2678	return nil
2679}
2680
2681type awsRestjson1_serializeOpGetBulkDeploymentStatus struct {
2682}
2683
2684func (*awsRestjson1_serializeOpGetBulkDeploymentStatus) ID() string {
2685	return "OperationSerializer"
2686}
2687
2688func (m *awsRestjson1_serializeOpGetBulkDeploymentStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2689	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2690) {
2691	request, ok := in.Request.(*smithyhttp.Request)
2692	if !ok {
2693		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2694	}
2695
2696	input, ok := in.Parameters.(*GetBulkDeploymentStatusInput)
2697	_ = input
2698	if !ok {
2699		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2700	}
2701
2702	opPath, opQuery := httpbinding.SplitURI("/greengrass/bulk/deployments/{BulkDeploymentId}/status")
2703	request.URL.Path = opPath
2704	if len(request.URL.RawQuery) > 0 {
2705		request.URL.RawQuery = "&" + opQuery
2706	} else {
2707		request.URL.RawQuery = opQuery
2708	}
2709
2710	request.Method = "GET"
2711	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2712	if err != nil {
2713		return out, metadata, &smithy.SerializationError{Err: err}
2714	}
2715
2716	if err := awsRestjson1_serializeOpHttpBindingsGetBulkDeploymentStatusInput(input, restEncoder); err != nil {
2717		return out, metadata, &smithy.SerializationError{Err: err}
2718	}
2719
2720	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2721		return out, metadata, &smithy.SerializationError{Err: err}
2722	}
2723	in.Request = request
2724
2725	return next.HandleSerialize(ctx, in)
2726}
2727func awsRestjson1_serializeOpHttpBindingsGetBulkDeploymentStatusInput(v *GetBulkDeploymentStatusInput, encoder *httpbinding.Encoder) error {
2728	if v == nil {
2729		return fmt.Errorf("unsupported serialization of nil %T", v)
2730	}
2731
2732	if v.BulkDeploymentId == nil || len(*v.BulkDeploymentId) == 0 {
2733		return &smithy.SerializationError{Err: fmt.Errorf("input member BulkDeploymentId must not be empty")}
2734	}
2735	if v.BulkDeploymentId != nil {
2736		if err := encoder.SetURI("BulkDeploymentId").String(*v.BulkDeploymentId); err != nil {
2737			return err
2738		}
2739	}
2740
2741	return nil
2742}
2743
2744type awsRestjson1_serializeOpGetConnectivityInfo struct {
2745}
2746
2747func (*awsRestjson1_serializeOpGetConnectivityInfo) ID() string {
2748	return "OperationSerializer"
2749}
2750
2751func (m *awsRestjson1_serializeOpGetConnectivityInfo) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2752	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2753) {
2754	request, ok := in.Request.(*smithyhttp.Request)
2755	if !ok {
2756		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2757	}
2758
2759	input, ok := in.Parameters.(*GetConnectivityInfoInput)
2760	_ = input
2761	if !ok {
2762		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2763	}
2764
2765	opPath, opQuery := httpbinding.SplitURI("/greengrass/things/{ThingName}/connectivityInfo")
2766	request.URL.Path = opPath
2767	if len(request.URL.RawQuery) > 0 {
2768		request.URL.RawQuery = "&" + opQuery
2769	} else {
2770		request.URL.RawQuery = opQuery
2771	}
2772
2773	request.Method = "GET"
2774	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2775	if err != nil {
2776		return out, metadata, &smithy.SerializationError{Err: err}
2777	}
2778
2779	if err := awsRestjson1_serializeOpHttpBindingsGetConnectivityInfoInput(input, restEncoder); err != nil {
2780		return out, metadata, &smithy.SerializationError{Err: err}
2781	}
2782
2783	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2784		return out, metadata, &smithy.SerializationError{Err: err}
2785	}
2786	in.Request = request
2787
2788	return next.HandleSerialize(ctx, in)
2789}
2790func awsRestjson1_serializeOpHttpBindingsGetConnectivityInfoInput(v *GetConnectivityInfoInput, encoder *httpbinding.Encoder) error {
2791	if v == nil {
2792		return fmt.Errorf("unsupported serialization of nil %T", v)
2793	}
2794
2795	if v.ThingName == nil || len(*v.ThingName) == 0 {
2796		return &smithy.SerializationError{Err: fmt.Errorf("input member ThingName must not be empty")}
2797	}
2798	if v.ThingName != nil {
2799		if err := encoder.SetURI("ThingName").String(*v.ThingName); err != nil {
2800			return err
2801		}
2802	}
2803
2804	return nil
2805}
2806
2807type awsRestjson1_serializeOpGetConnectorDefinition struct {
2808}
2809
2810func (*awsRestjson1_serializeOpGetConnectorDefinition) ID() string {
2811	return "OperationSerializer"
2812}
2813
2814func (m *awsRestjson1_serializeOpGetConnectorDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2815	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2816) {
2817	request, ok := in.Request.(*smithyhttp.Request)
2818	if !ok {
2819		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2820	}
2821
2822	input, ok := in.Parameters.(*GetConnectorDefinitionInput)
2823	_ = input
2824	if !ok {
2825		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2826	}
2827
2828	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}")
2829	request.URL.Path = opPath
2830	if len(request.URL.RawQuery) > 0 {
2831		request.URL.RawQuery = "&" + opQuery
2832	} else {
2833		request.URL.RawQuery = opQuery
2834	}
2835
2836	request.Method = "GET"
2837	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2838	if err != nil {
2839		return out, metadata, &smithy.SerializationError{Err: err}
2840	}
2841
2842	if err := awsRestjson1_serializeOpHttpBindingsGetConnectorDefinitionInput(input, restEncoder); err != nil {
2843		return out, metadata, &smithy.SerializationError{Err: err}
2844	}
2845
2846	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2847		return out, metadata, &smithy.SerializationError{Err: err}
2848	}
2849	in.Request = request
2850
2851	return next.HandleSerialize(ctx, in)
2852}
2853func awsRestjson1_serializeOpHttpBindingsGetConnectorDefinitionInput(v *GetConnectorDefinitionInput, encoder *httpbinding.Encoder) error {
2854	if v == nil {
2855		return fmt.Errorf("unsupported serialization of nil %T", v)
2856	}
2857
2858	if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 {
2859		return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")}
2860	}
2861	if v.ConnectorDefinitionId != nil {
2862		if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil {
2863			return err
2864		}
2865	}
2866
2867	return nil
2868}
2869
2870type awsRestjson1_serializeOpGetConnectorDefinitionVersion struct {
2871}
2872
2873func (*awsRestjson1_serializeOpGetConnectorDefinitionVersion) ID() string {
2874	return "OperationSerializer"
2875}
2876
2877func (m *awsRestjson1_serializeOpGetConnectorDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2878	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2879) {
2880	request, ok := in.Request.(*smithyhttp.Request)
2881	if !ok {
2882		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2883	}
2884
2885	input, ok := in.Parameters.(*GetConnectorDefinitionVersionInput)
2886	_ = input
2887	if !ok {
2888		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2889	}
2890
2891	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}/versions/{ConnectorDefinitionVersionId}")
2892	request.URL.Path = opPath
2893	if len(request.URL.RawQuery) > 0 {
2894		request.URL.RawQuery = "&" + opQuery
2895	} else {
2896		request.URL.RawQuery = opQuery
2897	}
2898
2899	request.Method = "GET"
2900	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2901	if err != nil {
2902		return out, metadata, &smithy.SerializationError{Err: err}
2903	}
2904
2905	if err := awsRestjson1_serializeOpHttpBindingsGetConnectorDefinitionVersionInput(input, restEncoder); err != nil {
2906		return out, metadata, &smithy.SerializationError{Err: err}
2907	}
2908
2909	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2910		return out, metadata, &smithy.SerializationError{Err: err}
2911	}
2912	in.Request = request
2913
2914	return next.HandleSerialize(ctx, in)
2915}
2916func awsRestjson1_serializeOpHttpBindingsGetConnectorDefinitionVersionInput(v *GetConnectorDefinitionVersionInput, encoder *httpbinding.Encoder) error {
2917	if v == nil {
2918		return fmt.Errorf("unsupported serialization of nil %T", v)
2919	}
2920
2921	if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 {
2922		return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")}
2923	}
2924	if v.ConnectorDefinitionId != nil {
2925		if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil {
2926			return err
2927		}
2928	}
2929
2930	if v.ConnectorDefinitionVersionId == nil || len(*v.ConnectorDefinitionVersionId) == 0 {
2931		return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionVersionId must not be empty")}
2932	}
2933	if v.ConnectorDefinitionVersionId != nil {
2934		if err := encoder.SetURI("ConnectorDefinitionVersionId").String(*v.ConnectorDefinitionVersionId); err != nil {
2935			return err
2936		}
2937	}
2938
2939	if v.NextToken != nil {
2940		encoder.SetQuery("NextToken").String(*v.NextToken)
2941	}
2942
2943	return nil
2944}
2945
2946type awsRestjson1_serializeOpGetCoreDefinition struct {
2947}
2948
2949func (*awsRestjson1_serializeOpGetCoreDefinition) ID() string {
2950	return "OperationSerializer"
2951}
2952
2953func (m *awsRestjson1_serializeOpGetCoreDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2954	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2955) {
2956	request, ok := in.Request.(*smithyhttp.Request)
2957	if !ok {
2958		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2959	}
2960
2961	input, ok := in.Parameters.(*GetCoreDefinitionInput)
2962	_ = input
2963	if !ok {
2964		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2965	}
2966
2967	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}")
2968	request.URL.Path = opPath
2969	if len(request.URL.RawQuery) > 0 {
2970		request.URL.RawQuery = "&" + opQuery
2971	} else {
2972		request.URL.RawQuery = opQuery
2973	}
2974
2975	request.Method = "GET"
2976	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2977	if err != nil {
2978		return out, metadata, &smithy.SerializationError{Err: err}
2979	}
2980
2981	if err := awsRestjson1_serializeOpHttpBindingsGetCoreDefinitionInput(input, restEncoder); err != nil {
2982		return out, metadata, &smithy.SerializationError{Err: err}
2983	}
2984
2985	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2986		return out, metadata, &smithy.SerializationError{Err: err}
2987	}
2988	in.Request = request
2989
2990	return next.HandleSerialize(ctx, in)
2991}
2992func awsRestjson1_serializeOpHttpBindingsGetCoreDefinitionInput(v *GetCoreDefinitionInput, encoder *httpbinding.Encoder) error {
2993	if v == nil {
2994		return fmt.Errorf("unsupported serialization of nil %T", v)
2995	}
2996
2997	if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 {
2998		return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")}
2999	}
3000	if v.CoreDefinitionId != nil {
3001		if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil {
3002			return err
3003		}
3004	}
3005
3006	return nil
3007}
3008
3009type awsRestjson1_serializeOpGetCoreDefinitionVersion struct {
3010}
3011
3012func (*awsRestjson1_serializeOpGetCoreDefinitionVersion) ID() string {
3013	return "OperationSerializer"
3014}
3015
3016func (m *awsRestjson1_serializeOpGetCoreDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3017	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3018) {
3019	request, ok := in.Request.(*smithyhttp.Request)
3020	if !ok {
3021		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3022	}
3023
3024	input, ok := in.Parameters.(*GetCoreDefinitionVersionInput)
3025	_ = input
3026	if !ok {
3027		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3028	}
3029
3030	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}/versions/{CoreDefinitionVersionId}")
3031	request.URL.Path = opPath
3032	if len(request.URL.RawQuery) > 0 {
3033		request.URL.RawQuery = "&" + opQuery
3034	} else {
3035		request.URL.RawQuery = opQuery
3036	}
3037
3038	request.Method = "GET"
3039	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3040	if err != nil {
3041		return out, metadata, &smithy.SerializationError{Err: err}
3042	}
3043
3044	if err := awsRestjson1_serializeOpHttpBindingsGetCoreDefinitionVersionInput(input, restEncoder); err != nil {
3045		return out, metadata, &smithy.SerializationError{Err: err}
3046	}
3047
3048	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3049		return out, metadata, &smithy.SerializationError{Err: err}
3050	}
3051	in.Request = request
3052
3053	return next.HandleSerialize(ctx, in)
3054}
3055func awsRestjson1_serializeOpHttpBindingsGetCoreDefinitionVersionInput(v *GetCoreDefinitionVersionInput, encoder *httpbinding.Encoder) error {
3056	if v == nil {
3057		return fmt.Errorf("unsupported serialization of nil %T", v)
3058	}
3059
3060	if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 {
3061		return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")}
3062	}
3063	if v.CoreDefinitionId != nil {
3064		if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil {
3065			return err
3066		}
3067	}
3068
3069	if v.CoreDefinitionVersionId == nil || len(*v.CoreDefinitionVersionId) == 0 {
3070		return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionVersionId must not be empty")}
3071	}
3072	if v.CoreDefinitionVersionId != nil {
3073		if err := encoder.SetURI("CoreDefinitionVersionId").String(*v.CoreDefinitionVersionId); err != nil {
3074			return err
3075		}
3076	}
3077
3078	return nil
3079}
3080
3081type awsRestjson1_serializeOpGetDeploymentStatus struct {
3082}
3083
3084func (*awsRestjson1_serializeOpGetDeploymentStatus) ID() string {
3085	return "OperationSerializer"
3086}
3087
3088func (m *awsRestjson1_serializeOpGetDeploymentStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3089	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3090) {
3091	request, ok := in.Request.(*smithyhttp.Request)
3092	if !ok {
3093		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3094	}
3095
3096	input, ok := in.Parameters.(*GetDeploymentStatusInput)
3097	_ = input
3098	if !ok {
3099		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3100	}
3101
3102	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/deployments/{DeploymentId}/status")
3103	request.URL.Path = opPath
3104	if len(request.URL.RawQuery) > 0 {
3105		request.URL.RawQuery = "&" + opQuery
3106	} else {
3107		request.URL.RawQuery = opQuery
3108	}
3109
3110	request.Method = "GET"
3111	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3112	if err != nil {
3113		return out, metadata, &smithy.SerializationError{Err: err}
3114	}
3115
3116	if err := awsRestjson1_serializeOpHttpBindingsGetDeploymentStatusInput(input, restEncoder); err != nil {
3117		return out, metadata, &smithy.SerializationError{Err: err}
3118	}
3119
3120	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3121		return out, metadata, &smithy.SerializationError{Err: err}
3122	}
3123	in.Request = request
3124
3125	return next.HandleSerialize(ctx, in)
3126}
3127func awsRestjson1_serializeOpHttpBindingsGetDeploymentStatusInput(v *GetDeploymentStatusInput, encoder *httpbinding.Encoder) error {
3128	if v == nil {
3129		return fmt.Errorf("unsupported serialization of nil %T", v)
3130	}
3131
3132	if v.DeploymentId == nil || len(*v.DeploymentId) == 0 {
3133		return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentId must not be empty")}
3134	}
3135	if v.DeploymentId != nil {
3136		if err := encoder.SetURI("DeploymentId").String(*v.DeploymentId); err != nil {
3137			return err
3138		}
3139	}
3140
3141	if v.GroupId == nil || len(*v.GroupId) == 0 {
3142		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
3143	}
3144	if v.GroupId != nil {
3145		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
3146			return err
3147		}
3148	}
3149
3150	return nil
3151}
3152
3153type awsRestjson1_serializeOpGetDeviceDefinition struct {
3154}
3155
3156func (*awsRestjson1_serializeOpGetDeviceDefinition) ID() string {
3157	return "OperationSerializer"
3158}
3159
3160func (m *awsRestjson1_serializeOpGetDeviceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3161	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3162) {
3163	request, ok := in.Request.(*smithyhttp.Request)
3164	if !ok {
3165		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3166	}
3167
3168	input, ok := in.Parameters.(*GetDeviceDefinitionInput)
3169	_ = input
3170	if !ok {
3171		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3172	}
3173
3174	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}")
3175	request.URL.Path = opPath
3176	if len(request.URL.RawQuery) > 0 {
3177		request.URL.RawQuery = "&" + opQuery
3178	} else {
3179		request.URL.RawQuery = opQuery
3180	}
3181
3182	request.Method = "GET"
3183	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3184	if err != nil {
3185		return out, metadata, &smithy.SerializationError{Err: err}
3186	}
3187
3188	if err := awsRestjson1_serializeOpHttpBindingsGetDeviceDefinitionInput(input, restEncoder); err != nil {
3189		return out, metadata, &smithy.SerializationError{Err: err}
3190	}
3191
3192	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3193		return out, metadata, &smithy.SerializationError{Err: err}
3194	}
3195	in.Request = request
3196
3197	return next.HandleSerialize(ctx, in)
3198}
3199func awsRestjson1_serializeOpHttpBindingsGetDeviceDefinitionInput(v *GetDeviceDefinitionInput, encoder *httpbinding.Encoder) error {
3200	if v == nil {
3201		return fmt.Errorf("unsupported serialization of nil %T", v)
3202	}
3203
3204	if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 {
3205		return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")}
3206	}
3207	if v.DeviceDefinitionId != nil {
3208		if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil {
3209			return err
3210		}
3211	}
3212
3213	return nil
3214}
3215
3216type awsRestjson1_serializeOpGetDeviceDefinitionVersion struct {
3217}
3218
3219func (*awsRestjson1_serializeOpGetDeviceDefinitionVersion) ID() string {
3220	return "OperationSerializer"
3221}
3222
3223func (m *awsRestjson1_serializeOpGetDeviceDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3224	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3225) {
3226	request, ok := in.Request.(*smithyhttp.Request)
3227	if !ok {
3228		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3229	}
3230
3231	input, ok := in.Parameters.(*GetDeviceDefinitionVersionInput)
3232	_ = input
3233	if !ok {
3234		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3235	}
3236
3237	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}/versions/{DeviceDefinitionVersionId}")
3238	request.URL.Path = opPath
3239	if len(request.URL.RawQuery) > 0 {
3240		request.URL.RawQuery = "&" + opQuery
3241	} else {
3242		request.URL.RawQuery = opQuery
3243	}
3244
3245	request.Method = "GET"
3246	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3247	if err != nil {
3248		return out, metadata, &smithy.SerializationError{Err: err}
3249	}
3250
3251	if err := awsRestjson1_serializeOpHttpBindingsGetDeviceDefinitionVersionInput(input, restEncoder); err != nil {
3252		return out, metadata, &smithy.SerializationError{Err: err}
3253	}
3254
3255	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3256		return out, metadata, &smithy.SerializationError{Err: err}
3257	}
3258	in.Request = request
3259
3260	return next.HandleSerialize(ctx, in)
3261}
3262func awsRestjson1_serializeOpHttpBindingsGetDeviceDefinitionVersionInput(v *GetDeviceDefinitionVersionInput, encoder *httpbinding.Encoder) error {
3263	if v == nil {
3264		return fmt.Errorf("unsupported serialization of nil %T", v)
3265	}
3266
3267	if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 {
3268		return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")}
3269	}
3270	if v.DeviceDefinitionId != nil {
3271		if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil {
3272			return err
3273		}
3274	}
3275
3276	if v.DeviceDefinitionVersionId == nil || len(*v.DeviceDefinitionVersionId) == 0 {
3277		return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionVersionId must not be empty")}
3278	}
3279	if v.DeviceDefinitionVersionId != nil {
3280		if err := encoder.SetURI("DeviceDefinitionVersionId").String(*v.DeviceDefinitionVersionId); err != nil {
3281			return err
3282		}
3283	}
3284
3285	if v.NextToken != nil {
3286		encoder.SetQuery("NextToken").String(*v.NextToken)
3287	}
3288
3289	return nil
3290}
3291
3292type awsRestjson1_serializeOpGetFunctionDefinition struct {
3293}
3294
3295func (*awsRestjson1_serializeOpGetFunctionDefinition) ID() string {
3296	return "OperationSerializer"
3297}
3298
3299func (m *awsRestjson1_serializeOpGetFunctionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3300	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3301) {
3302	request, ok := in.Request.(*smithyhttp.Request)
3303	if !ok {
3304		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3305	}
3306
3307	input, ok := in.Parameters.(*GetFunctionDefinitionInput)
3308	_ = input
3309	if !ok {
3310		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3311	}
3312
3313	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}")
3314	request.URL.Path = opPath
3315	if len(request.URL.RawQuery) > 0 {
3316		request.URL.RawQuery = "&" + opQuery
3317	} else {
3318		request.URL.RawQuery = opQuery
3319	}
3320
3321	request.Method = "GET"
3322	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3323	if err != nil {
3324		return out, metadata, &smithy.SerializationError{Err: err}
3325	}
3326
3327	if err := awsRestjson1_serializeOpHttpBindingsGetFunctionDefinitionInput(input, restEncoder); err != nil {
3328		return out, metadata, &smithy.SerializationError{Err: err}
3329	}
3330
3331	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3332		return out, metadata, &smithy.SerializationError{Err: err}
3333	}
3334	in.Request = request
3335
3336	return next.HandleSerialize(ctx, in)
3337}
3338func awsRestjson1_serializeOpHttpBindingsGetFunctionDefinitionInput(v *GetFunctionDefinitionInput, encoder *httpbinding.Encoder) error {
3339	if v == nil {
3340		return fmt.Errorf("unsupported serialization of nil %T", v)
3341	}
3342
3343	if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 {
3344		return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")}
3345	}
3346	if v.FunctionDefinitionId != nil {
3347		if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil {
3348			return err
3349		}
3350	}
3351
3352	return nil
3353}
3354
3355type awsRestjson1_serializeOpGetFunctionDefinitionVersion struct {
3356}
3357
3358func (*awsRestjson1_serializeOpGetFunctionDefinitionVersion) ID() string {
3359	return "OperationSerializer"
3360}
3361
3362func (m *awsRestjson1_serializeOpGetFunctionDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3363	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3364) {
3365	request, ok := in.Request.(*smithyhttp.Request)
3366	if !ok {
3367		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3368	}
3369
3370	input, ok := in.Parameters.(*GetFunctionDefinitionVersionInput)
3371	_ = input
3372	if !ok {
3373		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3374	}
3375
3376	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}/versions/{FunctionDefinitionVersionId}")
3377	request.URL.Path = opPath
3378	if len(request.URL.RawQuery) > 0 {
3379		request.URL.RawQuery = "&" + opQuery
3380	} else {
3381		request.URL.RawQuery = opQuery
3382	}
3383
3384	request.Method = "GET"
3385	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3386	if err != nil {
3387		return out, metadata, &smithy.SerializationError{Err: err}
3388	}
3389
3390	if err := awsRestjson1_serializeOpHttpBindingsGetFunctionDefinitionVersionInput(input, restEncoder); err != nil {
3391		return out, metadata, &smithy.SerializationError{Err: err}
3392	}
3393
3394	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3395		return out, metadata, &smithy.SerializationError{Err: err}
3396	}
3397	in.Request = request
3398
3399	return next.HandleSerialize(ctx, in)
3400}
3401func awsRestjson1_serializeOpHttpBindingsGetFunctionDefinitionVersionInput(v *GetFunctionDefinitionVersionInput, encoder *httpbinding.Encoder) error {
3402	if v == nil {
3403		return fmt.Errorf("unsupported serialization of nil %T", v)
3404	}
3405
3406	if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 {
3407		return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")}
3408	}
3409	if v.FunctionDefinitionId != nil {
3410		if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil {
3411			return err
3412		}
3413	}
3414
3415	if v.FunctionDefinitionVersionId == nil || len(*v.FunctionDefinitionVersionId) == 0 {
3416		return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionVersionId must not be empty")}
3417	}
3418	if v.FunctionDefinitionVersionId != nil {
3419		if err := encoder.SetURI("FunctionDefinitionVersionId").String(*v.FunctionDefinitionVersionId); err != nil {
3420			return err
3421		}
3422	}
3423
3424	if v.NextToken != nil {
3425		encoder.SetQuery("NextToken").String(*v.NextToken)
3426	}
3427
3428	return nil
3429}
3430
3431type awsRestjson1_serializeOpGetGroup struct {
3432}
3433
3434func (*awsRestjson1_serializeOpGetGroup) ID() string {
3435	return "OperationSerializer"
3436}
3437
3438func (m *awsRestjson1_serializeOpGetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3439	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3440) {
3441	request, ok := in.Request.(*smithyhttp.Request)
3442	if !ok {
3443		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3444	}
3445
3446	input, ok := in.Parameters.(*GetGroupInput)
3447	_ = input
3448	if !ok {
3449		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3450	}
3451
3452	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}")
3453	request.URL.Path = opPath
3454	if len(request.URL.RawQuery) > 0 {
3455		request.URL.RawQuery = "&" + opQuery
3456	} else {
3457		request.URL.RawQuery = opQuery
3458	}
3459
3460	request.Method = "GET"
3461	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3462	if err != nil {
3463		return out, metadata, &smithy.SerializationError{Err: err}
3464	}
3465
3466	if err := awsRestjson1_serializeOpHttpBindingsGetGroupInput(input, restEncoder); err != nil {
3467		return out, metadata, &smithy.SerializationError{Err: err}
3468	}
3469
3470	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3471		return out, metadata, &smithy.SerializationError{Err: err}
3472	}
3473	in.Request = request
3474
3475	return next.HandleSerialize(ctx, in)
3476}
3477func awsRestjson1_serializeOpHttpBindingsGetGroupInput(v *GetGroupInput, encoder *httpbinding.Encoder) error {
3478	if v == nil {
3479		return fmt.Errorf("unsupported serialization of nil %T", v)
3480	}
3481
3482	if v.GroupId == nil || len(*v.GroupId) == 0 {
3483		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
3484	}
3485	if v.GroupId != nil {
3486		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
3487			return err
3488		}
3489	}
3490
3491	return nil
3492}
3493
3494type awsRestjson1_serializeOpGetGroupCertificateAuthority struct {
3495}
3496
3497func (*awsRestjson1_serializeOpGetGroupCertificateAuthority) ID() string {
3498	return "OperationSerializer"
3499}
3500
3501func (m *awsRestjson1_serializeOpGetGroupCertificateAuthority) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3502	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3503) {
3504	request, ok := in.Request.(*smithyhttp.Request)
3505	if !ok {
3506		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3507	}
3508
3509	input, ok := in.Parameters.(*GetGroupCertificateAuthorityInput)
3510	_ = input
3511	if !ok {
3512		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3513	}
3514
3515	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/certificateauthorities/{CertificateAuthorityId}")
3516	request.URL.Path = opPath
3517	if len(request.URL.RawQuery) > 0 {
3518		request.URL.RawQuery = "&" + opQuery
3519	} else {
3520		request.URL.RawQuery = opQuery
3521	}
3522
3523	request.Method = "GET"
3524	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3525	if err != nil {
3526		return out, metadata, &smithy.SerializationError{Err: err}
3527	}
3528
3529	if err := awsRestjson1_serializeOpHttpBindingsGetGroupCertificateAuthorityInput(input, restEncoder); err != nil {
3530		return out, metadata, &smithy.SerializationError{Err: err}
3531	}
3532
3533	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3534		return out, metadata, &smithy.SerializationError{Err: err}
3535	}
3536	in.Request = request
3537
3538	return next.HandleSerialize(ctx, in)
3539}
3540func awsRestjson1_serializeOpHttpBindingsGetGroupCertificateAuthorityInput(v *GetGroupCertificateAuthorityInput, encoder *httpbinding.Encoder) error {
3541	if v == nil {
3542		return fmt.Errorf("unsupported serialization of nil %T", v)
3543	}
3544
3545	if v.CertificateAuthorityId == nil || len(*v.CertificateAuthorityId) == 0 {
3546		return &smithy.SerializationError{Err: fmt.Errorf("input member CertificateAuthorityId must not be empty")}
3547	}
3548	if v.CertificateAuthorityId != nil {
3549		if err := encoder.SetURI("CertificateAuthorityId").String(*v.CertificateAuthorityId); err != nil {
3550			return err
3551		}
3552	}
3553
3554	if v.GroupId == nil || len(*v.GroupId) == 0 {
3555		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
3556	}
3557	if v.GroupId != nil {
3558		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
3559			return err
3560		}
3561	}
3562
3563	return nil
3564}
3565
3566type awsRestjson1_serializeOpGetGroupCertificateConfiguration struct {
3567}
3568
3569func (*awsRestjson1_serializeOpGetGroupCertificateConfiguration) ID() string {
3570	return "OperationSerializer"
3571}
3572
3573func (m *awsRestjson1_serializeOpGetGroupCertificateConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3574	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3575) {
3576	request, ok := in.Request.(*smithyhttp.Request)
3577	if !ok {
3578		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3579	}
3580
3581	input, ok := in.Parameters.(*GetGroupCertificateConfigurationInput)
3582	_ = input
3583	if !ok {
3584		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3585	}
3586
3587	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry")
3588	request.URL.Path = opPath
3589	if len(request.URL.RawQuery) > 0 {
3590		request.URL.RawQuery = "&" + opQuery
3591	} else {
3592		request.URL.RawQuery = opQuery
3593	}
3594
3595	request.Method = "GET"
3596	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3597	if err != nil {
3598		return out, metadata, &smithy.SerializationError{Err: err}
3599	}
3600
3601	if err := awsRestjson1_serializeOpHttpBindingsGetGroupCertificateConfigurationInput(input, restEncoder); err != nil {
3602		return out, metadata, &smithy.SerializationError{Err: err}
3603	}
3604
3605	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3606		return out, metadata, &smithy.SerializationError{Err: err}
3607	}
3608	in.Request = request
3609
3610	return next.HandleSerialize(ctx, in)
3611}
3612func awsRestjson1_serializeOpHttpBindingsGetGroupCertificateConfigurationInput(v *GetGroupCertificateConfigurationInput, encoder *httpbinding.Encoder) error {
3613	if v == nil {
3614		return fmt.Errorf("unsupported serialization of nil %T", v)
3615	}
3616
3617	if v.GroupId == nil || len(*v.GroupId) == 0 {
3618		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
3619	}
3620	if v.GroupId != nil {
3621		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
3622			return err
3623		}
3624	}
3625
3626	return nil
3627}
3628
3629type awsRestjson1_serializeOpGetGroupVersion struct {
3630}
3631
3632func (*awsRestjson1_serializeOpGetGroupVersion) ID() string {
3633	return "OperationSerializer"
3634}
3635
3636func (m *awsRestjson1_serializeOpGetGroupVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3637	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3638) {
3639	request, ok := in.Request.(*smithyhttp.Request)
3640	if !ok {
3641		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3642	}
3643
3644	input, ok := in.Parameters.(*GetGroupVersionInput)
3645	_ = input
3646	if !ok {
3647		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3648	}
3649
3650	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/versions/{GroupVersionId}")
3651	request.URL.Path = opPath
3652	if len(request.URL.RawQuery) > 0 {
3653		request.URL.RawQuery = "&" + opQuery
3654	} else {
3655		request.URL.RawQuery = opQuery
3656	}
3657
3658	request.Method = "GET"
3659	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3660	if err != nil {
3661		return out, metadata, &smithy.SerializationError{Err: err}
3662	}
3663
3664	if err := awsRestjson1_serializeOpHttpBindingsGetGroupVersionInput(input, restEncoder); err != nil {
3665		return out, metadata, &smithy.SerializationError{Err: err}
3666	}
3667
3668	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3669		return out, metadata, &smithy.SerializationError{Err: err}
3670	}
3671	in.Request = request
3672
3673	return next.HandleSerialize(ctx, in)
3674}
3675func awsRestjson1_serializeOpHttpBindingsGetGroupVersionInput(v *GetGroupVersionInput, encoder *httpbinding.Encoder) error {
3676	if v == nil {
3677		return fmt.Errorf("unsupported serialization of nil %T", v)
3678	}
3679
3680	if v.GroupId == nil || len(*v.GroupId) == 0 {
3681		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
3682	}
3683	if v.GroupId != nil {
3684		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
3685			return err
3686		}
3687	}
3688
3689	if v.GroupVersionId == nil || len(*v.GroupVersionId) == 0 {
3690		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupVersionId must not be empty")}
3691	}
3692	if v.GroupVersionId != nil {
3693		if err := encoder.SetURI("GroupVersionId").String(*v.GroupVersionId); err != nil {
3694			return err
3695		}
3696	}
3697
3698	return nil
3699}
3700
3701type awsRestjson1_serializeOpGetLoggerDefinition struct {
3702}
3703
3704func (*awsRestjson1_serializeOpGetLoggerDefinition) ID() string {
3705	return "OperationSerializer"
3706}
3707
3708func (m *awsRestjson1_serializeOpGetLoggerDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3709	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3710) {
3711	request, ok := in.Request.(*smithyhttp.Request)
3712	if !ok {
3713		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3714	}
3715
3716	input, ok := in.Parameters.(*GetLoggerDefinitionInput)
3717	_ = input
3718	if !ok {
3719		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3720	}
3721
3722	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}")
3723	request.URL.Path = opPath
3724	if len(request.URL.RawQuery) > 0 {
3725		request.URL.RawQuery = "&" + opQuery
3726	} else {
3727		request.URL.RawQuery = opQuery
3728	}
3729
3730	request.Method = "GET"
3731	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3732	if err != nil {
3733		return out, metadata, &smithy.SerializationError{Err: err}
3734	}
3735
3736	if err := awsRestjson1_serializeOpHttpBindingsGetLoggerDefinitionInput(input, restEncoder); err != nil {
3737		return out, metadata, &smithy.SerializationError{Err: err}
3738	}
3739
3740	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3741		return out, metadata, &smithy.SerializationError{Err: err}
3742	}
3743	in.Request = request
3744
3745	return next.HandleSerialize(ctx, in)
3746}
3747func awsRestjson1_serializeOpHttpBindingsGetLoggerDefinitionInput(v *GetLoggerDefinitionInput, encoder *httpbinding.Encoder) error {
3748	if v == nil {
3749		return fmt.Errorf("unsupported serialization of nil %T", v)
3750	}
3751
3752	if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 {
3753		return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")}
3754	}
3755	if v.LoggerDefinitionId != nil {
3756		if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil {
3757			return err
3758		}
3759	}
3760
3761	return nil
3762}
3763
3764type awsRestjson1_serializeOpGetLoggerDefinitionVersion struct {
3765}
3766
3767func (*awsRestjson1_serializeOpGetLoggerDefinitionVersion) ID() string {
3768	return "OperationSerializer"
3769}
3770
3771func (m *awsRestjson1_serializeOpGetLoggerDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3772	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3773) {
3774	request, ok := in.Request.(*smithyhttp.Request)
3775	if !ok {
3776		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3777	}
3778
3779	input, ok := in.Parameters.(*GetLoggerDefinitionVersionInput)
3780	_ = input
3781	if !ok {
3782		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3783	}
3784
3785	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}/versions/{LoggerDefinitionVersionId}")
3786	request.URL.Path = opPath
3787	if len(request.URL.RawQuery) > 0 {
3788		request.URL.RawQuery = "&" + opQuery
3789	} else {
3790		request.URL.RawQuery = opQuery
3791	}
3792
3793	request.Method = "GET"
3794	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3795	if err != nil {
3796		return out, metadata, &smithy.SerializationError{Err: err}
3797	}
3798
3799	if err := awsRestjson1_serializeOpHttpBindingsGetLoggerDefinitionVersionInput(input, restEncoder); err != nil {
3800		return out, metadata, &smithy.SerializationError{Err: err}
3801	}
3802
3803	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3804		return out, metadata, &smithy.SerializationError{Err: err}
3805	}
3806	in.Request = request
3807
3808	return next.HandleSerialize(ctx, in)
3809}
3810func awsRestjson1_serializeOpHttpBindingsGetLoggerDefinitionVersionInput(v *GetLoggerDefinitionVersionInput, encoder *httpbinding.Encoder) error {
3811	if v == nil {
3812		return fmt.Errorf("unsupported serialization of nil %T", v)
3813	}
3814
3815	if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 {
3816		return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")}
3817	}
3818	if v.LoggerDefinitionId != nil {
3819		if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil {
3820			return err
3821		}
3822	}
3823
3824	if v.LoggerDefinitionVersionId == nil || len(*v.LoggerDefinitionVersionId) == 0 {
3825		return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionVersionId must not be empty")}
3826	}
3827	if v.LoggerDefinitionVersionId != nil {
3828		if err := encoder.SetURI("LoggerDefinitionVersionId").String(*v.LoggerDefinitionVersionId); err != nil {
3829			return err
3830		}
3831	}
3832
3833	if v.NextToken != nil {
3834		encoder.SetQuery("NextToken").String(*v.NextToken)
3835	}
3836
3837	return nil
3838}
3839
3840type awsRestjson1_serializeOpGetResourceDefinition struct {
3841}
3842
3843func (*awsRestjson1_serializeOpGetResourceDefinition) ID() string {
3844	return "OperationSerializer"
3845}
3846
3847func (m *awsRestjson1_serializeOpGetResourceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3848	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3849) {
3850	request, ok := in.Request.(*smithyhttp.Request)
3851	if !ok {
3852		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3853	}
3854
3855	input, ok := in.Parameters.(*GetResourceDefinitionInput)
3856	_ = input
3857	if !ok {
3858		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3859	}
3860
3861	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}")
3862	request.URL.Path = opPath
3863	if len(request.URL.RawQuery) > 0 {
3864		request.URL.RawQuery = "&" + opQuery
3865	} else {
3866		request.URL.RawQuery = opQuery
3867	}
3868
3869	request.Method = "GET"
3870	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3871	if err != nil {
3872		return out, metadata, &smithy.SerializationError{Err: err}
3873	}
3874
3875	if err := awsRestjson1_serializeOpHttpBindingsGetResourceDefinitionInput(input, restEncoder); err != nil {
3876		return out, metadata, &smithy.SerializationError{Err: err}
3877	}
3878
3879	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3880		return out, metadata, &smithy.SerializationError{Err: err}
3881	}
3882	in.Request = request
3883
3884	return next.HandleSerialize(ctx, in)
3885}
3886func awsRestjson1_serializeOpHttpBindingsGetResourceDefinitionInput(v *GetResourceDefinitionInput, encoder *httpbinding.Encoder) error {
3887	if v == nil {
3888		return fmt.Errorf("unsupported serialization of nil %T", v)
3889	}
3890
3891	if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 {
3892		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")}
3893	}
3894	if v.ResourceDefinitionId != nil {
3895		if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil {
3896			return err
3897		}
3898	}
3899
3900	return nil
3901}
3902
3903type awsRestjson1_serializeOpGetResourceDefinitionVersion struct {
3904}
3905
3906func (*awsRestjson1_serializeOpGetResourceDefinitionVersion) ID() string {
3907	return "OperationSerializer"
3908}
3909
3910func (m *awsRestjson1_serializeOpGetResourceDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3911	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3912) {
3913	request, ok := in.Request.(*smithyhttp.Request)
3914	if !ok {
3915		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3916	}
3917
3918	input, ok := in.Parameters.(*GetResourceDefinitionVersionInput)
3919	_ = input
3920	if !ok {
3921		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3922	}
3923
3924	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}/versions/{ResourceDefinitionVersionId}")
3925	request.URL.Path = opPath
3926	if len(request.URL.RawQuery) > 0 {
3927		request.URL.RawQuery = "&" + opQuery
3928	} else {
3929		request.URL.RawQuery = opQuery
3930	}
3931
3932	request.Method = "GET"
3933	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3934	if err != nil {
3935		return out, metadata, &smithy.SerializationError{Err: err}
3936	}
3937
3938	if err := awsRestjson1_serializeOpHttpBindingsGetResourceDefinitionVersionInput(input, restEncoder); err != nil {
3939		return out, metadata, &smithy.SerializationError{Err: err}
3940	}
3941
3942	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3943		return out, metadata, &smithy.SerializationError{Err: err}
3944	}
3945	in.Request = request
3946
3947	return next.HandleSerialize(ctx, in)
3948}
3949func awsRestjson1_serializeOpHttpBindingsGetResourceDefinitionVersionInput(v *GetResourceDefinitionVersionInput, encoder *httpbinding.Encoder) error {
3950	if v == nil {
3951		return fmt.Errorf("unsupported serialization of nil %T", v)
3952	}
3953
3954	if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 {
3955		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")}
3956	}
3957	if v.ResourceDefinitionId != nil {
3958		if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil {
3959			return err
3960		}
3961	}
3962
3963	if v.ResourceDefinitionVersionId == nil || len(*v.ResourceDefinitionVersionId) == 0 {
3964		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionVersionId must not be empty")}
3965	}
3966	if v.ResourceDefinitionVersionId != nil {
3967		if err := encoder.SetURI("ResourceDefinitionVersionId").String(*v.ResourceDefinitionVersionId); err != nil {
3968			return err
3969		}
3970	}
3971
3972	return nil
3973}
3974
3975type awsRestjson1_serializeOpGetServiceRoleForAccount struct {
3976}
3977
3978func (*awsRestjson1_serializeOpGetServiceRoleForAccount) ID() string {
3979	return "OperationSerializer"
3980}
3981
3982func (m *awsRestjson1_serializeOpGetServiceRoleForAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3983	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3984) {
3985	request, ok := in.Request.(*smithyhttp.Request)
3986	if !ok {
3987		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3988	}
3989
3990	input, ok := in.Parameters.(*GetServiceRoleForAccountInput)
3991	_ = input
3992	if !ok {
3993		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3994	}
3995
3996	opPath, opQuery := httpbinding.SplitURI("/greengrass/servicerole")
3997	request.URL.Path = opPath
3998	if len(request.URL.RawQuery) > 0 {
3999		request.URL.RawQuery = "&" + opQuery
4000	} else {
4001		request.URL.RawQuery = opQuery
4002	}
4003
4004	request.Method = "GET"
4005	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4006	if err != nil {
4007		return out, metadata, &smithy.SerializationError{Err: err}
4008	}
4009
4010	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4011		return out, metadata, &smithy.SerializationError{Err: err}
4012	}
4013	in.Request = request
4014
4015	return next.HandleSerialize(ctx, in)
4016}
4017func awsRestjson1_serializeOpHttpBindingsGetServiceRoleForAccountInput(v *GetServiceRoleForAccountInput, encoder *httpbinding.Encoder) error {
4018	if v == nil {
4019		return fmt.Errorf("unsupported serialization of nil %T", v)
4020	}
4021
4022	return nil
4023}
4024
4025type awsRestjson1_serializeOpGetSubscriptionDefinition struct {
4026}
4027
4028func (*awsRestjson1_serializeOpGetSubscriptionDefinition) ID() string {
4029	return "OperationSerializer"
4030}
4031
4032func (m *awsRestjson1_serializeOpGetSubscriptionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4033	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4034) {
4035	request, ok := in.Request.(*smithyhttp.Request)
4036	if !ok {
4037		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4038	}
4039
4040	input, ok := in.Parameters.(*GetSubscriptionDefinitionInput)
4041	_ = input
4042	if !ok {
4043		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4044	}
4045
4046	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}")
4047	request.URL.Path = opPath
4048	if len(request.URL.RawQuery) > 0 {
4049		request.URL.RawQuery = "&" + opQuery
4050	} else {
4051		request.URL.RawQuery = opQuery
4052	}
4053
4054	request.Method = "GET"
4055	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4056	if err != nil {
4057		return out, metadata, &smithy.SerializationError{Err: err}
4058	}
4059
4060	if err := awsRestjson1_serializeOpHttpBindingsGetSubscriptionDefinitionInput(input, restEncoder); err != nil {
4061		return out, metadata, &smithy.SerializationError{Err: err}
4062	}
4063
4064	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4065		return out, metadata, &smithy.SerializationError{Err: err}
4066	}
4067	in.Request = request
4068
4069	return next.HandleSerialize(ctx, in)
4070}
4071func awsRestjson1_serializeOpHttpBindingsGetSubscriptionDefinitionInput(v *GetSubscriptionDefinitionInput, encoder *httpbinding.Encoder) error {
4072	if v == nil {
4073		return fmt.Errorf("unsupported serialization of nil %T", v)
4074	}
4075
4076	if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 {
4077		return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")}
4078	}
4079	if v.SubscriptionDefinitionId != nil {
4080		if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil {
4081			return err
4082		}
4083	}
4084
4085	return nil
4086}
4087
4088type awsRestjson1_serializeOpGetSubscriptionDefinitionVersion struct {
4089}
4090
4091func (*awsRestjson1_serializeOpGetSubscriptionDefinitionVersion) ID() string {
4092	return "OperationSerializer"
4093}
4094
4095func (m *awsRestjson1_serializeOpGetSubscriptionDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4096	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4097) {
4098	request, ok := in.Request.(*smithyhttp.Request)
4099	if !ok {
4100		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4101	}
4102
4103	input, ok := in.Parameters.(*GetSubscriptionDefinitionVersionInput)
4104	_ = input
4105	if !ok {
4106		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4107	}
4108
4109	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions/{SubscriptionDefinitionVersionId}")
4110	request.URL.Path = opPath
4111	if len(request.URL.RawQuery) > 0 {
4112		request.URL.RawQuery = "&" + opQuery
4113	} else {
4114		request.URL.RawQuery = opQuery
4115	}
4116
4117	request.Method = "GET"
4118	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4119	if err != nil {
4120		return out, metadata, &smithy.SerializationError{Err: err}
4121	}
4122
4123	if err := awsRestjson1_serializeOpHttpBindingsGetSubscriptionDefinitionVersionInput(input, restEncoder); err != nil {
4124		return out, metadata, &smithy.SerializationError{Err: err}
4125	}
4126
4127	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4128		return out, metadata, &smithy.SerializationError{Err: err}
4129	}
4130	in.Request = request
4131
4132	return next.HandleSerialize(ctx, in)
4133}
4134func awsRestjson1_serializeOpHttpBindingsGetSubscriptionDefinitionVersionInput(v *GetSubscriptionDefinitionVersionInput, encoder *httpbinding.Encoder) error {
4135	if v == nil {
4136		return fmt.Errorf("unsupported serialization of nil %T", v)
4137	}
4138
4139	if v.NextToken != nil {
4140		encoder.SetQuery("NextToken").String(*v.NextToken)
4141	}
4142
4143	if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 {
4144		return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")}
4145	}
4146	if v.SubscriptionDefinitionId != nil {
4147		if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil {
4148			return err
4149		}
4150	}
4151
4152	if v.SubscriptionDefinitionVersionId == nil || len(*v.SubscriptionDefinitionVersionId) == 0 {
4153		return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionVersionId must not be empty")}
4154	}
4155	if v.SubscriptionDefinitionVersionId != nil {
4156		if err := encoder.SetURI("SubscriptionDefinitionVersionId").String(*v.SubscriptionDefinitionVersionId); err != nil {
4157			return err
4158		}
4159	}
4160
4161	return nil
4162}
4163
4164type awsRestjson1_serializeOpGetThingRuntimeConfiguration struct {
4165}
4166
4167func (*awsRestjson1_serializeOpGetThingRuntimeConfiguration) ID() string {
4168	return "OperationSerializer"
4169}
4170
4171func (m *awsRestjson1_serializeOpGetThingRuntimeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4172	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4173) {
4174	request, ok := in.Request.(*smithyhttp.Request)
4175	if !ok {
4176		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4177	}
4178
4179	input, ok := in.Parameters.(*GetThingRuntimeConfigurationInput)
4180	_ = input
4181	if !ok {
4182		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4183	}
4184
4185	opPath, opQuery := httpbinding.SplitURI("/greengrass/things/{ThingName}/runtimeconfig")
4186	request.URL.Path = opPath
4187	if len(request.URL.RawQuery) > 0 {
4188		request.URL.RawQuery = "&" + opQuery
4189	} else {
4190		request.URL.RawQuery = opQuery
4191	}
4192
4193	request.Method = "GET"
4194	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4195	if err != nil {
4196		return out, metadata, &smithy.SerializationError{Err: err}
4197	}
4198
4199	if err := awsRestjson1_serializeOpHttpBindingsGetThingRuntimeConfigurationInput(input, restEncoder); err != nil {
4200		return out, metadata, &smithy.SerializationError{Err: err}
4201	}
4202
4203	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4204		return out, metadata, &smithy.SerializationError{Err: err}
4205	}
4206	in.Request = request
4207
4208	return next.HandleSerialize(ctx, in)
4209}
4210func awsRestjson1_serializeOpHttpBindingsGetThingRuntimeConfigurationInput(v *GetThingRuntimeConfigurationInput, encoder *httpbinding.Encoder) error {
4211	if v == nil {
4212		return fmt.Errorf("unsupported serialization of nil %T", v)
4213	}
4214
4215	if v.ThingName == nil || len(*v.ThingName) == 0 {
4216		return &smithy.SerializationError{Err: fmt.Errorf("input member ThingName must not be empty")}
4217	}
4218	if v.ThingName != nil {
4219		if err := encoder.SetURI("ThingName").String(*v.ThingName); err != nil {
4220			return err
4221		}
4222	}
4223
4224	return nil
4225}
4226
4227type awsRestjson1_serializeOpListBulkDeploymentDetailedReports struct {
4228}
4229
4230func (*awsRestjson1_serializeOpListBulkDeploymentDetailedReports) ID() string {
4231	return "OperationSerializer"
4232}
4233
4234func (m *awsRestjson1_serializeOpListBulkDeploymentDetailedReports) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4235	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4236) {
4237	request, ok := in.Request.(*smithyhttp.Request)
4238	if !ok {
4239		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4240	}
4241
4242	input, ok := in.Parameters.(*ListBulkDeploymentDetailedReportsInput)
4243	_ = input
4244	if !ok {
4245		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4246	}
4247
4248	opPath, opQuery := httpbinding.SplitURI("/greengrass/bulk/deployments/{BulkDeploymentId}/detailed-reports")
4249	request.URL.Path = opPath
4250	if len(request.URL.RawQuery) > 0 {
4251		request.URL.RawQuery = "&" + opQuery
4252	} else {
4253		request.URL.RawQuery = opQuery
4254	}
4255
4256	request.Method = "GET"
4257	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4258	if err != nil {
4259		return out, metadata, &smithy.SerializationError{Err: err}
4260	}
4261
4262	if err := awsRestjson1_serializeOpHttpBindingsListBulkDeploymentDetailedReportsInput(input, restEncoder); err != nil {
4263		return out, metadata, &smithy.SerializationError{Err: err}
4264	}
4265
4266	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4267		return out, metadata, &smithy.SerializationError{Err: err}
4268	}
4269	in.Request = request
4270
4271	return next.HandleSerialize(ctx, in)
4272}
4273func awsRestjson1_serializeOpHttpBindingsListBulkDeploymentDetailedReportsInput(v *ListBulkDeploymentDetailedReportsInput, encoder *httpbinding.Encoder) error {
4274	if v == nil {
4275		return fmt.Errorf("unsupported serialization of nil %T", v)
4276	}
4277
4278	if v.BulkDeploymentId == nil || len(*v.BulkDeploymentId) == 0 {
4279		return &smithy.SerializationError{Err: fmt.Errorf("input member BulkDeploymentId must not be empty")}
4280	}
4281	if v.BulkDeploymentId != nil {
4282		if err := encoder.SetURI("BulkDeploymentId").String(*v.BulkDeploymentId); err != nil {
4283			return err
4284		}
4285	}
4286
4287	if v.MaxResults != nil {
4288		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4289	}
4290
4291	if v.NextToken != nil {
4292		encoder.SetQuery("NextToken").String(*v.NextToken)
4293	}
4294
4295	return nil
4296}
4297
4298type awsRestjson1_serializeOpListBulkDeployments struct {
4299}
4300
4301func (*awsRestjson1_serializeOpListBulkDeployments) ID() string {
4302	return "OperationSerializer"
4303}
4304
4305func (m *awsRestjson1_serializeOpListBulkDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4306	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4307) {
4308	request, ok := in.Request.(*smithyhttp.Request)
4309	if !ok {
4310		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4311	}
4312
4313	input, ok := in.Parameters.(*ListBulkDeploymentsInput)
4314	_ = input
4315	if !ok {
4316		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4317	}
4318
4319	opPath, opQuery := httpbinding.SplitURI("/greengrass/bulk/deployments")
4320	request.URL.Path = opPath
4321	if len(request.URL.RawQuery) > 0 {
4322		request.URL.RawQuery = "&" + opQuery
4323	} else {
4324		request.URL.RawQuery = opQuery
4325	}
4326
4327	request.Method = "GET"
4328	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4329	if err != nil {
4330		return out, metadata, &smithy.SerializationError{Err: err}
4331	}
4332
4333	if err := awsRestjson1_serializeOpHttpBindingsListBulkDeploymentsInput(input, restEncoder); err != nil {
4334		return out, metadata, &smithy.SerializationError{Err: err}
4335	}
4336
4337	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4338		return out, metadata, &smithy.SerializationError{Err: err}
4339	}
4340	in.Request = request
4341
4342	return next.HandleSerialize(ctx, in)
4343}
4344func awsRestjson1_serializeOpHttpBindingsListBulkDeploymentsInput(v *ListBulkDeploymentsInput, encoder *httpbinding.Encoder) error {
4345	if v == nil {
4346		return fmt.Errorf("unsupported serialization of nil %T", v)
4347	}
4348
4349	if v.MaxResults != nil {
4350		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4351	}
4352
4353	if v.NextToken != nil {
4354		encoder.SetQuery("NextToken").String(*v.NextToken)
4355	}
4356
4357	return nil
4358}
4359
4360type awsRestjson1_serializeOpListConnectorDefinitions struct {
4361}
4362
4363func (*awsRestjson1_serializeOpListConnectorDefinitions) ID() string {
4364	return "OperationSerializer"
4365}
4366
4367func (m *awsRestjson1_serializeOpListConnectorDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4368	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4369) {
4370	request, ok := in.Request.(*smithyhttp.Request)
4371	if !ok {
4372		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4373	}
4374
4375	input, ok := in.Parameters.(*ListConnectorDefinitionsInput)
4376	_ = input
4377	if !ok {
4378		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4379	}
4380
4381	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors")
4382	request.URL.Path = opPath
4383	if len(request.URL.RawQuery) > 0 {
4384		request.URL.RawQuery = "&" + opQuery
4385	} else {
4386		request.URL.RawQuery = opQuery
4387	}
4388
4389	request.Method = "GET"
4390	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4391	if err != nil {
4392		return out, metadata, &smithy.SerializationError{Err: err}
4393	}
4394
4395	if err := awsRestjson1_serializeOpHttpBindingsListConnectorDefinitionsInput(input, restEncoder); err != nil {
4396		return out, metadata, &smithy.SerializationError{Err: err}
4397	}
4398
4399	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4400		return out, metadata, &smithy.SerializationError{Err: err}
4401	}
4402	in.Request = request
4403
4404	return next.HandleSerialize(ctx, in)
4405}
4406func awsRestjson1_serializeOpHttpBindingsListConnectorDefinitionsInput(v *ListConnectorDefinitionsInput, encoder *httpbinding.Encoder) error {
4407	if v == nil {
4408		return fmt.Errorf("unsupported serialization of nil %T", v)
4409	}
4410
4411	if v.MaxResults != nil {
4412		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4413	}
4414
4415	if v.NextToken != nil {
4416		encoder.SetQuery("NextToken").String(*v.NextToken)
4417	}
4418
4419	return nil
4420}
4421
4422type awsRestjson1_serializeOpListConnectorDefinitionVersions struct {
4423}
4424
4425func (*awsRestjson1_serializeOpListConnectorDefinitionVersions) ID() string {
4426	return "OperationSerializer"
4427}
4428
4429func (m *awsRestjson1_serializeOpListConnectorDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4430	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4431) {
4432	request, ok := in.Request.(*smithyhttp.Request)
4433	if !ok {
4434		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4435	}
4436
4437	input, ok := in.Parameters.(*ListConnectorDefinitionVersionsInput)
4438	_ = input
4439	if !ok {
4440		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4441	}
4442
4443	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}/versions")
4444	request.URL.Path = opPath
4445	if len(request.URL.RawQuery) > 0 {
4446		request.URL.RawQuery = "&" + opQuery
4447	} else {
4448		request.URL.RawQuery = opQuery
4449	}
4450
4451	request.Method = "GET"
4452	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4453	if err != nil {
4454		return out, metadata, &smithy.SerializationError{Err: err}
4455	}
4456
4457	if err := awsRestjson1_serializeOpHttpBindingsListConnectorDefinitionVersionsInput(input, restEncoder); err != nil {
4458		return out, metadata, &smithy.SerializationError{Err: err}
4459	}
4460
4461	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4462		return out, metadata, &smithy.SerializationError{Err: err}
4463	}
4464	in.Request = request
4465
4466	return next.HandleSerialize(ctx, in)
4467}
4468func awsRestjson1_serializeOpHttpBindingsListConnectorDefinitionVersionsInput(v *ListConnectorDefinitionVersionsInput, encoder *httpbinding.Encoder) error {
4469	if v == nil {
4470		return fmt.Errorf("unsupported serialization of nil %T", v)
4471	}
4472
4473	if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 {
4474		return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")}
4475	}
4476	if v.ConnectorDefinitionId != nil {
4477		if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil {
4478			return err
4479		}
4480	}
4481
4482	if v.MaxResults != nil {
4483		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4484	}
4485
4486	if v.NextToken != nil {
4487		encoder.SetQuery("NextToken").String(*v.NextToken)
4488	}
4489
4490	return nil
4491}
4492
4493type awsRestjson1_serializeOpListCoreDefinitions struct {
4494}
4495
4496func (*awsRestjson1_serializeOpListCoreDefinitions) ID() string {
4497	return "OperationSerializer"
4498}
4499
4500func (m *awsRestjson1_serializeOpListCoreDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4501	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4502) {
4503	request, ok := in.Request.(*smithyhttp.Request)
4504	if !ok {
4505		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4506	}
4507
4508	input, ok := in.Parameters.(*ListCoreDefinitionsInput)
4509	_ = input
4510	if !ok {
4511		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4512	}
4513
4514	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores")
4515	request.URL.Path = opPath
4516	if len(request.URL.RawQuery) > 0 {
4517		request.URL.RawQuery = "&" + opQuery
4518	} else {
4519		request.URL.RawQuery = opQuery
4520	}
4521
4522	request.Method = "GET"
4523	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4524	if err != nil {
4525		return out, metadata, &smithy.SerializationError{Err: err}
4526	}
4527
4528	if err := awsRestjson1_serializeOpHttpBindingsListCoreDefinitionsInput(input, restEncoder); err != nil {
4529		return out, metadata, &smithy.SerializationError{Err: err}
4530	}
4531
4532	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4533		return out, metadata, &smithy.SerializationError{Err: err}
4534	}
4535	in.Request = request
4536
4537	return next.HandleSerialize(ctx, in)
4538}
4539func awsRestjson1_serializeOpHttpBindingsListCoreDefinitionsInput(v *ListCoreDefinitionsInput, encoder *httpbinding.Encoder) error {
4540	if v == nil {
4541		return fmt.Errorf("unsupported serialization of nil %T", v)
4542	}
4543
4544	if v.MaxResults != nil {
4545		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4546	}
4547
4548	if v.NextToken != nil {
4549		encoder.SetQuery("NextToken").String(*v.NextToken)
4550	}
4551
4552	return nil
4553}
4554
4555type awsRestjson1_serializeOpListCoreDefinitionVersions struct {
4556}
4557
4558func (*awsRestjson1_serializeOpListCoreDefinitionVersions) ID() string {
4559	return "OperationSerializer"
4560}
4561
4562func (m *awsRestjson1_serializeOpListCoreDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4563	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4564) {
4565	request, ok := in.Request.(*smithyhttp.Request)
4566	if !ok {
4567		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4568	}
4569
4570	input, ok := in.Parameters.(*ListCoreDefinitionVersionsInput)
4571	_ = input
4572	if !ok {
4573		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4574	}
4575
4576	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}/versions")
4577	request.URL.Path = opPath
4578	if len(request.URL.RawQuery) > 0 {
4579		request.URL.RawQuery = "&" + opQuery
4580	} else {
4581		request.URL.RawQuery = opQuery
4582	}
4583
4584	request.Method = "GET"
4585	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4586	if err != nil {
4587		return out, metadata, &smithy.SerializationError{Err: err}
4588	}
4589
4590	if err := awsRestjson1_serializeOpHttpBindingsListCoreDefinitionVersionsInput(input, restEncoder); err != nil {
4591		return out, metadata, &smithy.SerializationError{Err: err}
4592	}
4593
4594	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4595		return out, metadata, &smithy.SerializationError{Err: err}
4596	}
4597	in.Request = request
4598
4599	return next.HandleSerialize(ctx, in)
4600}
4601func awsRestjson1_serializeOpHttpBindingsListCoreDefinitionVersionsInput(v *ListCoreDefinitionVersionsInput, encoder *httpbinding.Encoder) error {
4602	if v == nil {
4603		return fmt.Errorf("unsupported serialization of nil %T", v)
4604	}
4605
4606	if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 {
4607		return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")}
4608	}
4609	if v.CoreDefinitionId != nil {
4610		if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil {
4611			return err
4612		}
4613	}
4614
4615	if v.MaxResults != nil {
4616		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4617	}
4618
4619	if v.NextToken != nil {
4620		encoder.SetQuery("NextToken").String(*v.NextToken)
4621	}
4622
4623	return nil
4624}
4625
4626type awsRestjson1_serializeOpListDeployments struct {
4627}
4628
4629func (*awsRestjson1_serializeOpListDeployments) ID() string {
4630	return "OperationSerializer"
4631}
4632
4633func (m *awsRestjson1_serializeOpListDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4634	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4635) {
4636	request, ok := in.Request.(*smithyhttp.Request)
4637	if !ok {
4638		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4639	}
4640
4641	input, ok := in.Parameters.(*ListDeploymentsInput)
4642	_ = input
4643	if !ok {
4644		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4645	}
4646
4647	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/deployments")
4648	request.URL.Path = opPath
4649	if len(request.URL.RawQuery) > 0 {
4650		request.URL.RawQuery = "&" + opQuery
4651	} else {
4652		request.URL.RawQuery = opQuery
4653	}
4654
4655	request.Method = "GET"
4656	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4657	if err != nil {
4658		return out, metadata, &smithy.SerializationError{Err: err}
4659	}
4660
4661	if err := awsRestjson1_serializeOpHttpBindingsListDeploymentsInput(input, restEncoder); err != nil {
4662		return out, metadata, &smithy.SerializationError{Err: err}
4663	}
4664
4665	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4666		return out, metadata, &smithy.SerializationError{Err: err}
4667	}
4668	in.Request = request
4669
4670	return next.HandleSerialize(ctx, in)
4671}
4672func awsRestjson1_serializeOpHttpBindingsListDeploymentsInput(v *ListDeploymentsInput, encoder *httpbinding.Encoder) error {
4673	if v == nil {
4674		return fmt.Errorf("unsupported serialization of nil %T", v)
4675	}
4676
4677	if v.GroupId == nil || len(*v.GroupId) == 0 {
4678		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
4679	}
4680	if v.GroupId != nil {
4681		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
4682			return err
4683		}
4684	}
4685
4686	if v.MaxResults != nil {
4687		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4688	}
4689
4690	if v.NextToken != nil {
4691		encoder.SetQuery("NextToken").String(*v.NextToken)
4692	}
4693
4694	return nil
4695}
4696
4697type awsRestjson1_serializeOpListDeviceDefinitions struct {
4698}
4699
4700func (*awsRestjson1_serializeOpListDeviceDefinitions) ID() string {
4701	return "OperationSerializer"
4702}
4703
4704func (m *awsRestjson1_serializeOpListDeviceDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4705	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4706) {
4707	request, ok := in.Request.(*smithyhttp.Request)
4708	if !ok {
4709		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4710	}
4711
4712	input, ok := in.Parameters.(*ListDeviceDefinitionsInput)
4713	_ = input
4714	if !ok {
4715		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4716	}
4717
4718	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices")
4719	request.URL.Path = opPath
4720	if len(request.URL.RawQuery) > 0 {
4721		request.URL.RawQuery = "&" + opQuery
4722	} else {
4723		request.URL.RawQuery = opQuery
4724	}
4725
4726	request.Method = "GET"
4727	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4728	if err != nil {
4729		return out, metadata, &smithy.SerializationError{Err: err}
4730	}
4731
4732	if err := awsRestjson1_serializeOpHttpBindingsListDeviceDefinitionsInput(input, restEncoder); err != nil {
4733		return out, metadata, &smithy.SerializationError{Err: err}
4734	}
4735
4736	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4737		return out, metadata, &smithy.SerializationError{Err: err}
4738	}
4739	in.Request = request
4740
4741	return next.HandleSerialize(ctx, in)
4742}
4743func awsRestjson1_serializeOpHttpBindingsListDeviceDefinitionsInput(v *ListDeviceDefinitionsInput, encoder *httpbinding.Encoder) error {
4744	if v == nil {
4745		return fmt.Errorf("unsupported serialization of nil %T", v)
4746	}
4747
4748	if v.MaxResults != nil {
4749		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4750	}
4751
4752	if v.NextToken != nil {
4753		encoder.SetQuery("NextToken").String(*v.NextToken)
4754	}
4755
4756	return nil
4757}
4758
4759type awsRestjson1_serializeOpListDeviceDefinitionVersions struct {
4760}
4761
4762func (*awsRestjson1_serializeOpListDeviceDefinitionVersions) ID() string {
4763	return "OperationSerializer"
4764}
4765
4766func (m *awsRestjson1_serializeOpListDeviceDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4767	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4768) {
4769	request, ok := in.Request.(*smithyhttp.Request)
4770	if !ok {
4771		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4772	}
4773
4774	input, ok := in.Parameters.(*ListDeviceDefinitionVersionsInput)
4775	_ = input
4776	if !ok {
4777		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4778	}
4779
4780	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}/versions")
4781	request.URL.Path = opPath
4782	if len(request.URL.RawQuery) > 0 {
4783		request.URL.RawQuery = "&" + opQuery
4784	} else {
4785		request.URL.RawQuery = opQuery
4786	}
4787
4788	request.Method = "GET"
4789	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4790	if err != nil {
4791		return out, metadata, &smithy.SerializationError{Err: err}
4792	}
4793
4794	if err := awsRestjson1_serializeOpHttpBindingsListDeviceDefinitionVersionsInput(input, restEncoder); err != nil {
4795		return out, metadata, &smithy.SerializationError{Err: err}
4796	}
4797
4798	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4799		return out, metadata, &smithy.SerializationError{Err: err}
4800	}
4801	in.Request = request
4802
4803	return next.HandleSerialize(ctx, in)
4804}
4805func awsRestjson1_serializeOpHttpBindingsListDeviceDefinitionVersionsInput(v *ListDeviceDefinitionVersionsInput, encoder *httpbinding.Encoder) error {
4806	if v == nil {
4807		return fmt.Errorf("unsupported serialization of nil %T", v)
4808	}
4809
4810	if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 {
4811		return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")}
4812	}
4813	if v.DeviceDefinitionId != nil {
4814		if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil {
4815			return err
4816		}
4817	}
4818
4819	if v.MaxResults != nil {
4820		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4821	}
4822
4823	if v.NextToken != nil {
4824		encoder.SetQuery("NextToken").String(*v.NextToken)
4825	}
4826
4827	return nil
4828}
4829
4830type awsRestjson1_serializeOpListFunctionDefinitions struct {
4831}
4832
4833func (*awsRestjson1_serializeOpListFunctionDefinitions) ID() string {
4834	return "OperationSerializer"
4835}
4836
4837func (m *awsRestjson1_serializeOpListFunctionDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4838	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4839) {
4840	request, ok := in.Request.(*smithyhttp.Request)
4841	if !ok {
4842		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4843	}
4844
4845	input, ok := in.Parameters.(*ListFunctionDefinitionsInput)
4846	_ = input
4847	if !ok {
4848		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4849	}
4850
4851	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions")
4852	request.URL.Path = opPath
4853	if len(request.URL.RawQuery) > 0 {
4854		request.URL.RawQuery = "&" + opQuery
4855	} else {
4856		request.URL.RawQuery = opQuery
4857	}
4858
4859	request.Method = "GET"
4860	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4861	if err != nil {
4862		return out, metadata, &smithy.SerializationError{Err: err}
4863	}
4864
4865	if err := awsRestjson1_serializeOpHttpBindingsListFunctionDefinitionsInput(input, restEncoder); err != nil {
4866		return out, metadata, &smithy.SerializationError{Err: err}
4867	}
4868
4869	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4870		return out, metadata, &smithy.SerializationError{Err: err}
4871	}
4872	in.Request = request
4873
4874	return next.HandleSerialize(ctx, in)
4875}
4876func awsRestjson1_serializeOpHttpBindingsListFunctionDefinitionsInput(v *ListFunctionDefinitionsInput, encoder *httpbinding.Encoder) error {
4877	if v == nil {
4878		return fmt.Errorf("unsupported serialization of nil %T", v)
4879	}
4880
4881	if v.MaxResults != nil {
4882		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4883	}
4884
4885	if v.NextToken != nil {
4886		encoder.SetQuery("NextToken").String(*v.NextToken)
4887	}
4888
4889	return nil
4890}
4891
4892type awsRestjson1_serializeOpListFunctionDefinitionVersions struct {
4893}
4894
4895func (*awsRestjson1_serializeOpListFunctionDefinitionVersions) ID() string {
4896	return "OperationSerializer"
4897}
4898
4899func (m *awsRestjson1_serializeOpListFunctionDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4900	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4901) {
4902	request, ok := in.Request.(*smithyhttp.Request)
4903	if !ok {
4904		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4905	}
4906
4907	input, ok := in.Parameters.(*ListFunctionDefinitionVersionsInput)
4908	_ = input
4909	if !ok {
4910		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4911	}
4912
4913	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}/versions")
4914	request.URL.Path = opPath
4915	if len(request.URL.RawQuery) > 0 {
4916		request.URL.RawQuery = "&" + opQuery
4917	} else {
4918		request.URL.RawQuery = opQuery
4919	}
4920
4921	request.Method = "GET"
4922	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4923	if err != nil {
4924		return out, metadata, &smithy.SerializationError{Err: err}
4925	}
4926
4927	if err := awsRestjson1_serializeOpHttpBindingsListFunctionDefinitionVersionsInput(input, restEncoder); err != nil {
4928		return out, metadata, &smithy.SerializationError{Err: err}
4929	}
4930
4931	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4932		return out, metadata, &smithy.SerializationError{Err: err}
4933	}
4934	in.Request = request
4935
4936	return next.HandleSerialize(ctx, in)
4937}
4938func awsRestjson1_serializeOpHttpBindingsListFunctionDefinitionVersionsInput(v *ListFunctionDefinitionVersionsInput, encoder *httpbinding.Encoder) error {
4939	if v == nil {
4940		return fmt.Errorf("unsupported serialization of nil %T", v)
4941	}
4942
4943	if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 {
4944		return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")}
4945	}
4946	if v.FunctionDefinitionId != nil {
4947		if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil {
4948			return err
4949		}
4950	}
4951
4952	if v.MaxResults != nil {
4953		encoder.SetQuery("MaxResults").String(*v.MaxResults)
4954	}
4955
4956	if v.NextToken != nil {
4957		encoder.SetQuery("NextToken").String(*v.NextToken)
4958	}
4959
4960	return nil
4961}
4962
4963type awsRestjson1_serializeOpListGroupCertificateAuthorities struct {
4964}
4965
4966func (*awsRestjson1_serializeOpListGroupCertificateAuthorities) ID() string {
4967	return "OperationSerializer"
4968}
4969
4970func (m *awsRestjson1_serializeOpListGroupCertificateAuthorities) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4971	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4972) {
4973	request, ok := in.Request.(*smithyhttp.Request)
4974	if !ok {
4975		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4976	}
4977
4978	input, ok := in.Parameters.(*ListGroupCertificateAuthoritiesInput)
4979	_ = input
4980	if !ok {
4981		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4982	}
4983
4984	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/certificateauthorities")
4985	request.URL.Path = opPath
4986	if len(request.URL.RawQuery) > 0 {
4987		request.URL.RawQuery = "&" + opQuery
4988	} else {
4989		request.URL.RawQuery = opQuery
4990	}
4991
4992	request.Method = "GET"
4993	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4994	if err != nil {
4995		return out, metadata, &smithy.SerializationError{Err: err}
4996	}
4997
4998	if err := awsRestjson1_serializeOpHttpBindingsListGroupCertificateAuthoritiesInput(input, restEncoder); err != nil {
4999		return out, metadata, &smithy.SerializationError{Err: err}
5000	}
5001
5002	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5003		return out, metadata, &smithy.SerializationError{Err: err}
5004	}
5005	in.Request = request
5006
5007	return next.HandleSerialize(ctx, in)
5008}
5009func awsRestjson1_serializeOpHttpBindingsListGroupCertificateAuthoritiesInput(v *ListGroupCertificateAuthoritiesInput, encoder *httpbinding.Encoder) error {
5010	if v == nil {
5011		return fmt.Errorf("unsupported serialization of nil %T", v)
5012	}
5013
5014	if v.GroupId == nil || len(*v.GroupId) == 0 {
5015		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
5016	}
5017	if v.GroupId != nil {
5018		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
5019			return err
5020		}
5021	}
5022
5023	return nil
5024}
5025
5026type awsRestjson1_serializeOpListGroups struct {
5027}
5028
5029func (*awsRestjson1_serializeOpListGroups) ID() string {
5030	return "OperationSerializer"
5031}
5032
5033func (m *awsRestjson1_serializeOpListGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5034	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5035) {
5036	request, ok := in.Request.(*smithyhttp.Request)
5037	if !ok {
5038		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5039	}
5040
5041	input, ok := in.Parameters.(*ListGroupsInput)
5042	_ = input
5043	if !ok {
5044		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5045	}
5046
5047	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups")
5048	request.URL.Path = opPath
5049	if len(request.URL.RawQuery) > 0 {
5050		request.URL.RawQuery = "&" + opQuery
5051	} else {
5052		request.URL.RawQuery = opQuery
5053	}
5054
5055	request.Method = "GET"
5056	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5057	if err != nil {
5058		return out, metadata, &smithy.SerializationError{Err: err}
5059	}
5060
5061	if err := awsRestjson1_serializeOpHttpBindingsListGroupsInput(input, restEncoder); err != nil {
5062		return out, metadata, &smithy.SerializationError{Err: err}
5063	}
5064
5065	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5066		return out, metadata, &smithy.SerializationError{Err: err}
5067	}
5068	in.Request = request
5069
5070	return next.HandleSerialize(ctx, in)
5071}
5072func awsRestjson1_serializeOpHttpBindingsListGroupsInput(v *ListGroupsInput, encoder *httpbinding.Encoder) error {
5073	if v == nil {
5074		return fmt.Errorf("unsupported serialization of nil %T", v)
5075	}
5076
5077	if v.MaxResults != nil {
5078		encoder.SetQuery("MaxResults").String(*v.MaxResults)
5079	}
5080
5081	if v.NextToken != nil {
5082		encoder.SetQuery("NextToken").String(*v.NextToken)
5083	}
5084
5085	return nil
5086}
5087
5088type awsRestjson1_serializeOpListGroupVersions struct {
5089}
5090
5091func (*awsRestjson1_serializeOpListGroupVersions) ID() string {
5092	return "OperationSerializer"
5093}
5094
5095func (m *awsRestjson1_serializeOpListGroupVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5096	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5097) {
5098	request, ok := in.Request.(*smithyhttp.Request)
5099	if !ok {
5100		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5101	}
5102
5103	input, ok := in.Parameters.(*ListGroupVersionsInput)
5104	_ = input
5105	if !ok {
5106		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5107	}
5108
5109	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/versions")
5110	request.URL.Path = opPath
5111	if len(request.URL.RawQuery) > 0 {
5112		request.URL.RawQuery = "&" + opQuery
5113	} else {
5114		request.URL.RawQuery = opQuery
5115	}
5116
5117	request.Method = "GET"
5118	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5119	if err != nil {
5120		return out, metadata, &smithy.SerializationError{Err: err}
5121	}
5122
5123	if err := awsRestjson1_serializeOpHttpBindingsListGroupVersionsInput(input, restEncoder); err != nil {
5124		return out, metadata, &smithy.SerializationError{Err: err}
5125	}
5126
5127	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5128		return out, metadata, &smithy.SerializationError{Err: err}
5129	}
5130	in.Request = request
5131
5132	return next.HandleSerialize(ctx, in)
5133}
5134func awsRestjson1_serializeOpHttpBindingsListGroupVersionsInput(v *ListGroupVersionsInput, encoder *httpbinding.Encoder) error {
5135	if v == nil {
5136		return fmt.Errorf("unsupported serialization of nil %T", v)
5137	}
5138
5139	if v.GroupId == nil || len(*v.GroupId) == 0 {
5140		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
5141	}
5142	if v.GroupId != nil {
5143		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
5144			return err
5145		}
5146	}
5147
5148	if v.MaxResults != nil {
5149		encoder.SetQuery("MaxResults").String(*v.MaxResults)
5150	}
5151
5152	if v.NextToken != nil {
5153		encoder.SetQuery("NextToken").String(*v.NextToken)
5154	}
5155
5156	return nil
5157}
5158
5159type awsRestjson1_serializeOpListLoggerDefinitions struct {
5160}
5161
5162func (*awsRestjson1_serializeOpListLoggerDefinitions) ID() string {
5163	return "OperationSerializer"
5164}
5165
5166func (m *awsRestjson1_serializeOpListLoggerDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5167	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5168) {
5169	request, ok := in.Request.(*smithyhttp.Request)
5170	if !ok {
5171		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5172	}
5173
5174	input, ok := in.Parameters.(*ListLoggerDefinitionsInput)
5175	_ = input
5176	if !ok {
5177		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5178	}
5179
5180	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers")
5181	request.URL.Path = opPath
5182	if len(request.URL.RawQuery) > 0 {
5183		request.URL.RawQuery = "&" + opQuery
5184	} else {
5185		request.URL.RawQuery = opQuery
5186	}
5187
5188	request.Method = "GET"
5189	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5190	if err != nil {
5191		return out, metadata, &smithy.SerializationError{Err: err}
5192	}
5193
5194	if err := awsRestjson1_serializeOpHttpBindingsListLoggerDefinitionsInput(input, restEncoder); err != nil {
5195		return out, metadata, &smithy.SerializationError{Err: err}
5196	}
5197
5198	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5199		return out, metadata, &smithy.SerializationError{Err: err}
5200	}
5201	in.Request = request
5202
5203	return next.HandleSerialize(ctx, in)
5204}
5205func awsRestjson1_serializeOpHttpBindingsListLoggerDefinitionsInput(v *ListLoggerDefinitionsInput, encoder *httpbinding.Encoder) error {
5206	if v == nil {
5207		return fmt.Errorf("unsupported serialization of nil %T", v)
5208	}
5209
5210	if v.MaxResults != nil {
5211		encoder.SetQuery("MaxResults").String(*v.MaxResults)
5212	}
5213
5214	if v.NextToken != nil {
5215		encoder.SetQuery("NextToken").String(*v.NextToken)
5216	}
5217
5218	return nil
5219}
5220
5221type awsRestjson1_serializeOpListLoggerDefinitionVersions struct {
5222}
5223
5224func (*awsRestjson1_serializeOpListLoggerDefinitionVersions) ID() string {
5225	return "OperationSerializer"
5226}
5227
5228func (m *awsRestjson1_serializeOpListLoggerDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5229	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5230) {
5231	request, ok := in.Request.(*smithyhttp.Request)
5232	if !ok {
5233		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5234	}
5235
5236	input, ok := in.Parameters.(*ListLoggerDefinitionVersionsInput)
5237	_ = input
5238	if !ok {
5239		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5240	}
5241
5242	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}/versions")
5243	request.URL.Path = opPath
5244	if len(request.URL.RawQuery) > 0 {
5245		request.URL.RawQuery = "&" + opQuery
5246	} else {
5247		request.URL.RawQuery = opQuery
5248	}
5249
5250	request.Method = "GET"
5251	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5252	if err != nil {
5253		return out, metadata, &smithy.SerializationError{Err: err}
5254	}
5255
5256	if err := awsRestjson1_serializeOpHttpBindingsListLoggerDefinitionVersionsInput(input, restEncoder); err != nil {
5257		return out, metadata, &smithy.SerializationError{Err: err}
5258	}
5259
5260	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5261		return out, metadata, &smithy.SerializationError{Err: err}
5262	}
5263	in.Request = request
5264
5265	return next.HandleSerialize(ctx, in)
5266}
5267func awsRestjson1_serializeOpHttpBindingsListLoggerDefinitionVersionsInput(v *ListLoggerDefinitionVersionsInput, encoder *httpbinding.Encoder) error {
5268	if v == nil {
5269		return fmt.Errorf("unsupported serialization of nil %T", v)
5270	}
5271
5272	if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 {
5273		return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")}
5274	}
5275	if v.LoggerDefinitionId != nil {
5276		if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil {
5277			return err
5278		}
5279	}
5280
5281	if v.MaxResults != nil {
5282		encoder.SetQuery("MaxResults").String(*v.MaxResults)
5283	}
5284
5285	if v.NextToken != nil {
5286		encoder.SetQuery("NextToken").String(*v.NextToken)
5287	}
5288
5289	return nil
5290}
5291
5292type awsRestjson1_serializeOpListResourceDefinitions struct {
5293}
5294
5295func (*awsRestjson1_serializeOpListResourceDefinitions) ID() string {
5296	return "OperationSerializer"
5297}
5298
5299func (m *awsRestjson1_serializeOpListResourceDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5300	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5301) {
5302	request, ok := in.Request.(*smithyhttp.Request)
5303	if !ok {
5304		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5305	}
5306
5307	input, ok := in.Parameters.(*ListResourceDefinitionsInput)
5308	_ = input
5309	if !ok {
5310		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5311	}
5312
5313	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources")
5314	request.URL.Path = opPath
5315	if len(request.URL.RawQuery) > 0 {
5316		request.URL.RawQuery = "&" + opQuery
5317	} else {
5318		request.URL.RawQuery = opQuery
5319	}
5320
5321	request.Method = "GET"
5322	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5323	if err != nil {
5324		return out, metadata, &smithy.SerializationError{Err: err}
5325	}
5326
5327	if err := awsRestjson1_serializeOpHttpBindingsListResourceDefinitionsInput(input, restEncoder); err != nil {
5328		return out, metadata, &smithy.SerializationError{Err: err}
5329	}
5330
5331	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5332		return out, metadata, &smithy.SerializationError{Err: err}
5333	}
5334	in.Request = request
5335
5336	return next.HandleSerialize(ctx, in)
5337}
5338func awsRestjson1_serializeOpHttpBindingsListResourceDefinitionsInput(v *ListResourceDefinitionsInput, encoder *httpbinding.Encoder) error {
5339	if v == nil {
5340		return fmt.Errorf("unsupported serialization of nil %T", v)
5341	}
5342
5343	if v.MaxResults != nil {
5344		encoder.SetQuery("MaxResults").String(*v.MaxResults)
5345	}
5346
5347	if v.NextToken != nil {
5348		encoder.SetQuery("NextToken").String(*v.NextToken)
5349	}
5350
5351	return nil
5352}
5353
5354type awsRestjson1_serializeOpListResourceDefinitionVersions struct {
5355}
5356
5357func (*awsRestjson1_serializeOpListResourceDefinitionVersions) ID() string {
5358	return "OperationSerializer"
5359}
5360
5361func (m *awsRestjson1_serializeOpListResourceDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5362	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5363) {
5364	request, ok := in.Request.(*smithyhttp.Request)
5365	if !ok {
5366		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5367	}
5368
5369	input, ok := in.Parameters.(*ListResourceDefinitionVersionsInput)
5370	_ = input
5371	if !ok {
5372		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5373	}
5374
5375	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}/versions")
5376	request.URL.Path = opPath
5377	if len(request.URL.RawQuery) > 0 {
5378		request.URL.RawQuery = "&" + opQuery
5379	} else {
5380		request.URL.RawQuery = opQuery
5381	}
5382
5383	request.Method = "GET"
5384	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5385	if err != nil {
5386		return out, metadata, &smithy.SerializationError{Err: err}
5387	}
5388
5389	if err := awsRestjson1_serializeOpHttpBindingsListResourceDefinitionVersionsInput(input, restEncoder); err != nil {
5390		return out, metadata, &smithy.SerializationError{Err: err}
5391	}
5392
5393	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5394		return out, metadata, &smithy.SerializationError{Err: err}
5395	}
5396	in.Request = request
5397
5398	return next.HandleSerialize(ctx, in)
5399}
5400func awsRestjson1_serializeOpHttpBindingsListResourceDefinitionVersionsInput(v *ListResourceDefinitionVersionsInput, encoder *httpbinding.Encoder) error {
5401	if v == nil {
5402		return fmt.Errorf("unsupported serialization of nil %T", v)
5403	}
5404
5405	if v.MaxResults != nil {
5406		encoder.SetQuery("MaxResults").String(*v.MaxResults)
5407	}
5408
5409	if v.NextToken != nil {
5410		encoder.SetQuery("NextToken").String(*v.NextToken)
5411	}
5412
5413	if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 {
5414		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")}
5415	}
5416	if v.ResourceDefinitionId != nil {
5417		if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil {
5418			return err
5419		}
5420	}
5421
5422	return nil
5423}
5424
5425type awsRestjson1_serializeOpListSubscriptionDefinitions struct {
5426}
5427
5428func (*awsRestjson1_serializeOpListSubscriptionDefinitions) ID() string {
5429	return "OperationSerializer"
5430}
5431
5432func (m *awsRestjson1_serializeOpListSubscriptionDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5433	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5434) {
5435	request, ok := in.Request.(*smithyhttp.Request)
5436	if !ok {
5437		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5438	}
5439
5440	input, ok := in.Parameters.(*ListSubscriptionDefinitionsInput)
5441	_ = input
5442	if !ok {
5443		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5444	}
5445
5446	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions")
5447	request.URL.Path = opPath
5448	if len(request.URL.RawQuery) > 0 {
5449		request.URL.RawQuery = "&" + opQuery
5450	} else {
5451		request.URL.RawQuery = opQuery
5452	}
5453
5454	request.Method = "GET"
5455	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5456	if err != nil {
5457		return out, metadata, &smithy.SerializationError{Err: err}
5458	}
5459
5460	if err := awsRestjson1_serializeOpHttpBindingsListSubscriptionDefinitionsInput(input, restEncoder); err != nil {
5461		return out, metadata, &smithy.SerializationError{Err: err}
5462	}
5463
5464	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5465		return out, metadata, &smithy.SerializationError{Err: err}
5466	}
5467	in.Request = request
5468
5469	return next.HandleSerialize(ctx, in)
5470}
5471func awsRestjson1_serializeOpHttpBindingsListSubscriptionDefinitionsInput(v *ListSubscriptionDefinitionsInput, encoder *httpbinding.Encoder) error {
5472	if v == nil {
5473		return fmt.Errorf("unsupported serialization of nil %T", v)
5474	}
5475
5476	if v.MaxResults != nil {
5477		encoder.SetQuery("MaxResults").String(*v.MaxResults)
5478	}
5479
5480	if v.NextToken != nil {
5481		encoder.SetQuery("NextToken").String(*v.NextToken)
5482	}
5483
5484	return nil
5485}
5486
5487type awsRestjson1_serializeOpListSubscriptionDefinitionVersions struct {
5488}
5489
5490func (*awsRestjson1_serializeOpListSubscriptionDefinitionVersions) ID() string {
5491	return "OperationSerializer"
5492}
5493
5494func (m *awsRestjson1_serializeOpListSubscriptionDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5495	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5496) {
5497	request, ok := in.Request.(*smithyhttp.Request)
5498	if !ok {
5499		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5500	}
5501
5502	input, ok := in.Parameters.(*ListSubscriptionDefinitionVersionsInput)
5503	_ = input
5504	if !ok {
5505		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5506	}
5507
5508	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions")
5509	request.URL.Path = opPath
5510	if len(request.URL.RawQuery) > 0 {
5511		request.URL.RawQuery = "&" + opQuery
5512	} else {
5513		request.URL.RawQuery = opQuery
5514	}
5515
5516	request.Method = "GET"
5517	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5518	if err != nil {
5519		return out, metadata, &smithy.SerializationError{Err: err}
5520	}
5521
5522	if err := awsRestjson1_serializeOpHttpBindingsListSubscriptionDefinitionVersionsInput(input, restEncoder); err != nil {
5523		return out, metadata, &smithy.SerializationError{Err: err}
5524	}
5525
5526	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5527		return out, metadata, &smithy.SerializationError{Err: err}
5528	}
5529	in.Request = request
5530
5531	return next.HandleSerialize(ctx, in)
5532}
5533func awsRestjson1_serializeOpHttpBindingsListSubscriptionDefinitionVersionsInput(v *ListSubscriptionDefinitionVersionsInput, encoder *httpbinding.Encoder) error {
5534	if v == nil {
5535		return fmt.Errorf("unsupported serialization of nil %T", v)
5536	}
5537
5538	if v.MaxResults != nil {
5539		encoder.SetQuery("MaxResults").String(*v.MaxResults)
5540	}
5541
5542	if v.NextToken != nil {
5543		encoder.SetQuery("NextToken").String(*v.NextToken)
5544	}
5545
5546	if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 {
5547		return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")}
5548	}
5549	if v.SubscriptionDefinitionId != nil {
5550		if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil {
5551			return err
5552		}
5553	}
5554
5555	return nil
5556}
5557
5558type awsRestjson1_serializeOpListTagsForResource struct {
5559}
5560
5561func (*awsRestjson1_serializeOpListTagsForResource) ID() string {
5562	return "OperationSerializer"
5563}
5564
5565func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5566	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5567) {
5568	request, ok := in.Request.(*smithyhttp.Request)
5569	if !ok {
5570		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5571	}
5572
5573	input, ok := in.Parameters.(*ListTagsForResourceInput)
5574	_ = input
5575	if !ok {
5576		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5577	}
5578
5579	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
5580	request.URL.Path = opPath
5581	if len(request.URL.RawQuery) > 0 {
5582		request.URL.RawQuery = "&" + opQuery
5583	} else {
5584		request.URL.RawQuery = opQuery
5585	}
5586
5587	request.Method = "GET"
5588	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5589	if err != nil {
5590		return out, metadata, &smithy.SerializationError{Err: err}
5591	}
5592
5593	if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil {
5594		return out, metadata, &smithy.SerializationError{Err: err}
5595	}
5596
5597	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5598		return out, metadata, &smithy.SerializationError{Err: err}
5599	}
5600	in.Request = request
5601
5602	return next.HandleSerialize(ctx, in)
5603}
5604func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error {
5605	if v == nil {
5606		return fmt.Errorf("unsupported serialization of nil %T", v)
5607	}
5608
5609	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
5610		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
5611	}
5612	if v.ResourceArn != nil {
5613		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
5614			return err
5615		}
5616	}
5617
5618	return nil
5619}
5620
5621type awsRestjson1_serializeOpResetDeployments struct {
5622}
5623
5624func (*awsRestjson1_serializeOpResetDeployments) ID() string {
5625	return "OperationSerializer"
5626}
5627
5628func (m *awsRestjson1_serializeOpResetDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5629	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5630) {
5631	request, ok := in.Request.(*smithyhttp.Request)
5632	if !ok {
5633		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5634	}
5635
5636	input, ok := in.Parameters.(*ResetDeploymentsInput)
5637	_ = input
5638	if !ok {
5639		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5640	}
5641
5642	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/deployments/$reset")
5643	request.URL.Path = opPath
5644	if len(request.URL.RawQuery) > 0 {
5645		request.URL.RawQuery = "&" + opQuery
5646	} else {
5647		request.URL.RawQuery = opQuery
5648	}
5649
5650	request.Method = "POST"
5651	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5652	if err != nil {
5653		return out, metadata, &smithy.SerializationError{Err: err}
5654	}
5655
5656	if err := awsRestjson1_serializeOpHttpBindingsResetDeploymentsInput(input, restEncoder); err != nil {
5657		return out, metadata, &smithy.SerializationError{Err: err}
5658	}
5659
5660	restEncoder.SetHeader("Content-Type").String("application/json")
5661
5662	jsonEncoder := smithyjson.NewEncoder()
5663	if err := awsRestjson1_serializeOpDocumentResetDeploymentsInput(input, jsonEncoder.Value); err != nil {
5664		return out, metadata, &smithy.SerializationError{Err: err}
5665	}
5666
5667	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5668		return out, metadata, &smithy.SerializationError{Err: err}
5669	}
5670
5671	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5672		return out, metadata, &smithy.SerializationError{Err: err}
5673	}
5674	in.Request = request
5675
5676	return next.HandleSerialize(ctx, in)
5677}
5678func awsRestjson1_serializeOpHttpBindingsResetDeploymentsInput(v *ResetDeploymentsInput, encoder *httpbinding.Encoder) error {
5679	if v == nil {
5680		return fmt.Errorf("unsupported serialization of nil %T", v)
5681	}
5682
5683	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
5684		locationName := "X-Amzn-Client-Token"
5685		encoder.SetHeader(locationName).String(*v.AmznClientToken)
5686	}
5687
5688	if v.GroupId == nil || len(*v.GroupId) == 0 {
5689		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
5690	}
5691	if v.GroupId != nil {
5692		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
5693			return err
5694		}
5695	}
5696
5697	return nil
5698}
5699
5700func awsRestjson1_serializeOpDocumentResetDeploymentsInput(v *ResetDeploymentsInput, value smithyjson.Value) error {
5701	object := value.Object()
5702	defer object.Close()
5703
5704	if v.Force {
5705		ok := object.Key("Force")
5706		ok.Boolean(v.Force)
5707	}
5708
5709	return nil
5710}
5711
5712type awsRestjson1_serializeOpStartBulkDeployment struct {
5713}
5714
5715func (*awsRestjson1_serializeOpStartBulkDeployment) ID() string {
5716	return "OperationSerializer"
5717}
5718
5719func (m *awsRestjson1_serializeOpStartBulkDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5720	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5721) {
5722	request, ok := in.Request.(*smithyhttp.Request)
5723	if !ok {
5724		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5725	}
5726
5727	input, ok := in.Parameters.(*StartBulkDeploymentInput)
5728	_ = input
5729	if !ok {
5730		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5731	}
5732
5733	opPath, opQuery := httpbinding.SplitURI("/greengrass/bulk/deployments")
5734	request.URL.Path = opPath
5735	if len(request.URL.RawQuery) > 0 {
5736		request.URL.RawQuery = "&" + opQuery
5737	} else {
5738		request.URL.RawQuery = opQuery
5739	}
5740
5741	request.Method = "POST"
5742	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5743	if err != nil {
5744		return out, metadata, &smithy.SerializationError{Err: err}
5745	}
5746
5747	if err := awsRestjson1_serializeOpHttpBindingsStartBulkDeploymentInput(input, restEncoder); err != nil {
5748		return out, metadata, &smithy.SerializationError{Err: err}
5749	}
5750
5751	restEncoder.SetHeader("Content-Type").String("application/json")
5752
5753	jsonEncoder := smithyjson.NewEncoder()
5754	if err := awsRestjson1_serializeOpDocumentStartBulkDeploymentInput(input, jsonEncoder.Value); err != nil {
5755		return out, metadata, &smithy.SerializationError{Err: err}
5756	}
5757
5758	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5759		return out, metadata, &smithy.SerializationError{Err: err}
5760	}
5761
5762	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5763		return out, metadata, &smithy.SerializationError{Err: err}
5764	}
5765	in.Request = request
5766
5767	return next.HandleSerialize(ctx, in)
5768}
5769func awsRestjson1_serializeOpHttpBindingsStartBulkDeploymentInput(v *StartBulkDeploymentInput, encoder *httpbinding.Encoder) error {
5770	if v == nil {
5771		return fmt.Errorf("unsupported serialization of nil %T", v)
5772	}
5773
5774	if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 {
5775		locationName := "X-Amzn-Client-Token"
5776		encoder.SetHeader(locationName).String(*v.AmznClientToken)
5777	}
5778
5779	return nil
5780}
5781
5782func awsRestjson1_serializeOpDocumentStartBulkDeploymentInput(v *StartBulkDeploymentInput, value smithyjson.Value) error {
5783	object := value.Object()
5784	defer object.Close()
5785
5786	if v.ExecutionRoleArn != nil {
5787		ok := object.Key("ExecutionRoleArn")
5788		ok.String(*v.ExecutionRoleArn)
5789	}
5790
5791	if v.InputFileUri != nil {
5792		ok := object.Key("InputFileUri")
5793		ok.String(*v.InputFileUri)
5794	}
5795
5796	if v.Tags != nil {
5797		ok := object.Key("tags")
5798		if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
5799			return err
5800		}
5801	}
5802
5803	return nil
5804}
5805
5806type awsRestjson1_serializeOpStopBulkDeployment struct {
5807}
5808
5809func (*awsRestjson1_serializeOpStopBulkDeployment) ID() string {
5810	return "OperationSerializer"
5811}
5812
5813func (m *awsRestjson1_serializeOpStopBulkDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5814	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5815) {
5816	request, ok := in.Request.(*smithyhttp.Request)
5817	if !ok {
5818		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5819	}
5820
5821	input, ok := in.Parameters.(*StopBulkDeploymentInput)
5822	_ = input
5823	if !ok {
5824		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5825	}
5826
5827	opPath, opQuery := httpbinding.SplitURI("/greengrass/bulk/deployments/{BulkDeploymentId}/$stop")
5828	request.URL.Path = opPath
5829	if len(request.URL.RawQuery) > 0 {
5830		request.URL.RawQuery = "&" + opQuery
5831	} else {
5832		request.URL.RawQuery = opQuery
5833	}
5834
5835	request.Method = "PUT"
5836	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5837	if err != nil {
5838		return out, metadata, &smithy.SerializationError{Err: err}
5839	}
5840
5841	if err := awsRestjson1_serializeOpHttpBindingsStopBulkDeploymentInput(input, restEncoder); err != nil {
5842		return out, metadata, &smithy.SerializationError{Err: err}
5843	}
5844
5845	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5846		return out, metadata, &smithy.SerializationError{Err: err}
5847	}
5848	in.Request = request
5849
5850	return next.HandleSerialize(ctx, in)
5851}
5852func awsRestjson1_serializeOpHttpBindingsStopBulkDeploymentInput(v *StopBulkDeploymentInput, encoder *httpbinding.Encoder) error {
5853	if v == nil {
5854		return fmt.Errorf("unsupported serialization of nil %T", v)
5855	}
5856
5857	if v.BulkDeploymentId == nil || len(*v.BulkDeploymentId) == 0 {
5858		return &smithy.SerializationError{Err: fmt.Errorf("input member BulkDeploymentId must not be empty")}
5859	}
5860	if v.BulkDeploymentId != nil {
5861		if err := encoder.SetURI("BulkDeploymentId").String(*v.BulkDeploymentId); err != nil {
5862			return err
5863		}
5864	}
5865
5866	return nil
5867}
5868
5869type awsRestjson1_serializeOpTagResource struct {
5870}
5871
5872func (*awsRestjson1_serializeOpTagResource) ID() string {
5873	return "OperationSerializer"
5874}
5875
5876func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5877	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5878) {
5879	request, ok := in.Request.(*smithyhttp.Request)
5880	if !ok {
5881		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5882	}
5883
5884	input, ok := in.Parameters.(*TagResourceInput)
5885	_ = input
5886	if !ok {
5887		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5888	}
5889
5890	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
5891	request.URL.Path = opPath
5892	if len(request.URL.RawQuery) > 0 {
5893		request.URL.RawQuery = "&" + opQuery
5894	} else {
5895		request.URL.RawQuery = opQuery
5896	}
5897
5898	request.Method = "POST"
5899	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5900	if err != nil {
5901		return out, metadata, &smithy.SerializationError{Err: err}
5902	}
5903
5904	if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
5905		return out, metadata, &smithy.SerializationError{Err: err}
5906	}
5907
5908	restEncoder.SetHeader("Content-Type").String("application/json")
5909
5910	jsonEncoder := smithyjson.NewEncoder()
5911	if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
5912		return out, metadata, &smithy.SerializationError{Err: err}
5913	}
5914
5915	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5916		return out, metadata, &smithy.SerializationError{Err: err}
5917	}
5918
5919	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5920		return out, metadata, &smithy.SerializationError{Err: err}
5921	}
5922	in.Request = request
5923
5924	return next.HandleSerialize(ctx, in)
5925}
5926func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
5927	if v == nil {
5928		return fmt.Errorf("unsupported serialization of nil %T", v)
5929	}
5930
5931	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
5932		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
5933	}
5934	if v.ResourceArn != nil {
5935		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
5936			return err
5937		}
5938	}
5939
5940	return nil
5941}
5942
5943func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
5944	object := value.Object()
5945	defer object.Close()
5946
5947	if v.Tags != nil {
5948		ok := object.Key("tags")
5949		if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
5950			return err
5951		}
5952	}
5953
5954	return nil
5955}
5956
5957type awsRestjson1_serializeOpUntagResource struct {
5958}
5959
5960func (*awsRestjson1_serializeOpUntagResource) ID() string {
5961	return "OperationSerializer"
5962}
5963
5964func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5965	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5966) {
5967	request, ok := in.Request.(*smithyhttp.Request)
5968	if !ok {
5969		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5970	}
5971
5972	input, ok := in.Parameters.(*UntagResourceInput)
5973	_ = input
5974	if !ok {
5975		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5976	}
5977
5978	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
5979	request.URL.Path = opPath
5980	if len(request.URL.RawQuery) > 0 {
5981		request.URL.RawQuery = "&" + opQuery
5982	} else {
5983		request.URL.RawQuery = opQuery
5984	}
5985
5986	request.Method = "DELETE"
5987	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5988	if err != nil {
5989		return out, metadata, &smithy.SerializationError{Err: err}
5990	}
5991
5992	if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil {
5993		return out, metadata, &smithy.SerializationError{Err: err}
5994	}
5995
5996	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5997		return out, metadata, &smithy.SerializationError{Err: err}
5998	}
5999	in.Request = request
6000
6001	return next.HandleSerialize(ctx, in)
6002}
6003func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
6004	if v == nil {
6005		return fmt.Errorf("unsupported serialization of nil %T", v)
6006	}
6007
6008	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
6009		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
6010	}
6011	if v.ResourceArn != nil {
6012		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
6013			return err
6014		}
6015	}
6016
6017	if v.TagKeys != nil {
6018		for i := range v.TagKeys {
6019			encoder.AddQuery("tagKeys").String(v.TagKeys[i])
6020		}
6021	}
6022
6023	return nil
6024}
6025
6026type awsRestjson1_serializeOpUpdateConnectivityInfo struct {
6027}
6028
6029func (*awsRestjson1_serializeOpUpdateConnectivityInfo) ID() string {
6030	return "OperationSerializer"
6031}
6032
6033func (m *awsRestjson1_serializeOpUpdateConnectivityInfo) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6034	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6035) {
6036	request, ok := in.Request.(*smithyhttp.Request)
6037	if !ok {
6038		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6039	}
6040
6041	input, ok := in.Parameters.(*UpdateConnectivityInfoInput)
6042	_ = input
6043	if !ok {
6044		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6045	}
6046
6047	opPath, opQuery := httpbinding.SplitURI("/greengrass/things/{ThingName}/connectivityInfo")
6048	request.URL.Path = opPath
6049	if len(request.URL.RawQuery) > 0 {
6050		request.URL.RawQuery = "&" + opQuery
6051	} else {
6052		request.URL.RawQuery = opQuery
6053	}
6054
6055	request.Method = "PUT"
6056	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6057	if err != nil {
6058		return out, metadata, &smithy.SerializationError{Err: err}
6059	}
6060
6061	if err := awsRestjson1_serializeOpHttpBindingsUpdateConnectivityInfoInput(input, restEncoder); err != nil {
6062		return out, metadata, &smithy.SerializationError{Err: err}
6063	}
6064
6065	restEncoder.SetHeader("Content-Type").String("application/json")
6066
6067	jsonEncoder := smithyjson.NewEncoder()
6068	if err := awsRestjson1_serializeOpDocumentUpdateConnectivityInfoInput(input, jsonEncoder.Value); err != nil {
6069		return out, metadata, &smithy.SerializationError{Err: err}
6070	}
6071
6072	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6073		return out, metadata, &smithy.SerializationError{Err: err}
6074	}
6075
6076	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6077		return out, metadata, &smithy.SerializationError{Err: err}
6078	}
6079	in.Request = request
6080
6081	return next.HandleSerialize(ctx, in)
6082}
6083func awsRestjson1_serializeOpHttpBindingsUpdateConnectivityInfoInput(v *UpdateConnectivityInfoInput, encoder *httpbinding.Encoder) error {
6084	if v == nil {
6085		return fmt.Errorf("unsupported serialization of nil %T", v)
6086	}
6087
6088	if v.ThingName == nil || len(*v.ThingName) == 0 {
6089		return &smithy.SerializationError{Err: fmt.Errorf("input member ThingName must not be empty")}
6090	}
6091	if v.ThingName != nil {
6092		if err := encoder.SetURI("ThingName").String(*v.ThingName); err != nil {
6093			return err
6094		}
6095	}
6096
6097	return nil
6098}
6099
6100func awsRestjson1_serializeOpDocumentUpdateConnectivityInfoInput(v *UpdateConnectivityInfoInput, value smithyjson.Value) error {
6101	object := value.Object()
6102	defer object.Close()
6103
6104	if v.ConnectivityInfo != nil {
6105		ok := object.Key("ConnectivityInfo")
6106		if err := awsRestjson1_serializeDocument__listOfConnectivityInfo(v.ConnectivityInfo, ok); err != nil {
6107			return err
6108		}
6109	}
6110
6111	return nil
6112}
6113
6114type awsRestjson1_serializeOpUpdateConnectorDefinition struct {
6115}
6116
6117func (*awsRestjson1_serializeOpUpdateConnectorDefinition) ID() string {
6118	return "OperationSerializer"
6119}
6120
6121func (m *awsRestjson1_serializeOpUpdateConnectorDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6122	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6123) {
6124	request, ok := in.Request.(*smithyhttp.Request)
6125	if !ok {
6126		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6127	}
6128
6129	input, ok := in.Parameters.(*UpdateConnectorDefinitionInput)
6130	_ = input
6131	if !ok {
6132		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6133	}
6134
6135	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}")
6136	request.URL.Path = opPath
6137	if len(request.URL.RawQuery) > 0 {
6138		request.URL.RawQuery = "&" + opQuery
6139	} else {
6140		request.URL.RawQuery = opQuery
6141	}
6142
6143	request.Method = "PUT"
6144	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6145	if err != nil {
6146		return out, metadata, &smithy.SerializationError{Err: err}
6147	}
6148
6149	if err := awsRestjson1_serializeOpHttpBindingsUpdateConnectorDefinitionInput(input, restEncoder); err != nil {
6150		return out, metadata, &smithy.SerializationError{Err: err}
6151	}
6152
6153	restEncoder.SetHeader("Content-Type").String("application/json")
6154
6155	jsonEncoder := smithyjson.NewEncoder()
6156	if err := awsRestjson1_serializeOpDocumentUpdateConnectorDefinitionInput(input, jsonEncoder.Value); err != nil {
6157		return out, metadata, &smithy.SerializationError{Err: err}
6158	}
6159
6160	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6161		return out, metadata, &smithy.SerializationError{Err: err}
6162	}
6163
6164	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6165		return out, metadata, &smithy.SerializationError{Err: err}
6166	}
6167	in.Request = request
6168
6169	return next.HandleSerialize(ctx, in)
6170}
6171func awsRestjson1_serializeOpHttpBindingsUpdateConnectorDefinitionInput(v *UpdateConnectorDefinitionInput, encoder *httpbinding.Encoder) error {
6172	if v == nil {
6173		return fmt.Errorf("unsupported serialization of nil %T", v)
6174	}
6175
6176	if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 {
6177		return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")}
6178	}
6179	if v.ConnectorDefinitionId != nil {
6180		if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil {
6181			return err
6182		}
6183	}
6184
6185	return nil
6186}
6187
6188func awsRestjson1_serializeOpDocumentUpdateConnectorDefinitionInput(v *UpdateConnectorDefinitionInput, value smithyjson.Value) error {
6189	object := value.Object()
6190	defer object.Close()
6191
6192	if v.Name != nil {
6193		ok := object.Key("Name")
6194		ok.String(*v.Name)
6195	}
6196
6197	return nil
6198}
6199
6200type awsRestjson1_serializeOpUpdateCoreDefinition struct {
6201}
6202
6203func (*awsRestjson1_serializeOpUpdateCoreDefinition) ID() string {
6204	return "OperationSerializer"
6205}
6206
6207func (m *awsRestjson1_serializeOpUpdateCoreDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6208	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6209) {
6210	request, ok := in.Request.(*smithyhttp.Request)
6211	if !ok {
6212		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6213	}
6214
6215	input, ok := in.Parameters.(*UpdateCoreDefinitionInput)
6216	_ = input
6217	if !ok {
6218		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6219	}
6220
6221	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}")
6222	request.URL.Path = opPath
6223	if len(request.URL.RawQuery) > 0 {
6224		request.URL.RawQuery = "&" + opQuery
6225	} else {
6226		request.URL.RawQuery = opQuery
6227	}
6228
6229	request.Method = "PUT"
6230	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6231	if err != nil {
6232		return out, metadata, &smithy.SerializationError{Err: err}
6233	}
6234
6235	if err := awsRestjson1_serializeOpHttpBindingsUpdateCoreDefinitionInput(input, restEncoder); err != nil {
6236		return out, metadata, &smithy.SerializationError{Err: err}
6237	}
6238
6239	restEncoder.SetHeader("Content-Type").String("application/json")
6240
6241	jsonEncoder := smithyjson.NewEncoder()
6242	if err := awsRestjson1_serializeOpDocumentUpdateCoreDefinitionInput(input, jsonEncoder.Value); err != nil {
6243		return out, metadata, &smithy.SerializationError{Err: err}
6244	}
6245
6246	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6247		return out, metadata, &smithy.SerializationError{Err: err}
6248	}
6249
6250	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6251		return out, metadata, &smithy.SerializationError{Err: err}
6252	}
6253	in.Request = request
6254
6255	return next.HandleSerialize(ctx, in)
6256}
6257func awsRestjson1_serializeOpHttpBindingsUpdateCoreDefinitionInput(v *UpdateCoreDefinitionInput, encoder *httpbinding.Encoder) error {
6258	if v == nil {
6259		return fmt.Errorf("unsupported serialization of nil %T", v)
6260	}
6261
6262	if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 {
6263		return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")}
6264	}
6265	if v.CoreDefinitionId != nil {
6266		if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil {
6267			return err
6268		}
6269	}
6270
6271	return nil
6272}
6273
6274func awsRestjson1_serializeOpDocumentUpdateCoreDefinitionInput(v *UpdateCoreDefinitionInput, value smithyjson.Value) error {
6275	object := value.Object()
6276	defer object.Close()
6277
6278	if v.Name != nil {
6279		ok := object.Key("Name")
6280		ok.String(*v.Name)
6281	}
6282
6283	return nil
6284}
6285
6286type awsRestjson1_serializeOpUpdateDeviceDefinition struct {
6287}
6288
6289func (*awsRestjson1_serializeOpUpdateDeviceDefinition) ID() string {
6290	return "OperationSerializer"
6291}
6292
6293func (m *awsRestjson1_serializeOpUpdateDeviceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6294	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6295) {
6296	request, ok := in.Request.(*smithyhttp.Request)
6297	if !ok {
6298		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6299	}
6300
6301	input, ok := in.Parameters.(*UpdateDeviceDefinitionInput)
6302	_ = input
6303	if !ok {
6304		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6305	}
6306
6307	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}")
6308	request.URL.Path = opPath
6309	if len(request.URL.RawQuery) > 0 {
6310		request.URL.RawQuery = "&" + opQuery
6311	} else {
6312		request.URL.RawQuery = opQuery
6313	}
6314
6315	request.Method = "PUT"
6316	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6317	if err != nil {
6318		return out, metadata, &smithy.SerializationError{Err: err}
6319	}
6320
6321	if err := awsRestjson1_serializeOpHttpBindingsUpdateDeviceDefinitionInput(input, restEncoder); err != nil {
6322		return out, metadata, &smithy.SerializationError{Err: err}
6323	}
6324
6325	restEncoder.SetHeader("Content-Type").String("application/json")
6326
6327	jsonEncoder := smithyjson.NewEncoder()
6328	if err := awsRestjson1_serializeOpDocumentUpdateDeviceDefinitionInput(input, jsonEncoder.Value); err != nil {
6329		return out, metadata, &smithy.SerializationError{Err: err}
6330	}
6331
6332	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6333		return out, metadata, &smithy.SerializationError{Err: err}
6334	}
6335
6336	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6337		return out, metadata, &smithy.SerializationError{Err: err}
6338	}
6339	in.Request = request
6340
6341	return next.HandleSerialize(ctx, in)
6342}
6343func awsRestjson1_serializeOpHttpBindingsUpdateDeviceDefinitionInput(v *UpdateDeviceDefinitionInput, encoder *httpbinding.Encoder) error {
6344	if v == nil {
6345		return fmt.Errorf("unsupported serialization of nil %T", v)
6346	}
6347
6348	if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 {
6349		return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")}
6350	}
6351	if v.DeviceDefinitionId != nil {
6352		if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil {
6353			return err
6354		}
6355	}
6356
6357	return nil
6358}
6359
6360func awsRestjson1_serializeOpDocumentUpdateDeviceDefinitionInput(v *UpdateDeviceDefinitionInput, value smithyjson.Value) error {
6361	object := value.Object()
6362	defer object.Close()
6363
6364	if v.Name != nil {
6365		ok := object.Key("Name")
6366		ok.String(*v.Name)
6367	}
6368
6369	return nil
6370}
6371
6372type awsRestjson1_serializeOpUpdateFunctionDefinition struct {
6373}
6374
6375func (*awsRestjson1_serializeOpUpdateFunctionDefinition) ID() string {
6376	return "OperationSerializer"
6377}
6378
6379func (m *awsRestjson1_serializeOpUpdateFunctionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6380	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6381) {
6382	request, ok := in.Request.(*smithyhttp.Request)
6383	if !ok {
6384		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6385	}
6386
6387	input, ok := in.Parameters.(*UpdateFunctionDefinitionInput)
6388	_ = input
6389	if !ok {
6390		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6391	}
6392
6393	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}")
6394	request.URL.Path = opPath
6395	if len(request.URL.RawQuery) > 0 {
6396		request.URL.RawQuery = "&" + opQuery
6397	} else {
6398		request.URL.RawQuery = opQuery
6399	}
6400
6401	request.Method = "PUT"
6402	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6403	if err != nil {
6404		return out, metadata, &smithy.SerializationError{Err: err}
6405	}
6406
6407	if err := awsRestjson1_serializeOpHttpBindingsUpdateFunctionDefinitionInput(input, restEncoder); err != nil {
6408		return out, metadata, &smithy.SerializationError{Err: err}
6409	}
6410
6411	restEncoder.SetHeader("Content-Type").String("application/json")
6412
6413	jsonEncoder := smithyjson.NewEncoder()
6414	if err := awsRestjson1_serializeOpDocumentUpdateFunctionDefinitionInput(input, jsonEncoder.Value); err != nil {
6415		return out, metadata, &smithy.SerializationError{Err: err}
6416	}
6417
6418	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6419		return out, metadata, &smithy.SerializationError{Err: err}
6420	}
6421
6422	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6423		return out, metadata, &smithy.SerializationError{Err: err}
6424	}
6425	in.Request = request
6426
6427	return next.HandleSerialize(ctx, in)
6428}
6429func awsRestjson1_serializeOpHttpBindingsUpdateFunctionDefinitionInput(v *UpdateFunctionDefinitionInput, encoder *httpbinding.Encoder) error {
6430	if v == nil {
6431		return fmt.Errorf("unsupported serialization of nil %T", v)
6432	}
6433
6434	if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 {
6435		return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")}
6436	}
6437	if v.FunctionDefinitionId != nil {
6438		if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil {
6439			return err
6440		}
6441	}
6442
6443	return nil
6444}
6445
6446func awsRestjson1_serializeOpDocumentUpdateFunctionDefinitionInput(v *UpdateFunctionDefinitionInput, value smithyjson.Value) error {
6447	object := value.Object()
6448	defer object.Close()
6449
6450	if v.Name != nil {
6451		ok := object.Key("Name")
6452		ok.String(*v.Name)
6453	}
6454
6455	return nil
6456}
6457
6458type awsRestjson1_serializeOpUpdateGroup struct {
6459}
6460
6461func (*awsRestjson1_serializeOpUpdateGroup) ID() string {
6462	return "OperationSerializer"
6463}
6464
6465func (m *awsRestjson1_serializeOpUpdateGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6466	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6467) {
6468	request, ok := in.Request.(*smithyhttp.Request)
6469	if !ok {
6470		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6471	}
6472
6473	input, ok := in.Parameters.(*UpdateGroupInput)
6474	_ = input
6475	if !ok {
6476		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6477	}
6478
6479	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}")
6480	request.URL.Path = opPath
6481	if len(request.URL.RawQuery) > 0 {
6482		request.URL.RawQuery = "&" + opQuery
6483	} else {
6484		request.URL.RawQuery = opQuery
6485	}
6486
6487	request.Method = "PUT"
6488	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6489	if err != nil {
6490		return out, metadata, &smithy.SerializationError{Err: err}
6491	}
6492
6493	if err := awsRestjson1_serializeOpHttpBindingsUpdateGroupInput(input, restEncoder); err != nil {
6494		return out, metadata, &smithy.SerializationError{Err: err}
6495	}
6496
6497	restEncoder.SetHeader("Content-Type").String("application/json")
6498
6499	jsonEncoder := smithyjson.NewEncoder()
6500	if err := awsRestjson1_serializeOpDocumentUpdateGroupInput(input, jsonEncoder.Value); err != nil {
6501		return out, metadata, &smithy.SerializationError{Err: err}
6502	}
6503
6504	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6505		return out, metadata, &smithy.SerializationError{Err: err}
6506	}
6507
6508	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6509		return out, metadata, &smithy.SerializationError{Err: err}
6510	}
6511	in.Request = request
6512
6513	return next.HandleSerialize(ctx, in)
6514}
6515func awsRestjson1_serializeOpHttpBindingsUpdateGroupInput(v *UpdateGroupInput, encoder *httpbinding.Encoder) error {
6516	if v == nil {
6517		return fmt.Errorf("unsupported serialization of nil %T", v)
6518	}
6519
6520	if v.GroupId == nil || len(*v.GroupId) == 0 {
6521		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
6522	}
6523	if v.GroupId != nil {
6524		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
6525			return err
6526		}
6527	}
6528
6529	return nil
6530}
6531
6532func awsRestjson1_serializeOpDocumentUpdateGroupInput(v *UpdateGroupInput, value smithyjson.Value) error {
6533	object := value.Object()
6534	defer object.Close()
6535
6536	if v.Name != nil {
6537		ok := object.Key("Name")
6538		ok.String(*v.Name)
6539	}
6540
6541	return nil
6542}
6543
6544type awsRestjson1_serializeOpUpdateGroupCertificateConfiguration struct {
6545}
6546
6547func (*awsRestjson1_serializeOpUpdateGroupCertificateConfiguration) ID() string {
6548	return "OperationSerializer"
6549}
6550
6551func (m *awsRestjson1_serializeOpUpdateGroupCertificateConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6552	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6553) {
6554	request, ok := in.Request.(*smithyhttp.Request)
6555	if !ok {
6556		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6557	}
6558
6559	input, ok := in.Parameters.(*UpdateGroupCertificateConfigurationInput)
6560	_ = input
6561	if !ok {
6562		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6563	}
6564
6565	opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry")
6566	request.URL.Path = opPath
6567	if len(request.URL.RawQuery) > 0 {
6568		request.URL.RawQuery = "&" + opQuery
6569	} else {
6570		request.URL.RawQuery = opQuery
6571	}
6572
6573	request.Method = "PUT"
6574	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6575	if err != nil {
6576		return out, metadata, &smithy.SerializationError{Err: err}
6577	}
6578
6579	if err := awsRestjson1_serializeOpHttpBindingsUpdateGroupCertificateConfigurationInput(input, restEncoder); err != nil {
6580		return out, metadata, &smithy.SerializationError{Err: err}
6581	}
6582
6583	restEncoder.SetHeader("Content-Type").String("application/json")
6584
6585	jsonEncoder := smithyjson.NewEncoder()
6586	if err := awsRestjson1_serializeOpDocumentUpdateGroupCertificateConfigurationInput(input, jsonEncoder.Value); err != nil {
6587		return out, metadata, &smithy.SerializationError{Err: err}
6588	}
6589
6590	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6591		return out, metadata, &smithy.SerializationError{Err: err}
6592	}
6593
6594	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6595		return out, metadata, &smithy.SerializationError{Err: err}
6596	}
6597	in.Request = request
6598
6599	return next.HandleSerialize(ctx, in)
6600}
6601func awsRestjson1_serializeOpHttpBindingsUpdateGroupCertificateConfigurationInput(v *UpdateGroupCertificateConfigurationInput, encoder *httpbinding.Encoder) error {
6602	if v == nil {
6603		return fmt.Errorf("unsupported serialization of nil %T", v)
6604	}
6605
6606	if v.GroupId == nil || len(*v.GroupId) == 0 {
6607		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")}
6608	}
6609	if v.GroupId != nil {
6610		if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil {
6611			return err
6612		}
6613	}
6614
6615	return nil
6616}
6617
6618func awsRestjson1_serializeOpDocumentUpdateGroupCertificateConfigurationInput(v *UpdateGroupCertificateConfigurationInput, value smithyjson.Value) error {
6619	object := value.Object()
6620	defer object.Close()
6621
6622	if v.CertificateExpiryInMilliseconds != nil {
6623		ok := object.Key("CertificateExpiryInMilliseconds")
6624		ok.String(*v.CertificateExpiryInMilliseconds)
6625	}
6626
6627	return nil
6628}
6629
6630type awsRestjson1_serializeOpUpdateLoggerDefinition struct {
6631}
6632
6633func (*awsRestjson1_serializeOpUpdateLoggerDefinition) ID() string {
6634	return "OperationSerializer"
6635}
6636
6637func (m *awsRestjson1_serializeOpUpdateLoggerDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6638	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6639) {
6640	request, ok := in.Request.(*smithyhttp.Request)
6641	if !ok {
6642		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6643	}
6644
6645	input, ok := in.Parameters.(*UpdateLoggerDefinitionInput)
6646	_ = input
6647	if !ok {
6648		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6649	}
6650
6651	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}")
6652	request.URL.Path = opPath
6653	if len(request.URL.RawQuery) > 0 {
6654		request.URL.RawQuery = "&" + opQuery
6655	} else {
6656		request.URL.RawQuery = opQuery
6657	}
6658
6659	request.Method = "PUT"
6660	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6661	if err != nil {
6662		return out, metadata, &smithy.SerializationError{Err: err}
6663	}
6664
6665	if err := awsRestjson1_serializeOpHttpBindingsUpdateLoggerDefinitionInput(input, restEncoder); err != nil {
6666		return out, metadata, &smithy.SerializationError{Err: err}
6667	}
6668
6669	restEncoder.SetHeader("Content-Type").String("application/json")
6670
6671	jsonEncoder := smithyjson.NewEncoder()
6672	if err := awsRestjson1_serializeOpDocumentUpdateLoggerDefinitionInput(input, jsonEncoder.Value); err != nil {
6673		return out, metadata, &smithy.SerializationError{Err: err}
6674	}
6675
6676	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6677		return out, metadata, &smithy.SerializationError{Err: err}
6678	}
6679
6680	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6681		return out, metadata, &smithy.SerializationError{Err: err}
6682	}
6683	in.Request = request
6684
6685	return next.HandleSerialize(ctx, in)
6686}
6687func awsRestjson1_serializeOpHttpBindingsUpdateLoggerDefinitionInput(v *UpdateLoggerDefinitionInput, encoder *httpbinding.Encoder) error {
6688	if v == nil {
6689		return fmt.Errorf("unsupported serialization of nil %T", v)
6690	}
6691
6692	if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 {
6693		return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")}
6694	}
6695	if v.LoggerDefinitionId != nil {
6696		if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil {
6697			return err
6698		}
6699	}
6700
6701	return nil
6702}
6703
6704func awsRestjson1_serializeOpDocumentUpdateLoggerDefinitionInput(v *UpdateLoggerDefinitionInput, value smithyjson.Value) error {
6705	object := value.Object()
6706	defer object.Close()
6707
6708	if v.Name != nil {
6709		ok := object.Key("Name")
6710		ok.String(*v.Name)
6711	}
6712
6713	return nil
6714}
6715
6716type awsRestjson1_serializeOpUpdateResourceDefinition struct {
6717}
6718
6719func (*awsRestjson1_serializeOpUpdateResourceDefinition) ID() string {
6720	return "OperationSerializer"
6721}
6722
6723func (m *awsRestjson1_serializeOpUpdateResourceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6724	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6725) {
6726	request, ok := in.Request.(*smithyhttp.Request)
6727	if !ok {
6728		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6729	}
6730
6731	input, ok := in.Parameters.(*UpdateResourceDefinitionInput)
6732	_ = input
6733	if !ok {
6734		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6735	}
6736
6737	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}")
6738	request.URL.Path = opPath
6739	if len(request.URL.RawQuery) > 0 {
6740		request.URL.RawQuery = "&" + opQuery
6741	} else {
6742		request.URL.RawQuery = opQuery
6743	}
6744
6745	request.Method = "PUT"
6746	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6747	if err != nil {
6748		return out, metadata, &smithy.SerializationError{Err: err}
6749	}
6750
6751	if err := awsRestjson1_serializeOpHttpBindingsUpdateResourceDefinitionInput(input, restEncoder); err != nil {
6752		return out, metadata, &smithy.SerializationError{Err: err}
6753	}
6754
6755	restEncoder.SetHeader("Content-Type").String("application/json")
6756
6757	jsonEncoder := smithyjson.NewEncoder()
6758	if err := awsRestjson1_serializeOpDocumentUpdateResourceDefinitionInput(input, jsonEncoder.Value); err != nil {
6759		return out, metadata, &smithy.SerializationError{Err: err}
6760	}
6761
6762	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6763		return out, metadata, &smithy.SerializationError{Err: err}
6764	}
6765
6766	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6767		return out, metadata, &smithy.SerializationError{Err: err}
6768	}
6769	in.Request = request
6770
6771	return next.HandleSerialize(ctx, in)
6772}
6773func awsRestjson1_serializeOpHttpBindingsUpdateResourceDefinitionInput(v *UpdateResourceDefinitionInput, encoder *httpbinding.Encoder) error {
6774	if v == nil {
6775		return fmt.Errorf("unsupported serialization of nil %T", v)
6776	}
6777
6778	if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 {
6779		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")}
6780	}
6781	if v.ResourceDefinitionId != nil {
6782		if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil {
6783			return err
6784		}
6785	}
6786
6787	return nil
6788}
6789
6790func awsRestjson1_serializeOpDocumentUpdateResourceDefinitionInput(v *UpdateResourceDefinitionInput, value smithyjson.Value) error {
6791	object := value.Object()
6792	defer object.Close()
6793
6794	if v.Name != nil {
6795		ok := object.Key("Name")
6796		ok.String(*v.Name)
6797	}
6798
6799	return nil
6800}
6801
6802type awsRestjson1_serializeOpUpdateSubscriptionDefinition struct {
6803}
6804
6805func (*awsRestjson1_serializeOpUpdateSubscriptionDefinition) ID() string {
6806	return "OperationSerializer"
6807}
6808
6809func (m *awsRestjson1_serializeOpUpdateSubscriptionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6810	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6811) {
6812	request, ok := in.Request.(*smithyhttp.Request)
6813	if !ok {
6814		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6815	}
6816
6817	input, ok := in.Parameters.(*UpdateSubscriptionDefinitionInput)
6818	_ = input
6819	if !ok {
6820		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6821	}
6822
6823	opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}")
6824	request.URL.Path = opPath
6825	if len(request.URL.RawQuery) > 0 {
6826		request.URL.RawQuery = "&" + opQuery
6827	} else {
6828		request.URL.RawQuery = opQuery
6829	}
6830
6831	request.Method = "PUT"
6832	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6833	if err != nil {
6834		return out, metadata, &smithy.SerializationError{Err: err}
6835	}
6836
6837	if err := awsRestjson1_serializeOpHttpBindingsUpdateSubscriptionDefinitionInput(input, restEncoder); err != nil {
6838		return out, metadata, &smithy.SerializationError{Err: err}
6839	}
6840
6841	restEncoder.SetHeader("Content-Type").String("application/json")
6842
6843	jsonEncoder := smithyjson.NewEncoder()
6844	if err := awsRestjson1_serializeOpDocumentUpdateSubscriptionDefinitionInput(input, jsonEncoder.Value); err != nil {
6845		return out, metadata, &smithy.SerializationError{Err: err}
6846	}
6847
6848	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6849		return out, metadata, &smithy.SerializationError{Err: err}
6850	}
6851
6852	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6853		return out, metadata, &smithy.SerializationError{Err: err}
6854	}
6855	in.Request = request
6856
6857	return next.HandleSerialize(ctx, in)
6858}
6859func awsRestjson1_serializeOpHttpBindingsUpdateSubscriptionDefinitionInput(v *UpdateSubscriptionDefinitionInput, encoder *httpbinding.Encoder) error {
6860	if v == nil {
6861		return fmt.Errorf("unsupported serialization of nil %T", v)
6862	}
6863
6864	if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 {
6865		return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")}
6866	}
6867	if v.SubscriptionDefinitionId != nil {
6868		if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil {
6869			return err
6870		}
6871	}
6872
6873	return nil
6874}
6875
6876func awsRestjson1_serializeOpDocumentUpdateSubscriptionDefinitionInput(v *UpdateSubscriptionDefinitionInput, value smithyjson.Value) error {
6877	object := value.Object()
6878	defer object.Close()
6879
6880	if v.Name != nil {
6881		ok := object.Key("Name")
6882		ok.String(*v.Name)
6883	}
6884
6885	return nil
6886}
6887
6888type awsRestjson1_serializeOpUpdateThingRuntimeConfiguration struct {
6889}
6890
6891func (*awsRestjson1_serializeOpUpdateThingRuntimeConfiguration) ID() string {
6892	return "OperationSerializer"
6893}
6894
6895func (m *awsRestjson1_serializeOpUpdateThingRuntimeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6896	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6897) {
6898	request, ok := in.Request.(*smithyhttp.Request)
6899	if !ok {
6900		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6901	}
6902
6903	input, ok := in.Parameters.(*UpdateThingRuntimeConfigurationInput)
6904	_ = input
6905	if !ok {
6906		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6907	}
6908
6909	opPath, opQuery := httpbinding.SplitURI("/greengrass/things/{ThingName}/runtimeconfig")
6910	request.URL.Path = opPath
6911	if len(request.URL.RawQuery) > 0 {
6912		request.URL.RawQuery = "&" + opQuery
6913	} else {
6914		request.URL.RawQuery = opQuery
6915	}
6916
6917	request.Method = "PUT"
6918	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6919	if err != nil {
6920		return out, metadata, &smithy.SerializationError{Err: err}
6921	}
6922
6923	if err := awsRestjson1_serializeOpHttpBindingsUpdateThingRuntimeConfigurationInput(input, restEncoder); err != nil {
6924		return out, metadata, &smithy.SerializationError{Err: err}
6925	}
6926
6927	restEncoder.SetHeader("Content-Type").String("application/json")
6928
6929	jsonEncoder := smithyjson.NewEncoder()
6930	if err := awsRestjson1_serializeOpDocumentUpdateThingRuntimeConfigurationInput(input, jsonEncoder.Value); err != nil {
6931		return out, metadata, &smithy.SerializationError{Err: err}
6932	}
6933
6934	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6935		return out, metadata, &smithy.SerializationError{Err: err}
6936	}
6937
6938	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6939		return out, metadata, &smithy.SerializationError{Err: err}
6940	}
6941	in.Request = request
6942
6943	return next.HandleSerialize(ctx, in)
6944}
6945func awsRestjson1_serializeOpHttpBindingsUpdateThingRuntimeConfigurationInput(v *UpdateThingRuntimeConfigurationInput, encoder *httpbinding.Encoder) error {
6946	if v == nil {
6947		return fmt.Errorf("unsupported serialization of nil %T", v)
6948	}
6949
6950	if v.ThingName == nil || len(*v.ThingName) == 0 {
6951		return &smithy.SerializationError{Err: fmt.Errorf("input member ThingName must not be empty")}
6952	}
6953	if v.ThingName != nil {
6954		if err := encoder.SetURI("ThingName").String(*v.ThingName); err != nil {
6955			return err
6956		}
6957	}
6958
6959	return nil
6960}
6961
6962func awsRestjson1_serializeOpDocumentUpdateThingRuntimeConfigurationInput(v *UpdateThingRuntimeConfigurationInput, value smithyjson.Value) error {
6963	object := value.Object()
6964	defer object.Close()
6965
6966	if v.TelemetryConfiguration != nil {
6967		ok := object.Key("TelemetryConfiguration")
6968		if err := awsRestjson1_serializeDocumentTelemetryConfigurationUpdate(v.TelemetryConfiguration, ok); err != nil {
6969			return err
6970		}
6971	}
6972
6973	return nil
6974}
6975
6976func awsRestjson1_serializeDocument__listOf__string(v []string, value smithyjson.Value) error {
6977	array := value.Array()
6978	defer array.Close()
6979
6980	for i := range v {
6981		av := array.Value()
6982		av.String(v[i])
6983	}
6984	return nil
6985}
6986
6987func awsRestjson1_serializeDocument__listOfConnectivityInfo(v []types.ConnectivityInfo, value smithyjson.Value) error {
6988	array := value.Array()
6989	defer array.Close()
6990
6991	for i := range v {
6992		av := array.Value()
6993		if err := awsRestjson1_serializeDocumentConnectivityInfo(&v[i], av); err != nil {
6994			return err
6995		}
6996	}
6997	return nil
6998}
6999
7000func awsRestjson1_serializeDocument__listOfConnector(v []types.Connector, value smithyjson.Value) error {
7001	array := value.Array()
7002	defer array.Close()
7003
7004	for i := range v {
7005		av := array.Value()
7006		if err := awsRestjson1_serializeDocumentConnector(&v[i], av); err != nil {
7007			return err
7008		}
7009	}
7010	return nil
7011}
7012
7013func awsRestjson1_serializeDocument__listOfCore(v []types.Core, value smithyjson.Value) error {
7014	array := value.Array()
7015	defer array.Close()
7016
7017	for i := range v {
7018		av := array.Value()
7019		if err := awsRestjson1_serializeDocumentCore(&v[i], av); err != nil {
7020			return err
7021		}
7022	}
7023	return nil
7024}
7025
7026func awsRestjson1_serializeDocument__listOfDevice(v []types.Device, value smithyjson.Value) error {
7027	array := value.Array()
7028	defer array.Close()
7029
7030	for i := range v {
7031		av := array.Value()
7032		if err := awsRestjson1_serializeDocumentDevice(&v[i], av); err != nil {
7033			return err
7034		}
7035	}
7036	return nil
7037}
7038
7039func awsRestjson1_serializeDocument__listOfFunction(v []types.Function, value smithyjson.Value) error {
7040	array := value.Array()
7041	defer array.Close()
7042
7043	for i := range v {
7044		av := array.Value()
7045		if err := awsRestjson1_serializeDocumentFunction(&v[i], av); err != nil {
7046			return err
7047		}
7048	}
7049	return nil
7050}
7051
7052func awsRestjson1_serializeDocument__listOfLogger(v []types.Logger, value smithyjson.Value) error {
7053	array := value.Array()
7054	defer array.Close()
7055
7056	for i := range v {
7057		av := array.Value()
7058		if err := awsRestjson1_serializeDocumentLogger(&v[i], av); err != nil {
7059			return err
7060		}
7061	}
7062	return nil
7063}
7064
7065func awsRestjson1_serializeDocument__listOfResource(v []types.Resource, value smithyjson.Value) error {
7066	array := value.Array()
7067	defer array.Close()
7068
7069	for i := range v {
7070		av := array.Value()
7071		if err := awsRestjson1_serializeDocumentResource(&v[i], av); err != nil {
7072			return err
7073		}
7074	}
7075	return nil
7076}
7077
7078func awsRestjson1_serializeDocument__listOfResourceAccessPolicy(v []types.ResourceAccessPolicy, value smithyjson.Value) error {
7079	array := value.Array()
7080	defer array.Close()
7081
7082	for i := range v {
7083		av := array.Value()
7084		if err := awsRestjson1_serializeDocumentResourceAccessPolicy(&v[i], av); err != nil {
7085			return err
7086		}
7087	}
7088	return nil
7089}
7090
7091func awsRestjson1_serializeDocument__listOfSubscription(v []types.Subscription, value smithyjson.Value) error {
7092	array := value.Array()
7093	defer array.Close()
7094
7095	for i := range v {
7096		av := array.Value()
7097		if err := awsRestjson1_serializeDocumentSubscription(&v[i], av); err != nil {
7098			return err
7099		}
7100	}
7101	return nil
7102}
7103
7104func awsRestjson1_serializeDocument__mapOf__string(v map[string]string, value smithyjson.Value) error {
7105	object := value.Object()
7106	defer object.Close()
7107
7108	for key := range v {
7109		om := object.Key(key)
7110		om.String(v[key])
7111	}
7112	return nil
7113}
7114
7115func awsRestjson1_serializeDocumentConnectivityInfo(v *types.ConnectivityInfo, value smithyjson.Value) error {
7116	object := value.Object()
7117	defer object.Close()
7118
7119	if v.HostAddress != nil {
7120		ok := object.Key("HostAddress")
7121		ok.String(*v.HostAddress)
7122	}
7123
7124	if v.Id != nil {
7125		ok := object.Key("Id")
7126		ok.String(*v.Id)
7127	}
7128
7129	if v.Metadata != nil {
7130		ok := object.Key("Metadata")
7131		ok.String(*v.Metadata)
7132	}
7133
7134	if v.PortNumber != 0 {
7135		ok := object.Key("PortNumber")
7136		ok.Integer(v.PortNumber)
7137	}
7138
7139	return nil
7140}
7141
7142func awsRestjson1_serializeDocumentConnector(v *types.Connector, value smithyjson.Value) error {
7143	object := value.Object()
7144	defer object.Close()
7145
7146	if v.ConnectorArn != nil {
7147		ok := object.Key("ConnectorArn")
7148		ok.String(*v.ConnectorArn)
7149	}
7150
7151	if v.Id != nil {
7152		ok := object.Key("Id")
7153		ok.String(*v.Id)
7154	}
7155
7156	if v.Parameters != nil {
7157		ok := object.Key("Parameters")
7158		if err := awsRestjson1_serializeDocument__mapOf__string(v.Parameters, ok); err != nil {
7159			return err
7160		}
7161	}
7162
7163	return nil
7164}
7165
7166func awsRestjson1_serializeDocumentConnectorDefinitionVersion(v *types.ConnectorDefinitionVersion, value smithyjson.Value) error {
7167	object := value.Object()
7168	defer object.Close()
7169
7170	if v.Connectors != nil {
7171		ok := object.Key("Connectors")
7172		if err := awsRestjson1_serializeDocument__listOfConnector(v.Connectors, ok); err != nil {
7173			return err
7174		}
7175	}
7176
7177	return nil
7178}
7179
7180func awsRestjson1_serializeDocumentCore(v *types.Core, value smithyjson.Value) error {
7181	object := value.Object()
7182	defer object.Close()
7183
7184	if v.CertificateArn != nil {
7185		ok := object.Key("CertificateArn")
7186		ok.String(*v.CertificateArn)
7187	}
7188
7189	if v.Id != nil {
7190		ok := object.Key("Id")
7191		ok.String(*v.Id)
7192	}
7193
7194	if v.SyncShadow {
7195		ok := object.Key("SyncShadow")
7196		ok.Boolean(v.SyncShadow)
7197	}
7198
7199	if v.ThingArn != nil {
7200		ok := object.Key("ThingArn")
7201		ok.String(*v.ThingArn)
7202	}
7203
7204	return nil
7205}
7206
7207func awsRestjson1_serializeDocumentCoreDefinitionVersion(v *types.CoreDefinitionVersion, value smithyjson.Value) error {
7208	object := value.Object()
7209	defer object.Close()
7210
7211	if v.Cores != nil {
7212		ok := object.Key("Cores")
7213		if err := awsRestjson1_serializeDocument__listOfCore(v.Cores, ok); err != nil {
7214			return err
7215		}
7216	}
7217
7218	return nil
7219}
7220
7221func awsRestjson1_serializeDocumentDevice(v *types.Device, value smithyjson.Value) error {
7222	object := value.Object()
7223	defer object.Close()
7224
7225	if v.CertificateArn != nil {
7226		ok := object.Key("CertificateArn")
7227		ok.String(*v.CertificateArn)
7228	}
7229
7230	if v.Id != nil {
7231		ok := object.Key("Id")
7232		ok.String(*v.Id)
7233	}
7234
7235	if v.SyncShadow {
7236		ok := object.Key("SyncShadow")
7237		ok.Boolean(v.SyncShadow)
7238	}
7239
7240	if v.ThingArn != nil {
7241		ok := object.Key("ThingArn")
7242		ok.String(*v.ThingArn)
7243	}
7244
7245	return nil
7246}
7247
7248func awsRestjson1_serializeDocumentDeviceDefinitionVersion(v *types.DeviceDefinitionVersion, value smithyjson.Value) error {
7249	object := value.Object()
7250	defer object.Close()
7251
7252	if v.Devices != nil {
7253		ok := object.Key("Devices")
7254		if err := awsRestjson1_serializeDocument__listOfDevice(v.Devices, ok); err != nil {
7255			return err
7256		}
7257	}
7258
7259	return nil
7260}
7261
7262func awsRestjson1_serializeDocumentFunction(v *types.Function, value smithyjson.Value) error {
7263	object := value.Object()
7264	defer object.Close()
7265
7266	if v.FunctionArn != nil {
7267		ok := object.Key("FunctionArn")
7268		ok.String(*v.FunctionArn)
7269	}
7270
7271	if v.FunctionConfiguration != nil {
7272		ok := object.Key("FunctionConfiguration")
7273		if err := awsRestjson1_serializeDocumentFunctionConfiguration(v.FunctionConfiguration, ok); err != nil {
7274			return err
7275		}
7276	}
7277
7278	if v.Id != nil {
7279		ok := object.Key("Id")
7280		ok.String(*v.Id)
7281	}
7282
7283	return nil
7284}
7285
7286func awsRestjson1_serializeDocumentFunctionConfiguration(v *types.FunctionConfiguration, value smithyjson.Value) error {
7287	object := value.Object()
7288	defer object.Close()
7289
7290	if len(v.EncodingType) > 0 {
7291		ok := object.Key("EncodingType")
7292		ok.String(string(v.EncodingType))
7293	}
7294
7295	if v.Environment != nil {
7296		ok := object.Key("Environment")
7297		if err := awsRestjson1_serializeDocumentFunctionConfigurationEnvironment(v.Environment, ok); err != nil {
7298			return err
7299		}
7300	}
7301
7302	if v.ExecArgs != nil {
7303		ok := object.Key("ExecArgs")
7304		ok.String(*v.ExecArgs)
7305	}
7306
7307	if v.Executable != nil {
7308		ok := object.Key("Executable")
7309		ok.String(*v.Executable)
7310	}
7311
7312	if v.MemorySize != 0 {
7313		ok := object.Key("MemorySize")
7314		ok.Integer(v.MemorySize)
7315	}
7316
7317	if v.Pinned {
7318		ok := object.Key("Pinned")
7319		ok.Boolean(v.Pinned)
7320	}
7321
7322	if v.Timeout != 0 {
7323		ok := object.Key("Timeout")
7324		ok.Integer(v.Timeout)
7325	}
7326
7327	return nil
7328}
7329
7330func awsRestjson1_serializeDocumentFunctionConfigurationEnvironment(v *types.FunctionConfigurationEnvironment, value smithyjson.Value) error {
7331	object := value.Object()
7332	defer object.Close()
7333
7334	if v.AccessSysfs {
7335		ok := object.Key("AccessSysfs")
7336		ok.Boolean(v.AccessSysfs)
7337	}
7338
7339	if v.Execution != nil {
7340		ok := object.Key("Execution")
7341		if err := awsRestjson1_serializeDocumentFunctionExecutionConfig(v.Execution, ok); err != nil {
7342			return err
7343		}
7344	}
7345
7346	if v.ResourceAccessPolicies != nil {
7347		ok := object.Key("ResourceAccessPolicies")
7348		if err := awsRestjson1_serializeDocument__listOfResourceAccessPolicy(v.ResourceAccessPolicies, ok); err != nil {
7349			return err
7350		}
7351	}
7352
7353	if v.Variables != nil {
7354		ok := object.Key("Variables")
7355		if err := awsRestjson1_serializeDocument__mapOf__string(v.Variables, ok); err != nil {
7356			return err
7357		}
7358	}
7359
7360	return nil
7361}
7362
7363func awsRestjson1_serializeDocumentFunctionDefaultConfig(v *types.FunctionDefaultConfig, value smithyjson.Value) error {
7364	object := value.Object()
7365	defer object.Close()
7366
7367	if v.Execution != nil {
7368		ok := object.Key("Execution")
7369		if err := awsRestjson1_serializeDocumentFunctionDefaultExecutionConfig(v.Execution, ok); err != nil {
7370			return err
7371		}
7372	}
7373
7374	return nil
7375}
7376
7377func awsRestjson1_serializeDocumentFunctionDefaultExecutionConfig(v *types.FunctionDefaultExecutionConfig, value smithyjson.Value) error {
7378	object := value.Object()
7379	defer object.Close()
7380
7381	if len(v.IsolationMode) > 0 {
7382		ok := object.Key("IsolationMode")
7383		ok.String(string(v.IsolationMode))
7384	}
7385
7386	if v.RunAs != nil {
7387		ok := object.Key("RunAs")
7388		if err := awsRestjson1_serializeDocumentFunctionRunAsConfig(v.RunAs, ok); err != nil {
7389			return err
7390		}
7391	}
7392
7393	return nil
7394}
7395
7396func awsRestjson1_serializeDocumentFunctionDefinitionVersion(v *types.FunctionDefinitionVersion, value smithyjson.Value) error {
7397	object := value.Object()
7398	defer object.Close()
7399
7400	if v.DefaultConfig != nil {
7401		ok := object.Key("DefaultConfig")
7402		if err := awsRestjson1_serializeDocumentFunctionDefaultConfig(v.DefaultConfig, ok); err != nil {
7403			return err
7404		}
7405	}
7406
7407	if v.Functions != nil {
7408		ok := object.Key("Functions")
7409		if err := awsRestjson1_serializeDocument__listOfFunction(v.Functions, ok); err != nil {
7410			return err
7411		}
7412	}
7413
7414	return nil
7415}
7416
7417func awsRestjson1_serializeDocumentFunctionExecutionConfig(v *types.FunctionExecutionConfig, value smithyjson.Value) error {
7418	object := value.Object()
7419	defer object.Close()
7420
7421	if len(v.IsolationMode) > 0 {
7422		ok := object.Key("IsolationMode")
7423		ok.String(string(v.IsolationMode))
7424	}
7425
7426	if v.RunAs != nil {
7427		ok := object.Key("RunAs")
7428		if err := awsRestjson1_serializeDocumentFunctionRunAsConfig(v.RunAs, ok); err != nil {
7429			return err
7430		}
7431	}
7432
7433	return nil
7434}
7435
7436func awsRestjson1_serializeDocumentFunctionRunAsConfig(v *types.FunctionRunAsConfig, value smithyjson.Value) error {
7437	object := value.Object()
7438	defer object.Close()
7439
7440	if v.Gid != 0 {
7441		ok := object.Key("Gid")
7442		ok.Integer(v.Gid)
7443	}
7444
7445	if v.Uid != 0 {
7446		ok := object.Key("Uid")
7447		ok.Integer(v.Uid)
7448	}
7449
7450	return nil
7451}
7452
7453func awsRestjson1_serializeDocumentGroupOwnerSetting(v *types.GroupOwnerSetting, value smithyjson.Value) error {
7454	object := value.Object()
7455	defer object.Close()
7456
7457	if v.AutoAddGroupOwner {
7458		ok := object.Key("AutoAddGroupOwner")
7459		ok.Boolean(v.AutoAddGroupOwner)
7460	}
7461
7462	if v.GroupOwner != nil {
7463		ok := object.Key("GroupOwner")
7464		ok.String(*v.GroupOwner)
7465	}
7466
7467	return nil
7468}
7469
7470func awsRestjson1_serializeDocumentGroupVersion(v *types.GroupVersion, value smithyjson.Value) error {
7471	object := value.Object()
7472	defer object.Close()
7473
7474	if v.ConnectorDefinitionVersionArn != nil {
7475		ok := object.Key("ConnectorDefinitionVersionArn")
7476		ok.String(*v.ConnectorDefinitionVersionArn)
7477	}
7478
7479	if v.CoreDefinitionVersionArn != nil {
7480		ok := object.Key("CoreDefinitionVersionArn")
7481		ok.String(*v.CoreDefinitionVersionArn)
7482	}
7483
7484	if v.DeviceDefinitionVersionArn != nil {
7485		ok := object.Key("DeviceDefinitionVersionArn")
7486		ok.String(*v.DeviceDefinitionVersionArn)
7487	}
7488
7489	if v.FunctionDefinitionVersionArn != nil {
7490		ok := object.Key("FunctionDefinitionVersionArn")
7491		ok.String(*v.FunctionDefinitionVersionArn)
7492	}
7493
7494	if v.LoggerDefinitionVersionArn != nil {
7495		ok := object.Key("LoggerDefinitionVersionArn")
7496		ok.String(*v.LoggerDefinitionVersionArn)
7497	}
7498
7499	if v.ResourceDefinitionVersionArn != nil {
7500		ok := object.Key("ResourceDefinitionVersionArn")
7501		ok.String(*v.ResourceDefinitionVersionArn)
7502	}
7503
7504	if v.SubscriptionDefinitionVersionArn != nil {
7505		ok := object.Key("SubscriptionDefinitionVersionArn")
7506		ok.String(*v.SubscriptionDefinitionVersionArn)
7507	}
7508
7509	return nil
7510}
7511
7512func awsRestjson1_serializeDocumentLocalDeviceResourceData(v *types.LocalDeviceResourceData, value smithyjson.Value) error {
7513	object := value.Object()
7514	defer object.Close()
7515
7516	if v.GroupOwnerSetting != nil {
7517		ok := object.Key("GroupOwnerSetting")
7518		if err := awsRestjson1_serializeDocumentGroupOwnerSetting(v.GroupOwnerSetting, ok); err != nil {
7519			return err
7520		}
7521	}
7522
7523	if v.SourcePath != nil {
7524		ok := object.Key("SourcePath")
7525		ok.String(*v.SourcePath)
7526	}
7527
7528	return nil
7529}
7530
7531func awsRestjson1_serializeDocumentLocalVolumeResourceData(v *types.LocalVolumeResourceData, value smithyjson.Value) error {
7532	object := value.Object()
7533	defer object.Close()
7534
7535	if v.DestinationPath != nil {
7536		ok := object.Key("DestinationPath")
7537		ok.String(*v.DestinationPath)
7538	}
7539
7540	if v.GroupOwnerSetting != nil {
7541		ok := object.Key("GroupOwnerSetting")
7542		if err := awsRestjson1_serializeDocumentGroupOwnerSetting(v.GroupOwnerSetting, ok); err != nil {
7543			return err
7544		}
7545	}
7546
7547	if v.SourcePath != nil {
7548		ok := object.Key("SourcePath")
7549		ok.String(*v.SourcePath)
7550	}
7551
7552	return nil
7553}
7554
7555func awsRestjson1_serializeDocumentLogger(v *types.Logger, value smithyjson.Value) error {
7556	object := value.Object()
7557	defer object.Close()
7558
7559	if len(v.Component) > 0 {
7560		ok := object.Key("Component")
7561		ok.String(string(v.Component))
7562	}
7563
7564	if v.Id != nil {
7565		ok := object.Key("Id")
7566		ok.String(*v.Id)
7567	}
7568
7569	if len(v.Level) > 0 {
7570		ok := object.Key("Level")
7571		ok.String(string(v.Level))
7572	}
7573
7574	if v.Space != 0 {
7575		ok := object.Key("Space")
7576		ok.Integer(v.Space)
7577	}
7578
7579	if len(v.Type) > 0 {
7580		ok := object.Key("Type")
7581		ok.String(string(v.Type))
7582	}
7583
7584	return nil
7585}
7586
7587func awsRestjson1_serializeDocumentLoggerDefinitionVersion(v *types.LoggerDefinitionVersion, value smithyjson.Value) error {
7588	object := value.Object()
7589	defer object.Close()
7590
7591	if v.Loggers != nil {
7592		ok := object.Key("Loggers")
7593		if err := awsRestjson1_serializeDocument__listOfLogger(v.Loggers, ok); err != nil {
7594			return err
7595		}
7596	}
7597
7598	return nil
7599}
7600
7601func awsRestjson1_serializeDocumentResource(v *types.Resource, value smithyjson.Value) error {
7602	object := value.Object()
7603	defer object.Close()
7604
7605	if v.Id != nil {
7606		ok := object.Key("Id")
7607		ok.String(*v.Id)
7608	}
7609
7610	if v.Name != nil {
7611		ok := object.Key("Name")
7612		ok.String(*v.Name)
7613	}
7614
7615	if v.ResourceDataContainer != nil {
7616		ok := object.Key("ResourceDataContainer")
7617		if err := awsRestjson1_serializeDocumentResourceDataContainer(v.ResourceDataContainer, ok); err != nil {
7618			return err
7619		}
7620	}
7621
7622	return nil
7623}
7624
7625func awsRestjson1_serializeDocumentResourceAccessPolicy(v *types.ResourceAccessPolicy, value smithyjson.Value) error {
7626	object := value.Object()
7627	defer object.Close()
7628
7629	if len(v.Permission) > 0 {
7630		ok := object.Key("Permission")
7631		ok.String(string(v.Permission))
7632	}
7633
7634	if v.ResourceId != nil {
7635		ok := object.Key("ResourceId")
7636		ok.String(*v.ResourceId)
7637	}
7638
7639	return nil
7640}
7641
7642func awsRestjson1_serializeDocumentResourceDataContainer(v *types.ResourceDataContainer, value smithyjson.Value) error {
7643	object := value.Object()
7644	defer object.Close()
7645
7646	if v.LocalDeviceResourceData != nil {
7647		ok := object.Key("LocalDeviceResourceData")
7648		if err := awsRestjson1_serializeDocumentLocalDeviceResourceData(v.LocalDeviceResourceData, ok); err != nil {
7649			return err
7650		}
7651	}
7652
7653	if v.LocalVolumeResourceData != nil {
7654		ok := object.Key("LocalVolumeResourceData")
7655		if err := awsRestjson1_serializeDocumentLocalVolumeResourceData(v.LocalVolumeResourceData, ok); err != nil {
7656			return err
7657		}
7658	}
7659
7660	if v.S3MachineLearningModelResourceData != nil {
7661		ok := object.Key("S3MachineLearningModelResourceData")
7662		if err := awsRestjson1_serializeDocumentS3MachineLearningModelResourceData(v.S3MachineLearningModelResourceData, ok); err != nil {
7663			return err
7664		}
7665	}
7666
7667	if v.SageMakerMachineLearningModelResourceData != nil {
7668		ok := object.Key("SageMakerMachineLearningModelResourceData")
7669		if err := awsRestjson1_serializeDocumentSageMakerMachineLearningModelResourceData(v.SageMakerMachineLearningModelResourceData, ok); err != nil {
7670			return err
7671		}
7672	}
7673
7674	if v.SecretsManagerSecretResourceData != nil {
7675		ok := object.Key("SecretsManagerSecretResourceData")
7676		if err := awsRestjson1_serializeDocumentSecretsManagerSecretResourceData(v.SecretsManagerSecretResourceData, ok); err != nil {
7677			return err
7678		}
7679	}
7680
7681	return nil
7682}
7683
7684func awsRestjson1_serializeDocumentResourceDefinitionVersion(v *types.ResourceDefinitionVersion, value smithyjson.Value) error {
7685	object := value.Object()
7686	defer object.Close()
7687
7688	if v.Resources != nil {
7689		ok := object.Key("Resources")
7690		if err := awsRestjson1_serializeDocument__listOfResource(v.Resources, ok); err != nil {
7691			return err
7692		}
7693	}
7694
7695	return nil
7696}
7697
7698func awsRestjson1_serializeDocumentResourceDownloadOwnerSetting(v *types.ResourceDownloadOwnerSetting, value smithyjson.Value) error {
7699	object := value.Object()
7700	defer object.Close()
7701
7702	if v.GroupOwner != nil {
7703		ok := object.Key("GroupOwner")
7704		ok.String(*v.GroupOwner)
7705	}
7706
7707	if len(v.GroupPermission) > 0 {
7708		ok := object.Key("GroupPermission")
7709		ok.String(string(v.GroupPermission))
7710	}
7711
7712	return nil
7713}
7714
7715func awsRestjson1_serializeDocumentS3MachineLearningModelResourceData(v *types.S3MachineLearningModelResourceData, value smithyjson.Value) error {
7716	object := value.Object()
7717	defer object.Close()
7718
7719	if v.DestinationPath != nil {
7720		ok := object.Key("DestinationPath")
7721		ok.String(*v.DestinationPath)
7722	}
7723
7724	if v.OwnerSetting != nil {
7725		ok := object.Key("OwnerSetting")
7726		if err := awsRestjson1_serializeDocumentResourceDownloadOwnerSetting(v.OwnerSetting, ok); err != nil {
7727			return err
7728		}
7729	}
7730
7731	if v.S3Uri != nil {
7732		ok := object.Key("S3Uri")
7733		ok.String(*v.S3Uri)
7734	}
7735
7736	return nil
7737}
7738
7739func awsRestjson1_serializeDocumentSageMakerMachineLearningModelResourceData(v *types.SageMakerMachineLearningModelResourceData, value smithyjson.Value) error {
7740	object := value.Object()
7741	defer object.Close()
7742
7743	if v.DestinationPath != nil {
7744		ok := object.Key("DestinationPath")
7745		ok.String(*v.DestinationPath)
7746	}
7747
7748	if v.OwnerSetting != nil {
7749		ok := object.Key("OwnerSetting")
7750		if err := awsRestjson1_serializeDocumentResourceDownloadOwnerSetting(v.OwnerSetting, ok); err != nil {
7751			return err
7752		}
7753	}
7754
7755	if v.SageMakerJobArn != nil {
7756		ok := object.Key("SageMakerJobArn")
7757		ok.String(*v.SageMakerJobArn)
7758	}
7759
7760	return nil
7761}
7762
7763func awsRestjson1_serializeDocumentSecretsManagerSecretResourceData(v *types.SecretsManagerSecretResourceData, value smithyjson.Value) error {
7764	object := value.Object()
7765	defer object.Close()
7766
7767	if v.AdditionalStagingLabelsToDownload != nil {
7768		ok := object.Key("AdditionalStagingLabelsToDownload")
7769		if err := awsRestjson1_serializeDocument__listOf__string(v.AdditionalStagingLabelsToDownload, ok); err != nil {
7770			return err
7771		}
7772	}
7773
7774	if v.ARN != nil {
7775		ok := object.Key("ARN")
7776		ok.String(*v.ARN)
7777	}
7778
7779	return nil
7780}
7781
7782func awsRestjson1_serializeDocumentSubscription(v *types.Subscription, value smithyjson.Value) error {
7783	object := value.Object()
7784	defer object.Close()
7785
7786	if v.Id != nil {
7787		ok := object.Key("Id")
7788		ok.String(*v.Id)
7789	}
7790
7791	if v.Source != nil {
7792		ok := object.Key("Source")
7793		ok.String(*v.Source)
7794	}
7795
7796	if v.Subject != nil {
7797		ok := object.Key("Subject")
7798		ok.String(*v.Subject)
7799	}
7800
7801	if v.Target != nil {
7802		ok := object.Key("Target")
7803		ok.String(*v.Target)
7804	}
7805
7806	return nil
7807}
7808
7809func awsRestjson1_serializeDocumentSubscriptionDefinitionVersion(v *types.SubscriptionDefinitionVersion, value smithyjson.Value) error {
7810	object := value.Object()
7811	defer object.Close()
7812
7813	if v.Subscriptions != nil {
7814		ok := object.Key("Subscriptions")
7815		if err := awsRestjson1_serializeDocument__listOfSubscription(v.Subscriptions, ok); err != nil {
7816			return err
7817		}
7818	}
7819
7820	return nil
7821}
7822
7823func awsRestjson1_serializeDocumentTags(v map[string]string, value smithyjson.Value) error {
7824	object := value.Object()
7825	defer object.Close()
7826
7827	for key := range v {
7828		om := object.Key(key)
7829		om.String(v[key])
7830	}
7831	return nil
7832}
7833
7834func awsRestjson1_serializeDocumentTelemetryConfigurationUpdate(v *types.TelemetryConfigurationUpdate, value smithyjson.Value) error {
7835	object := value.Object()
7836	defer object.Close()
7837
7838	if len(v.Telemetry) > 0 {
7839		ok := object.Key("Telemetry")
7840		ok.String(string(v.Telemetry))
7841	}
7842
7843	return nil
7844}
7845
7846func awsRestjson1_serializeDocumentUpdateTargets(v []string, value smithyjson.Value) error {
7847	array := value.Array()
7848	defer array.Close()
7849
7850	for i := range v {
7851		av := array.Value()
7852		av.String(v[i])
7853	}
7854	return nil
7855}
7856