1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package serverlessapplicationrepository
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/serverlessapplicationrepository/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_serializeOpCreateApplication struct {
18}
19
20func (*awsRestjson1_serializeOpCreateApplication) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsRestjson1_serializeOpCreateApplication) 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.(*CreateApplicationInput)
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("/applications")
39	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
40	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
41	request.Method = "POST"
42	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
43	if err != nil {
44		return out, metadata, &smithy.SerializationError{Err: err}
45	}
46
47	restEncoder.SetHeader("Content-Type").String("application/json")
48
49	jsonEncoder := smithyjson.NewEncoder()
50	if err := awsRestjson1_serializeOpDocumentCreateApplicationInput(input, jsonEncoder.Value); err != nil {
51		return out, metadata, &smithy.SerializationError{Err: err}
52	}
53
54	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
55		return out, metadata, &smithy.SerializationError{Err: err}
56	}
57
58	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
59		return out, metadata, &smithy.SerializationError{Err: err}
60	}
61	in.Request = request
62
63	return next.HandleSerialize(ctx, in)
64}
65func awsRestjson1_serializeOpHttpBindingsCreateApplicationInput(v *CreateApplicationInput, encoder *httpbinding.Encoder) error {
66	if v == nil {
67		return fmt.Errorf("unsupported serialization of nil %T", v)
68	}
69
70	return nil
71}
72
73func awsRestjson1_serializeOpDocumentCreateApplicationInput(v *CreateApplicationInput, value smithyjson.Value) error {
74	object := value.Object()
75	defer object.Close()
76
77	if v.Author != nil {
78		ok := object.Key("author")
79		ok.String(*v.Author)
80	}
81
82	if v.Description != nil {
83		ok := object.Key("description")
84		ok.String(*v.Description)
85	}
86
87	if v.HomePageUrl != nil {
88		ok := object.Key("homePageUrl")
89		ok.String(*v.HomePageUrl)
90	}
91
92	if v.Labels != nil {
93		ok := object.Key("labels")
94		if err := awsRestjson1_serializeDocument__listOf__string(v.Labels, ok); err != nil {
95			return err
96		}
97	}
98
99	if v.LicenseBody != nil {
100		ok := object.Key("licenseBody")
101		ok.String(*v.LicenseBody)
102	}
103
104	if v.LicenseUrl != nil {
105		ok := object.Key("licenseUrl")
106		ok.String(*v.LicenseUrl)
107	}
108
109	if v.Name != nil {
110		ok := object.Key("name")
111		ok.String(*v.Name)
112	}
113
114	if v.ReadmeBody != nil {
115		ok := object.Key("readmeBody")
116		ok.String(*v.ReadmeBody)
117	}
118
119	if v.ReadmeUrl != nil {
120		ok := object.Key("readmeUrl")
121		ok.String(*v.ReadmeUrl)
122	}
123
124	if v.SemanticVersion != nil {
125		ok := object.Key("semanticVersion")
126		ok.String(*v.SemanticVersion)
127	}
128
129	if v.SourceCodeArchiveUrl != nil {
130		ok := object.Key("sourceCodeArchiveUrl")
131		ok.String(*v.SourceCodeArchiveUrl)
132	}
133
134	if v.SourceCodeUrl != nil {
135		ok := object.Key("sourceCodeUrl")
136		ok.String(*v.SourceCodeUrl)
137	}
138
139	if v.SpdxLicenseId != nil {
140		ok := object.Key("spdxLicenseId")
141		ok.String(*v.SpdxLicenseId)
142	}
143
144	if v.TemplateBody != nil {
145		ok := object.Key("templateBody")
146		ok.String(*v.TemplateBody)
147	}
148
149	if v.TemplateUrl != nil {
150		ok := object.Key("templateUrl")
151		ok.String(*v.TemplateUrl)
152	}
153
154	return nil
155}
156
157type awsRestjson1_serializeOpCreateApplicationVersion struct {
158}
159
160func (*awsRestjson1_serializeOpCreateApplicationVersion) ID() string {
161	return "OperationSerializer"
162}
163
164func (m *awsRestjson1_serializeOpCreateApplicationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
165	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
166) {
167	request, ok := in.Request.(*smithyhttp.Request)
168	if !ok {
169		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
170	}
171
172	input, ok := in.Parameters.(*CreateApplicationVersionInput)
173	_ = input
174	if !ok {
175		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
176	}
177
178	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/versions/{SemanticVersion}")
179	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
180	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
181	request.Method = "PUT"
182	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
183	if err != nil {
184		return out, metadata, &smithy.SerializationError{Err: err}
185	}
186
187	if err := awsRestjson1_serializeOpHttpBindingsCreateApplicationVersionInput(input, restEncoder); err != nil {
188		return out, metadata, &smithy.SerializationError{Err: err}
189	}
190
191	restEncoder.SetHeader("Content-Type").String("application/json")
192
193	jsonEncoder := smithyjson.NewEncoder()
194	if err := awsRestjson1_serializeOpDocumentCreateApplicationVersionInput(input, jsonEncoder.Value); err != nil {
195		return out, metadata, &smithy.SerializationError{Err: err}
196	}
197
198	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
199		return out, metadata, &smithy.SerializationError{Err: err}
200	}
201
202	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
203		return out, metadata, &smithy.SerializationError{Err: err}
204	}
205	in.Request = request
206
207	return next.HandleSerialize(ctx, in)
208}
209func awsRestjson1_serializeOpHttpBindingsCreateApplicationVersionInput(v *CreateApplicationVersionInput, encoder *httpbinding.Encoder) error {
210	if v == nil {
211		return fmt.Errorf("unsupported serialization of nil %T", v)
212	}
213
214	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
215		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
216	}
217	if v.ApplicationId != nil {
218		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
219			return err
220		}
221	}
222
223	if v.SemanticVersion == nil || len(*v.SemanticVersion) == 0 {
224		return &smithy.SerializationError{Err: fmt.Errorf("input member SemanticVersion must not be empty")}
225	}
226	if v.SemanticVersion != nil {
227		if err := encoder.SetURI("SemanticVersion").String(*v.SemanticVersion); err != nil {
228			return err
229		}
230	}
231
232	return nil
233}
234
235func awsRestjson1_serializeOpDocumentCreateApplicationVersionInput(v *CreateApplicationVersionInput, value smithyjson.Value) error {
236	object := value.Object()
237	defer object.Close()
238
239	if v.SourceCodeArchiveUrl != nil {
240		ok := object.Key("sourceCodeArchiveUrl")
241		ok.String(*v.SourceCodeArchiveUrl)
242	}
243
244	if v.SourceCodeUrl != nil {
245		ok := object.Key("sourceCodeUrl")
246		ok.String(*v.SourceCodeUrl)
247	}
248
249	if v.TemplateBody != nil {
250		ok := object.Key("templateBody")
251		ok.String(*v.TemplateBody)
252	}
253
254	if v.TemplateUrl != nil {
255		ok := object.Key("templateUrl")
256		ok.String(*v.TemplateUrl)
257	}
258
259	return nil
260}
261
262type awsRestjson1_serializeOpCreateCloudFormationChangeSet struct {
263}
264
265func (*awsRestjson1_serializeOpCreateCloudFormationChangeSet) ID() string {
266	return "OperationSerializer"
267}
268
269func (m *awsRestjson1_serializeOpCreateCloudFormationChangeSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
270	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
271) {
272	request, ok := in.Request.(*smithyhttp.Request)
273	if !ok {
274		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
275	}
276
277	input, ok := in.Parameters.(*CreateCloudFormationChangeSetInput)
278	_ = input
279	if !ok {
280		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
281	}
282
283	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/changesets")
284	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
285	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
286	request.Method = "POST"
287	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
288	if err != nil {
289		return out, metadata, &smithy.SerializationError{Err: err}
290	}
291
292	if err := awsRestjson1_serializeOpHttpBindingsCreateCloudFormationChangeSetInput(input, restEncoder); err != nil {
293		return out, metadata, &smithy.SerializationError{Err: err}
294	}
295
296	restEncoder.SetHeader("Content-Type").String("application/json")
297
298	jsonEncoder := smithyjson.NewEncoder()
299	if err := awsRestjson1_serializeOpDocumentCreateCloudFormationChangeSetInput(input, jsonEncoder.Value); err != nil {
300		return out, metadata, &smithy.SerializationError{Err: err}
301	}
302
303	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
304		return out, metadata, &smithy.SerializationError{Err: err}
305	}
306
307	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
308		return out, metadata, &smithy.SerializationError{Err: err}
309	}
310	in.Request = request
311
312	return next.HandleSerialize(ctx, in)
313}
314func awsRestjson1_serializeOpHttpBindingsCreateCloudFormationChangeSetInput(v *CreateCloudFormationChangeSetInput, encoder *httpbinding.Encoder) error {
315	if v == nil {
316		return fmt.Errorf("unsupported serialization of nil %T", v)
317	}
318
319	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
320		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
321	}
322	if v.ApplicationId != nil {
323		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
324			return err
325		}
326	}
327
328	return nil
329}
330
331func awsRestjson1_serializeOpDocumentCreateCloudFormationChangeSetInput(v *CreateCloudFormationChangeSetInput, value smithyjson.Value) error {
332	object := value.Object()
333	defer object.Close()
334
335	if v.Capabilities != nil {
336		ok := object.Key("capabilities")
337		if err := awsRestjson1_serializeDocument__listOf__string(v.Capabilities, ok); err != nil {
338			return err
339		}
340	}
341
342	if v.ChangeSetName != nil {
343		ok := object.Key("changeSetName")
344		ok.String(*v.ChangeSetName)
345	}
346
347	if v.ClientToken != nil {
348		ok := object.Key("clientToken")
349		ok.String(*v.ClientToken)
350	}
351
352	if v.Description != nil {
353		ok := object.Key("description")
354		ok.String(*v.Description)
355	}
356
357	if v.NotificationArns != nil {
358		ok := object.Key("notificationArns")
359		if err := awsRestjson1_serializeDocument__listOf__string(v.NotificationArns, ok); err != nil {
360			return err
361		}
362	}
363
364	if v.ParameterOverrides != nil {
365		ok := object.Key("parameterOverrides")
366		if err := awsRestjson1_serializeDocument__listOfParameterValue(v.ParameterOverrides, ok); err != nil {
367			return err
368		}
369	}
370
371	if v.ResourceTypes != nil {
372		ok := object.Key("resourceTypes")
373		if err := awsRestjson1_serializeDocument__listOf__string(v.ResourceTypes, ok); err != nil {
374			return err
375		}
376	}
377
378	if v.RollbackConfiguration != nil {
379		ok := object.Key("rollbackConfiguration")
380		if err := awsRestjson1_serializeDocumentRollbackConfiguration(v.RollbackConfiguration, ok); err != nil {
381			return err
382		}
383	}
384
385	if v.SemanticVersion != nil {
386		ok := object.Key("semanticVersion")
387		ok.String(*v.SemanticVersion)
388	}
389
390	if v.StackName != nil {
391		ok := object.Key("stackName")
392		ok.String(*v.StackName)
393	}
394
395	if v.Tags != nil {
396		ok := object.Key("tags")
397		if err := awsRestjson1_serializeDocument__listOfTag(v.Tags, ok); err != nil {
398			return err
399		}
400	}
401
402	if v.TemplateId != nil {
403		ok := object.Key("templateId")
404		ok.String(*v.TemplateId)
405	}
406
407	return nil
408}
409
410type awsRestjson1_serializeOpCreateCloudFormationTemplate struct {
411}
412
413func (*awsRestjson1_serializeOpCreateCloudFormationTemplate) ID() string {
414	return "OperationSerializer"
415}
416
417func (m *awsRestjson1_serializeOpCreateCloudFormationTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
418	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
419) {
420	request, ok := in.Request.(*smithyhttp.Request)
421	if !ok {
422		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
423	}
424
425	input, ok := in.Parameters.(*CreateCloudFormationTemplateInput)
426	_ = input
427	if !ok {
428		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
429	}
430
431	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/templates")
432	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
433	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
434	request.Method = "POST"
435	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
436	if err != nil {
437		return out, metadata, &smithy.SerializationError{Err: err}
438	}
439
440	if err := awsRestjson1_serializeOpHttpBindingsCreateCloudFormationTemplateInput(input, restEncoder); err != nil {
441		return out, metadata, &smithy.SerializationError{Err: err}
442	}
443
444	restEncoder.SetHeader("Content-Type").String("application/json")
445
446	jsonEncoder := smithyjson.NewEncoder()
447	if err := awsRestjson1_serializeOpDocumentCreateCloudFormationTemplateInput(input, jsonEncoder.Value); err != nil {
448		return out, metadata, &smithy.SerializationError{Err: err}
449	}
450
451	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
452		return out, metadata, &smithy.SerializationError{Err: err}
453	}
454
455	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
456		return out, metadata, &smithy.SerializationError{Err: err}
457	}
458	in.Request = request
459
460	return next.HandleSerialize(ctx, in)
461}
462func awsRestjson1_serializeOpHttpBindingsCreateCloudFormationTemplateInput(v *CreateCloudFormationTemplateInput, encoder *httpbinding.Encoder) error {
463	if v == nil {
464		return fmt.Errorf("unsupported serialization of nil %T", v)
465	}
466
467	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
468		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
469	}
470	if v.ApplicationId != nil {
471		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
472			return err
473		}
474	}
475
476	return nil
477}
478
479func awsRestjson1_serializeOpDocumentCreateCloudFormationTemplateInput(v *CreateCloudFormationTemplateInput, value smithyjson.Value) error {
480	object := value.Object()
481	defer object.Close()
482
483	if v.SemanticVersion != nil {
484		ok := object.Key("semanticVersion")
485		ok.String(*v.SemanticVersion)
486	}
487
488	return nil
489}
490
491type awsRestjson1_serializeOpDeleteApplication struct {
492}
493
494func (*awsRestjson1_serializeOpDeleteApplication) ID() string {
495	return "OperationSerializer"
496}
497
498func (m *awsRestjson1_serializeOpDeleteApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
499	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
500) {
501	request, ok := in.Request.(*smithyhttp.Request)
502	if !ok {
503		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
504	}
505
506	input, ok := in.Parameters.(*DeleteApplicationInput)
507	_ = input
508	if !ok {
509		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
510	}
511
512	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}")
513	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
514	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
515	request.Method = "DELETE"
516	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
517	if err != nil {
518		return out, metadata, &smithy.SerializationError{Err: err}
519	}
520
521	if err := awsRestjson1_serializeOpHttpBindingsDeleteApplicationInput(input, restEncoder); err != nil {
522		return out, metadata, &smithy.SerializationError{Err: err}
523	}
524
525	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
526		return out, metadata, &smithy.SerializationError{Err: err}
527	}
528	in.Request = request
529
530	return next.HandleSerialize(ctx, in)
531}
532func awsRestjson1_serializeOpHttpBindingsDeleteApplicationInput(v *DeleteApplicationInput, encoder *httpbinding.Encoder) error {
533	if v == nil {
534		return fmt.Errorf("unsupported serialization of nil %T", v)
535	}
536
537	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
538		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
539	}
540	if v.ApplicationId != nil {
541		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
542			return err
543		}
544	}
545
546	return nil
547}
548
549type awsRestjson1_serializeOpGetApplication struct {
550}
551
552func (*awsRestjson1_serializeOpGetApplication) ID() string {
553	return "OperationSerializer"
554}
555
556func (m *awsRestjson1_serializeOpGetApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
557	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
558) {
559	request, ok := in.Request.(*smithyhttp.Request)
560	if !ok {
561		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
562	}
563
564	input, ok := in.Parameters.(*GetApplicationInput)
565	_ = input
566	if !ok {
567		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
568	}
569
570	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}")
571	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
572	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
573	request.Method = "GET"
574	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
575	if err != nil {
576		return out, metadata, &smithy.SerializationError{Err: err}
577	}
578
579	if err := awsRestjson1_serializeOpHttpBindingsGetApplicationInput(input, restEncoder); err != nil {
580		return out, metadata, &smithy.SerializationError{Err: err}
581	}
582
583	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
584		return out, metadata, &smithy.SerializationError{Err: err}
585	}
586	in.Request = request
587
588	return next.HandleSerialize(ctx, in)
589}
590func awsRestjson1_serializeOpHttpBindingsGetApplicationInput(v *GetApplicationInput, encoder *httpbinding.Encoder) error {
591	if v == nil {
592		return fmt.Errorf("unsupported serialization of nil %T", v)
593	}
594
595	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
596		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
597	}
598	if v.ApplicationId != nil {
599		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
600			return err
601		}
602	}
603
604	if v.SemanticVersion != nil {
605		encoder.SetQuery("semanticVersion").String(*v.SemanticVersion)
606	}
607
608	return nil
609}
610
611type awsRestjson1_serializeOpGetApplicationPolicy struct {
612}
613
614func (*awsRestjson1_serializeOpGetApplicationPolicy) ID() string {
615	return "OperationSerializer"
616}
617
618func (m *awsRestjson1_serializeOpGetApplicationPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
619	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
620) {
621	request, ok := in.Request.(*smithyhttp.Request)
622	if !ok {
623		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
624	}
625
626	input, ok := in.Parameters.(*GetApplicationPolicyInput)
627	_ = input
628	if !ok {
629		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
630	}
631
632	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/policy")
633	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
634	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
635	request.Method = "GET"
636	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
637	if err != nil {
638		return out, metadata, &smithy.SerializationError{Err: err}
639	}
640
641	if err := awsRestjson1_serializeOpHttpBindingsGetApplicationPolicyInput(input, restEncoder); err != nil {
642		return out, metadata, &smithy.SerializationError{Err: err}
643	}
644
645	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
646		return out, metadata, &smithy.SerializationError{Err: err}
647	}
648	in.Request = request
649
650	return next.HandleSerialize(ctx, in)
651}
652func awsRestjson1_serializeOpHttpBindingsGetApplicationPolicyInput(v *GetApplicationPolicyInput, encoder *httpbinding.Encoder) error {
653	if v == nil {
654		return fmt.Errorf("unsupported serialization of nil %T", v)
655	}
656
657	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
658		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
659	}
660	if v.ApplicationId != nil {
661		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
662			return err
663		}
664	}
665
666	return nil
667}
668
669type awsRestjson1_serializeOpGetCloudFormationTemplate struct {
670}
671
672func (*awsRestjson1_serializeOpGetCloudFormationTemplate) ID() string {
673	return "OperationSerializer"
674}
675
676func (m *awsRestjson1_serializeOpGetCloudFormationTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
677	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
678) {
679	request, ok := in.Request.(*smithyhttp.Request)
680	if !ok {
681		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
682	}
683
684	input, ok := in.Parameters.(*GetCloudFormationTemplateInput)
685	_ = input
686	if !ok {
687		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
688	}
689
690	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/templates/{TemplateId}")
691	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
692	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
693	request.Method = "GET"
694	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
695	if err != nil {
696		return out, metadata, &smithy.SerializationError{Err: err}
697	}
698
699	if err := awsRestjson1_serializeOpHttpBindingsGetCloudFormationTemplateInput(input, restEncoder); err != nil {
700		return out, metadata, &smithy.SerializationError{Err: err}
701	}
702
703	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
704		return out, metadata, &smithy.SerializationError{Err: err}
705	}
706	in.Request = request
707
708	return next.HandleSerialize(ctx, in)
709}
710func awsRestjson1_serializeOpHttpBindingsGetCloudFormationTemplateInput(v *GetCloudFormationTemplateInput, encoder *httpbinding.Encoder) error {
711	if v == nil {
712		return fmt.Errorf("unsupported serialization of nil %T", v)
713	}
714
715	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
716		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
717	}
718	if v.ApplicationId != nil {
719		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
720			return err
721		}
722	}
723
724	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
725		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
726	}
727	if v.TemplateId != nil {
728		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
729			return err
730		}
731	}
732
733	return nil
734}
735
736type awsRestjson1_serializeOpListApplicationDependencies struct {
737}
738
739func (*awsRestjson1_serializeOpListApplicationDependencies) ID() string {
740	return "OperationSerializer"
741}
742
743func (m *awsRestjson1_serializeOpListApplicationDependencies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
744	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
745) {
746	request, ok := in.Request.(*smithyhttp.Request)
747	if !ok {
748		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
749	}
750
751	input, ok := in.Parameters.(*ListApplicationDependenciesInput)
752	_ = input
753	if !ok {
754		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
755	}
756
757	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/dependencies")
758	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
759	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
760	request.Method = "GET"
761	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
762	if err != nil {
763		return out, metadata, &smithy.SerializationError{Err: err}
764	}
765
766	if err := awsRestjson1_serializeOpHttpBindingsListApplicationDependenciesInput(input, restEncoder); err != nil {
767		return out, metadata, &smithy.SerializationError{Err: err}
768	}
769
770	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
771		return out, metadata, &smithy.SerializationError{Err: err}
772	}
773	in.Request = request
774
775	return next.HandleSerialize(ctx, in)
776}
777func awsRestjson1_serializeOpHttpBindingsListApplicationDependenciesInput(v *ListApplicationDependenciesInput, encoder *httpbinding.Encoder) error {
778	if v == nil {
779		return fmt.Errorf("unsupported serialization of nil %T", v)
780	}
781
782	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
783		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
784	}
785	if v.ApplicationId != nil {
786		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
787			return err
788		}
789	}
790
791	if v.MaxItems != 0 {
792		encoder.SetQuery("maxItems").Integer(v.MaxItems)
793	}
794
795	if v.NextToken != nil {
796		encoder.SetQuery("nextToken").String(*v.NextToken)
797	}
798
799	if v.SemanticVersion != nil {
800		encoder.SetQuery("semanticVersion").String(*v.SemanticVersion)
801	}
802
803	return nil
804}
805
806type awsRestjson1_serializeOpListApplications struct {
807}
808
809func (*awsRestjson1_serializeOpListApplications) ID() string {
810	return "OperationSerializer"
811}
812
813func (m *awsRestjson1_serializeOpListApplications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
814	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
815) {
816	request, ok := in.Request.(*smithyhttp.Request)
817	if !ok {
818		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
819	}
820
821	input, ok := in.Parameters.(*ListApplicationsInput)
822	_ = input
823	if !ok {
824		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
825	}
826
827	opPath, opQuery := httpbinding.SplitURI("/applications")
828	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
829	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
830	request.Method = "GET"
831	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
832	if err != nil {
833		return out, metadata, &smithy.SerializationError{Err: err}
834	}
835
836	if err := awsRestjson1_serializeOpHttpBindingsListApplicationsInput(input, restEncoder); err != nil {
837		return out, metadata, &smithy.SerializationError{Err: err}
838	}
839
840	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
841		return out, metadata, &smithy.SerializationError{Err: err}
842	}
843	in.Request = request
844
845	return next.HandleSerialize(ctx, in)
846}
847func awsRestjson1_serializeOpHttpBindingsListApplicationsInput(v *ListApplicationsInput, encoder *httpbinding.Encoder) error {
848	if v == nil {
849		return fmt.Errorf("unsupported serialization of nil %T", v)
850	}
851
852	if v.MaxItems != 0 {
853		encoder.SetQuery("maxItems").Integer(v.MaxItems)
854	}
855
856	if v.NextToken != nil {
857		encoder.SetQuery("nextToken").String(*v.NextToken)
858	}
859
860	return nil
861}
862
863type awsRestjson1_serializeOpListApplicationVersions struct {
864}
865
866func (*awsRestjson1_serializeOpListApplicationVersions) ID() string {
867	return "OperationSerializer"
868}
869
870func (m *awsRestjson1_serializeOpListApplicationVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
871	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
872) {
873	request, ok := in.Request.(*smithyhttp.Request)
874	if !ok {
875		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
876	}
877
878	input, ok := in.Parameters.(*ListApplicationVersionsInput)
879	_ = input
880	if !ok {
881		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
882	}
883
884	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/versions")
885	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
886	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
887	request.Method = "GET"
888	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
889	if err != nil {
890		return out, metadata, &smithy.SerializationError{Err: err}
891	}
892
893	if err := awsRestjson1_serializeOpHttpBindingsListApplicationVersionsInput(input, restEncoder); err != nil {
894		return out, metadata, &smithy.SerializationError{Err: err}
895	}
896
897	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
898		return out, metadata, &smithy.SerializationError{Err: err}
899	}
900	in.Request = request
901
902	return next.HandleSerialize(ctx, in)
903}
904func awsRestjson1_serializeOpHttpBindingsListApplicationVersionsInput(v *ListApplicationVersionsInput, encoder *httpbinding.Encoder) error {
905	if v == nil {
906		return fmt.Errorf("unsupported serialization of nil %T", v)
907	}
908
909	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
910		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
911	}
912	if v.ApplicationId != nil {
913		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
914			return err
915		}
916	}
917
918	if v.MaxItems != 0 {
919		encoder.SetQuery("maxItems").Integer(v.MaxItems)
920	}
921
922	if v.NextToken != nil {
923		encoder.SetQuery("nextToken").String(*v.NextToken)
924	}
925
926	return nil
927}
928
929type awsRestjson1_serializeOpPutApplicationPolicy struct {
930}
931
932func (*awsRestjson1_serializeOpPutApplicationPolicy) ID() string {
933	return "OperationSerializer"
934}
935
936func (m *awsRestjson1_serializeOpPutApplicationPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
937	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
938) {
939	request, ok := in.Request.(*smithyhttp.Request)
940	if !ok {
941		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
942	}
943
944	input, ok := in.Parameters.(*PutApplicationPolicyInput)
945	_ = input
946	if !ok {
947		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
948	}
949
950	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/policy")
951	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
952	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
953	request.Method = "PUT"
954	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
955	if err != nil {
956		return out, metadata, &smithy.SerializationError{Err: err}
957	}
958
959	if err := awsRestjson1_serializeOpHttpBindingsPutApplicationPolicyInput(input, restEncoder); err != nil {
960		return out, metadata, &smithy.SerializationError{Err: err}
961	}
962
963	restEncoder.SetHeader("Content-Type").String("application/json")
964
965	jsonEncoder := smithyjson.NewEncoder()
966	if err := awsRestjson1_serializeOpDocumentPutApplicationPolicyInput(input, jsonEncoder.Value); err != nil {
967		return out, metadata, &smithy.SerializationError{Err: err}
968	}
969
970	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
971		return out, metadata, &smithy.SerializationError{Err: err}
972	}
973
974	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
975		return out, metadata, &smithy.SerializationError{Err: err}
976	}
977	in.Request = request
978
979	return next.HandleSerialize(ctx, in)
980}
981func awsRestjson1_serializeOpHttpBindingsPutApplicationPolicyInput(v *PutApplicationPolicyInput, encoder *httpbinding.Encoder) error {
982	if v == nil {
983		return fmt.Errorf("unsupported serialization of nil %T", v)
984	}
985
986	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
987		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
988	}
989	if v.ApplicationId != nil {
990		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
991			return err
992		}
993	}
994
995	return nil
996}
997
998func awsRestjson1_serializeOpDocumentPutApplicationPolicyInput(v *PutApplicationPolicyInput, value smithyjson.Value) error {
999	object := value.Object()
1000	defer object.Close()
1001
1002	if v.Statements != nil {
1003		ok := object.Key("statements")
1004		if err := awsRestjson1_serializeDocument__listOfApplicationPolicyStatement(v.Statements, ok); err != nil {
1005			return err
1006		}
1007	}
1008
1009	return nil
1010}
1011
1012type awsRestjson1_serializeOpUnshareApplication struct {
1013}
1014
1015func (*awsRestjson1_serializeOpUnshareApplication) ID() string {
1016	return "OperationSerializer"
1017}
1018
1019func (m *awsRestjson1_serializeOpUnshareApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1020	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1021) {
1022	request, ok := in.Request.(*smithyhttp.Request)
1023	if !ok {
1024		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1025	}
1026
1027	input, ok := in.Parameters.(*UnshareApplicationInput)
1028	_ = input
1029	if !ok {
1030		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1031	}
1032
1033	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/unshare")
1034	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1035	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1036	request.Method = "POST"
1037	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1038	if err != nil {
1039		return out, metadata, &smithy.SerializationError{Err: err}
1040	}
1041
1042	if err := awsRestjson1_serializeOpHttpBindingsUnshareApplicationInput(input, restEncoder); err != nil {
1043		return out, metadata, &smithy.SerializationError{Err: err}
1044	}
1045
1046	restEncoder.SetHeader("Content-Type").String("application/json")
1047
1048	jsonEncoder := smithyjson.NewEncoder()
1049	if err := awsRestjson1_serializeOpDocumentUnshareApplicationInput(input, jsonEncoder.Value); err != nil {
1050		return out, metadata, &smithy.SerializationError{Err: err}
1051	}
1052
1053	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1054		return out, metadata, &smithy.SerializationError{Err: err}
1055	}
1056
1057	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1058		return out, metadata, &smithy.SerializationError{Err: err}
1059	}
1060	in.Request = request
1061
1062	return next.HandleSerialize(ctx, in)
1063}
1064func awsRestjson1_serializeOpHttpBindingsUnshareApplicationInput(v *UnshareApplicationInput, encoder *httpbinding.Encoder) error {
1065	if v == nil {
1066		return fmt.Errorf("unsupported serialization of nil %T", v)
1067	}
1068
1069	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1070		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1071	}
1072	if v.ApplicationId != nil {
1073		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1074			return err
1075		}
1076	}
1077
1078	return nil
1079}
1080
1081func awsRestjson1_serializeOpDocumentUnshareApplicationInput(v *UnshareApplicationInput, value smithyjson.Value) error {
1082	object := value.Object()
1083	defer object.Close()
1084
1085	if v.OrganizationId != nil {
1086		ok := object.Key("organizationId")
1087		ok.String(*v.OrganizationId)
1088	}
1089
1090	return nil
1091}
1092
1093type awsRestjson1_serializeOpUpdateApplication struct {
1094}
1095
1096func (*awsRestjson1_serializeOpUpdateApplication) ID() string {
1097	return "OperationSerializer"
1098}
1099
1100func (m *awsRestjson1_serializeOpUpdateApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1101	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	request, ok := in.Request.(*smithyhttp.Request)
1104	if !ok {
1105		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1106	}
1107
1108	input, ok := in.Parameters.(*UpdateApplicationInput)
1109	_ = input
1110	if !ok {
1111		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1112	}
1113
1114	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}")
1115	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1116	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1117	request.Method = "PATCH"
1118	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1119	if err != nil {
1120		return out, metadata, &smithy.SerializationError{Err: err}
1121	}
1122
1123	if err := awsRestjson1_serializeOpHttpBindingsUpdateApplicationInput(input, restEncoder); err != nil {
1124		return out, metadata, &smithy.SerializationError{Err: err}
1125	}
1126
1127	restEncoder.SetHeader("Content-Type").String("application/json")
1128
1129	jsonEncoder := smithyjson.NewEncoder()
1130	if err := awsRestjson1_serializeOpDocumentUpdateApplicationInput(input, jsonEncoder.Value); err != nil {
1131		return out, metadata, &smithy.SerializationError{Err: err}
1132	}
1133
1134	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1135		return out, metadata, &smithy.SerializationError{Err: err}
1136	}
1137
1138	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1139		return out, metadata, &smithy.SerializationError{Err: err}
1140	}
1141	in.Request = request
1142
1143	return next.HandleSerialize(ctx, in)
1144}
1145func awsRestjson1_serializeOpHttpBindingsUpdateApplicationInput(v *UpdateApplicationInput, encoder *httpbinding.Encoder) error {
1146	if v == nil {
1147		return fmt.Errorf("unsupported serialization of nil %T", v)
1148	}
1149
1150	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1151		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1152	}
1153	if v.ApplicationId != nil {
1154		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1155			return err
1156		}
1157	}
1158
1159	return nil
1160}
1161
1162func awsRestjson1_serializeOpDocumentUpdateApplicationInput(v *UpdateApplicationInput, value smithyjson.Value) error {
1163	object := value.Object()
1164	defer object.Close()
1165
1166	if v.Author != nil {
1167		ok := object.Key("author")
1168		ok.String(*v.Author)
1169	}
1170
1171	if v.Description != nil {
1172		ok := object.Key("description")
1173		ok.String(*v.Description)
1174	}
1175
1176	if v.HomePageUrl != nil {
1177		ok := object.Key("homePageUrl")
1178		ok.String(*v.HomePageUrl)
1179	}
1180
1181	if v.Labels != nil {
1182		ok := object.Key("labels")
1183		if err := awsRestjson1_serializeDocument__listOf__string(v.Labels, ok); err != nil {
1184			return err
1185		}
1186	}
1187
1188	if v.ReadmeBody != nil {
1189		ok := object.Key("readmeBody")
1190		ok.String(*v.ReadmeBody)
1191	}
1192
1193	if v.ReadmeUrl != nil {
1194		ok := object.Key("readmeUrl")
1195		ok.String(*v.ReadmeUrl)
1196	}
1197
1198	return nil
1199}
1200
1201func awsRestjson1_serializeDocument__listOf__string(v []string, value smithyjson.Value) error {
1202	array := value.Array()
1203	defer array.Close()
1204
1205	for i := range v {
1206		av := array.Value()
1207		av.String(v[i])
1208	}
1209	return nil
1210}
1211
1212func awsRestjson1_serializeDocument__listOfApplicationPolicyStatement(v []types.ApplicationPolicyStatement, value smithyjson.Value) error {
1213	array := value.Array()
1214	defer array.Close()
1215
1216	for i := range v {
1217		av := array.Value()
1218		if err := awsRestjson1_serializeDocumentApplicationPolicyStatement(&v[i], av); err != nil {
1219			return err
1220		}
1221	}
1222	return nil
1223}
1224
1225func awsRestjson1_serializeDocument__listOfParameterValue(v []types.ParameterValue, value smithyjson.Value) error {
1226	array := value.Array()
1227	defer array.Close()
1228
1229	for i := range v {
1230		av := array.Value()
1231		if err := awsRestjson1_serializeDocumentParameterValue(&v[i], av); err != nil {
1232			return err
1233		}
1234	}
1235	return nil
1236}
1237
1238func awsRestjson1_serializeDocument__listOfRollbackTrigger(v []types.RollbackTrigger, value smithyjson.Value) error {
1239	array := value.Array()
1240	defer array.Close()
1241
1242	for i := range v {
1243		av := array.Value()
1244		if err := awsRestjson1_serializeDocumentRollbackTrigger(&v[i], av); err != nil {
1245			return err
1246		}
1247	}
1248	return nil
1249}
1250
1251func awsRestjson1_serializeDocument__listOfTag(v []types.Tag, value smithyjson.Value) error {
1252	array := value.Array()
1253	defer array.Close()
1254
1255	for i := range v {
1256		av := array.Value()
1257		if err := awsRestjson1_serializeDocumentTag(&v[i], av); err != nil {
1258			return err
1259		}
1260	}
1261	return nil
1262}
1263
1264func awsRestjson1_serializeDocumentApplicationPolicyStatement(v *types.ApplicationPolicyStatement, value smithyjson.Value) error {
1265	object := value.Object()
1266	defer object.Close()
1267
1268	if v.Actions != nil {
1269		ok := object.Key("actions")
1270		if err := awsRestjson1_serializeDocument__listOf__string(v.Actions, ok); err != nil {
1271			return err
1272		}
1273	}
1274
1275	if v.PrincipalOrgIDs != nil {
1276		ok := object.Key("principalOrgIDs")
1277		if err := awsRestjson1_serializeDocument__listOf__string(v.PrincipalOrgIDs, ok); err != nil {
1278			return err
1279		}
1280	}
1281
1282	if v.Principals != nil {
1283		ok := object.Key("principals")
1284		if err := awsRestjson1_serializeDocument__listOf__string(v.Principals, ok); err != nil {
1285			return err
1286		}
1287	}
1288
1289	if v.StatementId != nil {
1290		ok := object.Key("statementId")
1291		ok.String(*v.StatementId)
1292	}
1293
1294	return nil
1295}
1296
1297func awsRestjson1_serializeDocumentParameterValue(v *types.ParameterValue, value smithyjson.Value) error {
1298	object := value.Object()
1299	defer object.Close()
1300
1301	if v.Name != nil {
1302		ok := object.Key("name")
1303		ok.String(*v.Name)
1304	}
1305
1306	if v.Value != nil {
1307		ok := object.Key("value")
1308		ok.String(*v.Value)
1309	}
1310
1311	return nil
1312}
1313
1314func awsRestjson1_serializeDocumentRollbackConfiguration(v *types.RollbackConfiguration, value smithyjson.Value) error {
1315	object := value.Object()
1316	defer object.Close()
1317
1318	if v.MonitoringTimeInMinutes != 0 {
1319		ok := object.Key("monitoringTimeInMinutes")
1320		ok.Integer(v.MonitoringTimeInMinutes)
1321	}
1322
1323	if v.RollbackTriggers != nil {
1324		ok := object.Key("rollbackTriggers")
1325		if err := awsRestjson1_serializeDocument__listOfRollbackTrigger(v.RollbackTriggers, ok); err != nil {
1326			return err
1327		}
1328	}
1329
1330	return nil
1331}
1332
1333func awsRestjson1_serializeDocumentRollbackTrigger(v *types.RollbackTrigger, value smithyjson.Value) error {
1334	object := value.Object()
1335	defer object.Close()
1336
1337	if v.Arn != nil {
1338		ok := object.Key("arn")
1339		ok.String(*v.Arn)
1340	}
1341
1342	if v.Type != nil {
1343		ok := object.Key("type")
1344		ok.String(*v.Type)
1345	}
1346
1347	return nil
1348}
1349
1350func awsRestjson1_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
1351	object := value.Object()
1352	defer object.Close()
1353
1354	if v.Key != nil {
1355		ok := object.Key("key")
1356		ok.String(*v.Key)
1357	}
1358
1359	if v.Value != nil {
1360		ok := object.Key("value")
1361		ok.String(*v.Value)
1362	}
1363
1364	return nil
1365}
1366