1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package appconfig
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/appconfig/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 = opPath
40	if len(request.URL.RawQuery) > 0 {
41		request.URL.RawQuery = "&" + opQuery
42	} else {
43		request.URL.RawQuery = opQuery
44	}
45
46	request.Method = "POST"
47	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
48	if err != nil {
49		return out, metadata, &smithy.SerializationError{Err: err}
50	}
51
52	restEncoder.SetHeader("Content-Type").String("application/json")
53
54	jsonEncoder := smithyjson.NewEncoder()
55	if err := awsRestjson1_serializeOpDocumentCreateApplicationInput(input, jsonEncoder.Value); err != nil {
56		return out, metadata, &smithy.SerializationError{Err: err}
57	}
58
59	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
60		return out, metadata, &smithy.SerializationError{Err: err}
61	}
62
63	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
64		return out, metadata, &smithy.SerializationError{Err: err}
65	}
66	in.Request = request
67
68	return next.HandleSerialize(ctx, in)
69}
70func awsRestjson1_serializeOpHttpBindingsCreateApplicationInput(v *CreateApplicationInput, encoder *httpbinding.Encoder) error {
71	if v == nil {
72		return fmt.Errorf("unsupported serialization of nil %T", v)
73	}
74
75	return nil
76}
77
78func awsRestjson1_serializeOpDocumentCreateApplicationInput(v *CreateApplicationInput, value smithyjson.Value) error {
79	object := value.Object()
80	defer object.Close()
81
82	if v.Description != nil {
83		ok := object.Key("Description")
84		ok.String(*v.Description)
85	}
86
87	if v.Name != nil {
88		ok := object.Key("Name")
89		ok.String(*v.Name)
90	}
91
92	if v.Tags != nil {
93		ok := object.Key("Tags")
94		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
95			return err
96		}
97	}
98
99	return nil
100}
101
102type awsRestjson1_serializeOpCreateConfigurationProfile struct {
103}
104
105func (*awsRestjson1_serializeOpCreateConfigurationProfile) ID() string {
106	return "OperationSerializer"
107}
108
109func (m *awsRestjson1_serializeOpCreateConfigurationProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
110	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
111) {
112	request, ok := in.Request.(*smithyhttp.Request)
113	if !ok {
114		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
115	}
116
117	input, ok := in.Parameters.(*CreateConfigurationProfileInput)
118	_ = input
119	if !ok {
120		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
121	}
122
123	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles")
124	request.URL.Path = opPath
125	if len(request.URL.RawQuery) > 0 {
126		request.URL.RawQuery = "&" + opQuery
127	} else {
128		request.URL.RawQuery = opQuery
129	}
130
131	request.Method = "POST"
132	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
133	if err != nil {
134		return out, metadata, &smithy.SerializationError{Err: err}
135	}
136
137	if err := awsRestjson1_serializeOpHttpBindingsCreateConfigurationProfileInput(input, restEncoder); err != nil {
138		return out, metadata, &smithy.SerializationError{Err: err}
139	}
140
141	restEncoder.SetHeader("Content-Type").String("application/json")
142
143	jsonEncoder := smithyjson.NewEncoder()
144	if err := awsRestjson1_serializeOpDocumentCreateConfigurationProfileInput(input, jsonEncoder.Value); err != nil {
145		return out, metadata, &smithy.SerializationError{Err: err}
146	}
147
148	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
149		return out, metadata, &smithy.SerializationError{Err: err}
150	}
151
152	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
153		return out, metadata, &smithy.SerializationError{Err: err}
154	}
155	in.Request = request
156
157	return next.HandleSerialize(ctx, in)
158}
159func awsRestjson1_serializeOpHttpBindingsCreateConfigurationProfileInput(v *CreateConfigurationProfileInput, encoder *httpbinding.Encoder) error {
160	if v == nil {
161		return fmt.Errorf("unsupported serialization of nil %T", v)
162	}
163
164	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
165		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
166	}
167	if v.ApplicationId != nil {
168		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
169			return err
170		}
171	}
172
173	return nil
174}
175
176func awsRestjson1_serializeOpDocumentCreateConfigurationProfileInput(v *CreateConfigurationProfileInput, value smithyjson.Value) error {
177	object := value.Object()
178	defer object.Close()
179
180	if v.Description != nil {
181		ok := object.Key("Description")
182		ok.String(*v.Description)
183	}
184
185	if v.LocationUri != nil {
186		ok := object.Key("LocationUri")
187		ok.String(*v.LocationUri)
188	}
189
190	if v.Name != nil {
191		ok := object.Key("Name")
192		ok.String(*v.Name)
193	}
194
195	if v.RetrievalRoleArn != nil {
196		ok := object.Key("RetrievalRoleArn")
197		ok.String(*v.RetrievalRoleArn)
198	}
199
200	if v.Tags != nil {
201		ok := object.Key("Tags")
202		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
203			return err
204		}
205	}
206
207	if v.Validators != nil {
208		ok := object.Key("Validators")
209		if err := awsRestjson1_serializeDocumentValidatorList(v.Validators, ok); err != nil {
210			return err
211		}
212	}
213
214	return nil
215}
216
217type awsRestjson1_serializeOpCreateDeploymentStrategy struct {
218}
219
220func (*awsRestjson1_serializeOpCreateDeploymentStrategy) ID() string {
221	return "OperationSerializer"
222}
223
224func (m *awsRestjson1_serializeOpCreateDeploymentStrategy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
225	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
226) {
227	request, ok := in.Request.(*smithyhttp.Request)
228	if !ok {
229		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
230	}
231
232	input, ok := in.Parameters.(*CreateDeploymentStrategyInput)
233	_ = input
234	if !ok {
235		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
236	}
237
238	opPath, opQuery := httpbinding.SplitURI("/deploymentstrategies")
239	request.URL.Path = opPath
240	if len(request.URL.RawQuery) > 0 {
241		request.URL.RawQuery = "&" + opQuery
242	} else {
243		request.URL.RawQuery = opQuery
244	}
245
246	request.Method = "POST"
247	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
248	if err != nil {
249		return out, metadata, &smithy.SerializationError{Err: err}
250	}
251
252	restEncoder.SetHeader("Content-Type").String("application/json")
253
254	jsonEncoder := smithyjson.NewEncoder()
255	if err := awsRestjson1_serializeOpDocumentCreateDeploymentStrategyInput(input, jsonEncoder.Value); err != nil {
256		return out, metadata, &smithy.SerializationError{Err: err}
257	}
258
259	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
260		return out, metadata, &smithy.SerializationError{Err: err}
261	}
262
263	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
264		return out, metadata, &smithy.SerializationError{Err: err}
265	}
266	in.Request = request
267
268	return next.HandleSerialize(ctx, in)
269}
270func awsRestjson1_serializeOpHttpBindingsCreateDeploymentStrategyInput(v *CreateDeploymentStrategyInput, encoder *httpbinding.Encoder) error {
271	if v == nil {
272		return fmt.Errorf("unsupported serialization of nil %T", v)
273	}
274
275	return nil
276}
277
278func awsRestjson1_serializeOpDocumentCreateDeploymentStrategyInput(v *CreateDeploymentStrategyInput, value smithyjson.Value) error {
279	object := value.Object()
280	defer object.Close()
281
282	if v.DeploymentDurationInMinutes != 0 {
283		ok := object.Key("DeploymentDurationInMinutes")
284		ok.Integer(v.DeploymentDurationInMinutes)
285	}
286
287	if v.Description != nil {
288		ok := object.Key("Description")
289		ok.String(*v.Description)
290	}
291
292	if v.FinalBakeTimeInMinutes != 0 {
293		ok := object.Key("FinalBakeTimeInMinutes")
294		ok.Integer(v.FinalBakeTimeInMinutes)
295	}
296
297	if v.GrowthFactor != 0 {
298		ok := object.Key("GrowthFactor")
299		ok.Float(v.GrowthFactor)
300	}
301
302	if len(v.GrowthType) > 0 {
303		ok := object.Key("GrowthType")
304		ok.String(string(v.GrowthType))
305	}
306
307	if v.Name != nil {
308		ok := object.Key("Name")
309		ok.String(*v.Name)
310	}
311
312	if len(v.ReplicateTo) > 0 {
313		ok := object.Key("ReplicateTo")
314		ok.String(string(v.ReplicateTo))
315	}
316
317	if v.Tags != nil {
318		ok := object.Key("Tags")
319		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
320			return err
321		}
322	}
323
324	return nil
325}
326
327type awsRestjson1_serializeOpCreateEnvironment struct {
328}
329
330func (*awsRestjson1_serializeOpCreateEnvironment) ID() string {
331	return "OperationSerializer"
332}
333
334func (m *awsRestjson1_serializeOpCreateEnvironment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
335	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
336) {
337	request, ok := in.Request.(*smithyhttp.Request)
338	if !ok {
339		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
340	}
341
342	input, ok := in.Parameters.(*CreateEnvironmentInput)
343	_ = input
344	if !ok {
345		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
346	}
347
348	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments")
349	request.URL.Path = opPath
350	if len(request.URL.RawQuery) > 0 {
351		request.URL.RawQuery = "&" + opQuery
352	} else {
353		request.URL.RawQuery = opQuery
354	}
355
356	request.Method = "POST"
357	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
358	if err != nil {
359		return out, metadata, &smithy.SerializationError{Err: err}
360	}
361
362	if err := awsRestjson1_serializeOpHttpBindingsCreateEnvironmentInput(input, restEncoder); err != nil {
363		return out, metadata, &smithy.SerializationError{Err: err}
364	}
365
366	restEncoder.SetHeader("Content-Type").String("application/json")
367
368	jsonEncoder := smithyjson.NewEncoder()
369	if err := awsRestjson1_serializeOpDocumentCreateEnvironmentInput(input, jsonEncoder.Value); err != nil {
370		return out, metadata, &smithy.SerializationError{Err: err}
371	}
372
373	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
374		return out, metadata, &smithy.SerializationError{Err: err}
375	}
376
377	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
378		return out, metadata, &smithy.SerializationError{Err: err}
379	}
380	in.Request = request
381
382	return next.HandleSerialize(ctx, in)
383}
384func awsRestjson1_serializeOpHttpBindingsCreateEnvironmentInput(v *CreateEnvironmentInput, encoder *httpbinding.Encoder) error {
385	if v == nil {
386		return fmt.Errorf("unsupported serialization of nil %T", v)
387	}
388
389	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
390		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
391	}
392	if v.ApplicationId != nil {
393		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
394			return err
395		}
396	}
397
398	return nil
399}
400
401func awsRestjson1_serializeOpDocumentCreateEnvironmentInput(v *CreateEnvironmentInput, value smithyjson.Value) error {
402	object := value.Object()
403	defer object.Close()
404
405	if v.Description != nil {
406		ok := object.Key("Description")
407		ok.String(*v.Description)
408	}
409
410	if v.Monitors != nil {
411		ok := object.Key("Monitors")
412		if err := awsRestjson1_serializeDocumentMonitorList(v.Monitors, ok); err != nil {
413			return err
414		}
415	}
416
417	if v.Name != nil {
418		ok := object.Key("Name")
419		ok.String(*v.Name)
420	}
421
422	if v.Tags != nil {
423		ok := object.Key("Tags")
424		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
425			return err
426		}
427	}
428
429	return nil
430}
431
432type awsRestjson1_serializeOpCreateHostedConfigurationVersion struct {
433}
434
435func (*awsRestjson1_serializeOpCreateHostedConfigurationVersion) ID() string {
436	return "OperationSerializer"
437}
438
439func (m *awsRestjson1_serializeOpCreateHostedConfigurationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
440	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
441) {
442	request, ok := in.Request.(*smithyhttp.Request)
443	if !ok {
444		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
445	}
446
447	input, ok := in.Parameters.(*CreateHostedConfigurationVersionInput)
448	_ = input
449	if !ok {
450		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
451	}
452
453	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}/hostedconfigurationversions")
454	request.URL.Path = opPath
455	if len(request.URL.RawQuery) > 0 {
456		request.URL.RawQuery = "&" + opQuery
457	} else {
458		request.URL.RawQuery = opQuery
459	}
460
461	request.Method = "POST"
462	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
463	if err != nil {
464		return out, metadata, &smithy.SerializationError{Err: err}
465	}
466
467	if err := awsRestjson1_serializeOpHttpBindingsCreateHostedConfigurationVersionInput(input, restEncoder); err != nil {
468		return out, metadata, &smithy.SerializationError{Err: err}
469	}
470
471	if input.Content != nil {
472		if !restEncoder.HasHeader("Content-Type") {
473			restEncoder.SetHeader("Content-Type").String("application/octet-stream")
474		}
475
476		payload := bytes.NewReader(input.Content)
477		if request, err = request.SetStream(payload); err != nil {
478			return out, metadata, &smithy.SerializationError{Err: err}
479		}
480	}
481
482	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
483		return out, metadata, &smithy.SerializationError{Err: err}
484	}
485	in.Request = request
486
487	return next.HandleSerialize(ctx, in)
488}
489func awsRestjson1_serializeOpHttpBindingsCreateHostedConfigurationVersionInput(v *CreateHostedConfigurationVersionInput, encoder *httpbinding.Encoder) error {
490	if v == nil {
491		return fmt.Errorf("unsupported serialization of nil %T", v)
492	}
493
494	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
495		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
496	}
497	if v.ApplicationId != nil {
498		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
499			return err
500		}
501	}
502
503	if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 {
504		return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")}
505	}
506	if v.ConfigurationProfileId != nil {
507		if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil {
508			return err
509		}
510	}
511
512	if v.ContentType != nil && len(*v.ContentType) > 0 {
513		locationName := "Content-Type"
514		encoder.SetHeader(locationName).String(*v.ContentType)
515	}
516
517	if v.Description != nil && len(*v.Description) > 0 {
518		locationName := "Description"
519		encoder.SetHeader(locationName).String(*v.Description)
520	}
521
522	if v.LatestVersionNumber != 0 {
523		locationName := "Latest-Version-Number"
524		encoder.SetHeader(locationName).Integer(v.LatestVersionNumber)
525	}
526
527	return nil
528}
529
530type awsRestjson1_serializeOpDeleteApplication struct {
531}
532
533func (*awsRestjson1_serializeOpDeleteApplication) ID() string {
534	return "OperationSerializer"
535}
536
537func (m *awsRestjson1_serializeOpDeleteApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
538	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
539) {
540	request, ok := in.Request.(*smithyhttp.Request)
541	if !ok {
542		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
543	}
544
545	input, ok := in.Parameters.(*DeleteApplicationInput)
546	_ = input
547	if !ok {
548		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
549	}
550
551	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}")
552	request.URL.Path = opPath
553	if len(request.URL.RawQuery) > 0 {
554		request.URL.RawQuery = "&" + opQuery
555	} else {
556		request.URL.RawQuery = opQuery
557	}
558
559	request.Method = "DELETE"
560	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
561	if err != nil {
562		return out, metadata, &smithy.SerializationError{Err: err}
563	}
564
565	if err := awsRestjson1_serializeOpHttpBindingsDeleteApplicationInput(input, restEncoder); err != nil {
566		return out, metadata, &smithy.SerializationError{Err: err}
567	}
568
569	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
570		return out, metadata, &smithy.SerializationError{Err: err}
571	}
572	in.Request = request
573
574	return next.HandleSerialize(ctx, in)
575}
576func awsRestjson1_serializeOpHttpBindingsDeleteApplicationInput(v *DeleteApplicationInput, encoder *httpbinding.Encoder) error {
577	if v == nil {
578		return fmt.Errorf("unsupported serialization of nil %T", v)
579	}
580
581	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
582		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
583	}
584	if v.ApplicationId != nil {
585		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
586			return err
587		}
588	}
589
590	return nil
591}
592
593type awsRestjson1_serializeOpDeleteConfigurationProfile struct {
594}
595
596func (*awsRestjson1_serializeOpDeleteConfigurationProfile) ID() string {
597	return "OperationSerializer"
598}
599
600func (m *awsRestjson1_serializeOpDeleteConfigurationProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
601	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
602) {
603	request, ok := in.Request.(*smithyhttp.Request)
604	if !ok {
605		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
606	}
607
608	input, ok := in.Parameters.(*DeleteConfigurationProfileInput)
609	_ = input
610	if !ok {
611		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
612	}
613
614	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}")
615	request.URL.Path = opPath
616	if len(request.URL.RawQuery) > 0 {
617		request.URL.RawQuery = "&" + opQuery
618	} else {
619		request.URL.RawQuery = opQuery
620	}
621
622	request.Method = "DELETE"
623	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
624	if err != nil {
625		return out, metadata, &smithy.SerializationError{Err: err}
626	}
627
628	if err := awsRestjson1_serializeOpHttpBindingsDeleteConfigurationProfileInput(input, restEncoder); err != nil {
629		return out, metadata, &smithy.SerializationError{Err: err}
630	}
631
632	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
633		return out, metadata, &smithy.SerializationError{Err: err}
634	}
635	in.Request = request
636
637	return next.HandleSerialize(ctx, in)
638}
639func awsRestjson1_serializeOpHttpBindingsDeleteConfigurationProfileInput(v *DeleteConfigurationProfileInput, encoder *httpbinding.Encoder) error {
640	if v == nil {
641		return fmt.Errorf("unsupported serialization of nil %T", v)
642	}
643
644	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
645		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
646	}
647	if v.ApplicationId != nil {
648		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
649			return err
650		}
651	}
652
653	if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 {
654		return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")}
655	}
656	if v.ConfigurationProfileId != nil {
657		if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil {
658			return err
659		}
660	}
661
662	return nil
663}
664
665type awsRestjson1_serializeOpDeleteDeploymentStrategy struct {
666}
667
668func (*awsRestjson1_serializeOpDeleteDeploymentStrategy) ID() string {
669	return "OperationSerializer"
670}
671
672func (m *awsRestjson1_serializeOpDeleteDeploymentStrategy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
673	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
674) {
675	request, ok := in.Request.(*smithyhttp.Request)
676	if !ok {
677		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
678	}
679
680	input, ok := in.Parameters.(*DeleteDeploymentStrategyInput)
681	_ = input
682	if !ok {
683		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
684	}
685
686	opPath, opQuery := httpbinding.SplitURI("/deployementstrategies/{DeploymentStrategyId}")
687	request.URL.Path = opPath
688	if len(request.URL.RawQuery) > 0 {
689		request.URL.RawQuery = "&" + opQuery
690	} else {
691		request.URL.RawQuery = opQuery
692	}
693
694	request.Method = "DELETE"
695	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
696	if err != nil {
697		return out, metadata, &smithy.SerializationError{Err: err}
698	}
699
700	if err := awsRestjson1_serializeOpHttpBindingsDeleteDeploymentStrategyInput(input, restEncoder); err != nil {
701		return out, metadata, &smithy.SerializationError{Err: err}
702	}
703
704	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
705		return out, metadata, &smithy.SerializationError{Err: err}
706	}
707	in.Request = request
708
709	return next.HandleSerialize(ctx, in)
710}
711func awsRestjson1_serializeOpHttpBindingsDeleteDeploymentStrategyInput(v *DeleteDeploymentStrategyInput, encoder *httpbinding.Encoder) error {
712	if v == nil {
713		return fmt.Errorf("unsupported serialization of nil %T", v)
714	}
715
716	if v.DeploymentStrategyId == nil || len(*v.DeploymentStrategyId) == 0 {
717		return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentStrategyId must not be empty")}
718	}
719	if v.DeploymentStrategyId != nil {
720		if err := encoder.SetURI("DeploymentStrategyId").String(*v.DeploymentStrategyId); err != nil {
721			return err
722		}
723	}
724
725	return nil
726}
727
728type awsRestjson1_serializeOpDeleteEnvironment struct {
729}
730
731func (*awsRestjson1_serializeOpDeleteEnvironment) ID() string {
732	return "OperationSerializer"
733}
734
735func (m *awsRestjson1_serializeOpDeleteEnvironment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
736	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
737) {
738	request, ok := in.Request.(*smithyhttp.Request)
739	if !ok {
740		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
741	}
742
743	input, ok := in.Parameters.(*DeleteEnvironmentInput)
744	_ = input
745	if !ok {
746		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
747	}
748
749	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}")
750	request.URL.Path = opPath
751	if len(request.URL.RawQuery) > 0 {
752		request.URL.RawQuery = "&" + opQuery
753	} else {
754		request.URL.RawQuery = opQuery
755	}
756
757	request.Method = "DELETE"
758	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
759	if err != nil {
760		return out, metadata, &smithy.SerializationError{Err: err}
761	}
762
763	if err := awsRestjson1_serializeOpHttpBindingsDeleteEnvironmentInput(input, restEncoder); err != nil {
764		return out, metadata, &smithy.SerializationError{Err: err}
765	}
766
767	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
768		return out, metadata, &smithy.SerializationError{Err: err}
769	}
770	in.Request = request
771
772	return next.HandleSerialize(ctx, in)
773}
774func awsRestjson1_serializeOpHttpBindingsDeleteEnvironmentInput(v *DeleteEnvironmentInput, encoder *httpbinding.Encoder) error {
775	if v == nil {
776		return fmt.Errorf("unsupported serialization of nil %T", v)
777	}
778
779	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
780		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
781	}
782	if v.ApplicationId != nil {
783		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
784			return err
785		}
786	}
787
788	if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 {
789		return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")}
790	}
791	if v.EnvironmentId != nil {
792		if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil {
793			return err
794		}
795	}
796
797	return nil
798}
799
800type awsRestjson1_serializeOpDeleteHostedConfigurationVersion struct {
801}
802
803func (*awsRestjson1_serializeOpDeleteHostedConfigurationVersion) ID() string {
804	return "OperationSerializer"
805}
806
807func (m *awsRestjson1_serializeOpDeleteHostedConfigurationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
808	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
809) {
810	request, ok := in.Request.(*smithyhttp.Request)
811	if !ok {
812		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
813	}
814
815	input, ok := in.Parameters.(*DeleteHostedConfigurationVersionInput)
816	_ = input
817	if !ok {
818		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
819	}
820
821	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}/hostedconfigurationversions/{VersionNumber}")
822	request.URL.Path = opPath
823	if len(request.URL.RawQuery) > 0 {
824		request.URL.RawQuery = "&" + opQuery
825	} else {
826		request.URL.RawQuery = opQuery
827	}
828
829	request.Method = "DELETE"
830	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
831	if err != nil {
832		return out, metadata, &smithy.SerializationError{Err: err}
833	}
834
835	if err := awsRestjson1_serializeOpHttpBindingsDeleteHostedConfigurationVersionInput(input, restEncoder); err != nil {
836		return out, metadata, &smithy.SerializationError{Err: err}
837	}
838
839	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
840		return out, metadata, &smithy.SerializationError{Err: err}
841	}
842	in.Request = request
843
844	return next.HandleSerialize(ctx, in)
845}
846func awsRestjson1_serializeOpHttpBindingsDeleteHostedConfigurationVersionInput(v *DeleteHostedConfigurationVersionInput, encoder *httpbinding.Encoder) error {
847	if v == nil {
848		return fmt.Errorf("unsupported serialization of nil %T", v)
849	}
850
851	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
852		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
853	}
854	if v.ApplicationId != nil {
855		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
856			return err
857		}
858	}
859
860	if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 {
861		return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")}
862	}
863	if v.ConfigurationProfileId != nil {
864		if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil {
865			return err
866		}
867	}
868
869	if v.VersionNumber == 0 {
870		return &smithy.SerializationError{Err: fmt.Errorf("input member VersionNumber must not be empty")}
871	}
872	if v.VersionNumber != 0 {
873		if err := encoder.SetURI("VersionNumber").Integer(v.VersionNumber); err != nil {
874			return err
875		}
876	}
877
878	return nil
879}
880
881type awsRestjson1_serializeOpGetApplication struct {
882}
883
884func (*awsRestjson1_serializeOpGetApplication) ID() string {
885	return "OperationSerializer"
886}
887
888func (m *awsRestjson1_serializeOpGetApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
889	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
890) {
891	request, ok := in.Request.(*smithyhttp.Request)
892	if !ok {
893		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
894	}
895
896	input, ok := in.Parameters.(*GetApplicationInput)
897	_ = input
898	if !ok {
899		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
900	}
901
902	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}")
903	request.URL.Path = opPath
904	if len(request.URL.RawQuery) > 0 {
905		request.URL.RawQuery = "&" + opQuery
906	} else {
907		request.URL.RawQuery = opQuery
908	}
909
910	request.Method = "GET"
911	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
912	if err != nil {
913		return out, metadata, &smithy.SerializationError{Err: err}
914	}
915
916	if err := awsRestjson1_serializeOpHttpBindingsGetApplicationInput(input, restEncoder); err != nil {
917		return out, metadata, &smithy.SerializationError{Err: err}
918	}
919
920	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
921		return out, metadata, &smithy.SerializationError{Err: err}
922	}
923	in.Request = request
924
925	return next.HandleSerialize(ctx, in)
926}
927func awsRestjson1_serializeOpHttpBindingsGetApplicationInput(v *GetApplicationInput, encoder *httpbinding.Encoder) error {
928	if v == nil {
929		return fmt.Errorf("unsupported serialization of nil %T", v)
930	}
931
932	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
933		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
934	}
935	if v.ApplicationId != nil {
936		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
937			return err
938		}
939	}
940
941	return nil
942}
943
944type awsRestjson1_serializeOpGetConfiguration struct {
945}
946
947func (*awsRestjson1_serializeOpGetConfiguration) ID() string {
948	return "OperationSerializer"
949}
950
951func (m *awsRestjson1_serializeOpGetConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
952	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
953) {
954	request, ok := in.Request.(*smithyhttp.Request)
955	if !ok {
956		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
957	}
958
959	input, ok := in.Parameters.(*GetConfigurationInput)
960	_ = input
961	if !ok {
962		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
963	}
964
965	opPath, opQuery := httpbinding.SplitURI("/applications/{Application}/environments/{Environment}/configurations/{Configuration}")
966	request.URL.Path = opPath
967	if len(request.URL.RawQuery) > 0 {
968		request.URL.RawQuery = "&" + opQuery
969	} else {
970		request.URL.RawQuery = opQuery
971	}
972
973	request.Method = "GET"
974	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
975	if err != nil {
976		return out, metadata, &smithy.SerializationError{Err: err}
977	}
978
979	if err := awsRestjson1_serializeOpHttpBindingsGetConfigurationInput(input, restEncoder); err != nil {
980		return out, metadata, &smithy.SerializationError{Err: err}
981	}
982
983	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
984		return out, metadata, &smithy.SerializationError{Err: err}
985	}
986	in.Request = request
987
988	return next.HandleSerialize(ctx, in)
989}
990func awsRestjson1_serializeOpHttpBindingsGetConfigurationInput(v *GetConfigurationInput, encoder *httpbinding.Encoder) error {
991	if v == nil {
992		return fmt.Errorf("unsupported serialization of nil %T", v)
993	}
994
995	if v.Application == nil || len(*v.Application) == 0 {
996		return &smithy.SerializationError{Err: fmt.Errorf("input member Application must not be empty")}
997	}
998	if v.Application != nil {
999		if err := encoder.SetURI("Application").String(*v.Application); err != nil {
1000			return err
1001		}
1002	}
1003
1004	if v.ClientConfigurationVersion != nil {
1005		encoder.SetQuery("client_configuration_version").String(*v.ClientConfigurationVersion)
1006	}
1007
1008	if v.ClientId != nil {
1009		encoder.SetQuery("client_id").String(*v.ClientId)
1010	}
1011
1012	if v.Configuration == nil || len(*v.Configuration) == 0 {
1013		return &smithy.SerializationError{Err: fmt.Errorf("input member Configuration must not be empty")}
1014	}
1015	if v.Configuration != nil {
1016		if err := encoder.SetURI("Configuration").String(*v.Configuration); err != nil {
1017			return err
1018		}
1019	}
1020
1021	if v.Environment == nil || len(*v.Environment) == 0 {
1022		return &smithy.SerializationError{Err: fmt.Errorf("input member Environment must not be empty")}
1023	}
1024	if v.Environment != nil {
1025		if err := encoder.SetURI("Environment").String(*v.Environment); err != nil {
1026			return err
1027		}
1028	}
1029
1030	return nil
1031}
1032
1033type awsRestjson1_serializeOpGetConfigurationProfile struct {
1034}
1035
1036func (*awsRestjson1_serializeOpGetConfigurationProfile) ID() string {
1037	return "OperationSerializer"
1038}
1039
1040func (m *awsRestjson1_serializeOpGetConfigurationProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1041	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	request, ok := in.Request.(*smithyhttp.Request)
1044	if !ok {
1045		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1046	}
1047
1048	input, ok := in.Parameters.(*GetConfigurationProfileInput)
1049	_ = input
1050	if !ok {
1051		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1052	}
1053
1054	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}")
1055	request.URL.Path = opPath
1056	if len(request.URL.RawQuery) > 0 {
1057		request.URL.RawQuery = "&" + opQuery
1058	} else {
1059		request.URL.RawQuery = opQuery
1060	}
1061
1062	request.Method = "GET"
1063	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1064	if err != nil {
1065		return out, metadata, &smithy.SerializationError{Err: err}
1066	}
1067
1068	if err := awsRestjson1_serializeOpHttpBindingsGetConfigurationProfileInput(input, restEncoder); err != nil {
1069		return out, metadata, &smithy.SerializationError{Err: err}
1070	}
1071
1072	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1073		return out, metadata, &smithy.SerializationError{Err: err}
1074	}
1075	in.Request = request
1076
1077	return next.HandleSerialize(ctx, in)
1078}
1079func awsRestjson1_serializeOpHttpBindingsGetConfigurationProfileInput(v *GetConfigurationProfileInput, encoder *httpbinding.Encoder) error {
1080	if v == nil {
1081		return fmt.Errorf("unsupported serialization of nil %T", v)
1082	}
1083
1084	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1085		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1086	}
1087	if v.ApplicationId != nil {
1088		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1089			return err
1090		}
1091	}
1092
1093	if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 {
1094		return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")}
1095	}
1096	if v.ConfigurationProfileId != nil {
1097		if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil {
1098			return err
1099		}
1100	}
1101
1102	return nil
1103}
1104
1105type awsRestjson1_serializeOpGetDeployment struct {
1106}
1107
1108func (*awsRestjson1_serializeOpGetDeployment) ID() string {
1109	return "OperationSerializer"
1110}
1111
1112func (m *awsRestjson1_serializeOpGetDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1113	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1114) {
1115	request, ok := in.Request.(*smithyhttp.Request)
1116	if !ok {
1117		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1118	}
1119
1120	input, ok := in.Parameters.(*GetDeploymentInput)
1121	_ = input
1122	if !ok {
1123		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1124	}
1125
1126	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}/deployments/{DeploymentNumber}")
1127	request.URL.Path = opPath
1128	if len(request.URL.RawQuery) > 0 {
1129		request.URL.RawQuery = "&" + opQuery
1130	} else {
1131		request.URL.RawQuery = opQuery
1132	}
1133
1134	request.Method = "GET"
1135	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1136	if err != nil {
1137		return out, metadata, &smithy.SerializationError{Err: err}
1138	}
1139
1140	if err := awsRestjson1_serializeOpHttpBindingsGetDeploymentInput(input, restEncoder); err != nil {
1141		return out, metadata, &smithy.SerializationError{Err: err}
1142	}
1143
1144	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1145		return out, metadata, &smithy.SerializationError{Err: err}
1146	}
1147	in.Request = request
1148
1149	return next.HandleSerialize(ctx, in)
1150}
1151func awsRestjson1_serializeOpHttpBindingsGetDeploymentInput(v *GetDeploymentInput, encoder *httpbinding.Encoder) error {
1152	if v == nil {
1153		return fmt.Errorf("unsupported serialization of nil %T", v)
1154	}
1155
1156	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1157		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1158	}
1159	if v.ApplicationId != nil {
1160		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1161			return err
1162		}
1163	}
1164
1165	if v.DeploymentNumber == 0 {
1166		return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentNumber must not be empty")}
1167	}
1168	if v.DeploymentNumber != 0 {
1169		if err := encoder.SetURI("DeploymentNumber").Integer(v.DeploymentNumber); err != nil {
1170			return err
1171		}
1172	}
1173
1174	if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 {
1175		return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")}
1176	}
1177	if v.EnvironmentId != nil {
1178		if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil {
1179			return err
1180		}
1181	}
1182
1183	return nil
1184}
1185
1186type awsRestjson1_serializeOpGetDeploymentStrategy struct {
1187}
1188
1189func (*awsRestjson1_serializeOpGetDeploymentStrategy) ID() string {
1190	return "OperationSerializer"
1191}
1192
1193func (m *awsRestjson1_serializeOpGetDeploymentStrategy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1194	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1195) {
1196	request, ok := in.Request.(*smithyhttp.Request)
1197	if !ok {
1198		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1199	}
1200
1201	input, ok := in.Parameters.(*GetDeploymentStrategyInput)
1202	_ = input
1203	if !ok {
1204		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1205	}
1206
1207	opPath, opQuery := httpbinding.SplitURI("/deploymentstrategies/{DeploymentStrategyId}")
1208	request.URL.Path = opPath
1209	if len(request.URL.RawQuery) > 0 {
1210		request.URL.RawQuery = "&" + opQuery
1211	} else {
1212		request.URL.RawQuery = opQuery
1213	}
1214
1215	request.Method = "GET"
1216	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1217	if err != nil {
1218		return out, metadata, &smithy.SerializationError{Err: err}
1219	}
1220
1221	if err := awsRestjson1_serializeOpHttpBindingsGetDeploymentStrategyInput(input, restEncoder); err != nil {
1222		return out, metadata, &smithy.SerializationError{Err: err}
1223	}
1224
1225	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1226		return out, metadata, &smithy.SerializationError{Err: err}
1227	}
1228	in.Request = request
1229
1230	return next.HandleSerialize(ctx, in)
1231}
1232func awsRestjson1_serializeOpHttpBindingsGetDeploymentStrategyInput(v *GetDeploymentStrategyInput, encoder *httpbinding.Encoder) error {
1233	if v == nil {
1234		return fmt.Errorf("unsupported serialization of nil %T", v)
1235	}
1236
1237	if v.DeploymentStrategyId == nil || len(*v.DeploymentStrategyId) == 0 {
1238		return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentStrategyId must not be empty")}
1239	}
1240	if v.DeploymentStrategyId != nil {
1241		if err := encoder.SetURI("DeploymentStrategyId").String(*v.DeploymentStrategyId); err != nil {
1242			return err
1243		}
1244	}
1245
1246	return nil
1247}
1248
1249type awsRestjson1_serializeOpGetEnvironment struct {
1250}
1251
1252func (*awsRestjson1_serializeOpGetEnvironment) ID() string {
1253	return "OperationSerializer"
1254}
1255
1256func (m *awsRestjson1_serializeOpGetEnvironment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1257	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1258) {
1259	request, ok := in.Request.(*smithyhttp.Request)
1260	if !ok {
1261		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1262	}
1263
1264	input, ok := in.Parameters.(*GetEnvironmentInput)
1265	_ = input
1266	if !ok {
1267		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1268	}
1269
1270	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}")
1271	request.URL.Path = opPath
1272	if len(request.URL.RawQuery) > 0 {
1273		request.URL.RawQuery = "&" + opQuery
1274	} else {
1275		request.URL.RawQuery = opQuery
1276	}
1277
1278	request.Method = "GET"
1279	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1280	if err != nil {
1281		return out, metadata, &smithy.SerializationError{Err: err}
1282	}
1283
1284	if err := awsRestjson1_serializeOpHttpBindingsGetEnvironmentInput(input, restEncoder); err != nil {
1285		return out, metadata, &smithy.SerializationError{Err: err}
1286	}
1287
1288	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1289		return out, metadata, &smithy.SerializationError{Err: err}
1290	}
1291	in.Request = request
1292
1293	return next.HandleSerialize(ctx, in)
1294}
1295func awsRestjson1_serializeOpHttpBindingsGetEnvironmentInput(v *GetEnvironmentInput, encoder *httpbinding.Encoder) error {
1296	if v == nil {
1297		return fmt.Errorf("unsupported serialization of nil %T", v)
1298	}
1299
1300	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1301		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1302	}
1303	if v.ApplicationId != nil {
1304		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1305			return err
1306		}
1307	}
1308
1309	if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 {
1310		return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")}
1311	}
1312	if v.EnvironmentId != nil {
1313		if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil {
1314			return err
1315		}
1316	}
1317
1318	return nil
1319}
1320
1321type awsRestjson1_serializeOpGetHostedConfigurationVersion struct {
1322}
1323
1324func (*awsRestjson1_serializeOpGetHostedConfigurationVersion) ID() string {
1325	return "OperationSerializer"
1326}
1327
1328func (m *awsRestjson1_serializeOpGetHostedConfigurationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1329	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1330) {
1331	request, ok := in.Request.(*smithyhttp.Request)
1332	if !ok {
1333		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1334	}
1335
1336	input, ok := in.Parameters.(*GetHostedConfigurationVersionInput)
1337	_ = input
1338	if !ok {
1339		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1340	}
1341
1342	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}/hostedconfigurationversions/{VersionNumber}")
1343	request.URL.Path = opPath
1344	if len(request.URL.RawQuery) > 0 {
1345		request.URL.RawQuery = "&" + opQuery
1346	} else {
1347		request.URL.RawQuery = opQuery
1348	}
1349
1350	request.Method = "GET"
1351	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1352	if err != nil {
1353		return out, metadata, &smithy.SerializationError{Err: err}
1354	}
1355
1356	if err := awsRestjson1_serializeOpHttpBindingsGetHostedConfigurationVersionInput(input, restEncoder); err != nil {
1357		return out, metadata, &smithy.SerializationError{Err: err}
1358	}
1359
1360	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1361		return out, metadata, &smithy.SerializationError{Err: err}
1362	}
1363	in.Request = request
1364
1365	return next.HandleSerialize(ctx, in)
1366}
1367func awsRestjson1_serializeOpHttpBindingsGetHostedConfigurationVersionInput(v *GetHostedConfigurationVersionInput, encoder *httpbinding.Encoder) error {
1368	if v == nil {
1369		return fmt.Errorf("unsupported serialization of nil %T", v)
1370	}
1371
1372	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1373		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1374	}
1375	if v.ApplicationId != nil {
1376		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1377			return err
1378		}
1379	}
1380
1381	if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 {
1382		return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")}
1383	}
1384	if v.ConfigurationProfileId != nil {
1385		if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil {
1386			return err
1387		}
1388	}
1389
1390	if v.VersionNumber == 0 {
1391		return &smithy.SerializationError{Err: fmt.Errorf("input member VersionNumber must not be empty")}
1392	}
1393	if v.VersionNumber != 0 {
1394		if err := encoder.SetURI("VersionNumber").Integer(v.VersionNumber); err != nil {
1395			return err
1396		}
1397	}
1398
1399	return nil
1400}
1401
1402type awsRestjson1_serializeOpListApplications struct {
1403}
1404
1405func (*awsRestjson1_serializeOpListApplications) ID() string {
1406	return "OperationSerializer"
1407}
1408
1409func (m *awsRestjson1_serializeOpListApplications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1410	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1411) {
1412	request, ok := in.Request.(*smithyhttp.Request)
1413	if !ok {
1414		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1415	}
1416
1417	input, ok := in.Parameters.(*ListApplicationsInput)
1418	_ = input
1419	if !ok {
1420		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1421	}
1422
1423	opPath, opQuery := httpbinding.SplitURI("/applications")
1424	request.URL.Path = opPath
1425	if len(request.URL.RawQuery) > 0 {
1426		request.URL.RawQuery = "&" + opQuery
1427	} else {
1428		request.URL.RawQuery = opQuery
1429	}
1430
1431	request.Method = "GET"
1432	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1433	if err != nil {
1434		return out, metadata, &smithy.SerializationError{Err: err}
1435	}
1436
1437	if err := awsRestjson1_serializeOpHttpBindingsListApplicationsInput(input, restEncoder); err != nil {
1438		return out, metadata, &smithy.SerializationError{Err: err}
1439	}
1440
1441	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1442		return out, metadata, &smithy.SerializationError{Err: err}
1443	}
1444	in.Request = request
1445
1446	return next.HandleSerialize(ctx, in)
1447}
1448func awsRestjson1_serializeOpHttpBindingsListApplicationsInput(v *ListApplicationsInput, encoder *httpbinding.Encoder) error {
1449	if v == nil {
1450		return fmt.Errorf("unsupported serialization of nil %T", v)
1451	}
1452
1453	if v.MaxResults != 0 {
1454		encoder.SetQuery("max_results").Integer(v.MaxResults)
1455	}
1456
1457	if v.NextToken != nil {
1458		encoder.SetQuery("next_token").String(*v.NextToken)
1459	}
1460
1461	return nil
1462}
1463
1464type awsRestjson1_serializeOpListConfigurationProfiles struct {
1465}
1466
1467func (*awsRestjson1_serializeOpListConfigurationProfiles) ID() string {
1468	return "OperationSerializer"
1469}
1470
1471func (m *awsRestjson1_serializeOpListConfigurationProfiles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1472	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1473) {
1474	request, ok := in.Request.(*smithyhttp.Request)
1475	if !ok {
1476		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1477	}
1478
1479	input, ok := in.Parameters.(*ListConfigurationProfilesInput)
1480	_ = input
1481	if !ok {
1482		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1483	}
1484
1485	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles")
1486	request.URL.Path = opPath
1487	if len(request.URL.RawQuery) > 0 {
1488		request.URL.RawQuery = "&" + opQuery
1489	} else {
1490		request.URL.RawQuery = opQuery
1491	}
1492
1493	request.Method = "GET"
1494	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1495	if err != nil {
1496		return out, metadata, &smithy.SerializationError{Err: err}
1497	}
1498
1499	if err := awsRestjson1_serializeOpHttpBindingsListConfigurationProfilesInput(input, restEncoder); err != nil {
1500		return out, metadata, &smithy.SerializationError{Err: err}
1501	}
1502
1503	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1504		return out, metadata, &smithy.SerializationError{Err: err}
1505	}
1506	in.Request = request
1507
1508	return next.HandleSerialize(ctx, in)
1509}
1510func awsRestjson1_serializeOpHttpBindingsListConfigurationProfilesInput(v *ListConfigurationProfilesInput, encoder *httpbinding.Encoder) error {
1511	if v == nil {
1512		return fmt.Errorf("unsupported serialization of nil %T", v)
1513	}
1514
1515	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1516		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1517	}
1518	if v.ApplicationId != nil {
1519		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1520			return err
1521		}
1522	}
1523
1524	if v.MaxResults != 0 {
1525		encoder.SetQuery("max_results").Integer(v.MaxResults)
1526	}
1527
1528	if v.NextToken != nil {
1529		encoder.SetQuery("next_token").String(*v.NextToken)
1530	}
1531
1532	return nil
1533}
1534
1535type awsRestjson1_serializeOpListDeployments struct {
1536}
1537
1538func (*awsRestjson1_serializeOpListDeployments) ID() string {
1539	return "OperationSerializer"
1540}
1541
1542func (m *awsRestjson1_serializeOpListDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1543	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1544) {
1545	request, ok := in.Request.(*smithyhttp.Request)
1546	if !ok {
1547		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1548	}
1549
1550	input, ok := in.Parameters.(*ListDeploymentsInput)
1551	_ = input
1552	if !ok {
1553		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1554	}
1555
1556	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}/deployments")
1557	request.URL.Path = opPath
1558	if len(request.URL.RawQuery) > 0 {
1559		request.URL.RawQuery = "&" + opQuery
1560	} else {
1561		request.URL.RawQuery = opQuery
1562	}
1563
1564	request.Method = "GET"
1565	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1566	if err != nil {
1567		return out, metadata, &smithy.SerializationError{Err: err}
1568	}
1569
1570	if err := awsRestjson1_serializeOpHttpBindingsListDeploymentsInput(input, restEncoder); err != nil {
1571		return out, metadata, &smithy.SerializationError{Err: err}
1572	}
1573
1574	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1575		return out, metadata, &smithy.SerializationError{Err: err}
1576	}
1577	in.Request = request
1578
1579	return next.HandleSerialize(ctx, in)
1580}
1581func awsRestjson1_serializeOpHttpBindingsListDeploymentsInput(v *ListDeploymentsInput, encoder *httpbinding.Encoder) error {
1582	if v == nil {
1583		return fmt.Errorf("unsupported serialization of nil %T", v)
1584	}
1585
1586	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1587		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1588	}
1589	if v.ApplicationId != nil {
1590		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1591			return err
1592		}
1593	}
1594
1595	if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 {
1596		return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")}
1597	}
1598	if v.EnvironmentId != nil {
1599		if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil {
1600			return err
1601		}
1602	}
1603
1604	if v.MaxResults != 0 {
1605		encoder.SetQuery("max_results").Integer(v.MaxResults)
1606	}
1607
1608	if v.NextToken != nil {
1609		encoder.SetQuery("next_token").String(*v.NextToken)
1610	}
1611
1612	return nil
1613}
1614
1615type awsRestjson1_serializeOpListDeploymentStrategies struct {
1616}
1617
1618func (*awsRestjson1_serializeOpListDeploymentStrategies) ID() string {
1619	return "OperationSerializer"
1620}
1621
1622func (m *awsRestjson1_serializeOpListDeploymentStrategies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1623	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1624) {
1625	request, ok := in.Request.(*smithyhttp.Request)
1626	if !ok {
1627		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1628	}
1629
1630	input, ok := in.Parameters.(*ListDeploymentStrategiesInput)
1631	_ = input
1632	if !ok {
1633		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1634	}
1635
1636	opPath, opQuery := httpbinding.SplitURI("/deploymentstrategies")
1637	request.URL.Path = opPath
1638	if len(request.URL.RawQuery) > 0 {
1639		request.URL.RawQuery = "&" + opQuery
1640	} else {
1641		request.URL.RawQuery = opQuery
1642	}
1643
1644	request.Method = "GET"
1645	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1646	if err != nil {
1647		return out, metadata, &smithy.SerializationError{Err: err}
1648	}
1649
1650	if err := awsRestjson1_serializeOpHttpBindingsListDeploymentStrategiesInput(input, restEncoder); err != nil {
1651		return out, metadata, &smithy.SerializationError{Err: err}
1652	}
1653
1654	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1655		return out, metadata, &smithy.SerializationError{Err: err}
1656	}
1657	in.Request = request
1658
1659	return next.HandleSerialize(ctx, in)
1660}
1661func awsRestjson1_serializeOpHttpBindingsListDeploymentStrategiesInput(v *ListDeploymentStrategiesInput, encoder *httpbinding.Encoder) error {
1662	if v == nil {
1663		return fmt.Errorf("unsupported serialization of nil %T", v)
1664	}
1665
1666	if v.MaxResults != 0 {
1667		encoder.SetQuery("max_results").Integer(v.MaxResults)
1668	}
1669
1670	if v.NextToken != nil {
1671		encoder.SetQuery("next_token").String(*v.NextToken)
1672	}
1673
1674	return nil
1675}
1676
1677type awsRestjson1_serializeOpListEnvironments struct {
1678}
1679
1680func (*awsRestjson1_serializeOpListEnvironments) ID() string {
1681	return "OperationSerializer"
1682}
1683
1684func (m *awsRestjson1_serializeOpListEnvironments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1685	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1686) {
1687	request, ok := in.Request.(*smithyhttp.Request)
1688	if !ok {
1689		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1690	}
1691
1692	input, ok := in.Parameters.(*ListEnvironmentsInput)
1693	_ = input
1694	if !ok {
1695		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1696	}
1697
1698	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments")
1699	request.URL.Path = opPath
1700	if len(request.URL.RawQuery) > 0 {
1701		request.URL.RawQuery = "&" + opQuery
1702	} else {
1703		request.URL.RawQuery = opQuery
1704	}
1705
1706	request.Method = "GET"
1707	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1708	if err != nil {
1709		return out, metadata, &smithy.SerializationError{Err: err}
1710	}
1711
1712	if err := awsRestjson1_serializeOpHttpBindingsListEnvironmentsInput(input, restEncoder); err != nil {
1713		return out, metadata, &smithy.SerializationError{Err: err}
1714	}
1715
1716	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1717		return out, metadata, &smithy.SerializationError{Err: err}
1718	}
1719	in.Request = request
1720
1721	return next.HandleSerialize(ctx, in)
1722}
1723func awsRestjson1_serializeOpHttpBindingsListEnvironmentsInput(v *ListEnvironmentsInput, encoder *httpbinding.Encoder) error {
1724	if v == nil {
1725		return fmt.Errorf("unsupported serialization of nil %T", v)
1726	}
1727
1728	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1729		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1730	}
1731	if v.ApplicationId != nil {
1732		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1733			return err
1734		}
1735	}
1736
1737	if v.MaxResults != 0 {
1738		encoder.SetQuery("max_results").Integer(v.MaxResults)
1739	}
1740
1741	if v.NextToken != nil {
1742		encoder.SetQuery("next_token").String(*v.NextToken)
1743	}
1744
1745	return nil
1746}
1747
1748type awsRestjson1_serializeOpListHostedConfigurationVersions struct {
1749}
1750
1751func (*awsRestjson1_serializeOpListHostedConfigurationVersions) ID() string {
1752	return "OperationSerializer"
1753}
1754
1755func (m *awsRestjson1_serializeOpListHostedConfigurationVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1756	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1757) {
1758	request, ok := in.Request.(*smithyhttp.Request)
1759	if !ok {
1760		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1761	}
1762
1763	input, ok := in.Parameters.(*ListHostedConfigurationVersionsInput)
1764	_ = input
1765	if !ok {
1766		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1767	}
1768
1769	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}/hostedconfigurationversions")
1770	request.URL.Path = opPath
1771	if len(request.URL.RawQuery) > 0 {
1772		request.URL.RawQuery = "&" + opQuery
1773	} else {
1774		request.URL.RawQuery = opQuery
1775	}
1776
1777	request.Method = "GET"
1778	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1779	if err != nil {
1780		return out, metadata, &smithy.SerializationError{Err: err}
1781	}
1782
1783	if err := awsRestjson1_serializeOpHttpBindingsListHostedConfigurationVersionsInput(input, restEncoder); err != nil {
1784		return out, metadata, &smithy.SerializationError{Err: err}
1785	}
1786
1787	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1788		return out, metadata, &smithy.SerializationError{Err: err}
1789	}
1790	in.Request = request
1791
1792	return next.HandleSerialize(ctx, in)
1793}
1794func awsRestjson1_serializeOpHttpBindingsListHostedConfigurationVersionsInput(v *ListHostedConfigurationVersionsInput, encoder *httpbinding.Encoder) error {
1795	if v == nil {
1796		return fmt.Errorf("unsupported serialization of nil %T", v)
1797	}
1798
1799	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1800		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1801	}
1802	if v.ApplicationId != nil {
1803		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1804			return err
1805		}
1806	}
1807
1808	if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 {
1809		return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")}
1810	}
1811	if v.ConfigurationProfileId != nil {
1812		if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil {
1813			return err
1814		}
1815	}
1816
1817	if v.MaxResults != 0 {
1818		encoder.SetQuery("max_results").Integer(v.MaxResults)
1819	}
1820
1821	if v.NextToken != nil {
1822		encoder.SetQuery("next_token").String(*v.NextToken)
1823	}
1824
1825	return nil
1826}
1827
1828type awsRestjson1_serializeOpListTagsForResource struct {
1829}
1830
1831func (*awsRestjson1_serializeOpListTagsForResource) ID() string {
1832	return "OperationSerializer"
1833}
1834
1835func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1836	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1837) {
1838	request, ok := in.Request.(*smithyhttp.Request)
1839	if !ok {
1840		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1841	}
1842
1843	input, ok := in.Parameters.(*ListTagsForResourceInput)
1844	_ = input
1845	if !ok {
1846		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1847	}
1848
1849	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
1850	request.URL.Path = opPath
1851	if len(request.URL.RawQuery) > 0 {
1852		request.URL.RawQuery = "&" + opQuery
1853	} else {
1854		request.URL.RawQuery = opQuery
1855	}
1856
1857	request.Method = "GET"
1858	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1859	if err != nil {
1860		return out, metadata, &smithy.SerializationError{Err: err}
1861	}
1862
1863	if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil {
1864		return out, metadata, &smithy.SerializationError{Err: err}
1865	}
1866
1867	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1868		return out, metadata, &smithy.SerializationError{Err: err}
1869	}
1870	in.Request = request
1871
1872	return next.HandleSerialize(ctx, in)
1873}
1874func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error {
1875	if v == nil {
1876		return fmt.Errorf("unsupported serialization of nil %T", v)
1877	}
1878
1879	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
1880		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
1881	}
1882	if v.ResourceArn != nil {
1883		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
1884			return err
1885		}
1886	}
1887
1888	return nil
1889}
1890
1891type awsRestjson1_serializeOpStartDeployment struct {
1892}
1893
1894func (*awsRestjson1_serializeOpStartDeployment) ID() string {
1895	return "OperationSerializer"
1896}
1897
1898func (m *awsRestjson1_serializeOpStartDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1899	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1900) {
1901	request, ok := in.Request.(*smithyhttp.Request)
1902	if !ok {
1903		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1904	}
1905
1906	input, ok := in.Parameters.(*StartDeploymentInput)
1907	_ = input
1908	if !ok {
1909		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1910	}
1911
1912	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}/deployments")
1913	request.URL.Path = opPath
1914	if len(request.URL.RawQuery) > 0 {
1915		request.URL.RawQuery = "&" + opQuery
1916	} else {
1917		request.URL.RawQuery = opQuery
1918	}
1919
1920	request.Method = "POST"
1921	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1922	if err != nil {
1923		return out, metadata, &smithy.SerializationError{Err: err}
1924	}
1925
1926	if err := awsRestjson1_serializeOpHttpBindingsStartDeploymentInput(input, restEncoder); err != nil {
1927		return out, metadata, &smithy.SerializationError{Err: err}
1928	}
1929
1930	restEncoder.SetHeader("Content-Type").String("application/json")
1931
1932	jsonEncoder := smithyjson.NewEncoder()
1933	if err := awsRestjson1_serializeOpDocumentStartDeploymentInput(input, jsonEncoder.Value); err != nil {
1934		return out, metadata, &smithy.SerializationError{Err: err}
1935	}
1936
1937	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1938		return out, metadata, &smithy.SerializationError{Err: err}
1939	}
1940
1941	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1942		return out, metadata, &smithy.SerializationError{Err: err}
1943	}
1944	in.Request = request
1945
1946	return next.HandleSerialize(ctx, in)
1947}
1948func awsRestjson1_serializeOpHttpBindingsStartDeploymentInput(v *StartDeploymentInput, encoder *httpbinding.Encoder) error {
1949	if v == nil {
1950		return fmt.Errorf("unsupported serialization of nil %T", v)
1951	}
1952
1953	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
1954		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
1955	}
1956	if v.ApplicationId != nil {
1957		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
1958			return err
1959		}
1960	}
1961
1962	if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 {
1963		return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")}
1964	}
1965	if v.EnvironmentId != nil {
1966		if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil {
1967			return err
1968		}
1969	}
1970
1971	return nil
1972}
1973
1974func awsRestjson1_serializeOpDocumentStartDeploymentInput(v *StartDeploymentInput, value smithyjson.Value) error {
1975	object := value.Object()
1976	defer object.Close()
1977
1978	if v.ConfigurationProfileId != nil {
1979		ok := object.Key("ConfigurationProfileId")
1980		ok.String(*v.ConfigurationProfileId)
1981	}
1982
1983	if v.ConfigurationVersion != nil {
1984		ok := object.Key("ConfigurationVersion")
1985		ok.String(*v.ConfigurationVersion)
1986	}
1987
1988	if v.DeploymentStrategyId != nil {
1989		ok := object.Key("DeploymentStrategyId")
1990		ok.String(*v.DeploymentStrategyId)
1991	}
1992
1993	if v.Description != nil {
1994		ok := object.Key("Description")
1995		ok.String(*v.Description)
1996	}
1997
1998	if v.Tags != nil {
1999		ok := object.Key("Tags")
2000		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
2001			return err
2002		}
2003	}
2004
2005	return nil
2006}
2007
2008type awsRestjson1_serializeOpStopDeployment struct {
2009}
2010
2011func (*awsRestjson1_serializeOpStopDeployment) ID() string {
2012	return "OperationSerializer"
2013}
2014
2015func (m *awsRestjson1_serializeOpStopDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2016	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2017) {
2018	request, ok := in.Request.(*smithyhttp.Request)
2019	if !ok {
2020		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2021	}
2022
2023	input, ok := in.Parameters.(*StopDeploymentInput)
2024	_ = input
2025	if !ok {
2026		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2027	}
2028
2029	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}/deployments/{DeploymentNumber}")
2030	request.URL.Path = opPath
2031	if len(request.URL.RawQuery) > 0 {
2032		request.URL.RawQuery = "&" + opQuery
2033	} else {
2034		request.URL.RawQuery = opQuery
2035	}
2036
2037	request.Method = "DELETE"
2038	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2039	if err != nil {
2040		return out, metadata, &smithy.SerializationError{Err: err}
2041	}
2042
2043	if err := awsRestjson1_serializeOpHttpBindingsStopDeploymentInput(input, restEncoder); err != nil {
2044		return out, metadata, &smithy.SerializationError{Err: err}
2045	}
2046
2047	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2048		return out, metadata, &smithy.SerializationError{Err: err}
2049	}
2050	in.Request = request
2051
2052	return next.HandleSerialize(ctx, in)
2053}
2054func awsRestjson1_serializeOpHttpBindingsStopDeploymentInput(v *StopDeploymentInput, encoder *httpbinding.Encoder) error {
2055	if v == nil {
2056		return fmt.Errorf("unsupported serialization of nil %T", v)
2057	}
2058
2059	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
2060		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
2061	}
2062	if v.ApplicationId != nil {
2063		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
2064			return err
2065		}
2066	}
2067
2068	if v.DeploymentNumber == 0 {
2069		return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentNumber must not be empty")}
2070	}
2071	if v.DeploymentNumber != 0 {
2072		if err := encoder.SetURI("DeploymentNumber").Integer(v.DeploymentNumber); err != nil {
2073			return err
2074		}
2075	}
2076
2077	if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 {
2078		return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")}
2079	}
2080	if v.EnvironmentId != nil {
2081		if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil {
2082			return err
2083		}
2084	}
2085
2086	return nil
2087}
2088
2089type awsRestjson1_serializeOpTagResource struct {
2090}
2091
2092func (*awsRestjson1_serializeOpTagResource) ID() string {
2093	return "OperationSerializer"
2094}
2095
2096func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2097	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2098) {
2099	request, ok := in.Request.(*smithyhttp.Request)
2100	if !ok {
2101		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2102	}
2103
2104	input, ok := in.Parameters.(*TagResourceInput)
2105	_ = input
2106	if !ok {
2107		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2108	}
2109
2110	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
2111	request.URL.Path = opPath
2112	if len(request.URL.RawQuery) > 0 {
2113		request.URL.RawQuery = "&" + opQuery
2114	} else {
2115		request.URL.RawQuery = opQuery
2116	}
2117
2118	request.Method = "POST"
2119	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2120	if err != nil {
2121		return out, metadata, &smithy.SerializationError{Err: err}
2122	}
2123
2124	if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
2125		return out, metadata, &smithy.SerializationError{Err: err}
2126	}
2127
2128	restEncoder.SetHeader("Content-Type").String("application/json")
2129
2130	jsonEncoder := smithyjson.NewEncoder()
2131	if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
2132		return out, metadata, &smithy.SerializationError{Err: err}
2133	}
2134
2135	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2136		return out, metadata, &smithy.SerializationError{Err: err}
2137	}
2138
2139	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2140		return out, metadata, &smithy.SerializationError{Err: err}
2141	}
2142	in.Request = request
2143
2144	return next.HandleSerialize(ctx, in)
2145}
2146func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
2147	if v == nil {
2148		return fmt.Errorf("unsupported serialization of nil %T", v)
2149	}
2150
2151	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
2152		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
2153	}
2154	if v.ResourceArn != nil {
2155		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
2156			return err
2157		}
2158	}
2159
2160	return nil
2161}
2162
2163func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
2164	object := value.Object()
2165	defer object.Close()
2166
2167	if v.Tags != nil {
2168		ok := object.Key("Tags")
2169		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
2170			return err
2171		}
2172	}
2173
2174	return nil
2175}
2176
2177type awsRestjson1_serializeOpUntagResource struct {
2178}
2179
2180func (*awsRestjson1_serializeOpUntagResource) ID() string {
2181	return "OperationSerializer"
2182}
2183
2184func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2185	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2186) {
2187	request, ok := in.Request.(*smithyhttp.Request)
2188	if !ok {
2189		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2190	}
2191
2192	input, ok := in.Parameters.(*UntagResourceInput)
2193	_ = input
2194	if !ok {
2195		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2196	}
2197
2198	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
2199	request.URL.Path = opPath
2200	if len(request.URL.RawQuery) > 0 {
2201		request.URL.RawQuery = "&" + opQuery
2202	} else {
2203		request.URL.RawQuery = opQuery
2204	}
2205
2206	request.Method = "DELETE"
2207	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2208	if err != nil {
2209		return out, metadata, &smithy.SerializationError{Err: err}
2210	}
2211
2212	if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil {
2213		return out, metadata, &smithy.SerializationError{Err: err}
2214	}
2215
2216	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2217		return out, metadata, &smithy.SerializationError{Err: err}
2218	}
2219	in.Request = request
2220
2221	return next.HandleSerialize(ctx, in)
2222}
2223func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
2224	if v == nil {
2225		return fmt.Errorf("unsupported serialization of nil %T", v)
2226	}
2227
2228	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
2229		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
2230	}
2231	if v.ResourceArn != nil {
2232		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
2233			return err
2234		}
2235	}
2236
2237	if v.TagKeys != nil {
2238		for i := range v.TagKeys {
2239			encoder.AddQuery("tagKeys").String(v.TagKeys[i])
2240		}
2241	}
2242
2243	return nil
2244}
2245
2246type awsRestjson1_serializeOpUpdateApplication struct {
2247}
2248
2249func (*awsRestjson1_serializeOpUpdateApplication) ID() string {
2250	return "OperationSerializer"
2251}
2252
2253func (m *awsRestjson1_serializeOpUpdateApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2254	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2255) {
2256	request, ok := in.Request.(*smithyhttp.Request)
2257	if !ok {
2258		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2259	}
2260
2261	input, ok := in.Parameters.(*UpdateApplicationInput)
2262	_ = input
2263	if !ok {
2264		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2265	}
2266
2267	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}")
2268	request.URL.Path = opPath
2269	if len(request.URL.RawQuery) > 0 {
2270		request.URL.RawQuery = "&" + opQuery
2271	} else {
2272		request.URL.RawQuery = opQuery
2273	}
2274
2275	request.Method = "PATCH"
2276	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2277	if err != nil {
2278		return out, metadata, &smithy.SerializationError{Err: err}
2279	}
2280
2281	if err := awsRestjson1_serializeOpHttpBindingsUpdateApplicationInput(input, restEncoder); err != nil {
2282		return out, metadata, &smithy.SerializationError{Err: err}
2283	}
2284
2285	restEncoder.SetHeader("Content-Type").String("application/json")
2286
2287	jsonEncoder := smithyjson.NewEncoder()
2288	if err := awsRestjson1_serializeOpDocumentUpdateApplicationInput(input, jsonEncoder.Value); err != nil {
2289		return out, metadata, &smithy.SerializationError{Err: err}
2290	}
2291
2292	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2293		return out, metadata, &smithy.SerializationError{Err: err}
2294	}
2295
2296	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2297		return out, metadata, &smithy.SerializationError{Err: err}
2298	}
2299	in.Request = request
2300
2301	return next.HandleSerialize(ctx, in)
2302}
2303func awsRestjson1_serializeOpHttpBindingsUpdateApplicationInput(v *UpdateApplicationInput, encoder *httpbinding.Encoder) error {
2304	if v == nil {
2305		return fmt.Errorf("unsupported serialization of nil %T", v)
2306	}
2307
2308	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
2309		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
2310	}
2311	if v.ApplicationId != nil {
2312		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
2313			return err
2314		}
2315	}
2316
2317	return nil
2318}
2319
2320func awsRestjson1_serializeOpDocumentUpdateApplicationInput(v *UpdateApplicationInput, value smithyjson.Value) error {
2321	object := value.Object()
2322	defer object.Close()
2323
2324	if v.Description != nil {
2325		ok := object.Key("Description")
2326		ok.String(*v.Description)
2327	}
2328
2329	if v.Name != nil {
2330		ok := object.Key("Name")
2331		ok.String(*v.Name)
2332	}
2333
2334	return nil
2335}
2336
2337type awsRestjson1_serializeOpUpdateConfigurationProfile struct {
2338}
2339
2340func (*awsRestjson1_serializeOpUpdateConfigurationProfile) ID() string {
2341	return "OperationSerializer"
2342}
2343
2344func (m *awsRestjson1_serializeOpUpdateConfigurationProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2345	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2346) {
2347	request, ok := in.Request.(*smithyhttp.Request)
2348	if !ok {
2349		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2350	}
2351
2352	input, ok := in.Parameters.(*UpdateConfigurationProfileInput)
2353	_ = input
2354	if !ok {
2355		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2356	}
2357
2358	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}")
2359	request.URL.Path = opPath
2360	if len(request.URL.RawQuery) > 0 {
2361		request.URL.RawQuery = "&" + opQuery
2362	} else {
2363		request.URL.RawQuery = opQuery
2364	}
2365
2366	request.Method = "PATCH"
2367	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2368	if err != nil {
2369		return out, metadata, &smithy.SerializationError{Err: err}
2370	}
2371
2372	if err := awsRestjson1_serializeOpHttpBindingsUpdateConfigurationProfileInput(input, restEncoder); err != nil {
2373		return out, metadata, &smithy.SerializationError{Err: err}
2374	}
2375
2376	restEncoder.SetHeader("Content-Type").String("application/json")
2377
2378	jsonEncoder := smithyjson.NewEncoder()
2379	if err := awsRestjson1_serializeOpDocumentUpdateConfigurationProfileInput(input, jsonEncoder.Value); err != nil {
2380		return out, metadata, &smithy.SerializationError{Err: err}
2381	}
2382
2383	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2384		return out, metadata, &smithy.SerializationError{Err: err}
2385	}
2386
2387	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2388		return out, metadata, &smithy.SerializationError{Err: err}
2389	}
2390	in.Request = request
2391
2392	return next.HandleSerialize(ctx, in)
2393}
2394func awsRestjson1_serializeOpHttpBindingsUpdateConfigurationProfileInput(v *UpdateConfigurationProfileInput, encoder *httpbinding.Encoder) error {
2395	if v == nil {
2396		return fmt.Errorf("unsupported serialization of nil %T", v)
2397	}
2398
2399	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
2400		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
2401	}
2402	if v.ApplicationId != nil {
2403		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
2404			return err
2405		}
2406	}
2407
2408	if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 {
2409		return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")}
2410	}
2411	if v.ConfigurationProfileId != nil {
2412		if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil {
2413			return err
2414		}
2415	}
2416
2417	return nil
2418}
2419
2420func awsRestjson1_serializeOpDocumentUpdateConfigurationProfileInput(v *UpdateConfigurationProfileInput, value smithyjson.Value) error {
2421	object := value.Object()
2422	defer object.Close()
2423
2424	if v.Description != nil {
2425		ok := object.Key("Description")
2426		ok.String(*v.Description)
2427	}
2428
2429	if v.Name != nil {
2430		ok := object.Key("Name")
2431		ok.String(*v.Name)
2432	}
2433
2434	if v.RetrievalRoleArn != nil {
2435		ok := object.Key("RetrievalRoleArn")
2436		ok.String(*v.RetrievalRoleArn)
2437	}
2438
2439	if v.Validators != nil {
2440		ok := object.Key("Validators")
2441		if err := awsRestjson1_serializeDocumentValidatorList(v.Validators, ok); err != nil {
2442			return err
2443		}
2444	}
2445
2446	return nil
2447}
2448
2449type awsRestjson1_serializeOpUpdateDeploymentStrategy struct {
2450}
2451
2452func (*awsRestjson1_serializeOpUpdateDeploymentStrategy) ID() string {
2453	return "OperationSerializer"
2454}
2455
2456func (m *awsRestjson1_serializeOpUpdateDeploymentStrategy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2457	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2458) {
2459	request, ok := in.Request.(*smithyhttp.Request)
2460	if !ok {
2461		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2462	}
2463
2464	input, ok := in.Parameters.(*UpdateDeploymentStrategyInput)
2465	_ = input
2466	if !ok {
2467		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2468	}
2469
2470	opPath, opQuery := httpbinding.SplitURI("/deploymentstrategies/{DeploymentStrategyId}")
2471	request.URL.Path = opPath
2472	if len(request.URL.RawQuery) > 0 {
2473		request.URL.RawQuery = "&" + opQuery
2474	} else {
2475		request.URL.RawQuery = opQuery
2476	}
2477
2478	request.Method = "PATCH"
2479	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2480	if err != nil {
2481		return out, metadata, &smithy.SerializationError{Err: err}
2482	}
2483
2484	if err := awsRestjson1_serializeOpHttpBindingsUpdateDeploymentStrategyInput(input, restEncoder); err != nil {
2485		return out, metadata, &smithy.SerializationError{Err: err}
2486	}
2487
2488	restEncoder.SetHeader("Content-Type").String("application/json")
2489
2490	jsonEncoder := smithyjson.NewEncoder()
2491	if err := awsRestjson1_serializeOpDocumentUpdateDeploymentStrategyInput(input, jsonEncoder.Value); err != nil {
2492		return out, metadata, &smithy.SerializationError{Err: err}
2493	}
2494
2495	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2496		return out, metadata, &smithy.SerializationError{Err: err}
2497	}
2498
2499	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2500		return out, metadata, &smithy.SerializationError{Err: err}
2501	}
2502	in.Request = request
2503
2504	return next.HandleSerialize(ctx, in)
2505}
2506func awsRestjson1_serializeOpHttpBindingsUpdateDeploymentStrategyInput(v *UpdateDeploymentStrategyInput, encoder *httpbinding.Encoder) error {
2507	if v == nil {
2508		return fmt.Errorf("unsupported serialization of nil %T", v)
2509	}
2510
2511	if v.DeploymentStrategyId == nil || len(*v.DeploymentStrategyId) == 0 {
2512		return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentStrategyId must not be empty")}
2513	}
2514	if v.DeploymentStrategyId != nil {
2515		if err := encoder.SetURI("DeploymentStrategyId").String(*v.DeploymentStrategyId); err != nil {
2516			return err
2517		}
2518	}
2519
2520	return nil
2521}
2522
2523func awsRestjson1_serializeOpDocumentUpdateDeploymentStrategyInput(v *UpdateDeploymentStrategyInput, value smithyjson.Value) error {
2524	object := value.Object()
2525	defer object.Close()
2526
2527	if v.DeploymentDurationInMinutes != 0 {
2528		ok := object.Key("DeploymentDurationInMinutes")
2529		ok.Integer(v.DeploymentDurationInMinutes)
2530	}
2531
2532	if v.Description != nil {
2533		ok := object.Key("Description")
2534		ok.String(*v.Description)
2535	}
2536
2537	if v.FinalBakeTimeInMinutes != 0 {
2538		ok := object.Key("FinalBakeTimeInMinutes")
2539		ok.Integer(v.FinalBakeTimeInMinutes)
2540	}
2541
2542	if v.GrowthFactor != 0 {
2543		ok := object.Key("GrowthFactor")
2544		ok.Float(v.GrowthFactor)
2545	}
2546
2547	if len(v.GrowthType) > 0 {
2548		ok := object.Key("GrowthType")
2549		ok.String(string(v.GrowthType))
2550	}
2551
2552	return nil
2553}
2554
2555type awsRestjson1_serializeOpUpdateEnvironment struct {
2556}
2557
2558func (*awsRestjson1_serializeOpUpdateEnvironment) ID() string {
2559	return "OperationSerializer"
2560}
2561
2562func (m *awsRestjson1_serializeOpUpdateEnvironment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2563	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2564) {
2565	request, ok := in.Request.(*smithyhttp.Request)
2566	if !ok {
2567		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2568	}
2569
2570	input, ok := in.Parameters.(*UpdateEnvironmentInput)
2571	_ = input
2572	if !ok {
2573		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2574	}
2575
2576	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}")
2577	request.URL.Path = opPath
2578	if len(request.URL.RawQuery) > 0 {
2579		request.URL.RawQuery = "&" + opQuery
2580	} else {
2581		request.URL.RawQuery = opQuery
2582	}
2583
2584	request.Method = "PATCH"
2585	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2586	if err != nil {
2587		return out, metadata, &smithy.SerializationError{Err: err}
2588	}
2589
2590	if err := awsRestjson1_serializeOpHttpBindingsUpdateEnvironmentInput(input, restEncoder); err != nil {
2591		return out, metadata, &smithy.SerializationError{Err: err}
2592	}
2593
2594	restEncoder.SetHeader("Content-Type").String("application/json")
2595
2596	jsonEncoder := smithyjson.NewEncoder()
2597	if err := awsRestjson1_serializeOpDocumentUpdateEnvironmentInput(input, jsonEncoder.Value); err != nil {
2598		return out, metadata, &smithy.SerializationError{Err: err}
2599	}
2600
2601	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2602		return out, metadata, &smithy.SerializationError{Err: err}
2603	}
2604
2605	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2606		return out, metadata, &smithy.SerializationError{Err: err}
2607	}
2608	in.Request = request
2609
2610	return next.HandleSerialize(ctx, in)
2611}
2612func awsRestjson1_serializeOpHttpBindingsUpdateEnvironmentInput(v *UpdateEnvironmentInput, encoder *httpbinding.Encoder) error {
2613	if v == nil {
2614		return fmt.Errorf("unsupported serialization of nil %T", v)
2615	}
2616
2617	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
2618		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
2619	}
2620	if v.ApplicationId != nil {
2621		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
2622			return err
2623		}
2624	}
2625
2626	if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 {
2627		return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")}
2628	}
2629	if v.EnvironmentId != nil {
2630		if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil {
2631			return err
2632		}
2633	}
2634
2635	return nil
2636}
2637
2638func awsRestjson1_serializeOpDocumentUpdateEnvironmentInput(v *UpdateEnvironmentInput, value smithyjson.Value) error {
2639	object := value.Object()
2640	defer object.Close()
2641
2642	if v.Description != nil {
2643		ok := object.Key("Description")
2644		ok.String(*v.Description)
2645	}
2646
2647	if v.Monitors != nil {
2648		ok := object.Key("Monitors")
2649		if err := awsRestjson1_serializeDocumentMonitorList(v.Monitors, ok); err != nil {
2650			return err
2651		}
2652	}
2653
2654	if v.Name != nil {
2655		ok := object.Key("Name")
2656		ok.String(*v.Name)
2657	}
2658
2659	return nil
2660}
2661
2662type awsRestjson1_serializeOpValidateConfiguration struct {
2663}
2664
2665func (*awsRestjson1_serializeOpValidateConfiguration) ID() string {
2666	return "OperationSerializer"
2667}
2668
2669func (m *awsRestjson1_serializeOpValidateConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2670	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2671) {
2672	request, ok := in.Request.(*smithyhttp.Request)
2673	if !ok {
2674		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2675	}
2676
2677	input, ok := in.Parameters.(*ValidateConfigurationInput)
2678	_ = input
2679	if !ok {
2680		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2681	}
2682
2683	opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}/validators")
2684	request.URL.Path = opPath
2685	if len(request.URL.RawQuery) > 0 {
2686		request.URL.RawQuery = "&" + opQuery
2687	} else {
2688		request.URL.RawQuery = opQuery
2689	}
2690
2691	request.Method = "POST"
2692	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2693	if err != nil {
2694		return out, metadata, &smithy.SerializationError{Err: err}
2695	}
2696
2697	if err := awsRestjson1_serializeOpHttpBindingsValidateConfigurationInput(input, restEncoder); err != nil {
2698		return out, metadata, &smithy.SerializationError{Err: err}
2699	}
2700
2701	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2702		return out, metadata, &smithy.SerializationError{Err: err}
2703	}
2704	in.Request = request
2705
2706	return next.HandleSerialize(ctx, in)
2707}
2708func awsRestjson1_serializeOpHttpBindingsValidateConfigurationInput(v *ValidateConfigurationInput, encoder *httpbinding.Encoder) error {
2709	if v == nil {
2710		return fmt.Errorf("unsupported serialization of nil %T", v)
2711	}
2712
2713	if v.ApplicationId == nil || len(*v.ApplicationId) == 0 {
2714		return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")}
2715	}
2716	if v.ApplicationId != nil {
2717		if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil {
2718			return err
2719		}
2720	}
2721
2722	if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 {
2723		return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")}
2724	}
2725	if v.ConfigurationProfileId != nil {
2726		if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil {
2727			return err
2728		}
2729	}
2730
2731	if v.ConfigurationVersion != nil {
2732		encoder.SetQuery("configuration_version").String(*v.ConfigurationVersion)
2733	}
2734
2735	return nil
2736}
2737
2738func awsRestjson1_serializeDocumentMonitor(v *types.Monitor, value smithyjson.Value) error {
2739	object := value.Object()
2740	defer object.Close()
2741
2742	if v.AlarmArn != nil {
2743		ok := object.Key("AlarmArn")
2744		ok.String(*v.AlarmArn)
2745	}
2746
2747	if v.AlarmRoleArn != nil {
2748		ok := object.Key("AlarmRoleArn")
2749		ok.String(*v.AlarmRoleArn)
2750	}
2751
2752	return nil
2753}
2754
2755func awsRestjson1_serializeDocumentMonitorList(v []types.Monitor, value smithyjson.Value) error {
2756	array := value.Array()
2757	defer array.Close()
2758
2759	for i := range v {
2760		av := array.Value()
2761		if err := awsRestjson1_serializeDocumentMonitor(&v[i], av); err != nil {
2762			return err
2763		}
2764	}
2765	return nil
2766}
2767
2768func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error {
2769	object := value.Object()
2770	defer object.Close()
2771
2772	for key := range v {
2773		om := object.Key(key)
2774		om.String(v[key])
2775	}
2776	return nil
2777}
2778
2779func awsRestjson1_serializeDocumentValidator(v *types.Validator, value smithyjson.Value) error {
2780	object := value.Object()
2781	defer object.Close()
2782
2783	if v.Content != nil {
2784		ok := object.Key("Content")
2785		ok.String(*v.Content)
2786	}
2787
2788	if len(v.Type) > 0 {
2789		ok := object.Key("Type")
2790		ok.String(string(v.Type))
2791	}
2792
2793	return nil
2794}
2795
2796func awsRestjson1_serializeDocumentValidatorList(v []types.Validator, value smithyjson.Value) error {
2797	array := value.Array()
2798	defer array.Close()
2799
2800	for i := range v {
2801		av := array.Value()
2802		if err := awsRestjson1_serializeDocumentValidator(&v[i], av); err != nil {
2803			return err
2804		}
2805	}
2806	return nil
2807}
2808