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