1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package rekognition
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/rekognition/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCompareFaces struct {
14}
15
16func (*validateOpCompareFaces) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCompareFaces) 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.(*CompareFacesInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCompareFacesInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateCollection struct {
34}
35
36func (*validateOpCreateCollection) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateCollection) 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.(*CreateCollectionInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateCollectionInput(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 validateOpCreateProjectVersion struct {
74}
75
76func (*validateOpCreateProjectVersion) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateProjectVersion) 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.(*CreateProjectVersionInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateProjectVersionInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateStreamProcessor struct {
94}
95
96func (*validateOpCreateStreamProcessor) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateStreamProcessor) 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.(*CreateStreamProcessorInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateStreamProcessorInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeleteCollection struct {
114}
115
116func (*validateOpDeleteCollection) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeleteCollection) 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.(*DeleteCollectionInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeleteCollectionInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteFaces struct {
134}
135
136func (*validateOpDeleteFaces) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteFaces) 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.(*DeleteFacesInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteFacesInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteProject struct {
154}
155
156func (*validateOpDeleteProject) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteProject) 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.(*DeleteProjectInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteProjectInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteProjectVersion struct {
174}
175
176func (*validateOpDeleteProjectVersion) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteProjectVersion) 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.(*DeleteProjectVersionInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteProjectVersionInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteStreamProcessor struct {
194}
195
196func (*validateOpDeleteStreamProcessor) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteStreamProcessor) 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.(*DeleteStreamProcessorInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteStreamProcessorInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDescribeCollection struct {
214}
215
216func (*validateOpDescribeCollection) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDescribeCollection) 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.(*DescribeCollectionInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDescribeCollectionInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDescribeProjectVersions struct {
234}
235
236func (*validateOpDescribeProjectVersions) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDescribeProjectVersions) 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.(*DescribeProjectVersionsInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDescribeProjectVersionsInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDescribeStreamProcessor struct {
254}
255
256func (*validateOpDescribeStreamProcessor) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDescribeStreamProcessor) 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.(*DescribeStreamProcessorInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDescribeStreamProcessorInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDetectCustomLabels struct {
274}
275
276func (*validateOpDetectCustomLabels) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDetectCustomLabels) 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.(*DetectCustomLabelsInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDetectCustomLabelsInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDetectFaces struct {
294}
295
296func (*validateOpDetectFaces) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDetectFaces) 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.(*DetectFacesInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDetectFacesInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDetectLabels struct {
314}
315
316func (*validateOpDetectLabels) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDetectLabels) 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.(*DetectLabelsInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDetectLabelsInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDetectModerationLabels struct {
334}
335
336func (*validateOpDetectModerationLabels) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDetectModerationLabels) 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.(*DetectModerationLabelsInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDetectModerationLabelsInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDetectProtectiveEquipment struct {
354}
355
356func (*validateOpDetectProtectiveEquipment) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDetectProtectiveEquipment) 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.(*DetectProtectiveEquipmentInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDetectProtectiveEquipmentInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDetectText struct {
374}
375
376func (*validateOpDetectText) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDetectText) 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.(*DetectTextInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDetectTextInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpGetCelebrityInfo struct {
394}
395
396func (*validateOpGetCelebrityInfo) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpGetCelebrityInfo) 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.(*GetCelebrityInfoInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpGetCelebrityInfoInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpGetCelebrityRecognition struct {
414}
415
416func (*validateOpGetCelebrityRecognition) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpGetCelebrityRecognition) 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.(*GetCelebrityRecognitionInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpGetCelebrityRecognitionInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpGetContentModeration struct {
434}
435
436func (*validateOpGetContentModeration) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpGetContentModeration) 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.(*GetContentModerationInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpGetContentModerationInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpGetFaceDetection struct {
454}
455
456func (*validateOpGetFaceDetection) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpGetFaceDetection) 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.(*GetFaceDetectionInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpGetFaceDetectionInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpGetFaceSearch struct {
474}
475
476func (*validateOpGetFaceSearch) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpGetFaceSearch) 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.(*GetFaceSearchInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpGetFaceSearchInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpGetLabelDetection struct {
494}
495
496func (*validateOpGetLabelDetection) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpGetLabelDetection) 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.(*GetLabelDetectionInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpGetLabelDetectionInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpGetPersonTracking struct {
514}
515
516func (*validateOpGetPersonTracking) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpGetPersonTracking) 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.(*GetPersonTrackingInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpGetPersonTrackingInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpGetSegmentDetection struct {
534}
535
536func (*validateOpGetSegmentDetection) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpGetSegmentDetection) 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.(*GetSegmentDetectionInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpGetSegmentDetectionInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpGetTextDetection struct {
554}
555
556func (*validateOpGetTextDetection) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpGetTextDetection) 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.(*GetTextDetectionInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpGetTextDetectionInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpIndexFaces struct {
574}
575
576func (*validateOpIndexFaces) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpIndexFaces) 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.(*IndexFacesInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpIndexFacesInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpListFaces struct {
594}
595
596func (*validateOpListFaces) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpListFaces) 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.(*ListFacesInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpListFacesInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpListTagsForResource struct {
614}
615
616func (*validateOpListTagsForResource) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpListTagsForResourceInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpRecognizeCelebrities struct {
634}
635
636func (*validateOpRecognizeCelebrities) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpRecognizeCelebrities) 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.(*RecognizeCelebritiesInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpRecognizeCelebritiesInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpSearchFacesByImage struct {
654}
655
656func (*validateOpSearchFacesByImage) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpSearchFacesByImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
661	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
662) {
663	input, ok := in.Parameters.(*SearchFacesByImageInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpSearchFacesByImageInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpSearchFaces struct {
674}
675
676func (*validateOpSearchFaces) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpSearchFaces) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
681	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
682) {
683	input, ok := in.Parameters.(*SearchFacesInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpSearchFacesInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpStartCelebrityRecognition struct {
694}
695
696func (*validateOpStartCelebrityRecognition) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpStartCelebrityRecognition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
701	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
702) {
703	input, ok := in.Parameters.(*StartCelebrityRecognitionInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpStartCelebrityRecognitionInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpStartContentModeration struct {
714}
715
716func (*validateOpStartContentModeration) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpStartContentModeration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
721	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
722) {
723	input, ok := in.Parameters.(*StartContentModerationInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpStartContentModerationInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpStartFaceDetection struct {
734}
735
736func (*validateOpStartFaceDetection) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpStartFaceDetection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
741	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
742) {
743	input, ok := in.Parameters.(*StartFaceDetectionInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpStartFaceDetectionInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpStartFaceSearch struct {
754}
755
756func (*validateOpStartFaceSearch) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpStartFaceSearch) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
761	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
762) {
763	input, ok := in.Parameters.(*StartFaceSearchInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpStartFaceSearchInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpStartLabelDetection struct {
774}
775
776func (*validateOpStartLabelDetection) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpStartLabelDetection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
781	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
782) {
783	input, ok := in.Parameters.(*StartLabelDetectionInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpStartLabelDetectionInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpStartPersonTracking struct {
794}
795
796func (*validateOpStartPersonTracking) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpStartPersonTracking) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
802) {
803	input, ok := in.Parameters.(*StartPersonTrackingInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpStartPersonTrackingInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpStartProjectVersion struct {
814}
815
816func (*validateOpStartProjectVersion) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpStartProjectVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
822) {
823	input, ok := in.Parameters.(*StartProjectVersionInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpStartProjectVersionInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpStartSegmentDetection struct {
834}
835
836func (*validateOpStartSegmentDetection) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpStartSegmentDetection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
842) {
843	input, ok := in.Parameters.(*StartSegmentDetectionInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpStartSegmentDetectionInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpStartStreamProcessor struct {
854}
855
856func (*validateOpStartStreamProcessor) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpStartStreamProcessor) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
862) {
863	input, ok := in.Parameters.(*StartStreamProcessorInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpStartStreamProcessorInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpStartTextDetection struct {
874}
875
876func (*validateOpStartTextDetection) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpStartTextDetection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
882) {
883	input, ok := in.Parameters.(*StartTextDetectionInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpStartTextDetectionInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpStopProjectVersion struct {
894}
895
896func (*validateOpStopProjectVersion) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpStopProjectVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
902) {
903	input, ok := in.Parameters.(*StopProjectVersionInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpStopProjectVersionInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpStopStreamProcessor struct {
914}
915
916func (*validateOpStopStreamProcessor) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpStopStreamProcessor) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
922) {
923	input, ok := in.Parameters.(*StopStreamProcessorInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpStopStreamProcessorInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpTagResource struct {
934}
935
936func (*validateOpTagResource) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
942) {
943	input, ok := in.Parameters.(*TagResourceInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpTagResourceInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpUntagResource struct {
954}
955
956func (*validateOpUntagResource) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
962) {
963	input, ok := in.Parameters.(*UntagResourceInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpUntagResourceInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973func addOpCompareFacesValidationMiddleware(stack *middleware.Stack) error {
974	return stack.Initialize.Add(&validateOpCompareFaces{}, middleware.After)
975}
976
977func addOpCreateCollectionValidationMiddleware(stack *middleware.Stack) error {
978	return stack.Initialize.Add(&validateOpCreateCollection{}, middleware.After)
979}
980
981func addOpCreateProjectValidationMiddleware(stack *middleware.Stack) error {
982	return stack.Initialize.Add(&validateOpCreateProject{}, middleware.After)
983}
984
985func addOpCreateProjectVersionValidationMiddleware(stack *middleware.Stack) error {
986	return stack.Initialize.Add(&validateOpCreateProjectVersion{}, middleware.After)
987}
988
989func addOpCreateStreamProcessorValidationMiddleware(stack *middleware.Stack) error {
990	return stack.Initialize.Add(&validateOpCreateStreamProcessor{}, middleware.After)
991}
992
993func addOpDeleteCollectionValidationMiddleware(stack *middleware.Stack) error {
994	return stack.Initialize.Add(&validateOpDeleteCollection{}, middleware.After)
995}
996
997func addOpDeleteFacesValidationMiddleware(stack *middleware.Stack) error {
998	return stack.Initialize.Add(&validateOpDeleteFaces{}, middleware.After)
999}
1000
1001func addOpDeleteProjectValidationMiddleware(stack *middleware.Stack) error {
1002	return stack.Initialize.Add(&validateOpDeleteProject{}, middleware.After)
1003}
1004
1005func addOpDeleteProjectVersionValidationMiddleware(stack *middleware.Stack) error {
1006	return stack.Initialize.Add(&validateOpDeleteProjectVersion{}, middleware.After)
1007}
1008
1009func addOpDeleteStreamProcessorValidationMiddleware(stack *middleware.Stack) error {
1010	return stack.Initialize.Add(&validateOpDeleteStreamProcessor{}, middleware.After)
1011}
1012
1013func addOpDescribeCollectionValidationMiddleware(stack *middleware.Stack) error {
1014	return stack.Initialize.Add(&validateOpDescribeCollection{}, middleware.After)
1015}
1016
1017func addOpDescribeProjectVersionsValidationMiddleware(stack *middleware.Stack) error {
1018	return stack.Initialize.Add(&validateOpDescribeProjectVersions{}, middleware.After)
1019}
1020
1021func addOpDescribeStreamProcessorValidationMiddleware(stack *middleware.Stack) error {
1022	return stack.Initialize.Add(&validateOpDescribeStreamProcessor{}, middleware.After)
1023}
1024
1025func addOpDetectCustomLabelsValidationMiddleware(stack *middleware.Stack) error {
1026	return stack.Initialize.Add(&validateOpDetectCustomLabels{}, middleware.After)
1027}
1028
1029func addOpDetectFacesValidationMiddleware(stack *middleware.Stack) error {
1030	return stack.Initialize.Add(&validateOpDetectFaces{}, middleware.After)
1031}
1032
1033func addOpDetectLabelsValidationMiddleware(stack *middleware.Stack) error {
1034	return stack.Initialize.Add(&validateOpDetectLabels{}, middleware.After)
1035}
1036
1037func addOpDetectModerationLabelsValidationMiddleware(stack *middleware.Stack) error {
1038	return stack.Initialize.Add(&validateOpDetectModerationLabels{}, middleware.After)
1039}
1040
1041func addOpDetectProtectiveEquipmentValidationMiddleware(stack *middleware.Stack) error {
1042	return stack.Initialize.Add(&validateOpDetectProtectiveEquipment{}, middleware.After)
1043}
1044
1045func addOpDetectTextValidationMiddleware(stack *middleware.Stack) error {
1046	return stack.Initialize.Add(&validateOpDetectText{}, middleware.After)
1047}
1048
1049func addOpGetCelebrityInfoValidationMiddleware(stack *middleware.Stack) error {
1050	return stack.Initialize.Add(&validateOpGetCelebrityInfo{}, middleware.After)
1051}
1052
1053func addOpGetCelebrityRecognitionValidationMiddleware(stack *middleware.Stack) error {
1054	return stack.Initialize.Add(&validateOpGetCelebrityRecognition{}, middleware.After)
1055}
1056
1057func addOpGetContentModerationValidationMiddleware(stack *middleware.Stack) error {
1058	return stack.Initialize.Add(&validateOpGetContentModeration{}, middleware.After)
1059}
1060
1061func addOpGetFaceDetectionValidationMiddleware(stack *middleware.Stack) error {
1062	return stack.Initialize.Add(&validateOpGetFaceDetection{}, middleware.After)
1063}
1064
1065func addOpGetFaceSearchValidationMiddleware(stack *middleware.Stack) error {
1066	return stack.Initialize.Add(&validateOpGetFaceSearch{}, middleware.After)
1067}
1068
1069func addOpGetLabelDetectionValidationMiddleware(stack *middleware.Stack) error {
1070	return stack.Initialize.Add(&validateOpGetLabelDetection{}, middleware.After)
1071}
1072
1073func addOpGetPersonTrackingValidationMiddleware(stack *middleware.Stack) error {
1074	return stack.Initialize.Add(&validateOpGetPersonTracking{}, middleware.After)
1075}
1076
1077func addOpGetSegmentDetectionValidationMiddleware(stack *middleware.Stack) error {
1078	return stack.Initialize.Add(&validateOpGetSegmentDetection{}, middleware.After)
1079}
1080
1081func addOpGetTextDetectionValidationMiddleware(stack *middleware.Stack) error {
1082	return stack.Initialize.Add(&validateOpGetTextDetection{}, middleware.After)
1083}
1084
1085func addOpIndexFacesValidationMiddleware(stack *middleware.Stack) error {
1086	return stack.Initialize.Add(&validateOpIndexFaces{}, middleware.After)
1087}
1088
1089func addOpListFacesValidationMiddleware(stack *middleware.Stack) error {
1090	return stack.Initialize.Add(&validateOpListFaces{}, middleware.After)
1091}
1092
1093func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
1094	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
1095}
1096
1097func addOpRecognizeCelebritiesValidationMiddleware(stack *middleware.Stack) error {
1098	return stack.Initialize.Add(&validateOpRecognizeCelebrities{}, middleware.After)
1099}
1100
1101func addOpSearchFacesByImageValidationMiddleware(stack *middleware.Stack) error {
1102	return stack.Initialize.Add(&validateOpSearchFacesByImage{}, middleware.After)
1103}
1104
1105func addOpSearchFacesValidationMiddleware(stack *middleware.Stack) error {
1106	return stack.Initialize.Add(&validateOpSearchFaces{}, middleware.After)
1107}
1108
1109func addOpStartCelebrityRecognitionValidationMiddleware(stack *middleware.Stack) error {
1110	return stack.Initialize.Add(&validateOpStartCelebrityRecognition{}, middleware.After)
1111}
1112
1113func addOpStartContentModerationValidationMiddleware(stack *middleware.Stack) error {
1114	return stack.Initialize.Add(&validateOpStartContentModeration{}, middleware.After)
1115}
1116
1117func addOpStartFaceDetectionValidationMiddleware(stack *middleware.Stack) error {
1118	return stack.Initialize.Add(&validateOpStartFaceDetection{}, middleware.After)
1119}
1120
1121func addOpStartFaceSearchValidationMiddleware(stack *middleware.Stack) error {
1122	return stack.Initialize.Add(&validateOpStartFaceSearch{}, middleware.After)
1123}
1124
1125func addOpStartLabelDetectionValidationMiddleware(stack *middleware.Stack) error {
1126	return stack.Initialize.Add(&validateOpStartLabelDetection{}, middleware.After)
1127}
1128
1129func addOpStartPersonTrackingValidationMiddleware(stack *middleware.Stack) error {
1130	return stack.Initialize.Add(&validateOpStartPersonTracking{}, middleware.After)
1131}
1132
1133func addOpStartProjectVersionValidationMiddleware(stack *middleware.Stack) error {
1134	return stack.Initialize.Add(&validateOpStartProjectVersion{}, middleware.After)
1135}
1136
1137func addOpStartSegmentDetectionValidationMiddleware(stack *middleware.Stack) error {
1138	return stack.Initialize.Add(&validateOpStartSegmentDetection{}, middleware.After)
1139}
1140
1141func addOpStartStreamProcessorValidationMiddleware(stack *middleware.Stack) error {
1142	return stack.Initialize.Add(&validateOpStartStreamProcessor{}, middleware.After)
1143}
1144
1145func addOpStartTextDetectionValidationMiddleware(stack *middleware.Stack) error {
1146	return stack.Initialize.Add(&validateOpStartTextDetection{}, middleware.After)
1147}
1148
1149func addOpStopProjectVersionValidationMiddleware(stack *middleware.Stack) error {
1150	return stack.Initialize.Add(&validateOpStopProjectVersion{}, middleware.After)
1151}
1152
1153func addOpStopStreamProcessorValidationMiddleware(stack *middleware.Stack) error {
1154	return stack.Initialize.Add(&validateOpStopStreamProcessor{}, middleware.After)
1155}
1156
1157func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
1158	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
1159}
1160
1161func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
1162	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
1163}
1164
1165func validateHumanLoopConfig(v *types.HumanLoopConfig) error {
1166	if v == nil {
1167		return nil
1168	}
1169	invalidParams := smithy.InvalidParamsError{Context: "HumanLoopConfig"}
1170	if v.HumanLoopName == nil {
1171		invalidParams.Add(smithy.NewErrParamRequired("HumanLoopName"))
1172	}
1173	if v.FlowDefinitionArn == nil {
1174		invalidParams.Add(smithy.NewErrParamRequired("FlowDefinitionArn"))
1175	}
1176	if invalidParams.Len() > 0 {
1177		return invalidParams
1178	} else {
1179		return nil
1180	}
1181}
1182
1183func validateNotificationChannel(v *types.NotificationChannel) error {
1184	if v == nil {
1185		return nil
1186	}
1187	invalidParams := smithy.InvalidParamsError{Context: "NotificationChannel"}
1188	if v.SNSTopicArn == nil {
1189		invalidParams.Add(smithy.NewErrParamRequired("SNSTopicArn"))
1190	}
1191	if v.RoleArn == nil {
1192		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
1193	}
1194	if invalidParams.Len() > 0 {
1195		return invalidParams
1196	} else {
1197		return nil
1198	}
1199}
1200
1201func validateProtectiveEquipmentSummarizationAttributes(v *types.ProtectiveEquipmentSummarizationAttributes) error {
1202	if v == nil {
1203		return nil
1204	}
1205	invalidParams := smithy.InvalidParamsError{Context: "ProtectiveEquipmentSummarizationAttributes"}
1206	if v.MinConfidence == nil {
1207		invalidParams.Add(smithy.NewErrParamRequired("MinConfidence"))
1208	}
1209	if v.RequiredEquipmentTypes == nil {
1210		invalidParams.Add(smithy.NewErrParamRequired("RequiredEquipmentTypes"))
1211	}
1212	if invalidParams.Len() > 0 {
1213		return invalidParams
1214	} else {
1215		return nil
1216	}
1217}
1218
1219func validateOpCompareFacesInput(v *CompareFacesInput) error {
1220	if v == nil {
1221		return nil
1222	}
1223	invalidParams := smithy.InvalidParamsError{Context: "CompareFacesInput"}
1224	if v.SourceImage == nil {
1225		invalidParams.Add(smithy.NewErrParamRequired("SourceImage"))
1226	}
1227	if v.TargetImage == nil {
1228		invalidParams.Add(smithy.NewErrParamRequired("TargetImage"))
1229	}
1230	if invalidParams.Len() > 0 {
1231		return invalidParams
1232	} else {
1233		return nil
1234	}
1235}
1236
1237func validateOpCreateCollectionInput(v *CreateCollectionInput) error {
1238	if v == nil {
1239		return nil
1240	}
1241	invalidParams := smithy.InvalidParamsError{Context: "CreateCollectionInput"}
1242	if v.CollectionId == nil {
1243		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
1244	}
1245	if invalidParams.Len() > 0 {
1246		return invalidParams
1247	} else {
1248		return nil
1249	}
1250}
1251
1252func validateOpCreateProjectInput(v *CreateProjectInput) error {
1253	if v == nil {
1254		return nil
1255	}
1256	invalidParams := smithy.InvalidParamsError{Context: "CreateProjectInput"}
1257	if v.ProjectName == nil {
1258		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
1259	}
1260	if invalidParams.Len() > 0 {
1261		return invalidParams
1262	} else {
1263		return nil
1264	}
1265}
1266
1267func validateOpCreateProjectVersionInput(v *CreateProjectVersionInput) error {
1268	if v == nil {
1269		return nil
1270	}
1271	invalidParams := smithy.InvalidParamsError{Context: "CreateProjectVersionInput"}
1272	if v.ProjectArn == nil {
1273		invalidParams.Add(smithy.NewErrParamRequired("ProjectArn"))
1274	}
1275	if v.VersionName == nil {
1276		invalidParams.Add(smithy.NewErrParamRequired("VersionName"))
1277	}
1278	if v.OutputConfig == nil {
1279		invalidParams.Add(smithy.NewErrParamRequired("OutputConfig"))
1280	}
1281	if v.TrainingData == nil {
1282		invalidParams.Add(smithy.NewErrParamRequired("TrainingData"))
1283	}
1284	if v.TestingData == nil {
1285		invalidParams.Add(smithy.NewErrParamRequired("TestingData"))
1286	}
1287	if invalidParams.Len() > 0 {
1288		return invalidParams
1289	} else {
1290		return nil
1291	}
1292}
1293
1294func validateOpCreateStreamProcessorInput(v *CreateStreamProcessorInput) error {
1295	if v == nil {
1296		return nil
1297	}
1298	invalidParams := smithy.InvalidParamsError{Context: "CreateStreamProcessorInput"}
1299	if v.Input == nil {
1300		invalidParams.Add(smithy.NewErrParamRequired("Input"))
1301	}
1302	if v.Output == nil {
1303		invalidParams.Add(smithy.NewErrParamRequired("Output"))
1304	}
1305	if v.Name == nil {
1306		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1307	}
1308	if v.Settings == nil {
1309		invalidParams.Add(smithy.NewErrParamRequired("Settings"))
1310	}
1311	if v.RoleArn == nil {
1312		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
1313	}
1314	if invalidParams.Len() > 0 {
1315		return invalidParams
1316	} else {
1317		return nil
1318	}
1319}
1320
1321func validateOpDeleteCollectionInput(v *DeleteCollectionInput) error {
1322	if v == nil {
1323		return nil
1324	}
1325	invalidParams := smithy.InvalidParamsError{Context: "DeleteCollectionInput"}
1326	if v.CollectionId == nil {
1327		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
1328	}
1329	if invalidParams.Len() > 0 {
1330		return invalidParams
1331	} else {
1332		return nil
1333	}
1334}
1335
1336func validateOpDeleteFacesInput(v *DeleteFacesInput) error {
1337	if v == nil {
1338		return nil
1339	}
1340	invalidParams := smithy.InvalidParamsError{Context: "DeleteFacesInput"}
1341	if v.CollectionId == nil {
1342		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
1343	}
1344	if v.FaceIds == nil {
1345		invalidParams.Add(smithy.NewErrParamRequired("FaceIds"))
1346	}
1347	if invalidParams.Len() > 0 {
1348		return invalidParams
1349	} else {
1350		return nil
1351	}
1352}
1353
1354func validateOpDeleteProjectInput(v *DeleteProjectInput) error {
1355	if v == nil {
1356		return nil
1357	}
1358	invalidParams := smithy.InvalidParamsError{Context: "DeleteProjectInput"}
1359	if v.ProjectArn == nil {
1360		invalidParams.Add(smithy.NewErrParamRequired("ProjectArn"))
1361	}
1362	if invalidParams.Len() > 0 {
1363		return invalidParams
1364	} else {
1365		return nil
1366	}
1367}
1368
1369func validateOpDeleteProjectVersionInput(v *DeleteProjectVersionInput) error {
1370	if v == nil {
1371		return nil
1372	}
1373	invalidParams := smithy.InvalidParamsError{Context: "DeleteProjectVersionInput"}
1374	if v.ProjectVersionArn == nil {
1375		invalidParams.Add(smithy.NewErrParamRequired("ProjectVersionArn"))
1376	}
1377	if invalidParams.Len() > 0 {
1378		return invalidParams
1379	} else {
1380		return nil
1381	}
1382}
1383
1384func validateOpDeleteStreamProcessorInput(v *DeleteStreamProcessorInput) error {
1385	if v == nil {
1386		return nil
1387	}
1388	invalidParams := smithy.InvalidParamsError{Context: "DeleteStreamProcessorInput"}
1389	if v.Name == nil {
1390		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1391	}
1392	if invalidParams.Len() > 0 {
1393		return invalidParams
1394	} else {
1395		return nil
1396	}
1397}
1398
1399func validateOpDescribeCollectionInput(v *DescribeCollectionInput) error {
1400	if v == nil {
1401		return nil
1402	}
1403	invalidParams := smithy.InvalidParamsError{Context: "DescribeCollectionInput"}
1404	if v.CollectionId == nil {
1405		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
1406	}
1407	if invalidParams.Len() > 0 {
1408		return invalidParams
1409	} else {
1410		return nil
1411	}
1412}
1413
1414func validateOpDescribeProjectVersionsInput(v *DescribeProjectVersionsInput) error {
1415	if v == nil {
1416		return nil
1417	}
1418	invalidParams := smithy.InvalidParamsError{Context: "DescribeProjectVersionsInput"}
1419	if v.ProjectArn == nil {
1420		invalidParams.Add(smithy.NewErrParamRequired("ProjectArn"))
1421	}
1422	if invalidParams.Len() > 0 {
1423		return invalidParams
1424	} else {
1425		return nil
1426	}
1427}
1428
1429func validateOpDescribeStreamProcessorInput(v *DescribeStreamProcessorInput) error {
1430	if v == nil {
1431		return nil
1432	}
1433	invalidParams := smithy.InvalidParamsError{Context: "DescribeStreamProcessorInput"}
1434	if v.Name == nil {
1435		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1436	}
1437	if invalidParams.Len() > 0 {
1438		return invalidParams
1439	} else {
1440		return nil
1441	}
1442}
1443
1444func validateOpDetectCustomLabelsInput(v *DetectCustomLabelsInput) error {
1445	if v == nil {
1446		return nil
1447	}
1448	invalidParams := smithy.InvalidParamsError{Context: "DetectCustomLabelsInput"}
1449	if v.ProjectVersionArn == nil {
1450		invalidParams.Add(smithy.NewErrParamRequired("ProjectVersionArn"))
1451	}
1452	if v.Image == nil {
1453		invalidParams.Add(smithy.NewErrParamRequired("Image"))
1454	}
1455	if invalidParams.Len() > 0 {
1456		return invalidParams
1457	} else {
1458		return nil
1459	}
1460}
1461
1462func validateOpDetectFacesInput(v *DetectFacesInput) error {
1463	if v == nil {
1464		return nil
1465	}
1466	invalidParams := smithy.InvalidParamsError{Context: "DetectFacesInput"}
1467	if v.Image == nil {
1468		invalidParams.Add(smithy.NewErrParamRequired("Image"))
1469	}
1470	if invalidParams.Len() > 0 {
1471		return invalidParams
1472	} else {
1473		return nil
1474	}
1475}
1476
1477func validateOpDetectLabelsInput(v *DetectLabelsInput) error {
1478	if v == nil {
1479		return nil
1480	}
1481	invalidParams := smithy.InvalidParamsError{Context: "DetectLabelsInput"}
1482	if v.Image == nil {
1483		invalidParams.Add(smithy.NewErrParamRequired("Image"))
1484	}
1485	if invalidParams.Len() > 0 {
1486		return invalidParams
1487	} else {
1488		return nil
1489	}
1490}
1491
1492func validateOpDetectModerationLabelsInput(v *DetectModerationLabelsInput) error {
1493	if v == nil {
1494		return nil
1495	}
1496	invalidParams := smithy.InvalidParamsError{Context: "DetectModerationLabelsInput"}
1497	if v.Image == nil {
1498		invalidParams.Add(smithy.NewErrParamRequired("Image"))
1499	}
1500	if v.HumanLoopConfig != nil {
1501		if err := validateHumanLoopConfig(v.HumanLoopConfig); err != nil {
1502			invalidParams.AddNested("HumanLoopConfig", err.(smithy.InvalidParamsError))
1503		}
1504	}
1505	if invalidParams.Len() > 0 {
1506		return invalidParams
1507	} else {
1508		return nil
1509	}
1510}
1511
1512func validateOpDetectProtectiveEquipmentInput(v *DetectProtectiveEquipmentInput) error {
1513	if v == nil {
1514		return nil
1515	}
1516	invalidParams := smithy.InvalidParamsError{Context: "DetectProtectiveEquipmentInput"}
1517	if v.Image == nil {
1518		invalidParams.Add(smithy.NewErrParamRequired("Image"))
1519	}
1520	if v.SummarizationAttributes != nil {
1521		if err := validateProtectiveEquipmentSummarizationAttributes(v.SummarizationAttributes); err != nil {
1522			invalidParams.AddNested("SummarizationAttributes", err.(smithy.InvalidParamsError))
1523		}
1524	}
1525	if invalidParams.Len() > 0 {
1526		return invalidParams
1527	} else {
1528		return nil
1529	}
1530}
1531
1532func validateOpDetectTextInput(v *DetectTextInput) error {
1533	if v == nil {
1534		return nil
1535	}
1536	invalidParams := smithy.InvalidParamsError{Context: "DetectTextInput"}
1537	if v.Image == nil {
1538		invalidParams.Add(smithy.NewErrParamRequired("Image"))
1539	}
1540	if invalidParams.Len() > 0 {
1541		return invalidParams
1542	} else {
1543		return nil
1544	}
1545}
1546
1547func validateOpGetCelebrityInfoInput(v *GetCelebrityInfoInput) error {
1548	if v == nil {
1549		return nil
1550	}
1551	invalidParams := smithy.InvalidParamsError{Context: "GetCelebrityInfoInput"}
1552	if v.Id == nil {
1553		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1554	}
1555	if invalidParams.Len() > 0 {
1556		return invalidParams
1557	} else {
1558		return nil
1559	}
1560}
1561
1562func validateOpGetCelebrityRecognitionInput(v *GetCelebrityRecognitionInput) error {
1563	if v == nil {
1564		return nil
1565	}
1566	invalidParams := smithy.InvalidParamsError{Context: "GetCelebrityRecognitionInput"}
1567	if v.JobId == nil {
1568		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1569	}
1570	if invalidParams.Len() > 0 {
1571		return invalidParams
1572	} else {
1573		return nil
1574	}
1575}
1576
1577func validateOpGetContentModerationInput(v *GetContentModerationInput) error {
1578	if v == nil {
1579		return nil
1580	}
1581	invalidParams := smithy.InvalidParamsError{Context: "GetContentModerationInput"}
1582	if v.JobId == nil {
1583		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1584	}
1585	if invalidParams.Len() > 0 {
1586		return invalidParams
1587	} else {
1588		return nil
1589	}
1590}
1591
1592func validateOpGetFaceDetectionInput(v *GetFaceDetectionInput) error {
1593	if v == nil {
1594		return nil
1595	}
1596	invalidParams := smithy.InvalidParamsError{Context: "GetFaceDetectionInput"}
1597	if v.JobId == nil {
1598		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1599	}
1600	if invalidParams.Len() > 0 {
1601		return invalidParams
1602	} else {
1603		return nil
1604	}
1605}
1606
1607func validateOpGetFaceSearchInput(v *GetFaceSearchInput) error {
1608	if v == nil {
1609		return nil
1610	}
1611	invalidParams := smithy.InvalidParamsError{Context: "GetFaceSearchInput"}
1612	if v.JobId == nil {
1613		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1614	}
1615	if invalidParams.Len() > 0 {
1616		return invalidParams
1617	} else {
1618		return nil
1619	}
1620}
1621
1622func validateOpGetLabelDetectionInput(v *GetLabelDetectionInput) error {
1623	if v == nil {
1624		return nil
1625	}
1626	invalidParams := smithy.InvalidParamsError{Context: "GetLabelDetectionInput"}
1627	if v.JobId == nil {
1628		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1629	}
1630	if invalidParams.Len() > 0 {
1631		return invalidParams
1632	} else {
1633		return nil
1634	}
1635}
1636
1637func validateOpGetPersonTrackingInput(v *GetPersonTrackingInput) error {
1638	if v == nil {
1639		return nil
1640	}
1641	invalidParams := smithy.InvalidParamsError{Context: "GetPersonTrackingInput"}
1642	if v.JobId == nil {
1643		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1644	}
1645	if invalidParams.Len() > 0 {
1646		return invalidParams
1647	} else {
1648		return nil
1649	}
1650}
1651
1652func validateOpGetSegmentDetectionInput(v *GetSegmentDetectionInput) error {
1653	if v == nil {
1654		return nil
1655	}
1656	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentDetectionInput"}
1657	if v.JobId == nil {
1658		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1659	}
1660	if invalidParams.Len() > 0 {
1661		return invalidParams
1662	} else {
1663		return nil
1664	}
1665}
1666
1667func validateOpGetTextDetectionInput(v *GetTextDetectionInput) error {
1668	if v == nil {
1669		return nil
1670	}
1671	invalidParams := smithy.InvalidParamsError{Context: "GetTextDetectionInput"}
1672	if v.JobId == nil {
1673		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1674	}
1675	if invalidParams.Len() > 0 {
1676		return invalidParams
1677	} else {
1678		return nil
1679	}
1680}
1681
1682func validateOpIndexFacesInput(v *IndexFacesInput) error {
1683	if v == nil {
1684		return nil
1685	}
1686	invalidParams := smithy.InvalidParamsError{Context: "IndexFacesInput"}
1687	if v.CollectionId == nil {
1688		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
1689	}
1690	if v.Image == nil {
1691		invalidParams.Add(smithy.NewErrParamRequired("Image"))
1692	}
1693	if invalidParams.Len() > 0 {
1694		return invalidParams
1695	} else {
1696		return nil
1697	}
1698}
1699
1700func validateOpListFacesInput(v *ListFacesInput) error {
1701	if v == nil {
1702		return nil
1703	}
1704	invalidParams := smithy.InvalidParamsError{Context: "ListFacesInput"}
1705	if v.CollectionId == nil {
1706		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
1707	}
1708	if invalidParams.Len() > 0 {
1709		return invalidParams
1710	} else {
1711		return nil
1712	}
1713}
1714
1715func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1716	if v == nil {
1717		return nil
1718	}
1719	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1720	if v.ResourceArn == nil {
1721		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1722	}
1723	if invalidParams.Len() > 0 {
1724		return invalidParams
1725	} else {
1726		return nil
1727	}
1728}
1729
1730func validateOpRecognizeCelebritiesInput(v *RecognizeCelebritiesInput) error {
1731	if v == nil {
1732		return nil
1733	}
1734	invalidParams := smithy.InvalidParamsError{Context: "RecognizeCelebritiesInput"}
1735	if v.Image == nil {
1736		invalidParams.Add(smithy.NewErrParamRequired("Image"))
1737	}
1738	if invalidParams.Len() > 0 {
1739		return invalidParams
1740	} else {
1741		return nil
1742	}
1743}
1744
1745func validateOpSearchFacesByImageInput(v *SearchFacesByImageInput) error {
1746	if v == nil {
1747		return nil
1748	}
1749	invalidParams := smithy.InvalidParamsError{Context: "SearchFacesByImageInput"}
1750	if v.CollectionId == nil {
1751		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
1752	}
1753	if v.Image == nil {
1754		invalidParams.Add(smithy.NewErrParamRequired("Image"))
1755	}
1756	if invalidParams.Len() > 0 {
1757		return invalidParams
1758	} else {
1759		return nil
1760	}
1761}
1762
1763func validateOpSearchFacesInput(v *SearchFacesInput) error {
1764	if v == nil {
1765		return nil
1766	}
1767	invalidParams := smithy.InvalidParamsError{Context: "SearchFacesInput"}
1768	if v.CollectionId == nil {
1769		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
1770	}
1771	if v.FaceId == nil {
1772		invalidParams.Add(smithy.NewErrParamRequired("FaceId"))
1773	}
1774	if invalidParams.Len() > 0 {
1775		return invalidParams
1776	} else {
1777		return nil
1778	}
1779}
1780
1781func validateOpStartCelebrityRecognitionInput(v *StartCelebrityRecognitionInput) error {
1782	if v == nil {
1783		return nil
1784	}
1785	invalidParams := smithy.InvalidParamsError{Context: "StartCelebrityRecognitionInput"}
1786	if v.Video == nil {
1787		invalidParams.Add(smithy.NewErrParamRequired("Video"))
1788	}
1789	if v.NotificationChannel != nil {
1790		if err := validateNotificationChannel(v.NotificationChannel); err != nil {
1791			invalidParams.AddNested("NotificationChannel", err.(smithy.InvalidParamsError))
1792		}
1793	}
1794	if invalidParams.Len() > 0 {
1795		return invalidParams
1796	} else {
1797		return nil
1798	}
1799}
1800
1801func validateOpStartContentModerationInput(v *StartContentModerationInput) error {
1802	if v == nil {
1803		return nil
1804	}
1805	invalidParams := smithy.InvalidParamsError{Context: "StartContentModerationInput"}
1806	if v.Video == nil {
1807		invalidParams.Add(smithy.NewErrParamRequired("Video"))
1808	}
1809	if v.NotificationChannel != nil {
1810		if err := validateNotificationChannel(v.NotificationChannel); err != nil {
1811			invalidParams.AddNested("NotificationChannel", err.(smithy.InvalidParamsError))
1812		}
1813	}
1814	if invalidParams.Len() > 0 {
1815		return invalidParams
1816	} else {
1817		return nil
1818	}
1819}
1820
1821func validateOpStartFaceDetectionInput(v *StartFaceDetectionInput) error {
1822	if v == nil {
1823		return nil
1824	}
1825	invalidParams := smithy.InvalidParamsError{Context: "StartFaceDetectionInput"}
1826	if v.Video == nil {
1827		invalidParams.Add(smithy.NewErrParamRequired("Video"))
1828	}
1829	if v.NotificationChannel != nil {
1830		if err := validateNotificationChannel(v.NotificationChannel); err != nil {
1831			invalidParams.AddNested("NotificationChannel", err.(smithy.InvalidParamsError))
1832		}
1833	}
1834	if invalidParams.Len() > 0 {
1835		return invalidParams
1836	} else {
1837		return nil
1838	}
1839}
1840
1841func validateOpStartFaceSearchInput(v *StartFaceSearchInput) error {
1842	if v == nil {
1843		return nil
1844	}
1845	invalidParams := smithy.InvalidParamsError{Context: "StartFaceSearchInput"}
1846	if v.Video == nil {
1847		invalidParams.Add(smithy.NewErrParamRequired("Video"))
1848	}
1849	if v.CollectionId == nil {
1850		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
1851	}
1852	if v.NotificationChannel != nil {
1853		if err := validateNotificationChannel(v.NotificationChannel); err != nil {
1854			invalidParams.AddNested("NotificationChannel", err.(smithy.InvalidParamsError))
1855		}
1856	}
1857	if invalidParams.Len() > 0 {
1858		return invalidParams
1859	} else {
1860		return nil
1861	}
1862}
1863
1864func validateOpStartLabelDetectionInput(v *StartLabelDetectionInput) error {
1865	if v == nil {
1866		return nil
1867	}
1868	invalidParams := smithy.InvalidParamsError{Context: "StartLabelDetectionInput"}
1869	if v.Video == nil {
1870		invalidParams.Add(smithy.NewErrParamRequired("Video"))
1871	}
1872	if v.NotificationChannel != nil {
1873		if err := validateNotificationChannel(v.NotificationChannel); err != nil {
1874			invalidParams.AddNested("NotificationChannel", err.(smithy.InvalidParamsError))
1875		}
1876	}
1877	if invalidParams.Len() > 0 {
1878		return invalidParams
1879	} else {
1880		return nil
1881	}
1882}
1883
1884func validateOpStartPersonTrackingInput(v *StartPersonTrackingInput) error {
1885	if v == nil {
1886		return nil
1887	}
1888	invalidParams := smithy.InvalidParamsError{Context: "StartPersonTrackingInput"}
1889	if v.Video == nil {
1890		invalidParams.Add(smithy.NewErrParamRequired("Video"))
1891	}
1892	if v.NotificationChannel != nil {
1893		if err := validateNotificationChannel(v.NotificationChannel); err != nil {
1894			invalidParams.AddNested("NotificationChannel", err.(smithy.InvalidParamsError))
1895		}
1896	}
1897	if invalidParams.Len() > 0 {
1898		return invalidParams
1899	} else {
1900		return nil
1901	}
1902}
1903
1904func validateOpStartProjectVersionInput(v *StartProjectVersionInput) error {
1905	if v == nil {
1906		return nil
1907	}
1908	invalidParams := smithy.InvalidParamsError{Context: "StartProjectVersionInput"}
1909	if v.ProjectVersionArn == nil {
1910		invalidParams.Add(smithy.NewErrParamRequired("ProjectVersionArn"))
1911	}
1912	if v.MinInferenceUnits == nil {
1913		invalidParams.Add(smithy.NewErrParamRequired("MinInferenceUnits"))
1914	}
1915	if invalidParams.Len() > 0 {
1916		return invalidParams
1917	} else {
1918		return nil
1919	}
1920}
1921
1922func validateOpStartSegmentDetectionInput(v *StartSegmentDetectionInput) error {
1923	if v == nil {
1924		return nil
1925	}
1926	invalidParams := smithy.InvalidParamsError{Context: "StartSegmentDetectionInput"}
1927	if v.Video == nil {
1928		invalidParams.Add(smithy.NewErrParamRequired("Video"))
1929	}
1930	if v.NotificationChannel != nil {
1931		if err := validateNotificationChannel(v.NotificationChannel); err != nil {
1932			invalidParams.AddNested("NotificationChannel", err.(smithy.InvalidParamsError))
1933		}
1934	}
1935	if v.SegmentTypes == nil {
1936		invalidParams.Add(smithy.NewErrParamRequired("SegmentTypes"))
1937	}
1938	if invalidParams.Len() > 0 {
1939		return invalidParams
1940	} else {
1941		return nil
1942	}
1943}
1944
1945func validateOpStartStreamProcessorInput(v *StartStreamProcessorInput) error {
1946	if v == nil {
1947		return nil
1948	}
1949	invalidParams := smithy.InvalidParamsError{Context: "StartStreamProcessorInput"}
1950	if v.Name == nil {
1951		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1952	}
1953	if invalidParams.Len() > 0 {
1954		return invalidParams
1955	} else {
1956		return nil
1957	}
1958}
1959
1960func validateOpStartTextDetectionInput(v *StartTextDetectionInput) error {
1961	if v == nil {
1962		return nil
1963	}
1964	invalidParams := smithy.InvalidParamsError{Context: "StartTextDetectionInput"}
1965	if v.Video == nil {
1966		invalidParams.Add(smithy.NewErrParamRequired("Video"))
1967	}
1968	if v.NotificationChannel != nil {
1969		if err := validateNotificationChannel(v.NotificationChannel); err != nil {
1970			invalidParams.AddNested("NotificationChannel", err.(smithy.InvalidParamsError))
1971		}
1972	}
1973	if invalidParams.Len() > 0 {
1974		return invalidParams
1975	} else {
1976		return nil
1977	}
1978}
1979
1980func validateOpStopProjectVersionInput(v *StopProjectVersionInput) error {
1981	if v == nil {
1982		return nil
1983	}
1984	invalidParams := smithy.InvalidParamsError{Context: "StopProjectVersionInput"}
1985	if v.ProjectVersionArn == nil {
1986		invalidParams.Add(smithy.NewErrParamRequired("ProjectVersionArn"))
1987	}
1988	if invalidParams.Len() > 0 {
1989		return invalidParams
1990	} else {
1991		return nil
1992	}
1993}
1994
1995func validateOpStopStreamProcessorInput(v *StopStreamProcessorInput) error {
1996	if v == nil {
1997		return nil
1998	}
1999	invalidParams := smithy.InvalidParamsError{Context: "StopStreamProcessorInput"}
2000	if v.Name == nil {
2001		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2002	}
2003	if invalidParams.Len() > 0 {
2004		return invalidParams
2005	} else {
2006		return nil
2007	}
2008}
2009
2010func validateOpTagResourceInput(v *TagResourceInput) error {
2011	if v == nil {
2012		return nil
2013	}
2014	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
2015	if v.ResourceArn == nil {
2016		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2017	}
2018	if v.Tags == nil {
2019		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
2020	}
2021	if invalidParams.Len() > 0 {
2022		return invalidParams
2023	} else {
2024		return nil
2025	}
2026}
2027
2028func validateOpUntagResourceInput(v *UntagResourceInput) error {
2029	if v == nil {
2030		return nil
2031	}
2032	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
2033	if v.ResourceArn == nil {
2034		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2035	}
2036	if v.TagKeys == nil {
2037		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
2038	}
2039	if invalidParams.Len() > 0 {
2040		return invalidParams
2041	} else {
2042		return nil
2043	}
2044}
2045