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