1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package devopsguru
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/devopsguru/types"
10	smithy "github.com/aws/smithy-go"
11	"github.com/aws/smithy-go/encoding/httpbinding"
12	smithyjson "github.com/aws/smithy-go/encoding/json"
13	"github.com/aws/smithy-go/middleware"
14	smithytime "github.com/aws/smithy-go/time"
15	smithyhttp "github.com/aws/smithy-go/transport/http"
16)
17
18type awsRestjson1_serializeOpAddNotificationChannel struct {
19}
20
21func (*awsRestjson1_serializeOpAddNotificationChannel) ID() string {
22	return "OperationSerializer"
23}
24
25func (m *awsRestjson1_serializeOpAddNotificationChannel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
26	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
27) {
28	request, ok := in.Request.(*smithyhttp.Request)
29	if !ok {
30		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
31	}
32
33	input, ok := in.Parameters.(*AddNotificationChannelInput)
34	_ = input
35	if !ok {
36		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
37	}
38
39	opPath, opQuery := httpbinding.SplitURI("/channels")
40	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
41	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
42	request.Method = "PUT"
43	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
44	if err != nil {
45		return out, metadata, &smithy.SerializationError{Err: err}
46	}
47
48	restEncoder.SetHeader("Content-Type").String("application/json")
49
50	jsonEncoder := smithyjson.NewEncoder()
51	if err := awsRestjson1_serializeOpDocumentAddNotificationChannelInput(input, jsonEncoder.Value); err != nil {
52		return out, metadata, &smithy.SerializationError{Err: err}
53	}
54
55	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
56		return out, metadata, &smithy.SerializationError{Err: err}
57	}
58
59	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
60		return out, metadata, &smithy.SerializationError{Err: err}
61	}
62	in.Request = request
63
64	return next.HandleSerialize(ctx, in)
65}
66func awsRestjson1_serializeOpHttpBindingsAddNotificationChannelInput(v *AddNotificationChannelInput, encoder *httpbinding.Encoder) error {
67	if v == nil {
68		return fmt.Errorf("unsupported serialization of nil %T", v)
69	}
70
71	return nil
72}
73
74func awsRestjson1_serializeOpDocumentAddNotificationChannelInput(v *AddNotificationChannelInput, value smithyjson.Value) error {
75	object := value.Object()
76	defer object.Close()
77
78	if v.Config != nil {
79		ok := object.Key("Config")
80		if err := awsRestjson1_serializeDocumentNotificationChannelConfig(v.Config, ok); err != nil {
81			return err
82		}
83	}
84
85	return nil
86}
87
88type awsRestjson1_serializeOpDescribeAccountHealth struct {
89}
90
91func (*awsRestjson1_serializeOpDescribeAccountHealth) ID() string {
92	return "OperationSerializer"
93}
94
95func (m *awsRestjson1_serializeOpDescribeAccountHealth) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
96	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
97) {
98	request, ok := in.Request.(*smithyhttp.Request)
99	if !ok {
100		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
101	}
102
103	input, ok := in.Parameters.(*DescribeAccountHealthInput)
104	_ = input
105	if !ok {
106		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
107	}
108
109	opPath, opQuery := httpbinding.SplitURI("/accounts/health")
110	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
111	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
112	request.Method = "GET"
113	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
114	if err != nil {
115		return out, metadata, &smithy.SerializationError{Err: err}
116	}
117
118	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
119		return out, metadata, &smithy.SerializationError{Err: err}
120	}
121	in.Request = request
122
123	return next.HandleSerialize(ctx, in)
124}
125func awsRestjson1_serializeOpHttpBindingsDescribeAccountHealthInput(v *DescribeAccountHealthInput, encoder *httpbinding.Encoder) error {
126	if v == nil {
127		return fmt.Errorf("unsupported serialization of nil %T", v)
128	}
129
130	return nil
131}
132
133type awsRestjson1_serializeOpDescribeAccountOverview struct {
134}
135
136func (*awsRestjson1_serializeOpDescribeAccountOverview) ID() string {
137	return "OperationSerializer"
138}
139
140func (m *awsRestjson1_serializeOpDescribeAccountOverview) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
141	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
142) {
143	request, ok := in.Request.(*smithyhttp.Request)
144	if !ok {
145		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
146	}
147
148	input, ok := in.Parameters.(*DescribeAccountOverviewInput)
149	_ = input
150	if !ok {
151		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
152	}
153
154	opPath, opQuery := httpbinding.SplitURI("/accounts/overview")
155	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
156	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
157	request.Method = "POST"
158	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
159	if err != nil {
160		return out, metadata, &smithy.SerializationError{Err: err}
161	}
162
163	restEncoder.SetHeader("Content-Type").String("application/json")
164
165	jsonEncoder := smithyjson.NewEncoder()
166	if err := awsRestjson1_serializeOpDocumentDescribeAccountOverviewInput(input, jsonEncoder.Value); err != nil {
167		return out, metadata, &smithy.SerializationError{Err: err}
168	}
169
170	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
171		return out, metadata, &smithy.SerializationError{Err: err}
172	}
173
174	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
175		return out, metadata, &smithy.SerializationError{Err: err}
176	}
177	in.Request = request
178
179	return next.HandleSerialize(ctx, in)
180}
181func awsRestjson1_serializeOpHttpBindingsDescribeAccountOverviewInput(v *DescribeAccountOverviewInput, encoder *httpbinding.Encoder) error {
182	if v == nil {
183		return fmt.Errorf("unsupported serialization of nil %T", v)
184	}
185
186	return nil
187}
188
189func awsRestjson1_serializeOpDocumentDescribeAccountOverviewInput(v *DescribeAccountOverviewInput, value smithyjson.Value) error {
190	object := value.Object()
191	defer object.Close()
192
193	if v.FromTime != nil {
194		ok := object.Key("FromTime")
195		ok.Double(smithytime.FormatEpochSeconds(*v.FromTime))
196	}
197
198	if v.ToTime != nil {
199		ok := object.Key("ToTime")
200		ok.Double(smithytime.FormatEpochSeconds(*v.ToTime))
201	}
202
203	return nil
204}
205
206type awsRestjson1_serializeOpDescribeAnomaly struct {
207}
208
209func (*awsRestjson1_serializeOpDescribeAnomaly) ID() string {
210	return "OperationSerializer"
211}
212
213func (m *awsRestjson1_serializeOpDescribeAnomaly) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
214	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
215) {
216	request, ok := in.Request.(*smithyhttp.Request)
217	if !ok {
218		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
219	}
220
221	input, ok := in.Parameters.(*DescribeAnomalyInput)
222	_ = input
223	if !ok {
224		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
225	}
226
227	opPath, opQuery := httpbinding.SplitURI("/anomalies/{Id}")
228	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
229	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
230	request.Method = "GET"
231	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
232	if err != nil {
233		return out, metadata, &smithy.SerializationError{Err: err}
234	}
235
236	if err := awsRestjson1_serializeOpHttpBindingsDescribeAnomalyInput(input, restEncoder); err != nil {
237		return out, metadata, &smithy.SerializationError{Err: err}
238	}
239
240	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
241		return out, metadata, &smithy.SerializationError{Err: err}
242	}
243	in.Request = request
244
245	return next.HandleSerialize(ctx, in)
246}
247func awsRestjson1_serializeOpHttpBindingsDescribeAnomalyInput(v *DescribeAnomalyInput, encoder *httpbinding.Encoder) error {
248	if v == nil {
249		return fmt.Errorf("unsupported serialization of nil %T", v)
250	}
251
252	if v.Id == nil || len(*v.Id) == 0 {
253		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
254	}
255	if v.Id != nil {
256		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
257			return err
258		}
259	}
260
261	return nil
262}
263
264type awsRestjson1_serializeOpDescribeFeedback struct {
265}
266
267func (*awsRestjson1_serializeOpDescribeFeedback) ID() string {
268	return "OperationSerializer"
269}
270
271func (m *awsRestjson1_serializeOpDescribeFeedback) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
272	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
273) {
274	request, ok := in.Request.(*smithyhttp.Request)
275	if !ok {
276		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
277	}
278
279	input, ok := in.Parameters.(*DescribeFeedbackInput)
280	_ = input
281	if !ok {
282		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
283	}
284
285	opPath, opQuery := httpbinding.SplitURI("/feedback")
286	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
287	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
288	request.Method = "POST"
289	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
290	if err != nil {
291		return out, metadata, &smithy.SerializationError{Err: err}
292	}
293
294	restEncoder.SetHeader("Content-Type").String("application/json")
295
296	jsonEncoder := smithyjson.NewEncoder()
297	if err := awsRestjson1_serializeOpDocumentDescribeFeedbackInput(input, jsonEncoder.Value); err != nil {
298		return out, metadata, &smithy.SerializationError{Err: err}
299	}
300
301	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
302		return out, metadata, &smithy.SerializationError{Err: err}
303	}
304
305	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
306		return out, metadata, &smithy.SerializationError{Err: err}
307	}
308	in.Request = request
309
310	return next.HandleSerialize(ctx, in)
311}
312func awsRestjson1_serializeOpHttpBindingsDescribeFeedbackInput(v *DescribeFeedbackInput, encoder *httpbinding.Encoder) error {
313	if v == nil {
314		return fmt.Errorf("unsupported serialization of nil %T", v)
315	}
316
317	return nil
318}
319
320func awsRestjson1_serializeOpDocumentDescribeFeedbackInput(v *DescribeFeedbackInput, value smithyjson.Value) error {
321	object := value.Object()
322	defer object.Close()
323
324	if v.InsightId != nil {
325		ok := object.Key("InsightId")
326		ok.String(*v.InsightId)
327	}
328
329	return nil
330}
331
332type awsRestjson1_serializeOpDescribeInsight struct {
333}
334
335func (*awsRestjson1_serializeOpDescribeInsight) ID() string {
336	return "OperationSerializer"
337}
338
339func (m *awsRestjson1_serializeOpDescribeInsight) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
340	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
341) {
342	request, ok := in.Request.(*smithyhttp.Request)
343	if !ok {
344		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
345	}
346
347	input, ok := in.Parameters.(*DescribeInsightInput)
348	_ = input
349	if !ok {
350		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
351	}
352
353	opPath, opQuery := httpbinding.SplitURI("/insights/{Id}")
354	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
355	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
356	request.Method = "GET"
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_serializeOpHttpBindingsDescribeInsightInput(input, restEncoder); err != nil {
363		return out, metadata, &smithy.SerializationError{Err: err}
364	}
365
366	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
367		return out, metadata, &smithy.SerializationError{Err: err}
368	}
369	in.Request = request
370
371	return next.HandleSerialize(ctx, in)
372}
373func awsRestjson1_serializeOpHttpBindingsDescribeInsightInput(v *DescribeInsightInput, encoder *httpbinding.Encoder) error {
374	if v == nil {
375		return fmt.Errorf("unsupported serialization of nil %T", v)
376	}
377
378	if v.Id == nil || len(*v.Id) == 0 {
379		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
380	}
381	if v.Id != nil {
382		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
383			return err
384		}
385	}
386
387	return nil
388}
389
390type awsRestjson1_serializeOpDescribeResourceCollectionHealth struct {
391}
392
393func (*awsRestjson1_serializeOpDescribeResourceCollectionHealth) ID() string {
394	return "OperationSerializer"
395}
396
397func (m *awsRestjson1_serializeOpDescribeResourceCollectionHealth) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
398	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
399) {
400	request, ok := in.Request.(*smithyhttp.Request)
401	if !ok {
402		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
403	}
404
405	input, ok := in.Parameters.(*DescribeResourceCollectionHealthInput)
406	_ = input
407	if !ok {
408		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
409	}
410
411	opPath, opQuery := httpbinding.SplitURI("/accounts/health/resource-collection/{ResourceCollectionType}")
412	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
413	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
414	request.Method = "GET"
415	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
416	if err != nil {
417		return out, metadata, &smithy.SerializationError{Err: err}
418	}
419
420	if err := awsRestjson1_serializeOpHttpBindingsDescribeResourceCollectionHealthInput(input, restEncoder); err != nil {
421		return out, metadata, &smithy.SerializationError{Err: err}
422	}
423
424	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
425		return out, metadata, &smithy.SerializationError{Err: err}
426	}
427	in.Request = request
428
429	return next.HandleSerialize(ctx, in)
430}
431func awsRestjson1_serializeOpHttpBindingsDescribeResourceCollectionHealthInput(v *DescribeResourceCollectionHealthInput, encoder *httpbinding.Encoder) error {
432	if v == nil {
433		return fmt.Errorf("unsupported serialization of nil %T", v)
434	}
435
436	if v.NextToken != nil {
437		encoder.SetQuery("NextToken").String(*v.NextToken)
438	}
439
440	if len(v.ResourceCollectionType) == 0 {
441		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceCollectionType must not be empty")}
442	}
443	if len(v.ResourceCollectionType) > 0 {
444		if err := encoder.SetURI("ResourceCollectionType").String(string(v.ResourceCollectionType)); err != nil {
445			return err
446		}
447	}
448
449	return nil
450}
451
452type awsRestjson1_serializeOpDescribeServiceIntegration struct {
453}
454
455func (*awsRestjson1_serializeOpDescribeServiceIntegration) ID() string {
456	return "OperationSerializer"
457}
458
459func (m *awsRestjson1_serializeOpDescribeServiceIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
460	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
461) {
462	request, ok := in.Request.(*smithyhttp.Request)
463	if !ok {
464		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
465	}
466
467	input, ok := in.Parameters.(*DescribeServiceIntegrationInput)
468	_ = input
469	if !ok {
470		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
471	}
472
473	opPath, opQuery := httpbinding.SplitURI("/service-integrations")
474	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
475	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
476	request.Method = "GET"
477	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
478	if err != nil {
479		return out, metadata, &smithy.SerializationError{Err: err}
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_serializeOpHttpBindingsDescribeServiceIntegrationInput(v *DescribeServiceIntegrationInput, encoder *httpbinding.Encoder) error {
490	if v == nil {
491		return fmt.Errorf("unsupported serialization of nil %T", v)
492	}
493
494	return nil
495}
496
497type awsRestjson1_serializeOpGetCostEstimation struct {
498}
499
500func (*awsRestjson1_serializeOpGetCostEstimation) ID() string {
501	return "OperationSerializer"
502}
503
504func (m *awsRestjson1_serializeOpGetCostEstimation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
505	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
506) {
507	request, ok := in.Request.(*smithyhttp.Request)
508	if !ok {
509		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
510	}
511
512	input, ok := in.Parameters.(*GetCostEstimationInput)
513	_ = input
514	if !ok {
515		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
516	}
517
518	opPath, opQuery := httpbinding.SplitURI("/cost-estimation")
519	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
520	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
521	request.Method = "GET"
522	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
523	if err != nil {
524		return out, metadata, &smithy.SerializationError{Err: err}
525	}
526
527	if err := awsRestjson1_serializeOpHttpBindingsGetCostEstimationInput(input, restEncoder); err != nil {
528		return out, metadata, &smithy.SerializationError{Err: err}
529	}
530
531	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
532		return out, metadata, &smithy.SerializationError{Err: err}
533	}
534	in.Request = request
535
536	return next.HandleSerialize(ctx, in)
537}
538func awsRestjson1_serializeOpHttpBindingsGetCostEstimationInput(v *GetCostEstimationInput, encoder *httpbinding.Encoder) error {
539	if v == nil {
540		return fmt.Errorf("unsupported serialization of nil %T", v)
541	}
542
543	if v.NextToken != nil {
544		encoder.SetQuery("NextToken").String(*v.NextToken)
545	}
546
547	return nil
548}
549
550type awsRestjson1_serializeOpGetResourceCollection struct {
551}
552
553func (*awsRestjson1_serializeOpGetResourceCollection) ID() string {
554	return "OperationSerializer"
555}
556
557func (m *awsRestjson1_serializeOpGetResourceCollection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
558	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
559) {
560	request, ok := in.Request.(*smithyhttp.Request)
561	if !ok {
562		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
563	}
564
565	input, ok := in.Parameters.(*GetResourceCollectionInput)
566	_ = input
567	if !ok {
568		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
569	}
570
571	opPath, opQuery := httpbinding.SplitURI("/resource-collections/{ResourceCollectionType}")
572	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
573	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
574	request.Method = "GET"
575	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
576	if err != nil {
577		return out, metadata, &smithy.SerializationError{Err: err}
578	}
579
580	if err := awsRestjson1_serializeOpHttpBindingsGetResourceCollectionInput(input, restEncoder); err != nil {
581		return out, metadata, &smithy.SerializationError{Err: err}
582	}
583
584	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
585		return out, metadata, &smithy.SerializationError{Err: err}
586	}
587	in.Request = request
588
589	return next.HandleSerialize(ctx, in)
590}
591func awsRestjson1_serializeOpHttpBindingsGetResourceCollectionInput(v *GetResourceCollectionInput, encoder *httpbinding.Encoder) error {
592	if v == nil {
593		return fmt.Errorf("unsupported serialization of nil %T", v)
594	}
595
596	if v.NextToken != nil {
597		encoder.SetQuery("NextToken").String(*v.NextToken)
598	}
599
600	if len(v.ResourceCollectionType) == 0 {
601		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceCollectionType must not be empty")}
602	}
603	if len(v.ResourceCollectionType) > 0 {
604		if err := encoder.SetURI("ResourceCollectionType").String(string(v.ResourceCollectionType)); err != nil {
605			return err
606		}
607	}
608
609	return nil
610}
611
612type awsRestjson1_serializeOpListAnomaliesForInsight struct {
613}
614
615func (*awsRestjson1_serializeOpListAnomaliesForInsight) ID() string {
616	return "OperationSerializer"
617}
618
619func (m *awsRestjson1_serializeOpListAnomaliesForInsight) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
620	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
621) {
622	request, ok := in.Request.(*smithyhttp.Request)
623	if !ok {
624		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
625	}
626
627	input, ok := in.Parameters.(*ListAnomaliesForInsightInput)
628	_ = input
629	if !ok {
630		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
631	}
632
633	opPath, opQuery := httpbinding.SplitURI("/anomalies/insight/{InsightId}")
634	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
635	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
636	request.Method = "POST"
637	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
638	if err != nil {
639		return out, metadata, &smithy.SerializationError{Err: err}
640	}
641
642	if err := awsRestjson1_serializeOpHttpBindingsListAnomaliesForInsightInput(input, restEncoder); err != nil {
643		return out, metadata, &smithy.SerializationError{Err: err}
644	}
645
646	restEncoder.SetHeader("Content-Type").String("application/json")
647
648	jsonEncoder := smithyjson.NewEncoder()
649	if err := awsRestjson1_serializeOpDocumentListAnomaliesForInsightInput(input, jsonEncoder.Value); err != nil {
650		return out, metadata, &smithy.SerializationError{Err: err}
651	}
652
653	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
654		return out, metadata, &smithy.SerializationError{Err: err}
655	}
656
657	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
658		return out, metadata, &smithy.SerializationError{Err: err}
659	}
660	in.Request = request
661
662	return next.HandleSerialize(ctx, in)
663}
664func awsRestjson1_serializeOpHttpBindingsListAnomaliesForInsightInput(v *ListAnomaliesForInsightInput, encoder *httpbinding.Encoder) error {
665	if v == nil {
666		return fmt.Errorf("unsupported serialization of nil %T", v)
667	}
668
669	if v.InsightId == nil || len(*v.InsightId) == 0 {
670		return &smithy.SerializationError{Err: fmt.Errorf("input member InsightId must not be empty")}
671	}
672	if v.InsightId != nil {
673		if err := encoder.SetURI("InsightId").String(*v.InsightId); err != nil {
674			return err
675		}
676	}
677
678	return nil
679}
680
681func awsRestjson1_serializeOpDocumentListAnomaliesForInsightInput(v *ListAnomaliesForInsightInput, value smithyjson.Value) error {
682	object := value.Object()
683	defer object.Close()
684
685	if v.MaxResults != nil {
686		ok := object.Key("MaxResults")
687		ok.Integer(*v.MaxResults)
688	}
689
690	if v.NextToken != nil {
691		ok := object.Key("NextToken")
692		ok.String(*v.NextToken)
693	}
694
695	if v.StartTimeRange != nil {
696		ok := object.Key("StartTimeRange")
697		if err := awsRestjson1_serializeDocumentStartTimeRange(v.StartTimeRange, ok); err != nil {
698			return err
699		}
700	}
701
702	return nil
703}
704
705type awsRestjson1_serializeOpListEvents struct {
706}
707
708func (*awsRestjson1_serializeOpListEvents) ID() string {
709	return "OperationSerializer"
710}
711
712func (m *awsRestjson1_serializeOpListEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
713	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
714) {
715	request, ok := in.Request.(*smithyhttp.Request)
716	if !ok {
717		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
718	}
719
720	input, ok := in.Parameters.(*ListEventsInput)
721	_ = input
722	if !ok {
723		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
724	}
725
726	opPath, opQuery := httpbinding.SplitURI("/events")
727	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
728	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
729	request.Method = "POST"
730	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
731	if err != nil {
732		return out, metadata, &smithy.SerializationError{Err: err}
733	}
734
735	restEncoder.SetHeader("Content-Type").String("application/json")
736
737	jsonEncoder := smithyjson.NewEncoder()
738	if err := awsRestjson1_serializeOpDocumentListEventsInput(input, jsonEncoder.Value); err != nil {
739		return out, metadata, &smithy.SerializationError{Err: err}
740	}
741
742	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
743		return out, metadata, &smithy.SerializationError{Err: err}
744	}
745
746	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
747		return out, metadata, &smithy.SerializationError{Err: err}
748	}
749	in.Request = request
750
751	return next.HandleSerialize(ctx, in)
752}
753func awsRestjson1_serializeOpHttpBindingsListEventsInput(v *ListEventsInput, encoder *httpbinding.Encoder) error {
754	if v == nil {
755		return fmt.Errorf("unsupported serialization of nil %T", v)
756	}
757
758	return nil
759}
760
761func awsRestjson1_serializeOpDocumentListEventsInput(v *ListEventsInput, value smithyjson.Value) error {
762	object := value.Object()
763	defer object.Close()
764
765	if v.Filters != nil {
766		ok := object.Key("Filters")
767		if err := awsRestjson1_serializeDocumentListEventsFilters(v.Filters, ok); err != nil {
768			return err
769		}
770	}
771
772	if v.MaxResults != nil {
773		ok := object.Key("MaxResults")
774		ok.Integer(*v.MaxResults)
775	}
776
777	if v.NextToken != nil {
778		ok := object.Key("NextToken")
779		ok.String(*v.NextToken)
780	}
781
782	return nil
783}
784
785type awsRestjson1_serializeOpListInsights struct {
786}
787
788func (*awsRestjson1_serializeOpListInsights) ID() string {
789	return "OperationSerializer"
790}
791
792func (m *awsRestjson1_serializeOpListInsights) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
793	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
794) {
795	request, ok := in.Request.(*smithyhttp.Request)
796	if !ok {
797		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
798	}
799
800	input, ok := in.Parameters.(*ListInsightsInput)
801	_ = input
802	if !ok {
803		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
804	}
805
806	opPath, opQuery := httpbinding.SplitURI("/insights")
807	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
808	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
809	request.Method = "POST"
810	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
811	if err != nil {
812		return out, metadata, &smithy.SerializationError{Err: err}
813	}
814
815	restEncoder.SetHeader("Content-Type").String("application/json")
816
817	jsonEncoder := smithyjson.NewEncoder()
818	if err := awsRestjson1_serializeOpDocumentListInsightsInput(input, jsonEncoder.Value); err != nil {
819		return out, metadata, &smithy.SerializationError{Err: err}
820	}
821
822	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
823		return out, metadata, &smithy.SerializationError{Err: err}
824	}
825
826	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
827		return out, metadata, &smithy.SerializationError{Err: err}
828	}
829	in.Request = request
830
831	return next.HandleSerialize(ctx, in)
832}
833func awsRestjson1_serializeOpHttpBindingsListInsightsInput(v *ListInsightsInput, encoder *httpbinding.Encoder) error {
834	if v == nil {
835		return fmt.Errorf("unsupported serialization of nil %T", v)
836	}
837
838	return nil
839}
840
841func awsRestjson1_serializeOpDocumentListInsightsInput(v *ListInsightsInput, value smithyjson.Value) error {
842	object := value.Object()
843	defer object.Close()
844
845	if v.MaxResults != nil {
846		ok := object.Key("MaxResults")
847		ok.Integer(*v.MaxResults)
848	}
849
850	if v.NextToken != nil {
851		ok := object.Key("NextToken")
852		ok.String(*v.NextToken)
853	}
854
855	if v.StatusFilter != nil {
856		ok := object.Key("StatusFilter")
857		if err := awsRestjson1_serializeDocumentListInsightsStatusFilter(v.StatusFilter, ok); err != nil {
858			return err
859		}
860	}
861
862	return nil
863}
864
865type awsRestjson1_serializeOpListNotificationChannels struct {
866}
867
868func (*awsRestjson1_serializeOpListNotificationChannels) ID() string {
869	return "OperationSerializer"
870}
871
872func (m *awsRestjson1_serializeOpListNotificationChannels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
873	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
874) {
875	request, ok := in.Request.(*smithyhttp.Request)
876	if !ok {
877		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
878	}
879
880	input, ok := in.Parameters.(*ListNotificationChannelsInput)
881	_ = input
882	if !ok {
883		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
884	}
885
886	opPath, opQuery := httpbinding.SplitURI("/channels")
887	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
888	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
889	request.Method = "POST"
890	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
891	if err != nil {
892		return out, metadata, &smithy.SerializationError{Err: err}
893	}
894
895	restEncoder.SetHeader("Content-Type").String("application/json")
896
897	jsonEncoder := smithyjson.NewEncoder()
898	if err := awsRestjson1_serializeOpDocumentListNotificationChannelsInput(input, jsonEncoder.Value); err != nil {
899		return out, metadata, &smithy.SerializationError{Err: err}
900	}
901
902	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
903		return out, metadata, &smithy.SerializationError{Err: err}
904	}
905
906	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
907		return out, metadata, &smithy.SerializationError{Err: err}
908	}
909	in.Request = request
910
911	return next.HandleSerialize(ctx, in)
912}
913func awsRestjson1_serializeOpHttpBindingsListNotificationChannelsInput(v *ListNotificationChannelsInput, encoder *httpbinding.Encoder) error {
914	if v == nil {
915		return fmt.Errorf("unsupported serialization of nil %T", v)
916	}
917
918	return nil
919}
920
921func awsRestjson1_serializeOpDocumentListNotificationChannelsInput(v *ListNotificationChannelsInput, value smithyjson.Value) error {
922	object := value.Object()
923	defer object.Close()
924
925	if v.NextToken != nil {
926		ok := object.Key("NextToken")
927		ok.String(*v.NextToken)
928	}
929
930	return nil
931}
932
933type awsRestjson1_serializeOpListRecommendations struct {
934}
935
936func (*awsRestjson1_serializeOpListRecommendations) ID() string {
937	return "OperationSerializer"
938}
939
940func (m *awsRestjson1_serializeOpListRecommendations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
941	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
942) {
943	request, ok := in.Request.(*smithyhttp.Request)
944	if !ok {
945		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
946	}
947
948	input, ok := in.Parameters.(*ListRecommendationsInput)
949	_ = input
950	if !ok {
951		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
952	}
953
954	opPath, opQuery := httpbinding.SplitURI("/recommendations")
955	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
956	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
957	request.Method = "POST"
958	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
959	if err != nil {
960		return out, metadata, &smithy.SerializationError{Err: err}
961	}
962
963	restEncoder.SetHeader("Content-Type").String("application/json")
964
965	jsonEncoder := smithyjson.NewEncoder()
966	if err := awsRestjson1_serializeOpDocumentListRecommendationsInput(input, jsonEncoder.Value); err != nil {
967		return out, metadata, &smithy.SerializationError{Err: err}
968	}
969
970	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
971		return out, metadata, &smithy.SerializationError{Err: err}
972	}
973
974	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
975		return out, metadata, &smithy.SerializationError{Err: err}
976	}
977	in.Request = request
978
979	return next.HandleSerialize(ctx, in)
980}
981func awsRestjson1_serializeOpHttpBindingsListRecommendationsInput(v *ListRecommendationsInput, encoder *httpbinding.Encoder) error {
982	if v == nil {
983		return fmt.Errorf("unsupported serialization of nil %T", v)
984	}
985
986	return nil
987}
988
989func awsRestjson1_serializeOpDocumentListRecommendationsInput(v *ListRecommendationsInput, value smithyjson.Value) error {
990	object := value.Object()
991	defer object.Close()
992
993	if v.InsightId != nil {
994		ok := object.Key("InsightId")
995		ok.String(*v.InsightId)
996	}
997
998	if len(v.Locale) > 0 {
999		ok := object.Key("Locale")
1000		ok.String(string(v.Locale))
1001	}
1002
1003	if v.NextToken != nil {
1004		ok := object.Key("NextToken")
1005		ok.String(*v.NextToken)
1006	}
1007
1008	return nil
1009}
1010
1011type awsRestjson1_serializeOpPutFeedback struct {
1012}
1013
1014func (*awsRestjson1_serializeOpPutFeedback) ID() string {
1015	return "OperationSerializer"
1016}
1017
1018func (m *awsRestjson1_serializeOpPutFeedback) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1019	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1020) {
1021	request, ok := in.Request.(*smithyhttp.Request)
1022	if !ok {
1023		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1024	}
1025
1026	input, ok := in.Parameters.(*PutFeedbackInput)
1027	_ = input
1028	if !ok {
1029		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1030	}
1031
1032	opPath, opQuery := httpbinding.SplitURI("/feedback")
1033	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1034	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1035	request.Method = "PUT"
1036	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1037	if err != nil {
1038		return out, metadata, &smithy.SerializationError{Err: err}
1039	}
1040
1041	restEncoder.SetHeader("Content-Type").String("application/json")
1042
1043	jsonEncoder := smithyjson.NewEncoder()
1044	if err := awsRestjson1_serializeOpDocumentPutFeedbackInput(input, jsonEncoder.Value); err != nil {
1045		return out, metadata, &smithy.SerializationError{Err: err}
1046	}
1047
1048	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1049		return out, metadata, &smithy.SerializationError{Err: err}
1050	}
1051
1052	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1053		return out, metadata, &smithy.SerializationError{Err: err}
1054	}
1055	in.Request = request
1056
1057	return next.HandleSerialize(ctx, in)
1058}
1059func awsRestjson1_serializeOpHttpBindingsPutFeedbackInput(v *PutFeedbackInput, encoder *httpbinding.Encoder) error {
1060	if v == nil {
1061		return fmt.Errorf("unsupported serialization of nil %T", v)
1062	}
1063
1064	return nil
1065}
1066
1067func awsRestjson1_serializeOpDocumentPutFeedbackInput(v *PutFeedbackInput, value smithyjson.Value) error {
1068	object := value.Object()
1069	defer object.Close()
1070
1071	if v.InsightFeedback != nil {
1072		ok := object.Key("InsightFeedback")
1073		if err := awsRestjson1_serializeDocumentInsightFeedback(v.InsightFeedback, ok); err != nil {
1074			return err
1075		}
1076	}
1077
1078	return nil
1079}
1080
1081type awsRestjson1_serializeOpRemoveNotificationChannel struct {
1082}
1083
1084func (*awsRestjson1_serializeOpRemoveNotificationChannel) ID() string {
1085	return "OperationSerializer"
1086}
1087
1088func (m *awsRestjson1_serializeOpRemoveNotificationChannel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1089	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1090) {
1091	request, ok := in.Request.(*smithyhttp.Request)
1092	if !ok {
1093		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1094	}
1095
1096	input, ok := in.Parameters.(*RemoveNotificationChannelInput)
1097	_ = input
1098	if !ok {
1099		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1100	}
1101
1102	opPath, opQuery := httpbinding.SplitURI("/channels/{Id}")
1103	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1104	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1105	request.Method = "DELETE"
1106	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1107	if err != nil {
1108		return out, metadata, &smithy.SerializationError{Err: err}
1109	}
1110
1111	if err := awsRestjson1_serializeOpHttpBindingsRemoveNotificationChannelInput(input, restEncoder); err != nil {
1112		return out, metadata, &smithy.SerializationError{Err: err}
1113	}
1114
1115	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1116		return out, metadata, &smithy.SerializationError{Err: err}
1117	}
1118	in.Request = request
1119
1120	return next.HandleSerialize(ctx, in)
1121}
1122func awsRestjson1_serializeOpHttpBindingsRemoveNotificationChannelInput(v *RemoveNotificationChannelInput, encoder *httpbinding.Encoder) error {
1123	if v == nil {
1124		return fmt.Errorf("unsupported serialization of nil %T", v)
1125	}
1126
1127	if v.Id == nil || len(*v.Id) == 0 {
1128		return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
1129	}
1130	if v.Id != nil {
1131		if err := encoder.SetURI("Id").String(*v.Id); err != nil {
1132			return err
1133		}
1134	}
1135
1136	return nil
1137}
1138
1139type awsRestjson1_serializeOpSearchInsights struct {
1140}
1141
1142func (*awsRestjson1_serializeOpSearchInsights) ID() string {
1143	return "OperationSerializer"
1144}
1145
1146func (m *awsRestjson1_serializeOpSearchInsights) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1147	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1148) {
1149	request, ok := in.Request.(*smithyhttp.Request)
1150	if !ok {
1151		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1152	}
1153
1154	input, ok := in.Parameters.(*SearchInsightsInput)
1155	_ = input
1156	if !ok {
1157		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1158	}
1159
1160	opPath, opQuery := httpbinding.SplitURI("/insights/search")
1161	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1162	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1163	request.Method = "POST"
1164	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1165	if err != nil {
1166		return out, metadata, &smithy.SerializationError{Err: err}
1167	}
1168
1169	restEncoder.SetHeader("Content-Type").String("application/json")
1170
1171	jsonEncoder := smithyjson.NewEncoder()
1172	if err := awsRestjson1_serializeOpDocumentSearchInsightsInput(input, jsonEncoder.Value); err != nil {
1173		return out, metadata, &smithy.SerializationError{Err: err}
1174	}
1175
1176	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1177		return out, metadata, &smithy.SerializationError{Err: err}
1178	}
1179
1180	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1181		return out, metadata, &smithy.SerializationError{Err: err}
1182	}
1183	in.Request = request
1184
1185	return next.HandleSerialize(ctx, in)
1186}
1187func awsRestjson1_serializeOpHttpBindingsSearchInsightsInput(v *SearchInsightsInput, encoder *httpbinding.Encoder) error {
1188	if v == nil {
1189		return fmt.Errorf("unsupported serialization of nil %T", v)
1190	}
1191
1192	return nil
1193}
1194
1195func awsRestjson1_serializeOpDocumentSearchInsightsInput(v *SearchInsightsInput, value smithyjson.Value) error {
1196	object := value.Object()
1197	defer object.Close()
1198
1199	if v.Filters != nil {
1200		ok := object.Key("Filters")
1201		if err := awsRestjson1_serializeDocumentSearchInsightsFilters(v.Filters, ok); err != nil {
1202			return err
1203		}
1204	}
1205
1206	if v.MaxResults != nil {
1207		ok := object.Key("MaxResults")
1208		ok.Integer(*v.MaxResults)
1209	}
1210
1211	if v.NextToken != nil {
1212		ok := object.Key("NextToken")
1213		ok.String(*v.NextToken)
1214	}
1215
1216	if v.StartTimeRange != nil {
1217		ok := object.Key("StartTimeRange")
1218		if err := awsRestjson1_serializeDocumentStartTimeRange(v.StartTimeRange, ok); err != nil {
1219			return err
1220		}
1221	}
1222
1223	if len(v.Type) > 0 {
1224		ok := object.Key("Type")
1225		ok.String(string(v.Type))
1226	}
1227
1228	return nil
1229}
1230
1231type awsRestjson1_serializeOpStartCostEstimation struct {
1232}
1233
1234func (*awsRestjson1_serializeOpStartCostEstimation) ID() string {
1235	return "OperationSerializer"
1236}
1237
1238func (m *awsRestjson1_serializeOpStartCostEstimation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1239	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1240) {
1241	request, ok := in.Request.(*smithyhttp.Request)
1242	if !ok {
1243		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1244	}
1245
1246	input, ok := in.Parameters.(*StartCostEstimationInput)
1247	_ = input
1248	if !ok {
1249		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1250	}
1251
1252	opPath, opQuery := httpbinding.SplitURI("/cost-estimation")
1253	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1254	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1255	request.Method = "PUT"
1256	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1257	if err != nil {
1258		return out, metadata, &smithy.SerializationError{Err: err}
1259	}
1260
1261	restEncoder.SetHeader("Content-Type").String("application/json")
1262
1263	jsonEncoder := smithyjson.NewEncoder()
1264	if err := awsRestjson1_serializeOpDocumentStartCostEstimationInput(input, jsonEncoder.Value); err != nil {
1265		return out, metadata, &smithy.SerializationError{Err: err}
1266	}
1267
1268	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1269		return out, metadata, &smithy.SerializationError{Err: err}
1270	}
1271
1272	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1273		return out, metadata, &smithy.SerializationError{Err: err}
1274	}
1275	in.Request = request
1276
1277	return next.HandleSerialize(ctx, in)
1278}
1279func awsRestjson1_serializeOpHttpBindingsStartCostEstimationInput(v *StartCostEstimationInput, encoder *httpbinding.Encoder) error {
1280	if v == nil {
1281		return fmt.Errorf("unsupported serialization of nil %T", v)
1282	}
1283
1284	return nil
1285}
1286
1287func awsRestjson1_serializeOpDocumentStartCostEstimationInput(v *StartCostEstimationInput, value smithyjson.Value) error {
1288	object := value.Object()
1289	defer object.Close()
1290
1291	if v.ClientToken != nil {
1292		ok := object.Key("ClientToken")
1293		ok.String(*v.ClientToken)
1294	}
1295
1296	if v.ResourceCollection != nil {
1297		ok := object.Key("ResourceCollection")
1298		if err := awsRestjson1_serializeDocumentCostEstimationResourceCollectionFilter(v.ResourceCollection, ok); err != nil {
1299			return err
1300		}
1301	}
1302
1303	return nil
1304}
1305
1306type awsRestjson1_serializeOpUpdateResourceCollection struct {
1307}
1308
1309func (*awsRestjson1_serializeOpUpdateResourceCollection) ID() string {
1310	return "OperationSerializer"
1311}
1312
1313func (m *awsRestjson1_serializeOpUpdateResourceCollection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1314	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1315) {
1316	request, ok := in.Request.(*smithyhttp.Request)
1317	if !ok {
1318		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1319	}
1320
1321	input, ok := in.Parameters.(*UpdateResourceCollectionInput)
1322	_ = input
1323	if !ok {
1324		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1325	}
1326
1327	opPath, opQuery := httpbinding.SplitURI("/resource-collections")
1328	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1329	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1330	request.Method = "PUT"
1331	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1332	if err != nil {
1333		return out, metadata, &smithy.SerializationError{Err: err}
1334	}
1335
1336	restEncoder.SetHeader("Content-Type").String("application/json")
1337
1338	jsonEncoder := smithyjson.NewEncoder()
1339	if err := awsRestjson1_serializeOpDocumentUpdateResourceCollectionInput(input, jsonEncoder.Value); err != nil {
1340		return out, metadata, &smithy.SerializationError{Err: err}
1341	}
1342
1343	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1344		return out, metadata, &smithy.SerializationError{Err: err}
1345	}
1346
1347	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1348		return out, metadata, &smithy.SerializationError{Err: err}
1349	}
1350	in.Request = request
1351
1352	return next.HandleSerialize(ctx, in)
1353}
1354func awsRestjson1_serializeOpHttpBindingsUpdateResourceCollectionInput(v *UpdateResourceCollectionInput, encoder *httpbinding.Encoder) error {
1355	if v == nil {
1356		return fmt.Errorf("unsupported serialization of nil %T", v)
1357	}
1358
1359	return nil
1360}
1361
1362func awsRestjson1_serializeOpDocumentUpdateResourceCollectionInput(v *UpdateResourceCollectionInput, value smithyjson.Value) error {
1363	object := value.Object()
1364	defer object.Close()
1365
1366	if len(v.Action) > 0 {
1367		ok := object.Key("Action")
1368		ok.String(string(v.Action))
1369	}
1370
1371	if v.ResourceCollection != nil {
1372		ok := object.Key("ResourceCollection")
1373		if err := awsRestjson1_serializeDocumentUpdateResourceCollectionFilter(v.ResourceCollection, ok); err != nil {
1374			return err
1375		}
1376	}
1377
1378	return nil
1379}
1380
1381type awsRestjson1_serializeOpUpdateServiceIntegration struct {
1382}
1383
1384func (*awsRestjson1_serializeOpUpdateServiceIntegration) ID() string {
1385	return "OperationSerializer"
1386}
1387
1388func (m *awsRestjson1_serializeOpUpdateServiceIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1389	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1390) {
1391	request, ok := in.Request.(*smithyhttp.Request)
1392	if !ok {
1393		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1394	}
1395
1396	input, ok := in.Parameters.(*UpdateServiceIntegrationInput)
1397	_ = input
1398	if !ok {
1399		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1400	}
1401
1402	opPath, opQuery := httpbinding.SplitURI("/service-integrations")
1403	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1404	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1405	request.Method = "PUT"
1406	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1407	if err != nil {
1408		return out, metadata, &smithy.SerializationError{Err: err}
1409	}
1410
1411	restEncoder.SetHeader("Content-Type").String("application/json")
1412
1413	jsonEncoder := smithyjson.NewEncoder()
1414	if err := awsRestjson1_serializeOpDocumentUpdateServiceIntegrationInput(input, jsonEncoder.Value); err != nil {
1415		return out, metadata, &smithy.SerializationError{Err: err}
1416	}
1417
1418	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1419		return out, metadata, &smithy.SerializationError{Err: err}
1420	}
1421
1422	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1423		return out, metadata, &smithy.SerializationError{Err: err}
1424	}
1425	in.Request = request
1426
1427	return next.HandleSerialize(ctx, in)
1428}
1429func awsRestjson1_serializeOpHttpBindingsUpdateServiceIntegrationInput(v *UpdateServiceIntegrationInput, encoder *httpbinding.Encoder) error {
1430	if v == nil {
1431		return fmt.Errorf("unsupported serialization of nil %T", v)
1432	}
1433
1434	return nil
1435}
1436
1437func awsRestjson1_serializeOpDocumentUpdateServiceIntegrationInput(v *UpdateServiceIntegrationInput, value smithyjson.Value) error {
1438	object := value.Object()
1439	defer object.Close()
1440
1441	if v.ServiceIntegration != nil {
1442		ok := object.Key("ServiceIntegration")
1443		if err := awsRestjson1_serializeDocumentUpdateServiceIntegrationConfig(v.ServiceIntegration, ok); err != nil {
1444			return err
1445		}
1446	}
1447
1448	return nil
1449}
1450
1451func awsRestjson1_serializeDocumentCloudFormationCollection(v *types.CloudFormationCollection, value smithyjson.Value) error {
1452	object := value.Object()
1453	defer object.Close()
1454
1455	if v.StackNames != nil {
1456		ok := object.Key("StackNames")
1457		if err := awsRestjson1_serializeDocumentStackNames(v.StackNames, ok); err != nil {
1458			return err
1459		}
1460	}
1461
1462	return nil
1463}
1464
1465func awsRestjson1_serializeDocumentCloudFormationCostEstimationResourceCollectionFilter(v *types.CloudFormationCostEstimationResourceCollectionFilter, value smithyjson.Value) error {
1466	object := value.Object()
1467	defer object.Close()
1468
1469	if v.StackNames != nil {
1470		ok := object.Key("StackNames")
1471		if err := awsRestjson1_serializeDocumentCostEstimationStackNames(v.StackNames, ok); err != nil {
1472			return err
1473		}
1474	}
1475
1476	return nil
1477}
1478
1479func awsRestjson1_serializeDocumentCostEstimationResourceCollectionFilter(v *types.CostEstimationResourceCollectionFilter, value smithyjson.Value) error {
1480	object := value.Object()
1481	defer object.Close()
1482
1483	if v.CloudFormation != nil {
1484		ok := object.Key("CloudFormation")
1485		if err := awsRestjson1_serializeDocumentCloudFormationCostEstimationResourceCollectionFilter(v.CloudFormation, ok); err != nil {
1486			return err
1487		}
1488	}
1489
1490	return nil
1491}
1492
1493func awsRestjson1_serializeDocumentCostEstimationStackNames(v []string, value smithyjson.Value) error {
1494	array := value.Array()
1495	defer array.Close()
1496
1497	for i := range v {
1498		av := array.Value()
1499		av.String(v[i])
1500	}
1501	return nil
1502}
1503
1504func awsRestjson1_serializeDocumentEndTimeRange(v *types.EndTimeRange, value smithyjson.Value) error {
1505	object := value.Object()
1506	defer object.Close()
1507
1508	if v.FromTime != nil {
1509		ok := object.Key("FromTime")
1510		ok.Double(smithytime.FormatEpochSeconds(*v.FromTime))
1511	}
1512
1513	if v.ToTime != nil {
1514		ok := object.Key("ToTime")
1515		ok.Double(smithytime.FormatEpochSeconds(*v.ToTime))
1516	}
1517
1518	return nil
1519}
1520
1521func awsRestjson1_serializeDocumentEventTimeRange(v *types.EventTimeRange, value smithyjson.Value) error {
1522	object := value.Object()
1523	defer object.Close()
1524
1525	if v.FromTime != nil {
1526		ok := object.Key("FromTime")
1527		ok.Double(smithytime.FormatEpochSeconds(*v.FromTime))
1528	}
1529
1530	if v.ToTime != nil {
1531		ok := object.Key("ToTime")
1532		ok.Double(smithytime.FormatEpochSeconds(*v.ToTime))
1533	}
1534
1535	return nil
1536}
1537
1538func awsRestjson1_serializeDocumentInsightFeedback(v *types.InsightFeedback, value smithyjson.Value) error {
1539	object := value.Object()
1540	defer object.Close()
1541
1542	if len(v.Feedback) > 0 {
1543		ok := object.Key("Feedback")
1544		ok.String(string(v.Feedback))
1545	}
1546
1547	if v.Id != nil {
1548		ok := object.Key("Id")
1549		ok.String(*v.Id)
1550	}
1551
1552	return nil
1553}
1554
1555func awsRestjson1_serializeDocumentInsightSeverities(v []types.InsightSeverity, value smithyjson.Value) error {
1556	array := value.Array()
1557	defer array.Close()
1558
1559	for i := range v {
1560		av := array.Value()
1561		av.String(string(v[i]))
1562	}
1563	return nil
1564}
1565
1566func awsRestjson1_serializeDocumentInsightStatuses(v []types.InsightStatus, value smithyjson.Value) error {
1567	array := value.Array()
1568	defer array.Close()
1569
1570	for i := range v {
1571		av := array.Value()
1572		av.String(string(v[i]))
1573	}
1574	return nil
1575}
1576
1577func awsRestjson1_serializeDocumentListEventsFilters(v *types.ListEventsFilters, value smithyjson.Value) error {
1578	object := value.Object()
1579	defer object.Close()
1580
1581	if len(v.DataSource) > 0 {
1582		ok := object.Key("DataSource")
1583		ok.String(string(v.DataSource))
1584	}
1585
1586	if len(v.EventClass) > 0 {
1587		ok := object.Key("EventClass")
1588		ok.String(string(v.EventClass))
1589	}
1590
1591	if v.EventSource != nil {
1592		ok := object.Key("EventSource")
1593		ok.String(*v.EventSource)
1594	}
1595
1596	if v.EventTimeRange != nil {
1597		ok := object.Key("EventTimeRange")
1598		if err := awsRestjson1_serializeDocumentEventTimeRange(v.EventTimeRange, ok); err != nil {
1599			return err
1600		}
1601	}
1602
1603	if v.InsightId != nil {
1604		ok := object.Key("InsightId")
1605		ok.String(*v.InsightId)
1606	}
1607
1608	if v.ResourceCollection != nil {
1609		ok := object.Key("ResourceCollection")
1610		if err := awsRestjson1_serializeDocumentResourceCollection(v.ResourceCollection, ok); err != nil {
1611			return err
1612		}
1613	}
1614
1615	return nil
1616}
1617
1618func awsRestjson1_serializeDocumentListInsightsAnyStatusFilter(v *types.ListInsightsAnyStatusFilter, value smithyjson.Value) error {
1619	object := value.Object()
1620	defer object.Close()
1621
1622	if v.StartTimeRange != nil {
1623		ok := object.Key("StartTimeRange")
1624		if err := awsRestjson1_serializeDocumentStartTimeRange(v.StartTimeRange, ok); err != nil {
1625			return err
1626		}
1627	}
1628
1629	if len(v.Type) > 0 {
1630		ok := object.Key("Type")
1631		ok.String(string(v.Type))
1632	}
1633
1634	return nil
1635}
1636
1637func awsRestjson1_serializeDocumentListInsightsClosedStatusFilter(v *types.ListInsightsClosedStatusFilter, value smithyjson.Value) error {
1638	object := value.Object()
1639	defer object.Close()
1640
1641	if v.EndTimeRange != nil {
1642		ok := object.Key("EndTimeRange")
1643		if err := awsRestjson1_serializeDocumentEndTimeRange(v.EndTimeRange, ok); err != nil {
1644			return err
1645		}
1646	}
1647
1648	if len(v.Type) > 0 {
1649		ok := object.Key("Type")
1650		ok.String(string(v.Type))
1651	}
1652
1653	return nil
1654}
1655
1656func awsRestjson1_serializeDocumentListInsightsOngoingStatusFilter(v *types.ListInsightsOngoingStatusFilter, value smithyjson.Value) error {
1657	object := value.Object()
1658	defer object.Close()
1659
1660	if len(v.Type) > 0 {
1661		ok := object.Key("Type")
1662		ok.String(string(v.Type))
1663	}
1664
1665	return nil
1666}
1667
1668func awsRestjson1_serializeDocumentListInsightsStatusFilter(v *types.ListInsightsStatusFilter, value smithyjson.Value) error {
1669	object := value.Object()
1670	defer object.Close()
1671
1672	if v.Any != nil {
1673		ok := object.Key("Any")
1674		if err := awsRestjson1_serializeDocumentListInsightsAnyStatusFilter(v.Any, ok); err != nil {
1675			return err
1676		}
1677	}
1678
1679	if v.Closed != nil {
1680		ok := object.Key("Closed")
1681		if err := awsRestjson1_serializeDocumentListInsightsClosedStatusFilter(v.Closed, ok); err != nil {
1682			return err
1683		}
1684	}
1685
1686	if v.Ongoing != nil {
1687		ok := object.Key("Ongoing")
1688		if err := awsRestjson1_serializeDocumentListInsightsOngoingStatusFilter(v.Ongoing, ok); err != nil {
1689			return err
1690		}
1691	}
1692
1693	return nil
1694}
1695
1696func awsRestjson1_serializeDocumentNotificationChannelConfig(v *types.NotificationChannelConfig, value smithyjson.Value) error {
1697	object := value.Object()
1698	defer object.Close()
1699
1700	if v.Sns != nil {
1701		ok := object.Key("Sns")
1702		if err := awsRestjson1_serializeDocumentSnsChannelConfig(v.Sns, ok); err != nil {
1703			return err
1704		}
1705	}
1706
1707	return nil
1708}
1709
1710func awsRestjson1_serializeDocumentOpsCenterIntegrationConfig(v *types.OpsCenterIntegrationConfig, value smithyjson.Value) error {
1711	object := value.Object()
1712	defer object.Close()
1713
1714	if len(v.OptInStatus) > 0 {
1715		ok := object.Key("OptInStatus")
1716		ok.String(string(v.OptInStatus))
1717	}
1718
1719	return nil
1720}
1721
1722func awsRestjson1_serializeDocumentResourceCollection(v *types.ResourceCollection, value smithyjson.Value) error {
1723	object := value.Object()
1724	defer object.Close()
1725
1726	if v.CloudFormation != nil {
1727		ok := object.Key("CloudFormation")
1728		if err := awsRestjson1_serializeDocumentCloudFormationCollection(v.CloudFormation, ok); err != nil {
1729			return err
1730		}
1731	}
1732
1733	return nil
1734}
1735
1736func awsRestjson1_serializeDocumentSearchInsightsFilters(v *types.SearchInsightsFilters, value smithyjson.Value) error {
1737	object := value.Object()
1738	defer object.Close()
1739
1740	if v.ResourceCollection != nil {
1741		ok := object.Key("ResourceCollection")
1742		if err := awsRestjson1_serializeDocumentResourceCollection(v.ResourceCollection, ok); err != nil {
1743			return err
1744		}
1745	}
1746
1747	if v.ServiceCollection != nil {
1748		ok := object.Key("ServiceCollection")
1749		if err := awsRestjson1_serializeDocumentServiceCollection(v.ServiceCollection, ok); err != nil {
1750			return err
1751		}
1752	}
1753
1754	if v.Severities != nil {
1755		ok := object.Key("Severities")
1756		if err := awsRestjson1_serializeDocumentInsightSeverities(v.Severities, ok); err != nil {
1757			return err
1758		}
1759	}
1760
1761	if v.Statuses != nil {
1762		ok := object.Key("Statuses")
1763		if err := awsRestjson1_serializeDocumentInsightStatuses(v.Statuses, ok); err != nil {
1764			return err
1765		}
1766	}
1767
1768	return nil
1769}
1770
1771func awsRestjson1_serializeDocumentServiceCollection(v *types.ServiceCollection, value smithyjson.Value) error {
1772	object := value.Object()
1773	defer object.Close()
1774
1775	if v.ServiceNames != nil {
1776		ok := object.Key("ServiceNames")
1777		if err := awsRestjson1_serializeDocumentServiceNames(v.ServiceNames, ok); err != nil {
1778			return err
1779		}
1780	}
1781
1782	return nil
1783}
1784
1785func awsRestjson1_serializeDocumentServiceNames(v []types.ServiceName, value smithyjson.Value) error {
1786	array := value.Array()
1787	defer array.Close()
1788
1789	for i := range v {
1790		av := array.Value()
1791		av.String(string(v[i]))
1792	}
1793	return nil
1794}
1795
1796func awsRestjson1_serializeDocumentSnsChannelConfig(v *types.SnsChannelConfig, value smithyjson.Value) error {
1797	object := value.Object()
1798	defer object.Close()
1799
1800	if v.TopicArn != nil {
1801		ok := object.Key("TopicArn")
1802		ok.String(*v.TopicArn)
1803	}
1804
1805	return nil
1806}
1807
1808func awsRestjson1_serializeDocumentStackNames(v []string, value smithyjson.Value) error {
1809	array := value.Array()
1810	defer array.Close()
1811
1812	for i := range v {
1813		av := array.Value()
1814		av.String(v[i])
1815	}
1816	return nil
1817}
1818
1819func awsRestjson1_serializeDocumentStartTimeRange(v *types.StartTimeRange, value smithyjson.Value) error {
1820	object := value.Object()
1821	defer object.Close()
1822
1823	if v.FromTime != nil {
1824		ok := object.Key("FromTime")
1825		ok.Double(smithytime.FormatEpochSeconds(*v.FromTime))
1826	}
1827
1828	if v.ToTime != nil {
1829		ok := object.Key("ToTime")
1830		ok.Double(smithytime.FormatEpochSeconds(*v.ToTime))
1831	}
1832
1833	return nil
1834}
1835
1836func awsRestjson1_serializeDocumentUpdateCloudFormationCollectionFilter(v *types.UpdateCloudFormationCollectionFilter, value smithyjson.Value) error {
1837	object := value.Object()
1838	defer object.Close()
1839
1840	if v.StackNames != nil {
1841		ok := object.Key("StackNames")
1842		if err := awsRestjson1_serializeDocumentUpdateStackNames(v.StackNames, ok); err != nil {
1843			return err
1844		}
1845	}
1846
1847	return nil
1848}
1849
1850func awsRestjson1_serializeDocumentUpdateResourceCollectionFilter(v *types.UpdateResourceCollectionFilter, value smithyjson.Value) error {
1851	object := value.Object()
1852	defer object.Close()
1853
1854	if v.CloudFormation != nil {
1855		ok := object.Key("CloudFormation")
1856		if err := awsRestjson1_serializeDocumentUpdateCloudFormationCollectionFilter(v.CloudFormation, ok); err != nil {
1857			return err
1858		}
1859	}
1860
1861	return nil
1862}
1863
1864func awsRestjson1_serializeDocumentUpdateServiceIntegrationConfig(v *types.UpdateServiceIntegrationConfig, value smithyjson.Value) error {
1865	object := value.Object()
1866	defer object.Close()
1867
1868	if v.OpsCenter != nil {
1869		ok := object.Key("OpsCenter")
1870		if err := awsRestjson1_serializeDocumentOpsCenterIntegrationConfig(v.OpsCenter, ok); err != nil {
1871			return err
1872		}
1873	}
1874
1875	return nil
1876}
1877
1878func awsRestjson1_serializeDocumentUpdateStackNames(v []string, value smithyjson.Value) error {
1879	array := value.Array()
1880	defer array.Close()
1881
1882	for i := range v {
1883		av := array.Value()
1884		av.String(v[i])
1885	}
1886	return nil
1887}
1888