1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package forecast
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/forecast/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateDatasetGroup struct {
14}
15
16func (*validateOpCreateDatasetGroup) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateDatasetGroup) 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.(*CreateDatasetGroupInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateDatasetGroupInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateDatasetImportJob struct {
34}
35
36func (*validateOpCreateDatasetImportJob) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateDatasetImportJob) 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.(*CreateDatasetImportJobInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateDatasetImportJobInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateDataset struct {
54}
55
56func (*validateOpCreateDataset) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateDataset) 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.(*CreateDatasetInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateDatasetInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateForecastExportJob struct {
74}
75
76func (*validateOpCreateForecastExportJob) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateForecastExportJob) 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.(*CreateForecastExportJobInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateForecastExportJobInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateForecast struct {
94}
95
96func (*validateOpCreateForecast) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateForecast) 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.(*CreateForecastInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateForecastInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreatePredictorBacktestExportJob struct {
114}
115
116func (*validateOpCreatePredictorBacktestExportJob) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreatePredictorBacktestExportJob) 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.(*CreatePredictorBacktestExportJobInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreatePredictorBacktestExportJobInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreatePredictor struct {
134}
135
136func (*validateOpCreatePredictor) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreatePredictor) 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.(*CreatePredictorInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreatePredictorInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteDatasetGroup struct {
154}
155
156func (*validateOpDeleteDatasetGroup) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteDatasetGroup) 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.(*DeleteDatasetGroupInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteDatasetGroupInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteDatasetImportJob struct {
174}
175
176func (*validateOpDeleteDatasetImportJob) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteDatasetImportJob) 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.(*DeleteDatasetImportJobInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteDatasetImportJobInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteDataset struct {
194}
195
196func (*validateOpDeleteDataset) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteDataset) 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.(*DeleteDatasetInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteDatasetInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDeleteForecastExportJob struct {
214}
215
216func (*validateOpDeleteForecastExportJob) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDeleteForecastExportJob) 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.(*DeleteForecastExportJobInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDeleteForecastExportJobInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteForecast struct {
234}
235
236func (*validateOpDeleteForecast) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteForecast) 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.(*DeleteForecastInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteForecastInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeletePredictorBacktestExportJob struct {
254}
255
256func (*validateOpDeletePredictorBacktestExportJob) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeletePredictorBacktestExportJob) 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.(*DeletePredictorBacktestExportJobInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeletePredictorBacktestExportJobInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDeletePredictor struct {
274}
275
276func (*validateOpDeletePredictor) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDeletePredictor) 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.(*DeletePredictorInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDeletePredictorInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDescribeDatasetGroup struct {
294}
295
296func (*validateOpDescribeDatasetGroup) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDescribeDatasetGroup) 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.(*DescribeDatasetGroupInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDescribeDatasetGroupInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDescribeDatasetImportJob struct {
314}
315
316func (*validateOpDescribeDatasetImportJob) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDescribeDatasetImportJob) 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.(*DescribeDatasetImportJobInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDescribeDatasetImportJobInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDescribeDataset struct {
334}
335
336func (*validateOpDescribeDataset) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDescribeDataset) 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.(*DescribeDatasetInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDescribeDatasetInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDescribeForecastExportJob struct {
354}
355
356func (*validateOpDescribeForecastExportJob) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDescribeForecastExportJob) 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.(*DescribeForecastExportJobInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDescribeForecastExportJobInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDescribeForecast struct {
374}
375
376func (*validateOpDescribeForecast) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDescribeForecast) 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.(*DescribeForecastInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDescribeForecastInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDescribePredictorBacktestExportJob struct {
394}
395
396func (*validateOpDescribePredictorBacktestExportJob) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDescribePredictorBacktestExportJob) 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.(*DescribePredictorBacktestExportJobInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDescribePredictorBacktestExportJobInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDescribePredictor struct {
414}
415
416func (*validateOpDescribePredictor) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDescribePredictor) 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.(*DescribePredictorInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDescribePredictorInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpGetAccuracyMetrics struct {
434}
435
436func (*validateOpGetAccuracyMetrics) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpGetAccuracyMetrics) 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.(*GetAccuracyMetricsInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpGetAccuracyMetricsInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpListDatasetImportJobs struct {
454}
455
456func (*validateOpListDatasetImportJobs) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpListDatasetImportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
462) {
463	input, ok := in.Parameters.(*ListDatasetImportJobsInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpListDatasetImportJobsInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpListForecastExportJobs struct {
474}
475
476func (*validateOpListForecastExportJobs) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpListForecastExportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
482) {
483	input, ok := in.Parameters.(*ListForecastExportJobsInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpListForecastExportJobsInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpListForecasts struct {
494}
495
496func (*validateOpListForecasts) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpListForecasts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
502) {
503	input, ok := in.Parameters.(*ListForecastsInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpListForecastsInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpListPredictorBacktestExportJobs struct {
514}
515
516func (*validateOpListPredictorBacktestExportJobs) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpListPredictorBacktestExportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
522) {
523	input, ok := in.Parameters.(*ListPredictorBacktestExportJobsInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpListPredictorBacktestExportJobsInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpListPredictors struct {
534}
535
536func (*validateOpListPredictors) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpListPredictors) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
542) {
543	input, ok := in.Parameters.(*ListPredictorsInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpListPredictorsInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpListTagsForResource struct {
554}
555
556func (*validateOpListTagsForResource) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
562) {
563	input, ok := in.Parameters.(*ListTagsForResourceInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpListTagsForResourceInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpStopResource struct {
574}
575
576func (*validateOpStopResource) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpStopResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
582) {
583	input, ok := in.Parameters.(*StopResourceInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpStopResourceInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpTagResource struct {
594}
595
596func (*validateOpTagResource) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
602) {
603	input, ok := in.Parameters.(*TagResourceInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpTagResourceInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpUntagResource struct {
614}
615
616func (*validateOpUntagResource) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
622) {
623	input, ok := in.Parameters.(*UntagResourceInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpUntagResourceInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpUpdateDatasetGroup struct {
634}
635
636func (*validateOpUpdateDatasetGroup) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpUpdateDatasetGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
641	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
642) {
643	input, ok := in.Parameters.(*UpdateDatasetGroupInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpUpdateDatasetGroupInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653func addOpCreateDatasetGroupValidationMiddleware(stack *middleware.Stack) error {
654	return stack.Initialize.Add(&validateOpCreateDatasetGroup{}, middleware.After)
655}
656
657func addOpCreateDatasetImportJobValidationMiddleware(stack *middleware.Stack) error {
658	return stack.Initialize.Add(&validateOpCreateDatasetImportJob{}, middleware.After)
659}
660
661func addOpCreateDatasetValidationMiddleware(stack *middleware.Stack) error {
662	return stack.Initialize.Add(&validateOpCreateDataset{}, middleware.After)
663}
664
665func addOpCreateForecastExportJobValidationMiddleware(stack *middleware.Stack) error {
666	return stack.Initialize.Add(&validateOpCreateForecastExportJob{}, middleware.After)
667}
668
669func addOpCreateForecastValidationMiddleware(stack *middleware.Stack) error {
670	return stack.Initialize.Add(&validateOpCreateForecast{}, middleware.After)
671}
672
673func addOpCreatePredictorBacktestExportJobValidationMiddleware(stack *middleware.Stack) error {
674	return stack.Initialize.Add(&validateOpCreatePredictorBacktestExportJob{}, middleware.After)
675}
676
677func addOpCreatePredictorValidationMiddleware(stack *middleware.Stack) error {
678	return stack.Initialize.Add(&validateOpCreatePredictor{}, middleware.After)
679}
680
681func addOpDeleteDatasetGroupValidationMiddleware(stack *middleware.Stack) error {
682	return stack.Initialize.Add(&validateOpDeleteDatasetGroup{}, middleware.After)
683}
684
685func addOpDeleteDatasetImportJobValidationMiddleware(stack *middleware.Stack) error {
686	return stack.Initialize.Add(&validateOpDeleteDatasetImportJob{}, middleware.After)
687}
688
689func addOpDeleteDatasetValidationMiddleware(stack *middleware.Stack) error {
690	return stack.Initialize.Add(&validateOpDeleteDataset{}, middleware.After)
691}
692
693func addOpDeleteForecastExportJobValidationMiddleware(stack *middleware.Stack) error {
694	return stack.Initialize.Add(&validateOpDeleteForecastExportJob{}, middleware.After)
695}
696
697func addOpDeleteForecastValidationMiddleware(stack *middleware.Stack) error {
698	return stack.Initialize.Add(&validateOpDeleteForecast{}, middleware.After)
699}
700
701func addOpDeletePredictorBacktestExportJobValidationMiddleware(stack *middleware.Stack) error {
702	return stack.Initialize.Add(&validateOpDeletePredictorBacktestExportJob{}, middleware.After)
703}
704
705func addOpDeletePredictorValidationMiddleware(stack *middleware.Stack) error {
706	return stack.Initialize.Add(&validateOpDeletePredictor{}, middleware.After)
707}
708
709func addOpDescribeDatasetGroupValidationMiddleware(stack *middleware.Stack) error {
710	return stack.Initialize.Add(&validateOpDescribeDatasetGroup{}, middleware.After)
711}
712
713func addOpDescribeDatasetImportJobValidationMiddleware(stack *middleware.Stack) error {
714	return stack.Initialize.Add(&validateOpDescribeDatasetImportJob{}, middleware.After)
715}
716
717func addOpDescribeDatasetValidationMiddleware(stack *middleware.Stack) error {
718	return stack.Initialize.Add(&validateOpDescribeDataset{}, middleware.After)
719}
720
721func addOpDescribeForecastExportJobValidationMiddleware(stack *middleware.Stack) error {
722	return stack.Initialize.Add(&validateOpDescribeForecastExportJob{}, middleware.After)
723}
724
725func addOpDescribeForecastValidationMiddleware(stack *middleware.Stack) error {
726	return stack.Initialize.Add(&validateOpDescribeForecast{}, middleware.After)
727}
728
729func addOpDescribePredictorBacktestExportJobValidationMiddleware(stack *middleware.Stack) error {
730	return stack.Initialize.Add(&validateOpDescribePredictorBacktestExportJob{}, middleware.After)
731}
732
733func addOpDescribePredictorValidationMiddleware(stack *middleware.Stack) error {
734	return stack.Initialize.Add(&validateOpDescribePredictor{}, middleware.After)
735}
736
737func addOpGetAccuracyMetricsValidationMiddleware(stack *middleware.Stack) error {
738	return stack.Initialize.Add(&validateOpGetAccuracyMetrics{}, middleware.After)
739}
740
741func addOpListDatasetImportJobsValidationMiddleware(stack *middleware.Stack) error {
742	return stack.Initialize.Add(&validateOpListDatasetImportJobs{}, middleware.After)
743}
744
745func addOpListForecastExportJobsValidationMiddleware(stack *middleware.Stack) error {
746	return stack.Initialize.Add(&validateOpListForecastExportJobs{}, middleware.After)
747}
748
749func addOpListForecastsValidationMiddleware(stack *middleware.Stack) error {
750	return stack.Initialize.Add(&validateOpListForecasts{}, middleware.After)
751}
752
753func addOpListPredictorBacktestExportJobsValidationMiddleware(stack *middleware.Stack) error {
754	return stack.Initialize.Add(&validateOpListPredictorBacktestExportJobs{}, middleware.After)
755}
756
757func addOpListPredictorsValidationMiddleware(stack *middleware.Stack) error {
758	return stack.Initialize.Add(&validateOpListPredictors{}, middleware.After)
759}
760
761func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
762	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
763}
764
765func addOpStopResourceValidationMiddleware(stack *middleware.Stack) error {
766	return stack.Initialize.Add(&validateOpStopResource{}, middleware.After)
767}
768
769func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
770	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
771}
772
773func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
774	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
775}
776
777func addOpUpdateDatasetGroupValidationMiddleware(stack *middleware.Stack) error {
778	return stack.Initialize.Add(&validateOpUpdateDatasetGroup{}, middleware.After)
779}
780
781func validateCategoricalParameterRange(v *types.CategoricalParameterRange) error {
782	if v == nil {
783		return nil
784	}
785	invalidParams := smithy.InvalidParamsError{Context: "CategoricalParameterRange"}
786	if v.Name == nil {
787		invalidParams.Add(smithy.NewErrParamRequired("Name"))
788	}
789	if v.Values == nil {
790		invalidParams.Add(smithy.NewErrParamRequired("Values"))
791	}
792	if invalidParams.Len() > 0 {
793		return invalidParams
794	} else {
795		return nil
796	}
797}
798
799func validateCategoricalParameterRanges(v []types.CategoricalParameterRange) error {
800	if v == nil {
801		return nil
802	}
803	invalidParams := smithy.InvalidParamsError{Context: "CategoricalParameterRanges"}
804	for i := range v {
805		if err := validateCategoricalParameterRange(&v[i]); err != nil {
806			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
807		}
808	}
809	if invalidParams.Len() > 0 {
810		return invalidParams
811	} else {
812		return nil
813	}
814}
815
816func validateContinuousParameterRange(v *types.ContinuousParameterRange) error {
817	if v == nil {
818		return nil
819	}
820	invalidParams := smithy.InvalidParamsError{Context: "ContinuousParameterRange"}
821	if v.Name == nil {
822		invalidParams.Add(smithy.NewErrParamRequired("Name"))
823	}
824	if v.MaxValue == nil {
825		invalidParams.Add(smithy.NewErrParamRequired("MaxValue"))
826	}
827	if v.MinValue == nil {
828		invalidParams.Add(smithy.NewErrParamRequired("MinValue"))
829	}
830	if invalidParams.Len() > 0 {
831		return invalidParams
832	} else {
833		return nil
834	}
835}
836
837func validateContinuousParameterRanges(v []types.ContinuousParameterRange) error {
838	if v == nil {
839		return nil
840	}
841	invalidParams := smithy.InvalidParamsError{Context: "ContinuousParameterRanges"}
842	for i := range v {
843		if err := validateContinuousParameterRange(&v[i]); err != nil {
844			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
845		}
846	}
847	if invalidParams.Len() > 0 {
848		return invalidParams
849	} else {
850		return nil
851	}
852}
853
854func validateDataDestination(v *types.DataDestination) error {
855	if v == nil {
856		return nil
857	}
858	invalidParams := smithy.InvalidParamsError{Context: "DataDestination"}
859	if v.S3Config == nil {
860		invalidParams.Add(smithy.NewErrParamRequired("S3Config"))
861	} else if v.S3Config != nil {
862		if err := validateS3Config(v.S3Config); err != nil {
863			invalidParams.AddNested("S3Config", err.(smithy.InvalidParamsError))
864		}
865	}
866	if invalidParams.Len() > 0 {
867		return invalidParams
868	} else {
869		return nil
870	}
871}
872
873func validateDataSource(v *types.DataSource) error {
874	if v == nil {
875		return nil
876	}
877	invalidParams := smithy.InvalidParamsError{Context: "DataSource"}
878	if v.S3Config == nil {
879		invalidParams.Add(smithy.NewErrParamRequired("S3Config"))
880	} else if v.S3Config != nil {
881		if err := validateS3Config(v.S3Config); err != nil {
882			invalidParams.AddNested("S3Config", err.(smithy.InvalidParamsError))
883		}
884	}
885	if invalidParams.Len() > 0 {
886		return invalidParams
887	} else {
888		return nil
889	}
890}
891
892func validateEncryptionConfig(v *types.EncryptionConfig) error {
893	if v == nil {
894		return nil
895	}
896	invalidParams := smithy.InvalidParamsError{Context: "EncryptionConfig"}
897	if v.RoleArn == nil {
898		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
899	}
900	if v.KMSKeyArn == nil {
901		invalidParams.Add(smithy.NewErrParamRequired("KMSKeyArn"))
902	}
903	if invalidParams.Len() > 0 {
904		return invalidParams
905	} else {
906		return nil
907	}
908}
909
910func validateFeaturization(v *types.Featurization) error {
911	if v == nil {
912		return nil
913	}
914	invalidParams := smithy.InvalidParamsError{Context: "Featurization"}
915	if v.AttributeName == nil {
916		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
917	}
918	if v.FeaturizationPipeline != nil {
919		if err := validateFeaturizationPipeline(v.FeaturizationPipeline); err != nil {
920			invalidParams.AddNested("FeaturizationPipeline", err.(smithy.InvalidParamsError))
921		}
922	}
923	if invalidParams.Len() > 0 {
924		return invalidParams
925	} else {
926		return nil
927	}
928}
929
930func validateFeaturizationConfig(v *types.FeaturizationConfig) error {
931	if v == nil {
932		return nil
933	}
934	invalidParams := smithy.InvalidParamsError{Context: "FeaturizationConfig"}
935	if v.ForecastFrequency == nil {
936		invalidParams.Add(smithy.NewErrParamRequired("ForecastFrequency"))
937	}
938	if v.Featurizations != nil {
939		if err := validateFeaturizations(v.Featurizations); err != nil {
940			invalidParams.AddNested("Featurizations", err.(smithy.InvalidParamsError))
941		}
942	}
943	if invalidParams.Len() > 0 {
944		return invalidParams
945	} else {
946		return nil
947	}
948}
949
950func validateFeaturizationMethod(v *types.FeaturizationMethod) error {
951	if v == nil {
952		return nil
953	}
954	invalidParams := smithy.InvalidParamsError{Context: "FeaturizationMethod"}
955	if len(v.FeaturizationMethodName) == 0 {
956		invalidParams.Add(smithy.NewErrParamRequired("FeaturizationMethodName"))
957	}
958	if invalidParams.Len() > 0 {
959		return invalidParams
960	} else {
961		return nil
962	}
963}
964
965func validateFeaturizationPipeline(v []types.FeaturizationMethod) error {
966	if v == nil {
967		return nil
968	}
969	invalidParams := smithy.InvalidParamsError{Context: "FeaturizationPipeline"}
970	for i := range v {
971		if err := validateFeaturizationMethod(&v[i]); err != nil {
972			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
973		}
974	}
975	if invalidParams.Len() > 0 {
976		return invalidParams
977	} else {
978		return nil
979	}
980}
981
982func validateFeaturizations(v []types.Featurization) error {
983	if v == nil {
984		return nil
985	}
986	invalidParams := smithy.InvalidParamsError{Context: "Featurizations"}
987	for i := range v {
988		if err := validateFeaturization(&v[i]); err != nil {
989			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
990		}
991	}
992	if invalidParams.Len() > 0 {
993		return invalidParams
994	} else {
995		return nil
996	}
997}
998
999func validateFilter(v *types.Filter) error {
1000	if v == nil {
1001		return nil
1002	}
1003	invalidParams := smithy.InvalidParamsError{Context: "Filter"}
1004	if v.Key == nil {
1005		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1006	}
1007	if v.Value == nil {
1008		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1009	}
1010	if len(v.Condition) == 0 {
1011		invalidParams.Add(smithy.NewErrParamRequired("Condition"))
1012	}
1013	if invalidParams.Len() > 0 {
1014		return invalidParams
1015	} else {
1016		return nil
1017	}
1018}
1019
1020func validateFilters(v []types.Filter) error {
1021	if v == nil {
1022		return nil
1023	}
1024	invalidParams := smithy.InvalidParamsError{Context: "Filters"}
1025	for i := range v {
1026		if err := validateFilter(&v[i]); err != nil {
1027			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1028		}
1029	}
1030	if invalidParams.Len() > 0 {
1031		return invalidParams
1032	} else {
1033		return nil
1034	}
1035}
1036
1037func validateHyperParameterTuningJobConfig(v *types.HyperParameterTuningJobConfig) error {
1038	if v == nil {
1039		return nil
1040	}
1041	invalidParams := smithy.InvalidParamsError{Context: "HyperParameterTuningJobConfig"}
1042	if v.ParameterRanges != nil {
1043		if err := validateParameterRanges(v.ParameterRanges); err != nil {
1044			invalidParams.AddNested("ParameterRanges", err.(smithy.InvalidParamsError))
1045		}
1046	}
1047	if invalidParams.Len() > 0 {
1048		return invalidParams
1049	} else {
1050		return nil
1051	}
1052}
1053
1054func validateInputDataConfig(v *types.InputDataConfig) error {
1055	if v == nil {
1056		return nil
1057	}
1058	invalidParams := smithy.InvalidParamsError{Context: "InputDataConfig"}
1059	if v.DatasetGroupArn == nil {
1060		invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn"))
1061	}
1062	if v.SupplementaryFeatures != nil {
1063		if err := validateSupplementaryFeatures(v.SupplementaryFeatures); err != nil {
1064			invalidParams.AddNested("SupplementaryFeatures", err.(smithy.InvalidParamsError))
1065		}
1066	}
1067	if invalidParams.Len() > 0 {
1068		return invalidParams
1069	} else {
1070		return nil
1071	}
1072}
1073
1074func validateIntegerParameterRange(v *types.IntegerParameterRange) error {
1075	if v == nil {
1076		return nil
1077	}
1078	invalidParams := smithy.InvalidParamsError{Context: "IntegerParameterRange"}
1079	if v.Name == nil {
1080		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1081	}
1082	if v.MaxValue == nil {
1083		invalidParams.Add(smithy.NewErrParamRequired("MaxValue"))
1084	}
1085	if v.MinValue == nil {
1086		invalidParams.Add(smithy.NewErrParamRequired("MinValue"))
1087	}
1088	if invalidParams.Len() > 0 {
1089		return invalidParams
1090	} else {
1091		return nil
1092	}
1093}
1094
1095func validateIntegerParameterRanges(v []types.IntegerParameterRange) error {
1096	if v == nil {
1097		return nil
1098	}
1099	invalidParams := smithy.InvalidParamsError{Context: "IntegerParameterRanges"}
1100	for i := range v {
1101		if err := validateIntegerParameterRange(&v[i]); err != nil {
1102			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1103		}
1104	}
1105	if invalidParams.Len() > 0 {
1106		return invalidParams
1107	} else {
1108		return nil
1109	}
1110}
1111
1112func validateParameterRanges(v *types.ParameterRanges) error {
1113	if v == nil {
1114		return nil
1115	}
1116	invalidParams := smithy.InvalidParamsError{Context: "ParameterRanges"}
1117	if v.CategoricalParameterRanges != nil {
1118		if err := validateCategoricalParameterRanges(v.CategoricalParameterRanges); err != nil {
1119			invalidParams.AddNested("CategoricalParameterRanges", err.(smithy.InvalidParamsError))
1120		}
1121	}
1122	if v.ContinuousParameterRanges != nil {
1123		if err := validateContinuousParameterRanges(v.ContinuousParameterRanges); err != nil {
1124			invalidParams.AddNested("ContinuousParameterRanges", err.(smithy.InvalidParamsError))
1125		}
1126	}
1127	if v.IntegerParameterRanges != nil {
1128		if err := validateIntegerParameterRanges(v.IntegerParameterRanges); err != nil {
1129			invalidParams.AddNested("IntegerParameterRanges", err.(smithy.InvalidParamsError))
1130		}
1131	}
1132	if invalidParams.Len() > 0 {
1133		return invalidParams
1134	} else {
1135		return nil
1136	}
1137}
1138
1139func validateS3Config(v *types.S3Config) error {
1140	if v == nil {
1141		return nil
1142	}
1143	invalidParams := smithy.InvalidParamsError{Context: "S3Config"}
1144	if v.Path == nil {
1145		invalidParams.Add(smithy.NewErrParamRequired("Path"))
1146	}
1147	if v.RoleArn == nil {
1148		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
1149	}
1150	if invalidParams.Len() > 0 {
1151		return invalidParams
1152	} else {
1153		return nil
1154	}
1155}
1156
1157func validateSupplementaryFeature(v *types.SupplementaryFeature) error {
1158	if v == nil {
1159		return nil
1160	}
1161	invalidParams := smithy.InvalidParamsError{Context: "SupplementaryFeature"}
1162	if v.Name == nil {
1163		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1164	}
1165	if v.Value == nil {
1166		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1167	}
1168	if invalidParams.Len() > 0 {
1169		return invalidParams
1170	} else {
1171		return nil
1172	}
1173}
1174
1175func validateSupplementaryFeatures(v []types.SupplementaryFeature) error {
1176	if v == nil {
1177		return nil
1178	}
1179	invalidParams := smithy.InvalidParamsError{Context: "SupplementaryFeatures"}
1180	for i := range v {
1181		if err := validateSupplementaryFeature(&v[i]); err != nil {
1182			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1183		}
1184	}
1185	if invalidParams.Len() > 0 {
1186		return invalidParams
1187	} else {
1188		return nil
1189	}
1190}
1191
1192func validateTag(v *types.Tag) error {
1193	if v == nil {
1194		return nil
1195	}
1196	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
1197	if v.Key == nil {
1198		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1199	}
1200	if v.Value == nil {
1201		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1202	}
1203	if invalidParams.Len() > 0 {
1204		return invalidParams
1205	} else {
1206		return nil
1207	}
1208}
1209
1210func validateTags(v []types.Tag) error {
1211	if v == nil {
1212		return nil
1213	}
1214	invalidParams := smithy.InvalidParamsError{Context: "Tags"}
1215	for i := range v {
1216		if err := validateTag(&v[i]); err != nil {
1217			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1218		}
1219	}
1220	if invalidParams.Len() > 0 {
1221		return invalidParams
1222	} else {
1223		return nil
1224	}
1225}
1226
1227func validateOpCreateDatasetGroupInput(v *CreateDatasetGroupInput) error {
1228	if v == nil {
1229		return nil
1230	}
1231	invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetGroupInput"}
1232	if v.DatasetGroupName == nil {
1233		invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupName"))
1234	}
1235	if len(v.Domain) == 0 {
1236		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
1237	}
1238	if v.Tags != nil {
1239		if err := validateTags(v.Tags); err != nil {
1240			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1241		}
1242	}
1243	if invalidParams.Len() > 0 {
1244		return invalidParams
1245	} else {
1246		return nil
1247	}
1248}
1249
1250func validateOpCreateDatasetImportJobInput(v *CreateDatasetImportJobInput) error {
1251	if v == nil {
1252		return nil
1253	}
1254	invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetImportJobInput"}
1255	if v.DatasetImportJobName == nil {
1256		invalidParams.Add(smithy.NewErrParamRequired("DatasetImportJobName"))
1257	}
1258	if v.DatasetArn == nil {
1259		invalidParams.Add(smithy.NewErrParamRequired("DatasetArn"))
1260	}
1261	if v.DataSource == nil {
1262		invalidParams.Add(smithy.NewErrParamRequired("DataSource"))
1263	} else if v.DataSource != nil {
1264		if err := validateDataSource(v.DataSource); err != nil {
1265			invalidParams.AddNested("DataSource", err.(smithy.InvalidParamsError))
1266		}
1267	}
1268	if v.Tags != nil {
1269		if err := validateTags(v.Tags); err != nil {
1270			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1271		}
1272	}
1273	if invalidParams.Len() > 0 {
1274		return invalidParams
1275	} else {
1276		return nil
1277	}
1278}
1279
1280func validateOpCreateDatasetInput(v *CreateDatasetInput) error {
1281	if v == nil {
1282		return nil
1283	}
1284	invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetInput"}
1285	if v.DatasetName == nil {
1286		invalidParams.Add(smithy.NewErrParamRequired("DatasetName"))
1287	}
1288	if len(v.Domain) == 0 {
1289		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
1290	}
1291	if len(v.DatasetType) == 0 {
1292		invalidParams.Add(smithy.NewErrParamRequired("DatasetType"))
1293	}
1294	if v.Schema == nil {
1295		invalidParams.Add(smithy.NewErrParamRequired("Schema"))
1296	}
1297	if v.EncryptionConfig != nil {
1298		if err := validateEncryptionConfig(v.EncryptionConfig); err != nil {
1299			invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError))
1300		}
1301	}
1302	if v.Tags != nil {
1303		if err := validateTags(v.Tags); err != nil {
1304			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1305		}
1306	}
1307	if invalidParams.Len() > 0 {
1308		return invalidParams
1309	} else {
1310		return nil
1311	}
1312}
1313
1314func validateOpCreateForecastExportJobInput(v *CreateForecastExportJobInput) error {
1315	if v == nil {
1316		return nil
1317	}
1318	invalidParams := smithy.InvalidParamsError{Context: "CreateForecastExportJobInput"}
1319	if v.ForecastExportJobName == nil {
1320		invalidParams.Add(smithy.NewErrParamRequired("ForecastExportJobName"))
1321	}
1322	if v.ForecastArn == nil {
1323		invalidParams.Add(smithy.NewErrParamRequired("ForecastArn"))
1324	}
1325	if v.Destination == nil {
1326		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
1327	} else if v.Destination != nil {
1328		if err := validateDataDestination(v.Destination); err != nil {
1329			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
1330		}
1331	}
1332	if v.Tags != nil {
1333		if err := validateTags(v.Tags); err != nil {
1334			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1335		}
1336	}
1337	if invalidParams.Len() > 0 {
1338		return invalidParams
1339	} else {
1340		return nil
1341	}
1342}
1343
1344func validateOpCreateForecastInput(v *CreateForecastInput) error {
1345	if v == nil {
1346		return nil
1347	}
1348	invalidParams := smithy.InvalidParamsError{Context: "CreateForecastInput"}
1349	if v.ForecastName == nil {
1350		invalidParams.Add(smithy.NewErrParamRequired("ForecastName"))
1351	}
1352	if v.PredictorArn == nil {
1353		invalidParams.Add(smithy.NewErrParamRequired("PredictorArn"))
1354	}
1355	if v.Tags != nil {
1356		if err := validateTags(v.Tags); err != nil {
1357			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1358		}
1359	}
1360	if invalidParams.Len() > 0 {
1361		return invalidParams
1362	} else {
1363		return nil
1364	}
1365}
1366
1367func validateOpCreatePredictorBacktestExportJobInput(v *CreatePredictorBacktestExportJobInput) error {
1368	if v == nil {
1369		return nil
1370	}
1371	invalidParams := smithy.InvalidParamsError{Context: "CreatePredictorBacktestExportJobInput"}
1372	if v.PredictorBacktestExportJobName == nil {
1373		invalidParams.Add(smithy.NewErrParamRequired("PredictorBacktestExportJobName"))
1374	}
1375	if v.PredictorArn == nil {
1376		invalidParams.Add(smithy.NewErrParamRequired("PredictorArn"))
1377	}
1378	if v.Destination == nil {
1379		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
1380	} else if v.Destination != nil {
1381		if err := validateDataDestination(v.Destination); err != nil {
1382			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
1383		}
1384	}
1385	if v.Tags != nil {
1386		if err := validateTags(v.Tags); err != nil {
1387			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1388		}
1389	}
1390	if invalidParams.Len() > 0 {
1391		return invalidParams
1392	} else {
1393		return nil
1394	}
1395}
1396
1397func validateOpCreatePredictorInput(v *CreatePredictorInput) error {
1398	if v == nil {
1399		return nil
1400	}
1401	invalidParams := smithy.InvalidParamsError{Context: "CreatePredictorInput"}
1402	if v.PredictorName == nil {
1403		invalidParams.Add(smithy.NewErrParamRequired("PredictorName"))
1404	}
1405	if v.ForecastHorizon == nil {
1406		invalidParams.Add(smithy.NewErrParamRequired("ForecastHorizon"))
1407	}
1408	if v.HPOConfig != nil {
1409		if err := validateHyperParameterTuningJobConfig(v.HPOConfig); err != nil {
1410			invalidParams.AddNested("HPOConfig", err.(smithy.InvalidParamsError))
1411		}
1412	}
1413	if v.InputDataConfig == nil {
1414		invalidParams.Add(smithy.NewErrParamRequired("InputDataConfig"))
1415	} else if v.InputDataConfig != nil {
1416		if err := validateInputDataConfig(v.InputDataConfig); err != nil {
1417			invalidParams.AddNested("InputDataConfig", err.(smithy.InvalidParamsError))
1418		}
1419	}
1420	if v.FeaturizationConfig == nil {
1421		invalidParams.Add(smithy.NewErrParamRequired("FeaturizationConfig"))
1422	} else if v.FeaturizationConfig != nil {
1423		if err := validateFeaturizationConfig(v.FeaturizationConfig); err != nil {
1424			invalidParams.AddNested("FeaturizationConfig", err.(smithy.InvalidParamsError))
1425		}
1426	}
1427	if v.EncryptionConfig != nil {
1428		if err := validateEncryptionConfig(v.EncryptionConfig); err != nil {
1429			invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError))
1430		}
1431	}
1432	if v.Tags != nil {
1433		if err := validateTags(v.Tags); err != nil {
1434			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1435		}
1436	}
1437	if invalidParams.Len() > 0 {
1438		return invalidParams
1439	} else {
1440		return nil
1441	}
1442}
1443
1444func validateOpDeleteDatasetGroupInput(v *DeleteDatasetGroupInput) error {
1445	if v == nil {
1446		return nil
1447	}
1448	invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetGroupInput"}
1449	if v.DatasetGroupArn == nil {
1450		invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn"))
1451	}
1452	if invalidParams.Len() > 0 {
1453		return invalidParams
1454	} else {
1455		return nil
1456	}
1457}
1458
1459func validateOpDeleteDatasetImportJobInput(v *DeleteDatasetImportJobInput) error {
1460	if v == nil {
1461		return nil
1462	}
1463	invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetImportJobInput"}
1464	if v.DatasetImportJobArn == nil {
1465		invalidParams.Add(smithy.NewErrParamRequired("DatasetImportJobArn"))
1466	}
1467	if invalidParams.Len() > 0 {
1468		return invalidParams
1469	} else {
1470		return nil
1471	}
1472}
1473
1474func validateOpDeleteDatasetInput(v *DeleteDatasetInput) error {
1475	if v == nil {
1476		return nil
1477	}
1478	invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetInput"}
1479	if v.DatasetArn == nil {
1480		invalidParams.Add(smithy.NewErrParamRequired("DatasetArn"))
1481	}
1482	if invalidParams.Len() > 0 {
1483		return invalidParams
1484	} else {
1485		return nil
1486	}
1487}
1488
1489func validateOpDeleteForecastExportJobInput(v *DeleteForecastExportJobInput) error {
1490	if v == nil {
1491		return nil
1492	}
1493	invalidParams := smithy.InvalidParamsError{Context: "DeleteForecastExportJobInput"}
1494	if v.ForecastExportJobArn == nil {
1495		invalidParams.Add(smithy.NewErrParamRequired("ForecastExportJobArn"))
1496	}
1497	if invalidParams.Len() > 0 {
1498		return invalidParams
1499	} else {
1500		return nil
1501	}
1502}
1503
1504func validateOpDeleteForecastInput(v *DeleteForecastInput) error {
1505	if v == nil {
1506		return nil
1507	}
1508	invalidParams := smithy.InvalidParamsError{Context: "DeleteForecastInput"}
1509	if v.ForecastArn == nil {
1510		invalidParams.Add(smithy.NewErrParamRequired("ForecastArn"))
1511	}
1512	if invalidParams.Len() > 0 {
1513		return invalidParams
1514	} else {
1515		return nil
1516	}
1517}
1518
1519func validateOpDeletePredictorBacktestExportJobInput(v *DeletePredictorBacktestExportJobInput) error {
1520	if v == nil {
1521		return nil
1522	}
1523	invalidParams := smithy.InvalidParamsError{Context: "DeletePredictorBacktestExportJobInput"}
1524	if v.PredictorBacktestExportJobArn == nil {
1525		invalidParams.Add(smithy.NewErrParamRequired("PredictorBacktestExportJobArn"))
1526	}
1527	if invalidParams.Len() > 0 {
1528		return invalidParams
1529	} else {
1530		return nil
1531	}
1532}
1533
1534func validateOpDeletePredictorInput(v *DeletePredictorInput) error {
1535	if v == nil {
1536		return nil
1537	}
1538	invalidParams := smithy.InvalidParamsError{Context: "DeletePredictorInput"}
1539	if v.PredictorArn == nil {
1540		invalidParams.Add(smithy.NewErrParamRequired("PredictorArn"))
1541	}
1542	if invalidParams.Len() > 0 {
1543		return invalidParams
1544	} else {
1545		return nil
1546	}
1547}
1548
1549func validateOpDescribeDatasetGroupInput(v *DescribeDatasetGroupInput) error {
1550	if v == nil {
1551		return nil
1552	}
1553	invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetGroupInput"}
1554	if v.DatasetGroupArn == nil {
1555		invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn"))
1556	}
1557	if invalidParams.Len() > 0 {
1558		return invalidParams
1559	} else {
1560		return nil
1561	}
1562}
1563
1564func validateOpDescribeDatasetImportJobInput(v *DescribeDatasetImportJobInput) error {
1565	if v == nil {
1566		return nil
1567	}
1568	invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetImportJobInput"}
1569	if v.DatasetImportJobArn == nil {
1570		invalidParams.Add(smithy.NewErrParamRequired("DatasetImportJobArn"))
1571	}
1572	if invalidParams.Len() > 0 {
1573		return invalidParams
1574	} else {
1575		return nil
1576	}
1577}
1578
1579func validateOpDescribeDatasetInput(v *DescribeDatasetInput) error {
1580	if v == nil {
1581		return nil
1582	}
1583	invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetInput"}
1584	if v.DatasetArn == nil {
1585		invalidParams.Add(smithy.NewErrParamRequired("DatasetArn"))
1586	}
1587	if invalidParams.Len() > 0 {
1588		return invalidParams
1589	} else {
1590		return nil
1591	}
1592}
1593
1594func validateOpDescribeForecastExportJobInput(v *DescribeForecastExportJobInput) error {
1595	if v == nil {
1596		return nil
1597	}
1598	invalidParams := smithy.InvalidParamsError{Context: "DescribeForecastExportJobInput"}
1599	if v.ForecastExportJobArn == nil {
1600		invalidParams.Add(smithy.NewErrParamRequired("ForecastExportJobArn"))
1601	}
1602	if invalidParams.Len() > 0 {
1603		return invalidParams
1604	} else {
1605		return nil
1606	}
1607}
1608
1609func validateOpDescribeForecastInput(v *DescribeForecastInput) error {
1610	if v == nil {
1611		return nil
1612	}
1613	invalidParams := smithy.InvalidParamsError{Context: "DescribeForecastInput"}
1614	if v.ForecastArn == nil {
1615		invalidParams.Add(smithy.NewErrParamRequired("ForecastArn"))
1616	}
1617	if invalidParams.Len() > 0 {
1618		return invalidParams
1619	} else {
1620		return nil
1621	}
1622}
1623
1624func validateOpDescribePredictorBacktestExportJobInput(v *DescribePredictorBacktestExportJobInput) error {
1625	if v == nil {
1626		return nil
1627	}
1628	invalidParams := smithy.InvalidParamsError{Context: "DescribePredictorBacktestExportJobInput"}
1629	if v.PredictorBacktestExportJobArn == nil {
1630		invalidParams.Add(smithy.NewErrParamRequired("PredictorBacktestExportJobArn"))
1631	}
1632	if invalidParams.Len() > 0 {
1633		return invalidParams
1634	} else {
1635		return nil
1636	}
1637}
1638
1639func validateOpDescribePredictorInput(v *DescribePredictorInput) error {
1640	if v == nil {
1641		return nil
1642	}
1643	invalidParams := smithy.InvalidParamsError{Context: "DescribePredictorInput"}
1644	if v.PredictorArn == nil {
1645		invalidParams.Add(smithy.NewErrParamRequired("PredictorArn"))
1646	}
1647	if invalidParams.Len() > 0 {
1648		return invalidParams
1649	} else {
1650		return nil
1651	}
1652}
1653
1654func validateOpGetAccuracyMetricsInput(v *GetAccuracyMetricsInput) error {
1655	if v == nil {
1656		return nil
1657	}
1658	invalidParams := smithy.InvalidParamsError{Context: "GetAccuracyMetricsInput"}
1659	if v.PredictorArn == nil {
1660		invalidParams.Add(smithy.NewErrParamRequired("PredictorArn"))
1661	}
1662	if invalidParams.Len() > 0 {
1663		return invalidParams
1664	} else {
1665		return nil
1666	}
1667}
1668
1669func validateOpListDatasetImportJobsInput(v *ListDatasetImportJobsInput) error {
1670	if v == nil {
1671		return nil
1672	}
1673	invalidParams := smithy.InvalidParamsError{Context: "ListDatasetImportJobsInput"}
1674	if v.Filters != nil {
1675		if err := validateFilters(v.Filters); err != nil {
1676			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
1677		}
1678	}
1679	if invalidParams.Len() > 0 {
1680		return invalidParams
1681	} else {
1682		return nil
1683	}
1684}
1685
1686func validateOpListForecastExportJobsInput(v *ListForecastExportJobsInput) error {
1687	if v == nil {
1688		return nil
1689	}
1690	invalidParams := smithy.InvalidParamsError{Context: "ListForecastExportJobsInput"}
1691	if v.Filters != nil {
1692		if err := validateFilters(v.Filters); err != nil {
1693			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
1694		}
1695	}
1696	if invalidParams.Len() > 0 {
1697		return invalidParams
1698	} else {
1699		return nil
1700	}
1701}
1702
1703func validateOpListForecastsInput(v *ListForecastsInput) error {
1704	if v == nil {
1705		return nil
1706	}
1707	invalidParams := smithy.InvalidParamsError{Context: "ListForecastsInput"}
1708	if v.Filters != nil {
1709		if err := validateFilters(v.Filters); err != nil {
1710			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
1711		}
1712	}
1713	if invalidParams.Len() > 0 {
1714		return invalidParams
1715	} else {
1716		return nil
1717	}
1718}
1719
1720func validateOpListPredictorBacktestExportJobsInput(v *ListPredictorBacktestExportJobsInput) error {
1721	if v == nil {
1722		return nil
1723	}
1724	invalidParams := smithy.InvalidParamsError{Context: "ListPredictorBacktestExportJobsInput"}
1725	if v.Filters != nil {
1726		if err := validateFilters(v.Filters); err != nil {
1727			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
1728		}
1729	}
1730	if invalidParams.Len() > 0 {
1731		return invalidParams
1732	} else {
1733		return nil
1734	}
1735}
1736
1737func validateOpListPredictorsInput(v *ListPredictorsInput) error {
1738	if v == nil {
1739		return nil
1740	}
1741	invalidParams := smithy.InvalidParamsError{Context: "ListPredictorsInput"}
1742	if v.Filters != nil {
1743		if err := validateFilters(v.Filters); err != nil {
1744			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
1745		}
1746	}
1747	if invalidParams.Len() > 0 {
1748		return invalidParams
1749	} else {
1750		return nil
1751	}
1752}
1753
1754func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1755	if v == nil {
1756		return nil
1757	}
1758	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1759	if v.ResourceArn == nil {
1760		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1761	}
1762	if invalidParams.Len() > 0 {
1763		return invalidParams
1764	} else {
1765		return nil
1766	}
1767}
1768
1769func validateOpStopResourceInput(v *StopResourceInput) error {
1770	if v == nil {
1771		return nil
1772	}
1773	invalidParams := smithy.InvalidParamsError{Context: "StopResourceInput"}
1774	if v.ResourceArn == nil {
1775		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1776	}
1777	if invalidParams.Len() > 0 {
1778		return invalidParams
1779	} else {
1780		return nil
1781	}
1782}
1783
1784func validateOpTagResourceInput(v *TagResourceInput) error {
1785	if v == nil {
1786		return nil
1787	}
1788	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1789	if v.ResourceArn == nil {
1790		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1791	}
1792	if v.Tags == nil {
1793		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1794	} else if v.Tags != nil {
1795		if err := validateTags(v.Tags); err != nil {
1796			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1797		}
1798	}
1799	if invalidParams.Len() > 0 {
1800		return invalidParams
1801	} else {
1802		return nil
1803	}
1804}
1805
1806func validateOpUntagResourceInput(v *UntagResourceInput) error {
1807	if v == nil {
1808		return nil
1809	}
1810	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1811	if v.ResourceArn == nil {
1812		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1813	}
1814	if v.TagKeys == nil {
1815		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1816	}
1817	if invalidParams.Len() > 0 {
1818		return invalidParams
1819	} else {
1820		return nil
1821	}
1822}
1823
1824func validateOpUpdateDatasetGroupInput(v *UpdateDatasetGroupInput) error {
1825	if v == nil {
1826		return nil
1827	}
1828	invalidParams := smithy.InvalidParamsError{Context: "UpdateDatasetGroupInput"}
1829	if v.DatasetGroupArn == nil {
1830		invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn"))
1831	}
1832	if v.DatasetArns == nil {
1833		invalidParams.Add(smithy.NewErrParamRequired("DatasetArns"))
1834	}
1835	if invalidParams.Len() > 0 {
1836		return invalidParams
1837	} else {
1838		return nil
1839	}
1840}
1841