1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package lookoutmetrics
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/lookoutmetrics/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpActivateAnomalyDetector struct {
14}
15
16func (*validateOpActivateAnomalyDetector) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpActivateAnomalyDetector) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
21	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
22) {
23	input, ok := in.Parameters.(*ActivateAnomalyDetectorInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpActivateAnomalyDetectorInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpBackTestAnomalyDetector struct {
34}
35
36func (*validateOpBackTestAnomalyDetector) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpBackTestAnomalyDetector) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
41	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
42) {
43	input, ok := in.Parameters.(*BackTestAnomalyDetectorInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpBackTestAnomalyDetectorInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateAlert struct {
54}
55
56func (*validateOpCreateAlert) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateAlert) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
61	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
62) {
63	input, ok := in.Parameters.(*CreateAlertInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateAlertInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateAnomalyDetector struct {
74}
75
76func (*validateOpCreateAnomalyDetector) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateAnomalyDetector) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
81	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
82) {
83	input, ok := in.Parameters.(*CreateAnomalyDetectorInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateAnomalyDetectorInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateMetricSet struct {
94}
95
96func (*validateOpCreateMetricSet) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateMetricSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
102) {
103	input, ok := in.Parameters.(*CreateMetricSetInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateMetricSetInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeleteAlert struct {
114}
115
116func (*validateOpDeleteAlert) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeleteAlert) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
122) {
123	input, ok := in.Parameters.(*DeleteAlertInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeleteAlertInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteAnomalyDetector struct {
134}
135
136func (*validateOpDeleteAnomalyDetector) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteAnomalyDetector) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
142) {
143	input, ok := in.Parameters.(*DeleteAnomalyDetectorInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteAnomalyDetectorInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDescribeAlert struct {
154}
155
156func (*validateOpDescribeAlert) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDescribeAlert) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
162) {
163	input, ok := in.Parameters.(*DescribeAlertInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDescribeAlertInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDescribeAnomalyDetectionExecutions struct {
174}
175
176func (*validateOpDescribeAnomalyDetectionExecutions) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDescribeAnomalyDetectionExecutions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
182) {
183	input, ok := in.Parameters.(*DescribeAnomalyDetectionExecutionsInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDescribeAnomalyDetectionExecutionsInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDescribeAnomalyDetector struct {
194}
195
196func (*validateOpDescribeAnomalyDetector) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDescribeAnomalyDetector) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
202) {
203	input, ok := in.Parameters.(*DescribeAnomalyDetectorInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDescribeAnomalyDetectorInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDescribeMetricSet struct {
214}
215
216func (*validateOpDescribeMetricSet) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDescribeMetricSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
222) {
223	input, ok := in.Parameters.(*DescribeMetricSetInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDescribeMetricSetInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpGetAnomalyGroup struct {
234}
235
236func (*validateOpGetAnomalyGroup) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpGetAnomalyGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
242) {
243	input, ok := in.Parameters.(*GetAnomalyGroupInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpGetAnomalyGroupInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpGetFeedback struct {
254}
255
256func (*validateOpGetFeedback) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpGetFeedback) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
262) {
263	input, ok := in.Parameters.(*GetFeedbackInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpGetFeedbackInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpGetSampleData struct {
274}
275
276func (*validateOpGetSampleData) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpGetSampleData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
282) {
283	input, ok := in.Parameters.(*GetSampleDataInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpGetSampleDataInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpListAnomalyGroupSummaries struct {
294}
295
296func (*validateOpListAnomalyGroupSummaries) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpListAnomalyGroupSummaries) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
302) {
303	input, ok := in.Parameters.(*ListAnomalyGroupSummariesInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpListAnomalyGroupSummariesInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpListAnomalyGroupTimeSeries struct {
314}
315
316func (*validateOpListAnomalyGroupTimeSeries) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpListAnomalyGroupTimeSeries) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
322) {
323	input, ok := in.Parameters.(*ListAnomalyGroupTimeSeriesInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpListAnomalyGroupTimeSeriesInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpListTagsForResource struct {
334}
335
336func (*validateOpListTagsForResource) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
342) {
343	input, ok := in.Parameters.(*ListTagsForResourceInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpListTagsForResourceInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpPutFeedback struct {
354}
355
356func (*validateOpPutFeedback) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpPutFeedback) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
362) {
363	input, ok := in.Parameters.(*PutFeedbackInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpPutFeedbackInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpTagResource struct {
374}
375
376func (*validateOpTagResource) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
382) {
383	input, ok := in.Parameters.(*TagResourceInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpTagResourceInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpUntagResource struct {
394}
395
396func (*validateOpUntagResource) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
402) {
403	input, ok := in.Parameters.(*UntagResourceInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpUntagResourceInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpUpdateAnomalyDetector struct {
414}
415
416func (*validateOpUpdateAnomalyDetector) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpUpdateAnomalyDetector) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
422) {
423	input, ok := in.Parameters.(*UpdateAnomalyDetectorInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpUpdateAnomalyDetectorInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpUpdateMetricSet struct {
434}
435
436func (*validateOpUpdateMetricSet) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpUpdateMetricSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
442) {
443	input, ok := in.Parameters.(*UpdateMetricSetInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpUpdateMetricSetInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453func addOpActivateAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error {
454	return stack.Initialize.Add(&validateOpActivateAnomalyDetector{}, middleware.After)
455}
456
457func addOpBackTestAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error {
458	return stack.Initialize.Add(&validateOpBackTestAnomalyDetector{}, middleware.After)
459}
460
461func addOpCreateAlertValidationMiddleware(stack *middleware.Stack) error {
462	return stack.Initialize.Add(&validateOpCreateAlert{}, middleware.After)
463}
464
465func addOpCreateAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error {
466	return stack.Initialize.Add(&validateOpCreateAnomalyDetector{}, middleware.After)
467}
468
469func addOpCreateMetricSetValidationMiddleware(stack *middleware.Stack) error {
470	return stack.Initialize.Add(&validateOpCreateMetricSet{}, middleware.After)
471}
472
473func addOpDeleteAlertValidationMiddleware(stack *middleware.Stack) error {
474	return stack.Initialize.Add(&validateOpDeleteAlert{}, middleware.After)
475}
476
477func addOpDeleteAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error {
478	return stack.Initialize.Add(&validateOpDeleteAnomalyDetector{}, middleware.After)
479}
480
481func addOpDescribeAlertValidationMiddleware(stack *middleware.Stack) error {
482	return stack.Initialize.Add(&validateOpDescribeAlert{}, middleware.After)
483}
484
485func addOpDescribeAnomalyDetectionExecutionsValidationMiddleware(stack *middleware.Stack) error {
486	return stack.Initialize.Add(&validateOpDescribeAnomalyDetectionExecutions{}, middleware.After)
487}
488
489func addOpDescribeAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error {
490	return stack.Initialize.Add(&validateOpDescribeAnomalyDetector{}, middleware.After)
491}
492
493func addOpDescribeMetricSetValidationMiddleware(stack *middleware.Stack) error {
494	return stack.Initialize.Add(&validateOpDescribeMetricSet{}, middleware.After)
495}
496
497func addOpGetAnomalyGroupValidationMiddleware(stack *middleware.Stack) error {
498	return stack.Initialize.Add(&validateOpGetAnomalyGroup{}, middleware.After)
499}
500
501func addOpGetFeedbackValidationMiddleware(stack *middleware.Stack) error {
502	return stack.Initialize.Add(&validateOpGetFeedback{}, middleware.After)
503}
504
505func addOpGetSampleDataValidationMiddleware(stack *middleware.Stack) error {
506	return stack.Initialize.Add(&validateOpGetSampleData{}, middleware.After)
507}
508
509func addOpListAnomalyGroupSummariesValidationMiddleware(stack *middleware.Stack) error {
510	return stack.Initialize.Add(&validateOpListAnomalyGroupSummaries{}, middleware.After)
511}
512
513func addOpListAnomalyGroupTimeSeriesValidationMiddleware(stack *middleware.Stack) error {
514	return stack.Initialize.Add(&validateOpListAnomalyGroupTimeSeries{}, middleware.After)
515}
516
517func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
518	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
519}
520
521func addOpPutFeedbackValidationMiddleware(stack *middleware.Stack) error {
522	return stack.Initialize.Add(&validateOpPutFeedback{}, middleware.After)
523}
524
525func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
526	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
527}
528
529func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
530	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
531}
532
533func addOpUpdateAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error {
534	return stack.Initialize.Add(&validateOpUpdateAnomalyDetector{}, middleware.After)
535}
536
537func addOpUpdateMetricSetValidationMiddleware(stack *middleware.Stack) error {
538	return stack.Initialize.Add(&validateOpUpdateMetricSet{}, middleware.After)
539}
540
541func validateAction(v *types.Action) error {
542	if v == nil {
543		return nil
544	}
545	invalidParams := smithy.InvalidParamsError{Context: "Action"}
546	if v.SNSConfiguration != nil {
547		if err := validateSNSConfiguration(v.SNSConfiguration); err != nil {
548			invalidParams.AddNested("SNSConfiguration", err.(smithy.InvalidParamsError))
549		}
550	}
551	if v.LambdaConfiguration != nil {
552		if err := validateLambdaConfiguration(v.LambdaConfiguration); err != nil {
553			invalidParams.AddNested("LambdaConfiguration", err.(smithy.InvalidParamsError))
554		}
555	}
556	if invalidParams.Len() > 0 {
557		return invalidParams
558	} else {
559		return nil
560	}
561}
562
563func validateAnomalyGroupTimeSeries(v *types.AnomalyGroupTimeSeries) error {
564	if v == nil {
565		return nil
566	}
567	invalidParams := smithy.InvalidParamsError{Context: "AnomalyGroupTimeSeries"}
568	if v.AnomalyGroupId == nil {
569		invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupId"))
570	}
571	if invalidParams.Len() > 0 {
572		return invalidParams
573	} else {
574		return nil
575	}
576}
577
578func validateAnomalyGroupTimeSeriesFeedback(v *types.AnomalyGroupTimeSeriesFeedback) error {
579	if v == nil {
580		return nil
581	}
582	invalidParams := smithy.InvalidParamsError{Context: "AnomalyGroupTimeSeriesFeedback"}
583	if v.AnomalyGroupId == nil {
584		invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupId"))
585	}
586	if v.TimeSeriesId == nil {
587		invalidParams.Add(smithy.NewErrParamRequired("TimeSeriesId"))
588	}
589	if v.IsAnomaly == nil {
590		invalidParams.Add(smithy.NewErrParamRequired("IsAnomaly"))
591	}
592	if invalidParams.Len() > 0 {
593		return invalidParams
594	} else {
595		return nil
596	}
597}
598
599func validateAppFlowConfig(v *types.AppFlowConfig) error {
600	if v == nil {
601		return nil
602	}
603	invalidParams := smithy.InvalidParamsError{Context: "AppFlowConfig"}
604	if v.RoleArn == nil {
605		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
606	}
607	if v.FlowName == nil {
608		invalidParams.Add(smithy.NewErrParamRequired("FlowName"))
609	}
610	if invalidParams.Len() > 0 {
611		return invalidParams
612	} else {
613		return nil
614	}
615}
616
617func validateCloudWatchConfig(v *types.CloudWatchConfig) error {
618	if v == nil {
619		return nil
620	}
621	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchConfig"}
622	if v.RoleArn == nil {
623		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
624	}
625	if invalidParams.Len() > 0 {
626		return invalidParams
627	} else {
628		return nil
629	}
630}
631
632func validateLambdaConfiguration(v *types.LambdaConfiguration) error {
633	if v == nil {
634		return nil
635	}
636	invalidParams := smithy.InvalidParamsError{Context: "LambdaConfiguration"}
637	if v.RoleArn == nil {
638		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
639	}
640	if v.LambdaArn == nil {
641		invalidParams.Add(smithy.NewErrParamRequired("LambdaArn"))
642	}
643	if invalidParams.Len() > 0 {
644		return invalidParams
645	} else {
646		return nil
647	}
648}
649
650func validateMetric(v *types.Metric) error {
651	if v == nil {
652		return nil
653	}
654	invalidParams := smithy.InvalidParamsError{Context: "Metric"}
655	if v.MetricName == nil {
656		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
657	}
658	if len(v.AggregationFunction) == 0 {
659		invalidParams.Add(smithy.NewErrParamRequired("AggregationFunction"))
660	}
661	if invalidParams.Len() > 0 {
662		return invalidParams
663	} else {
664		return nil
665	}
666}
667
668func validateMetricList(v []types.Metric) error {
669	if v == nil {
670		return nil
671	}
672	invalidParams := smithy.InvalidParamsError{Context: "MetricList"}
673	for i := range v {
674		if err := validateMetric(&v[i]); err != nil {
675			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
676		}
677	}
678	if invalidParams.Len() > 0 {
679		return invalidParams
680	} else {
681		return nil
682	}
683}
684
685func validateMetricSource(v *types.MetricSource) error {
686	if v == nil {
687		return nil
688	}
689	invalidParams := smithy.InvalidParamsError{Context: "MetricSource"}
690	if v.S3SourceConfig != nil {
691		if err := validateS3SourceConfig(v.S3SourceConfig); err != nil {
692			invalidParams.AddNested("S3SourceConfig", err.(smithy.InvalidParamsError))
693		}
694	}
695	if v.AppFlowConfig != nil {
696		if err := validateAppFlowConfig(v.AppFlowConfig); err != nil {
697			invalidParams.AddNested("AppFlowConfig", err.(smithy.InvalidParamsError))
698		}
699	}
700	if v.CloudWatchConfig != nil {
701		if err := validateCloudWatchConfig(v.CloudWatchConfig); err != nil {
702			invalidParams.AddNested("CloudWatchConfig", err.(smithy.InvalidParamsError))
703		}
704	}
705	if v.RDSSourceConfig != nil {
706		if err := validateRDSSourceConfig(v.RDSSourceConfig); err != nil {
707			invalidParams.AddNested("RDSSourceConfig", err.(smithy.InvalidParamsError))
708		}
709	}
710	if v.RedshiftSourceConfig != nil {
711		if err := validateRedshiftSourceConfig(v.RedshiftSourceConfig); err != nil {
712			invalidParams.AddNested("RedshiftSourceConfig", err.(smithy.InvalidParamsError))
713		}
714	}
715	if invalidParams.Len() > 0 {
716		return invalidParams
717	} else {
718		return nil
719	}
720}
721
722func validateRDSSourceConfig(v *types.RDSSourceConfig) error {
723	if v == nil {
724		return nil
725	}
726	invalidParams := smithy.InvalidParamsError{Context: "RDSSourceConfig"}
727	if v.DBInstanceIdentifier == nil {
728		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
729	}
730	if v.DatabaseHost == nil {
731		invalidParams.Add(smithy.NewErrParamRequired("DatabaseHost"))
732	}
733	if v.SecretManagerArn == nil {
734		invalidParams.Add(smithy.NewErrParamRequired("SecretManagerArn"))
735	}
736	if v.DatabaseName == nil {
737		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
738	}
739	if v.TableName == nil {
740		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
741	}
742	if v.RoleArn == nil {
743		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
744	}
745	if v.VpcConfiguration == nil {
746		invalidParams.Add(smithy.NewErrParamRequired("VpcConfiguration"))
747	} else if v.VpcConfiguration != nil {
748		if err := validateVpcConfiguration(v.VpcConfiguration); err != nil {
749			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
750		}
751	}
752	if invalidParams.Len() > 0 {
753		return invalidParams
754	} else {
755		return nil
756	}
757}
758
759func validateRedshiftSourceConfig(v *types.RedshiftSourceConfig) error {
760	if v == nil {
761		return nil
762	}
763	invalidParams := smithy.InvalidParamsError{Context: "RedshiftSourceConfig"}
764	if v.ClusterIdentifier == nil {
765		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
766	}
767	if v.DatabaseHost == nil {
768		invalidParams.Add(smithy.NewErrParamRequired("DatabaseHost"))
769	}
770	if v.SecretManagerArn == nil {
771		invalidParams.Add(smithy.NewErrParamRequired("SecretManagerArn"))
772	}
773	if v.DatabaseName == nil {
774		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
775	}
776	if v.TableName == nil {
777		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
778	}
779	if v.RoleArn == nil {
780		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
781	}
782	if v.VpcConfiguration == nil {
783		invalidParams.Add(smithy.NewErrParamRequired("VpcConfiguration"))
784	} else if v.VpcConfiguration != nil {
785		if err := validateVpcConfiguration(v.VpcConfiguration); err != nil {
786			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
787		}
788	}
789	if invalidParams.Len() > 0 {
790		return invalidParams
791	} else {
792		return nil
793	}
794}
795
796func validateS3SourceConfig(v *types.S3SourceConfig) error {
797	if v == nil {
798		return nil
799	}
800	invalidParams := smithy.InvalidParamsError{Context: "S3SourceConfig"}
801	if v.RoleArn == nil {
802		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
803	}
804	if invalidParams.Len() > 0 {
805		return invalidParams
806	} else {
807		return nil
808	}
809}
810
811func validateSampleDataS3SourceConfig(v *types.SampleDataS3SourceConfig) error {
812	if v == nil {
813		return nil
814	}
815	invalidParams := smithy.InvalidParamsError{Context: "SampleDataS3SourceConfig"}
816	if v.RoleArn == nil {
817		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
818	}
819	if v.FileFormatDescriptor == nil {
820		invalidParams.Add(smithy.NewErrParamRequired("FileFormatDescriptor"))
821	}
822	if invalidParams.Len() > 0 {
823		return invalidParams
824	} else {
825		return nil
826	}
827}
828
829func validateSNSConfiguration(v *types.SNSConfiguration) error {
830	if v == nil {
831		return nil
832	}
833	invalidParams := smithy.InvalidParamsError{Context: "SNSConfiguration"}
834	if v.RoleArn == nil {
835		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
836	}
837	if v.SnsTopicArn == nil {
838		invalidParams.Add(smithy.NewErrParamRequired("SnsTopicArn"))
839	}
840	if invalidParams.Len() > 0 {
841		return invalidParams
842	} else {
843		return nil
844	}
845}
846
847func validateVpcConfiguration(v *types.VpcConfiguration) error {
848	if v == nil {
849		return nil
850	}
851	invalidParams := smithy.InvalidParamsError{Context: "VpcConfiguration"}
852	if v.SubnetIdList == nil {
853		invalidParams.Add(smithy.NewErrParamRequired("SubnetIdList"))
854	}
855	if v.SecurityGroupIdList == nil {
856		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIdList"))
857	}
858	if invalidParams.Len() > 0 {
859		return invalidParams
860	} else {
861		return nil
862	}
863}
864
865func validateOpActivateAnomalyDetectorInput(v *ActivateAnomalyDetectorInput) error {
866	if v == nil {
867		return nil
868	}
869	invalidParams := smithy.InvalidParamsError{Context: "ActivateAnomalyDetectorInput"}
870	if v.AnomalyDetectorArn == nil {
871		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
872	}
873	if invalidParams.Len() > 0 {
874		return invalidParams
875	} else {
876		return nil
877	}
878}
879
880func validateOpBackTestAnomalyDetectorInput(v *BackTestAnomalyDetectorInput) error {
881	if v == nil {
882		return nil
883	}
884	invalidParams := smithy.InvalidParamsError{Context: "BackTestAnomalyDetectorInput"}
885	if v.AnomalyDetectorArn == nil {
886		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
887	}
888	if invalidParams.Len() > 0 {
889		return invalidParams
890	} else {
891		return nil
892	}
893}
894
895func validateOpCreateAlertInput(v *CreateAlertInput) error {
896	if v == nil {
897		return nil
898	}
899	invalidParams := smithy.InvalidParamsError{Context: "CreateAlertInput"}
900	if v.AlertName == nil {
901		invalidParams.Add(smithy.NewErrParamRequired("AlertName"))
902	}
903	if v.AnomalyDetectorArn == nil {
904		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
905	}
906	if v.Action == nil {
907		invalidParams.Add(smithy.NewErrParamRequired("Action"))
908	} else if v.Action != nil {
909		if err := validateAction(v.Action); err != nil {
910			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
911		}
912	}
913	if invalidParams.Len() > 0 {
914		return invalidParams
915	} else {
916		return nil
917	}
918}
919
920func validateOpCreateAnomalyDetectorInput(v *CreateAnomalyDetectorInput) error {
921	if v == nil {
922		return nil
923	}
924	invalidParams := smithy.InvalidParamsError{Context: "CreateAnomalyDetectorInput"}
925	if v.AnomalyDetectorName == nil {
926		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorName"))
927	}
928	if v.AnomalyDetectorConfig == nil {
929		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorConfig"))
930	}
931	if invalidParams.Len() > 0 {
932		return invalidParams
933	} else {
934		return nil
935	}
936}
937
938func validateOpCreateMetricSetInput(v *CreateMetricSetInput) error {
939	if v == nil {
940		return nil
941	}
942	invalidParams := smithy.InvalidParamsError{Context: "CreateMetricSetInput"}
943	if v.AnomalyDetectorArn == nil {
944		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
945	}
946	if v.MetricSetName == nil {
947		invalidParams.Add(smithy.NewErrParamRequired("MetricSetName"))
948	}
949	if v.MetricList == nil {
950		invalidParams.Add(smithy.NewErrParamRequired("MetricList"))
951	} else if v.MetricList != nil {
952		if err := validateMetricList(v.MetricList); err != nil {
953			invalidParams.AddNested("MetricList", err.(smithy.InvalidParamsError))
954		}
955	}
956	if v.MetricSource == nil {
957		invalidParams.Add(smithy.NewErrParamRequired("MetricSource"))
958	} else if v.MetricSource != nil {
959		if err := validateMetricSource(v.MetricSource); err != nil {
960			invalidParams.AddNested("MetricSource", err.(smithy.InvalidParamsError))
961		}
962	}
963	if invalidParams.Len() > 0 {
964		return invalidParams
965	} else {
966		return nil
967	}
968}
969
970func validateOpDeleteAlertInput(v *DeleteAlertInput) error {
971	if v == nil {
972		return nil
973	}
974	invalidParams := smithy.InvalidParamsError{Context: "DeleteAlertInput"}
975	if v.AlertArn == nil {
976		invalidParams.Add(smithy.NewErrParamRequired("AlertArn"))
977	}
978	if invalidParams.Len() > 0 {
979		return invalidParams
980	} else {
981		return nil
982	}
983}
984
985func validateOpDeleteAnomalyDetectorInput(v *DeleteAnomalyDetectorInput) error {
986	if v == nil {
987		return nil
988	}
989	invalidParams := smithy.InvalidParamsError{Context: "DeleteAnomalyDetectorInput"}
990	if v.AnomalyDetectorArn == nil {
991		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
992	}
993	if invalidParams.Len() > 0 {
994		return invalidParams
995	} else {
996		return nil
997	}
998}
999
1000func validateOpDescribeAlertInput(v *DescribeAlertInput) error {
1001	if v == nil {
1002		return nil
1003	}
1004	invalidParams := smithy.InvalidParamsError{Context: "DescribeAlertInput"}
1005	if v.AlertArn == nil {
1006		invalidParams.Add(smithy.NewErrParamRequired("AlertArn"))
1007	}
1008	if invalidParams.Len() > 0 {
1009		return invalidParams
1010	} else {
1011		return nil
1012	}
1013}
1014
1015func validateOpDescribeAnomalyDetectionExecutionsInput(v *DescribeAnomalyDetectionExecutionsInput) error {
1016	if v == nil {
1017		return nil
1018	}
1019	invalidParams := smithy.InvalidParamsError{Context: "DescribeAnomalyDetectionExecutionsInput"}
1020	if v.AnomalyDetectorArn == nil {
1021		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
1022	}
1023	if invalidParams.Len() > 0 {
1024		return invalidParams
1025	} else {
1026		return nil
1027	}
1028}
1029
1030func validateOpDescribeAnomalyDetectorInput(v *DescribeAnomalyDetectorInput) error {
1031	if v == nil {
1032		return nil
1033	}
1034	invalidParams := smithy.InvalidParamsError{Context: "DescribeAnomalyDetectorInput"}
1035	if v.AnomalyDetectorArn == nil {
1036		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
1037	}
1038	if invalidParams.Len() > 0 {
1039		return invalidParams
1040	} else {
1041		return nil
1042	}
1043}
1044
1045func validateOpDescribeMetricSetInput(v *DescribeMetricSetInput) error {
1046	if v == nil {
1047		return nil
1048	}
1049	invalidParams := smithy.InvalidParamsError{Context: "DescribeMetricSetInput"}
1050	if v.MetricSetArn == nil {
1051		invalidParams.Add(smithy.NewErrParamRequired("MetricSetArn"))
1052	}
1053	if invalidParams.Len() > 0 {
1054		return invalidParams
1055	} else {
1056		return nil
1057	}
1058}
1059
1060func validateOpGetAnomalyGroupInput(v *GetAnomalyGroupInput) error {
1061	if v == nil {
1062		return nil
1063	}
1064	invalidParams := smithy.InvalidParamsError{Context: "GetAnomalyGroupInput"}
1065	if v.AnomalyGroupId == nil {
1066		invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupId"))
1067	}
1068	if v.AnomalyDetectorArn == nil {
1069		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
1070	}
1071	if invalidParams.Len() > 0 {
1072		return invalidParams
1073	} else {
1074		return nil
1075	}
1076}
1077
1078func validateOpGetFeedbackInput(v *GetFeedbackInput) error {
1079	if v == nil {
1080		return nil
1081	}
1082	invalidParams := smithy.InvalidParamsError{Context: "GetFeedbackInput"}
1083	if v.AnomalyDetectorArn == nil {
1084		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
1085	}
1086	if v.AnomalyGroupTimeSeriesFeedback == nil {
1087		invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupTimeSeriesFeedback"))
1088	} else if v.AnomalyGroupTimeSeriesFeedback != nil {
1089		if err := validateAnomalyGroupTimeSeries(v.AnomalyGroupTimeSeriesFeedback); err != nil {
1090			invalidParams.AddNested("AnomalyGroupTimeSeriesFeedback", err.(smithy.InvalidParamsError))
1091		}
1092	}
1093	if invalidParams.Len() > 0 {
1094		return invalidParams
1095	} else {
1096		return nil
1097	}
1098}
1099
1100func validateOpGetSampleDataInput(v *GetSampleDataInput) error {
1101	if v == nil {
1102		return nil
1103	}
1104	invalidParams := smithy.InvalidParamsError{Context: "GetSampleDataInput"}
1105	if v.S3SourceConfig != nil {
1106		if err := validateSampleDataS3SourceConfig(v.S3SourceConfig); err != nil {
1107			invalidParams.AddNested("S3SourceConfig", err.(smithy.InvalidParamsError))
1108		}
1109	}
1110	if invalidParams.Len() > 0 {
1111		return invalidParams
1112	} else {
1113		return nil
1114	}
1115}
1116
1117func validateOpListAnomalyGroupSummariesInput(v *ListAnomalyGroupSummariesInput) error {
1118	if v == nil {
1119		return nil
1120	}
1121	invalidParams := smithy.InvalidParamsError{Context: "ListAnomalyGroupSummariesInput"}
1122	if v.AnomalyDetectorArn == nil {
1123		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
1124	}
1125	if invalidParams.Len() > 0 {
1126		return invalidParams
1127	} else {
1128		return nil
1129	}
1130}
1131
1132func validateOpListAnomalyGroupTimeSeriesInput(v *ListAnomalyGroupTimeSeriesInput) error {
1133	if v == nil {
1134		return nil
1135	}
1136	invalidParams := smithy.InvalidParamsError{Context: "ListAnomalyGroupTimeSeriesInput"}
1137	if v.AnomalyDetectorArn == nil {
1138		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
1139	}
1140	if v.AnomalyGroupId == nil {
1141		invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupId"))
1142	}
1143	if v.MetricName == nil {
1144		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
1145	}
1146	if invalidParams.Len() > 0 {
1147		return invalidParams
1148	} else {
1149		return nil
1150	}
1151}
1152
1153func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1154	if v == nil {
1155		return nil
1156	}
1157	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1158	if v.ResourceArn == nil {
1159		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1160	}
1161	if invalidParams.Len() > 0 {
1162		return invalidParams
1163	} else {
1164		return nil
1165	}
1166}
1167
1168func validateOpPutFeedbackInput(v *PutFeedbackInput) error {
1169	if v == nil {
1170		return nil
1171	}
1172	invalidParams := smithy.InvalidParamsError{Context: "PutFeedbackInput"}
1173	if v.AnomalyDetectorArn == nil {
1174		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
1175	}
1176	if v.AnomalyGroupTimeSeriesFeedback == nil {
1177		invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupTimeSeriesFeedback"))
1178	} else if v.AnomalyGroupTimeSeriesFeedback != nil {
1179		if err := validateAnomalyGroupTimeSeriesFeedback(v.AnomalyGroupTimeSeriesFeedback); err != nil {
1180			invalidParams.AddNested("AnomalyGroupTimeSeriesFeedback", err.(smithy.InvalidParamsError))
1181		}
1182	}
1183	if invalidParams.Len() > 0 {
1184		return invalidParams
1185	} else {
1186		return nil
1187	}
1188}
1189
1190func validateOpTagResourceInput(v *TagResourceInput) error {
1191	if v == nil {
1192		return nil
1193	}
1194	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1195	if v.ResourceArn == nil {
1196		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1197	}
1198	if v.Tags == nil {
1199		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1200	}
1201	if invalidParams.Len() > 0 {
1202		return invalidParams
1203	} else {
1204		return nil
1205	}
1206}
1207
1208func validateOpUntagResourceInput(v *UntagResourceInput) error {
1209	if v == nil {
1210		return nil
1211	}
1212	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1213	if v.ResourceArn == nil {
1214		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1215	}
1216	if v.TagKeys == nil {
1217		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1218	}
1219	if invalidParams.Len() > 0 {
1220		return invalidParams
1221	} else {
1222		return nil
1223	}
1224}
1225
1226func validateOpUpdateAnomalyDetectorInput(v *UpdateAnomalyDetectorInput) error {
1227	if v == nil {
1228		return nil
1229	}
1230	invalidParams := smithy.InvalidParamsError{Context: "UpdateAnomalyDetectorInput"}
1231	if v.AnomalyDetectorArn == nil {
1232		invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn"))
1233	}
1234	if invalidParams.Len() > 0 {
1235		return invalidParams
1236	} else {
1237		return nil
1238	}
1239}
1240
1241func validateOpUpdateMetricSetInput(v *UpdateMetricSetInput) error {
1242	if v == nil {
1243		return nil
1244	}
1245	invalidParams := smithy.InvalidParamsError{Context: "UpdateMetricSetInput"}
1246	if v.MetricSetArn == nil {
1247		invalidParams.Add(smithy.NewErrParamRequired("MetricSetArn"))
1248	}
1249	if v.MetricList != nil {
1250		if err := validateMetricList(v.MetricList); err != nil {
1251			invalidParams.AddNested("MetricList", err.(smithy.InvalidParamsError))
1252		}
1253	}
1254	if v.MetricSource != nil {
1255		if err := validateMetricSource(v.MetricSource); err != nil {
1256			invalidParams.AddNested("MetricSource", err.(smithy.InvalidParamsError))
1257		}
1258	}
1259	if invalidParams.Len() > 0 {
1260		return invalidParams
1261	} else {
1262		return nil
1263	}
1264}
1265