1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package lookoutequipment
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/lookoutequipment/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateDataset struct {
14}
15
16func (*validateOpCreateDataset) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateDataset) 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.(*CreateDatasetInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateDatasetInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateInferenceScheduler struct {
34}
35
36func (*validateOpCreateInferenceScheduler) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateInferenceScheduler) 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.(*CreateInferenceSchedulerInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateInferenceSchedulerInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateModel struct {
54}
55
56func (*validateOpCreateModel) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateModel) 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.(*CreateModelInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateModelInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpDeleteDataset struct {
74}
75
76func (*validateOpDeleteDataset) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpDeleteDataset) 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.(*DeleteDatasetInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpDeleteDatasetInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpDeleteInferenceScheduler struct {
94}
95
96func (*validateOpDeleteInferenceScheduler) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDeleteInferenceScheduler) 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.(*DeleteInferenceSchedulerInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDeleteInferenceSchedulerInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeleteModel struct {
114}
115
116func (*validateOpDeleteModel) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeleteModel) 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.(*DeleteModelInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeleteModelInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDescribeDataIngestionJob struct {
134}
135
136func (*validateOpDescribeDataIngestionJob) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDescribeDataIngestionJob) 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.(*DescribeDataIngestionJobInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDescribeDataIngestionJobInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDescribeDataset struct {
154}
155
156func (*validateOpDescribeDataset) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDescribeDataset) 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.(*DescribeDatasetInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDescribeDatasetInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDescribeInferenceScheduler struct {
174}
175
176func (*validateOpDescribeInferenceScheduler) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDescribeInferenceScheduler) 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.(*DescribeInferenceSchedulerInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDescribeInferenceSchedulerInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDescribeModel struct {
194}
195
196func (*validateOpDescribeModel) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDescribeModel) 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.(*DescribeModelInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDescribeModelInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpListInferenceExecutions struct {
214}
215
216func (*validateOpListInferenceExecutions) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpListInferenceExecutions) 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.(*ListInferenceExecutionsInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpListInferenceExecutionsInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpListTagsForResource struct {
234}
235
236func (*validateOpListTagsForResource) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpListTagsForResourceInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpStartDataIngestionJob struct {
254}
255
256func (*validateOpStartDataIngestionJob) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpStartDataIngestionJob) 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.(*StartDataIngestionJobInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpStartDataIngestionJobInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpStartInferenceScheduler struct {
274}
275
276func (*validateOpStartInferenceScheduler) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpStartInferenceScheduler) 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.(*StartInferenceSchedulerInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpStartInferenceSchedulerInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpStopInferenceScheduler struct {
294}
295
296func (*validateOpStopInferenceScheduler) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpStopInferenceScheduler) 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.(*StopInferenceSchedulerInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpStopInferenceSchedulerInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpTagResource struct {
314}
315
316func (*validateOpTagResource) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpTagResource) 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.(*TagResourceInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpTagResourceInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpUntagResource struct {
334}
335
336func (*validateOpUntagResource) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpUntagResource) 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.(*UntagResourceInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpUntagResourceInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpUpdateInferenceScheduler struct {
354}
355
356func (*validateOpUpdateInferenceScheduler) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpUpdateInferenceScheduler) 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.(*UpdateInferenceSchedulerInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpUpdateInferenceSchedulerInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373func addOpCreateDatasetValidationMiddleware(stack *middleware.Stack) error {
374	return stack.Initialize.Add(&validateOpCreateDataset{}, middleware.After)
375}
376
377func addOpCreateInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error {
378	return stack.Initialize.Add(&validateOpCreateInferenceScheduler{}, middleware.After)
379}
380
381func addOpCreateModelValidationMiddleware(stack *middleware.Stack) error {
382	return stack.Initialize.Add(&validateOpCreateModel{}, middleware.After)
383}
384
385func addOpDeleteDatasetValidationMiddleware(stack *middleware.Stack) error {
386	return stack.Initialize.Add(&validateOpDeleteDataset{}, middleware.After)
387}
388
389func addOpDeleteInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error {
390	return stack.Initialize.Add(&validateOpDeleteInferenceScheduler{}, middleware.After)
391}
392
393func addOpDeleteModelValidationMiddleware(stack *middleware.Stack) error {
394	return stack.Initialize.Add(&validateOpDeleteModel{}, middleware.After)
395}
396
397func addOpDescribeDataIngestionJobValidationMiddleware(stack *middleware.Stack) error {
398	return stack.Initialize.Add(&validateOpDescribeDataIngestionJob{}, middleware.After)
399}
400
401func addOpDescribeDatasetValidationMiddleware(stack *middleware.Stack) error {
402	return stack.Initialize.Add(&validateOpDescribeDataset{}, middleware.After)
403}
404
405func addOpDescribeInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error {
406	return stack.Initialize.Add(&validateOpDescribeInferenceScheduler{}, middleware.After)
407}
408
409func addOpDescribeModelValidationMiddleware(stack *middleware.Stack) error {
410	return stack.Initialize.Add(&validateOpDescribeModel{}, middleware.After)
411}
412
413func addOpListInferenceExecutionsValidationMiddleware(stack *middleware.Stack) error {
414	return stack.Initialize.Add(&validateOpListInferenceExecutions{}, middleware.After)
415}
416
417func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
418	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
419}
420
421func addOpStartDataIngestionJobValidationMiddleware(stack *middleware.Stack) error {
422	return stack.Initialize.Add(&validateOpStartDataIngestionJob{}, middleware.After)
423}
424
425func addOpStartInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error {
426	return stack.Initialize.Add(&validateOpStartInferenceScheduler{}, middleware.After)
427}
428
429func addOpStopInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error {
430	return stack.Initialize.Add(&validateOpStopInferenceScheduler{}, middleware.After)
431}
432
433func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
434	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
435}
436
437func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
438	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
439}
440
441func addOpUpdateInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error {
442	return stack.Initialize.Add(&validateOpUpdateInferenceScheduler{}, middleware.After)
443}
444
445func validateInferenceInputConfiguration(v *types.InferenceInputConfiguration) error {
446	if v == nil {
447		return nil
448	}
449	invalidParams := smithy.InvalidParamsError{Context: "InferenceInputConfiguration"}
450	if v.S3InputConfiguration != nil {
451		if err := validateInferenceS3InputConfiguration(v.S3InputConfiguration); err != nil {
452			invalidParams.AddNested("S3InputConfiguration", err.(smithy.InvalidParamsError))
453		}
454	}
455	if invalidParams.Len() > 0 {
456		return invalidParams
457	} else {
458		return nil
459	}
460}
461
462func validateInferenceOutputConfiguration(v *types.InferenceOutputConfiguration) error {
463	if v == nil {
464		return nil
465	}
466	invalidParams := smithy.InvalidParamsError{Context: "InferenceOutputConfiguration"}
467	if v.S3OutputConfiguration == nil {
468		invalidParams.Add(smithy.NewErrParamRequired("S3OutputConfiguration"))
469	} else if v.S3OutputConfiguration != nil {
470		if err := validateInferenceS3OutputConfiguration(v.S3OutputConfiguration); err != nil {
471			invalidParams.AddNested("S3OutputConfiguration", err.(smithy.InvalidParamsError))
472		}
473	}
474	if invalidParams.Len() > 0 {
475		return invalidParams
476	} else {
477		return nil
478	}
479}
480
481func validateInferenceS3InputConfiguration(v *types.InferenceS3InputConfiguration) error {
482	if v == nil {
483		return nil
484	}
485	invalidParams := smithy.InvalidParamsError{Context: "InferenceS3InputConfiguration"}
486	if v.Bucket == nil {
487		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
488	}
489	if invalidParams.Len() > 0 {
490		return invalidParams
491	} else {
492		return nil
493	}
494}
495
496func validateInferenceS3OutputConfiguration(v *types.InferenceS3OutputConfiguration) error {
497	if v == nil {
498		return nil
499	}
500	invalidParams := smithy.InvalidParamsError{Context: "InferenceS3OutputConfiguration"}
501	if v.Bucket == nil {
502		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
503	}
504	if invalidParams.Len() > 0 {
505		return invalidParams
506	} else {
507		return nil
508	}
509}
510
511func validateIngestionInputConfiguration(v *types.IngestionInputConfiguration) error {
512	if v == nil {
513		return nil
514	}
515	invalidParams := smithy.InvalidParamsError{Context: "IngestionInputConfiguration"}
516	if v.S3InputConfiguration == nil {
517		invalidParams.Add(smithy.NewErrParamRequired("S3InputConfiguration"))
518	} else if v.S3InputConfiguration != nil {
519		if err := validateIngestionS3InputConfiguration(v.S3InputConfiguration); err != nil {
520			invalidParams.AddNested("S3InputConfiguration", err.(smithy.InvalidParamsError))
521		}
522	}
523	if invalidParams.Len() > 0 {
524		return invalidParams
525	} else {
526		return nil
527	}
528}
529
530func validateIngestionS3InputConfiguration(v *types.IngestionS3InputConfiguration) error {
531	if v == nil {
532		return nil
533	}
534	invalidParams := smithy.InvalidParamsError{Context: "IngestionS3InputConfiguration"}
535	if v.Bucket == nil {
536		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
537	}
538	if invalidParams.Len() > 0 {
539		return invalidParams
540	} else {
541		return nil
542	}
543}
544
545func validateLabelsInputConfiguration(v *types.LabelsInputConfiguration) error {
546	if v == nil {
547		return nil
548	}
549	invalidParams := smithy.InvalidParamsError{Context: "LabelsInputConfiguration"}
550	if v.S3InputConfiguration == nil {
551		invalidParams.Add(smithy.NewErrParamRequired("S3InputConfiguration"))
552	} else if v.S3InputConfiguration != nil {
553		if err := validateLabelsS3InputConfiguration(v.S3InputConfiguration); err != nil {
554			invalidParams.AddNested("S3InputConfiguration", err.(smithy.InvalidParamsError))
555		}
556	}
557	if invalidParams.Len() > 0 {
558		return invalidParams
559	} else {
560		return nil
561	}
562}
563
564func validateLabelsS3InputConfiguration(v *types.LabelsS3InputConfiguration) error {
565	if v == nil {
566		return nil
567	}
568	invalidParams := smithy.InvalidParamsError{Context: "LabelsS3InputConfiguration"}
569	if v.Bucket == nil {
570		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
571	}
572	if invalidParams.Len() > 0 {
573		return invalidParams
574	} else {
575		return nil
576	}
577}
578
579func validateTag(v *types.Tag) error {
580	if v == nil {
581		return nil
582	}
583	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
584	if v.Key == nil {
585		invalidParams.Add(smithy.NewErrParamRequired("Key"))
586	}
587	if v.Value == nil {
588		invalidParams.Add(smithy.NewErrParamRequired("Value"))
589	}
590	if invalidParams.Len() > 0 {
591		return invalidParams
592	} else {
593		return nil
594	}
595}
596
597func validateTagList(v []types.Tag) error {
598	if v == nil {
599		return nil
600	}
601	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
602	for i := range v {
603		if err := validateTag(&v[i]); err != nil {
604			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
605		}
606	}
607	if invalidParams.Len() > 0 {
608		return invalidParams
609	} else {
610		return nil
611	}
612}
613
614func validateOpCreateDatasetInput(v *CreateDatasetInput) error {
615	if v == nil {
616		return nil
617	}
618	invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetInput"}
619	if v.DatasetName == nil {
620		invalidParams.Add(smithy.NewErrParamRequired("DatasetName"))
621	}
622	if v.DatasetSchema == nil {
623		invalidParams.Add(smithy.NewErrParamRequired("DatasetSchema"))
624	}
625	if v.ClientToken == nil {
626		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
627	}
628	if v.Tags != nil {
629		if err := validateTagList(v.Tags); err != nil {
630			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
631		}
632	}
633	if invalidParams.Len() > 0 {
634		return invalidParams
635	} else {
636		return nil
637	}
638}
639
640func validateOpCreateInferenceSchedulerInput(v *CreateInferenceSchedulerInput) error {
641	if v == nil {
642		return nil
643	}
644	invalidParams := smithy.InvalidParamsError{Context: "CreateInferenceSchedulerInput"}
645	if v.ModelName == nil {
646		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
647	}
648	if v.InferenceSchedulerName == nil {
649		invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName"))
650	}
651	if len(v.DataUploadFrequency) == 0 {
652		invalidParams.Add(smithy.NewErrParamRequired("DataUploadFrequency"))
653	}
654	if v.DataInputConfiguration == nil {
655		invalidParams.Add(smithy.NewErrParamRequired("DataInputConfiguration"))
656	} else if v.DataInputConfiguration != nil {
657		if err := validateInferenceInputConfiguration(v.DataInputConfiguration); err != nil {
658			invalidParams.AddNested("DataInputConfiguration", err.(smithy.InvalidParamsError))
659		}
660	}
661	if v.DataOutputConfiguration == nil {
662		invalidParams.Add(smithy.NewErrParamRequired("DataOutputConfiguration"))
663	} else if v.DataOutputConfiguration != nil {
664		if err := validateInferenceOutputConfiguration(v.DataOutputConfiguration); err != nil {
665			invalidParams.AddNested("DataOutputConfiguration", err.(smithy.InvalidParamsError))
666		}
667	}
668	if v.RoleArn == nil {
669		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
670	}
671	if v.ClientToken == nil {
672		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
673	}
674	if v.Tags != nil {
675		if err := validateTagList(v.Tags); err != nil {
676			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
677		}
678	}
679	if invalidParams.Len() > 0 {
680		return invalidParams
681	} else {
682		return nil
683	}
684}
685
686func validateOpCreateModelInput(v *CreateModelInput) error {
687	if v == nil {
688		return nil
689	}
690	invalidParams := smithy.InvalidParamsError{Context: "CreateModelInput"}
691	if v.ModelName == nil {
692		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
693	}
694	if v.DatasetName == nil {
695		invalidParams.Add(smithy.NewErrParamRequired("DatasetName"))
696	}
697	if v.LabelsInputConfiguration != nil {
698		if err := validateLabelsInputConfiguration(v.LabelsInputConfiguration); err != nil {
699			invalidParams.AddNested("LabelsInputConfiguration", err.(smithy.InvalidParamsError))
700		}
701	}
702	if v.ClientToken == nil {
703		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
704	}
705	if v.Tags != nil {
706		if err := validateTagList(v.Tags); err != nil {
707			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
708		}
709	}
710	if invalidParams.Len() > 0 {
711		return invalidParams
712	} else {
713		return nil
714	}
715}
716
717func validateOpDeleteDatasetInput(v *DeleteDatasetInput) error {
718	if v == nil {
719		return nil
720	}
721	invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetInput"}
722	if v.DatasetName == nil {
723		invalidParams.Add(smithy.NewErrParamRequired("DatasetName"))
724	}
725	if invalidParams.Len() > 0 {
726		return invalidParams
727	} else {
728		return nil
729	}
730}
731
732func validateOpDeleteInferenceSchedulerInput(v *DeleteInferenceSchedulerInput) error {
733	if v == nil {
734		return nil
735	}
736	invalidParams := smithy.InvalidParamsError{Context: "DeleteInferenceSchedulerInput"}
737	if v.InferenceSchedulerName == nil {
738		invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName"))
739	}
740	if invalidParams.Len() > 0 {
741		return invalidParams
742	} else {
743		return nil
744	}
745}
746
747func validateOpDeleteModelInput(v *DeleteModelInput) error {
748	if v == nil {
749		return nil
750	}
751	invalidParams := smithy.InvalidParamsError{Context: "DeleteModelInput"}
752	if v.ModelName == nil {
753		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
754	}
755	if invalidParams.Len() > 0 {
756		return invalidParams
757	} else {
758		return nil
759	}
760}
761
762func validateOpDescribeDataIngestionJobInput(v *DescribeDataIngestionJobInput) error {
763	if v == nil {
764		return nil
765	}
766	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataIngestionJobInput"}
767	if v.JobId == nil {
768		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
769	}
770	if invalidParams.Len() > 0 {
771		return invalidParams
772	} else {
773		return nil
774	}
775}
776
777func validateOpDescribeDatasetInput(v *DescribeDatasetInput) error {
778	if v == nil {
779		return nil
780	}
781	invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetInput"}
782	if v.DatasetName == nil {
783		invalidParams.Add(smithy.NewErrParamRequired("DatasetName"))
784	}
785	if invalidParams.Len() > 0 {
786		return invalidParams
787	} else {
788		return nil
789	}
790}
791
792func validateOpDescribeInferenceSchedulerInput(v *DescribeInferenceSchedulerInput) error {
793	if v == nil {
794		return nil
795	}
796	invalidParams := smithy.InvalidParamsError{Context: "DescribeInferenceSchedulerInput"}
797	if v.InferenceSchedulerName == nil {
798		invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName"))
799	}
800	if invalidParams.Len() > 0 {
801		return invalidParams
802	} else {
803		return nil
804	}
805}
806
807func validateOpDescribeModelInput(v *DescribeModelInput) error {
808	if v == nil {
809		return nil
810	}
811	invalidParams := smithy.InvalidParamsError{Context: "DescribeModelInput"}
812	if v.ModelName == nil {
813		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
814	}
815	if invalidParams.Len() > 0 {
816		return invalidParams
817	} else {
818		return nil
819	}
820}
821
822func validateOpListInferenceExecutionsInput(v *ListInferenceExecutionsInput) error {
823	if v == nil {
824		return nil
825	}
826	invalidParams := smithy.InvalidParamsError{Context: "ListInferenceExecutionsInput"}
827	if v.InferenceSchedulerName == nil {
828		invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName"))
829	}
830	if invalidParams.Len() > 0 {
831		return invalidParams
832	} else {
833		return nil
834	}
835}
836
837func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
838	if v == nil {
839		return nil
840	}
841	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
842	if v.ResourceArn == nil {
843		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
844	}
845	if invalidParams.Len() > 0 {
846		return invalidParams
847	} else {
848		return nil
849	}
850}
851
852func validateOpStartDataIngestionJobInput(v *StartDataIngestionJobInput) error {
853	if v == nil {
854		return nil
855	}
856	invalidParams := smithy.InvalidParamsError{Context: "StartDataIngestionJobInput"}
857	if v.DatasetName == nil {
858		invalidParams.Add(smithy.NewErrParamRequired("DatasetName"))
859	}
860	if v.IngestionInputConfiguration == nil {
861		invalidParams.Add(smithy.NewErrParamRequired("IngestionInputConfiguration"))
862	} else if v.IngestionInputConfiguration != nil {
863		if err := validateIngestionInputConfiguration(v.IngestionInputConfiguration); err != nil {
864			invalidParams.AddNested("IngestionInputConfiguration", err.(smithy.InvalidParamsError))
865		}
866	}
867	if v.RoleArn == nil {
868		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
869	}
870	if v.ClientToken == nil {
871		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
872	}
873	if invalidParams.Len() > 0 {
874		return invalidParams
875	} else {
876		return nil
877	}
878}
879
880func validateOpStartInferenceSchedulerInput(v *StartInferenceSchedulerInput) error {
881	if v == nil {
882		return nil
883	}
884	invalidParams := smithy.InvalidParamsError{Context: "StartInferenceSchedulerInput"}
885	if v.InferenceSchedulerName == nil {
886		invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName"))
887	}
888	if invalidParams.Len() > 0 {
889		return invalidParams
890	} else {
891		return nil
892	}
893}
894
895func validateOpStopInferenceSchedulerInput(v *StopInferenceSchedulerInput) error {
896	if v == nil {
897		return nil
898	}
899	invalidParams := smithy.InvalidParamsError{Context: "StopInferenceSchedulerInput"}
900	if v.InferenceSchedulerName == nil {
901		invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName"))
902	}
903	if invalidParams.Len() > 0 {
904		return invalidParams
905	} else {
906		return nil
907	}
908}
909
910func validateOpTagResourceInput(v *TagResourceInput) error {
911	if v == nil {
912		return nil
913	}
914	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
915	if v.ResourceArn == nil {
916		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
917	}
918	if v.Tags == nil {
919		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
920	} else if v.Tags != nil {
921		if err := validateTagList(v.Tags); err != nil {
922			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
923		}
924	}
925	if invalidParams.Len() > 0 {
926		return invalidParams
927	} else {
928		return nil
929	}
930}
931
932func validateOpUntagResourceInput(v *UntagResourceInput) error {
933	if v == nil {
934		return nil
935	}
936	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
937	if v.ResourceArn == nil {
938		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
939	}
940	if v.TagKeys == nil {
941		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
942	}
943	if invalidParams.Len() > 0 {
944		return invalidParams
945	} else {
946		return nil
947	}
948}
949
950func validateOpUpdateInferenceSchedulerInput(v *UpdateInferenceSchedulerInput) error {
951	if v == nil {
952		return nil
953	}
954	invalidParams := smithy.InvalidParamsError{Context: "UpdateInferenceSchedulerInput"}
955	if v.InferenceSchedulerName == nil {
956		invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName"))
957	}
958	if v.DataInputConfiguration != nil {
959		if err := validateInferenceInputConfiguration(v.DataInputConfiguration); err != nil {
960			invalidParams.AddNested("DataInputConfiguration", err.(smithy.InvalidParamsError))
961		}
962	}
963	if v.DataOutputConfiguration != nil {
964		if err := validateInferenceOutputConfiguration(v.DataOutputConfiguration); err != nil {
965			invalidParams.AddNested("DataOutputConfiguration", err.(smithy.InvalidParamsError))
966		}
967	}
968	if invalidParams.Len() > 0 {
969		return invalidParams
970	} else {
971		return nil
972	}
973}
974