1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package lookoutvision
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/lookoutvision/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 validateOpCreateModel struct {
34}
35
36func (*validateOpCreateModel) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateModel) 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.(*CreateModelInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateModelInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateProject struct {
54}
55
56func (*validateOpCreateProject) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateProject) 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.(*CreateProjectInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateProjectInput(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 validateOpDeleteModel struct {
94}
95
96func (*validateOpDeleteModel) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDeleteModel) 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.(*DeleteModelInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDeleteModelInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeleteProject struct {
114}
115
116func (*validateOpDeleteProject) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeleteProject) 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.(*DeleteProjectInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeleteProjectInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDescribeDataset struct {
134}
135
136func (*validateOpDescribeDataset) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDescribeDataset) 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.(*DescribeDatasetInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDescribeDatasetInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDescribeModel struct {
154}
155
156func (*validateOpDescribeModel) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDescribeModel) 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.(*DescribeModelInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDescribeModelInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDescribeProject struct {
174}
175
176func (*validateOpDescribeProject) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDescribeProject) 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.(*DescribeProjectInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDescribeProjectInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDetectAnomalies struct {
194}
195
196func (*validateOpDetectAnomalies) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDetectAnomalies) 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.(*DetectAnomaliesInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDetectAnomaliesInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpListDatasetEntries struct {
214}
215
216func (*validateOpListDatasetEntries) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpListDatasetEntries) 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.(*ListDatasetEntriesInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpListDatasetEntriesInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpListModels struct {
234}
235
236func (*validateOpListModels) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpListModels) 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.(*ListModelsInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpListModelsInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpListTagsForResource struct {
254}
255
256func (*validateOpListTagsForResource) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpListTagsForResourceInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpStartModel struct {
274}
275
276func (*validateOpStartModel) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpStartModel) 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.(*StartModelInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpStartModelInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpStopModel struct {
294}
295
296func (*validateOpStopModel) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpStopModel) 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.(*StopModelInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpStopModelInput(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 validateOpUpdateDatasetEntries struct {
354}
355
356func (*validateOpUpdateDatasetEntries) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpUpdateDatasetEntries) 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.(*UpdateDatasetEntriesInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpUpdateDatasetEntriesInput(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 addOpCreateModelValidationMiddleware(stack *middleware.Stack) error {
378	return stack.Initialize.Add(&validateOpCreateModel{}, middleware.After)
379}
380
381func addOpCreateProjectValidationMiddleware(stack *middleware.Stack) error {
382	return stack.Initialize.Add(&validateOpCreateProject{}, middleware.After)
383}
384
385func addOpDeleteDatasetValidationMiddleware(stack *middleware.Stack) error {
386	return stack.Initialize.Add(&validateOpDeleteDataset{}, middleware.After)
387}
388
389func addOpDeleteModelValidationMiddleware(stack *middleware.Stack) error {
390	return stack.Initialize.Add(&validateOpDeleteModel{}, middleware.After)
391}
392
393func addOpDeleteProjectValidationMiddleware(stack *middleware.Stack) error {
394	return stack.Initialize.Add(&validateOpDeleteProject{}, middleware.After)
395}
396
397func addOpDescribeDatasetValidationMiddleware(stack *middleware.Stack) error {
398	return stack.Initialize.Add(&validateOpDescribeDataset{}, middleware.After)
399}
400
401func addOpDescribeModelValidationMiddleware(stack *middleware.Stack) error {
402	return stack.Initialize.Add(&validateOpDescribeModel{}, middleware.After)
403}
404
405func addOpDescribeProjectValidationMiddleware(stack *middleware.Stack) error {
406	return stack.Initialize.Add(&validateOpDescribeProject{}, middleware.After)
407}
408
409func addOpDetectAnomaliesValidationMiddleware(stack *middleware.Stack) error {
410	return stack.Initialize.Add(&validateOpDetectAnomalies{}, middleware.After)
411}
412
413func addOpListDatasetEntriesValidationMiddleware(stack *middleware.Stack) error {
414	return stack.Initialize.Add(&validateOpListDatasetEntries{}, middleware.After)
415}
416
417func addOpListModelsValidationMiddleware(stack *middleware.Stack) error {
418	return stack.Initialize.Add(&validateOpListModels{}, middleware.After)
419}
420
421func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
422	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
423}
424
425func addOpStartModelValidationMiddleware(stack *middleware.Stack) error {
426	return stack.Initialize.Add(&validateOpStartModel{}, middleware.After)
427}
428
429func addOpStopModelValidationMiddleware(stack *middleware.Stack) error {
430	return stack.Initialize.Add(&validateOpStopModel{}, 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 addOpUpdateDatasetEntriesValidationMiddleware(stack *middleware.Stack) error {
442	return stack.Initialize.Add(&validateOpUpdateDatasetEntries{}, middleware.After)
443}
444
445func validateDatasetGroundTruthManifest(v *types.DatasetGroundTruthManifest) error {
446	if v == nil {
447		return nil
448	}
449	invalidParams := smithy.InvalidParamsError{Context: "DatasetGroundTruthManifest"}
450	if v.S3Object != nil {
451		if err := validateInputS3Object(v.S3Object); err != nil {
452			invalidParams.AddNested("S3Object", err.(smithy.InvalidParamsError))
453		}
454	}
455	if invalidParams.Len() > 0 {
456		return invalidParams
457	} else {
458		return nil
459	}
460}
461
462func validateDatasetSource(v *types.DatasetSource) error {
463	if v == nil {
464		return nil
465	}
466	invalidParams := smithy.InvalidParamsError{Context: "DatasetSource"}
467	if v.GroundTruthManifest != nil {
468		if err := validateDatasetGroundTruthManifest(v.GroundTruthManifest); err != nil {
469			invalidParams.AddNested("GroundTruthManifest", err.(smithy.InvalidParamsError))
470		}
471	}
472	if invalidParams.Len() > 0 {
473		return invalidParams
474	} else {
475		return nil
476	}
477}
478
479func validateInputS3Object(v *types.InputS3Object) error {
480	if v == nil {
481		return nil
482	}
483	invalidParams := smithy.InvalidParamsError{Context: "InputS3Object"}
484	if v.Bucket == nil {
485		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
486	}
487	if v.Key == nil {
488		invalidParams.Add(smithy.NewErrParamRequired("Key"))
489	}
490	if invalidParams.Len() > 0 {
491		return invalidParams
492	} else {
493		return nil
494	}
495}
496
497func validateOutputConfig(v *types.OutputConfig) error {
498	if v == nil {
499		return nil
500	}
501	invalidParams := smithy.InvalidParamsError{Context: "OutputConfig"}
502	if v.S3Location == nil {
503		invalidParams.Add(smithy.NewErrParamRequired("S3Location"))
504	} else if v.S3Location != nil {
505		if err := validateS3Location(v.S3Location); err != nil {
506			invalidParams.AddNested("S3Location", err.(smithy.InvalidParamsError))
507		}
508	}
509	if invalidParams.Len() > 0 {
510		return invalidParams
511	} else {
512		return nil
513	}
514}
515
516func validateS3Location(v *types.S3Location) error {
517	if v == nil {
518		return nil
519	}
520	invalidParams := smithy.InvalidParamsError{Context: "S3Location"}
521	if v.Bucket == nil {
522		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
523	}
524	if invalidParams.Len() > 0 {
525		return invalidParams
526	} else {
527		return nil
528	}
529}
530
531func validateTag(v *types.Tag) error {
532	if v == nil {
533		return nil
534	}
535	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
536	if v.Key == nil {
537		invalidParams.Add(smithy.NewErrParamRequired("Key"))
538	}
539	if v.Value == nil {
540		invalidParams.Add(smithy.NewErrParamRequired("Value"))
541	}
542	if invalidParams.Len() > 0 {
543		return invalidParams
544	} else {
545		return nil
546	}
547}
548
549func validateTagList(v []types.Tag) error {
550	if v == nil {
551		return nil
552	}
553	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
554	for i := range v {
555		if err := validateTag(&v[i]); err != nil {
556			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
557		}
558	}
559	if invalidParams.Len() > 0 {
560		return invalidParams
561	} else {
562		return nil
563	}
564}
565
566func validateOpCreateDatasetInput(v *CreateDatasetInput) error {
567	if v == nil {
568		return nil
569	}
570	invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetInput"}
571	if v.ProjectName == nil {
572		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
573	}
574	if v.DatasetType == nil {
575		invalidParams.Add(smithy.NewErrParamRequired("DatasetType"))
576	}
577	if v.DatasetSource != nil {
578		if err := validateDatasetSource(v.DatasetSource); err != nil {
579			invalidParams.AddNested("DatasetSource", err.(smithy.InvalidParamsError))
580		}
581	}
582	if invalidParams.Len() > 0 {
583		return invalidParams
584	} else {
585		return nil
586	}
587}
588
589func validateOpCreateModelInput(v *CreateModelInput) error {
590	if v == nil {
591		return nil
592	}
593	invalidParams := smithy.InvalidParamsError{Context: "CreateModelInput"}
594	if v.ProjectName == nil {
595		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
596	}
597	if v.OutputConfig == nil {
598		invalidParams.Add(smithy.NewErrParamRequired("OutputConfig"))
599	} else if v.OutputConfig != nil {
600		if err := validateOutputConfig(v.OutputConfig); err != nil {
601			invalidParams.AddNested("OutputConfig", err.(smithy.InvalidParamsError))
602		}
603	}
604	if v.Tags != nil {
605		if err := validateTagList(v.Tags); err != nil {
606			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
607		}
608	}
609	if invalidParams.Len() > 0 {
610		return invalidParams
611	} else {
612		return nil
613	}
614}
615
616func validateOpCreateProjectInput(v *CreateProjectInput) error {
617	if v == nil {
618		return nil
619	}
620	invalidParams := smithy.InvalidParamsError{Context: "CreateProjectInput"}
621	if v.ProjectName == nil {
622		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
623	}
624	if invalidParams.Len() > 0 {
625		return invalidParams
626	} else {
627		return nil
628	}
629}
630
631func validateOpDeleteDatasetInput(v *DeleteDatasetInput) error {
632	if v == nil {
633		return nil
634	}
635	invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetInput"}
636	if v.ProjectName == nil {
637		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
638	}
639	if v.DatasetType == nil {
640		invalidParams.Add(smithy.NewErrParamRequired("DatasetType"))
641	}
642	if invalidParams.Len() > 0 {
643		return invalidParams
644	} else {
645		return nil
646	}
647}
648
649func validateOpDeleteModelInput(v *DeleteModelInput) error {
650	if v == nil {
651		return nil
652	}
653	invalidParams := smithy.InvalidParamsError{Context: "DeleteModelInput"}
654	if v.ProjectName == nil {
655		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
656	}
657	if v.ModelVersion == nil {
658		invalidParams.Add(smithy.NewErrParamRequired("ModelVersion"))
659	}
660	if invalidParams.Len() > 0 {
661		return invalidParams
662	} else {
663		return nil
664	}
665}
666
667func validateOpDeleteProjectInput(v *DeleteProjectInput) error {
668	if v == nil {
669		return nil
670	}
671	invalidParams := smithy.InvalidParamsError{Context: "DeleteProjectInput"}
672	if v.ProjectName == nil {
673		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
674	}
675	if invalidParams.Len() > 0 {
676		return invalidParams
677	} else {
678		return nil
679	}
680}
681
682func validateOpDescribeDatasetInput(v *DescribeDatasetInput) error {
683	if v == nil {
684		return nil
685	}
686	invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetInput"}
687	if v.ProjectName == nil {
688		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
689	}
690	if v.DatasetType == nil {
691		invalidParams.Add(smithy.NewErrParamRequired("DatasetType"))
692	}
693	if invalidParams.Len() > 0 {
694		return invalidParams
695	} else {
696		return nil
697	}
698}
699
700func validateOpDescribeModelInput(v *DescribeModelInput) error {
701	if v == nil {
702		return nil
703	}
704	invalidParams := smithy.InvalidParamsError{Context: "DescribeModelInput"}
705	if v.ProjectName == nil {
706		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
707	}
708	if v.ModelVersion == nil {
709		invalidParams.Add(smithy.NewErrParamRequired("ModelVersion"))
710	}
711	if invalidParams.Len() > 0 {
712		return invalidParams
713	} else {
714		return nil
715	}
716}
717
718func validateOpDescribeProjectInput(v *DescribeProjectInput) error {
719	if v == nil {
720		return nil
721	}
722	invalidParams := smithy.InvalidParamsError{Context: "DescribeProjectInput"}
723	if v.ProjectName == nil {
724		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
725	}
726	if invalidParams.Len() > 0 {
727		return invalidParams
728	} else {
729		return nil
730	}
731}
732
733func validateOpDetectAnomaliesInput(v *DetectAnomaliesInput) error {
734	if v == nil {
735		return nil
736	}
737	invalidParams := smithy.InvalidParamsError{Context: "DetectAnomaliesInput"}
738	if v.ProjectName == nil {
739		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
740	}
741	if v.ModelVersion == nil {
742		invalidParams.Add(smithy.NewErrParamRequired("ModelVersion"))
743	}
744	if v.Body == nil {
745		invalidParams.Add(smithy.NewErrParamRequired("Body"))
746	}
747	if v.ContentType == nil {
748		invalidParams.Add(smithy.NewErrParamRequired("ContentType"))
749	}
750	if invalidParams.Len() > 0 {
751		return invalidParams
752	} else {
753		return nil
754	}
755}
756
757func validateOpListDatasetEntriesInput(v *ListDatasetEntriesInput) error {
758	if v == nil {
759		return nil
760	}
761	invalidParams := smithy.InvalidParamsError{Context: "ListDatasetEntriesInput"}
762	if v.ProjectName == nil {
763		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
764	}
765	if v.DatasetType == nil {
766		invalidParams.Add(smithy.NewErrParamRequired("DatasetType"))
767	}
768	if invalidParams.Len() > 0 {
769		return invalidParams
770	} else {
771		return nil
772	}
773}
774
775func validateOpListModelsInput(v *ListModelsInput) error {
776	if v == nil {
777		return nil
778	}
779	invalidParams := smithy.InvalidParamsError{Context: "ListModelsInput"}
780	if v.ProjectName == nil {
781		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
782	}
783	if invalidParams.Len() > 0 {
784		return invalidParams
785	} else {
786		return nil
787	}
788}
789
790func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
791	if v == nil {
792		return nil
793	}
794	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
795	if v.ResourceArn == nil {
796		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
797	}
798	if invalidParams.Len() > 0 {
799		return invalidParams
800	} else {
801		return nil
802	}
803}
804
805func validateOpStartModelInput(v *StartModelInput) error {
806	if v == nil {
807		return nil
808	}
809	invalidParams := smithy.InvalidParamsError{Context: "StartModelInput"}
810	if v.ProjectName == nil {
811		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
812	}
813	if v.ModelVersion == nil {
814		invalidParams.Add(smithy.NewErrParamRequired("ModelVersion"))
815	}
816	if v.MinInferenceUnits == nil {
817		invalidParams.Add(smithy.NewErrParamRequired("MinInferenceUnits"))
818	}
819	if invalidParams.Len() > 0 {
820		return invalidParams
821	} else {
822		return nil
823	}
824}
825
826func validateOpStopModelInput(v *StopModelInput) error {
827	if v == nil {
828		return nil
829	}
830	invalidParams := smithy.InvalidParamsError{Context: "StopModelInput"}
831	if v.ProjectName == nil {
832		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
833	}
834	if v.ModelVersion == nil {
835		invalidParams.Add(smithy.NewErrParamRequired("ModelVersion"))
836	}
837	if invalidParams.Len() > 0 {
838		return invalidParams
839	} else {
840		return nil
841	}
842}
843
844func validateOpTagResourceInput(v *TagResourceInput) error {
845	if v == nil {
846		return nil
847	}
848	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
849	if v.ResourceArn == nil {
850		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
851	}
852	if v.Tags == nil {
853		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
854	} else if v.Tags != nil {
855		if err := validateTagList(v.Tags); err != nil {
856			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
857		}
858	}
859	if invalidParams.Len() > 0 {
860		return invalidParams
861	} else {
862		return nil
863	}
864}
865
866func validateOpUntagResourceInput(v *UntagResourceInput) error {
867	if v == nil {
868		return nil
869	}
870	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
871	if v.ResourceArn == nil {
872		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
873	}
874	if v.TagKeys == nil {
875		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
876	}
877	if invalidParams.Len() > 0 {
878		return invalidParams
879	} else {
880		return nil
881	}
882}
883
884func validateOpUpdateDatasetEntriesInput(v *UpdateDatasetEntriesInput) error {
885	if v == nil {
886		return nil
887	}
888	invalidParams := smithy.InvalidParamsError{Context: "UpdateDatasetEntriesInput"}
889	if v.ProjectName == nil {
890		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
891	}
892	if v.DatasetType == nil {
893		invalidParams.Add(smithy.NewErrParamRequired("DatasetType"))
894	}
895	if v.Changes == nil {
896		invalidParams.Add(smithy.NewErrParamRequired("Changes"))
897	}
898	if invalidParams.Len() > 0 {
899		return invalidParams
900	} else {
901		return nil
902	}
903}
904