1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package schemas
4
5import (
6	"context"
7	"fmt"
8	smithy "github.com/aws/smithy-go"
9	"github.com/aws/smithy-go/middleware"
10)
11
12type validateOpCreateDiscoverer struct {
13}
14
15func (*validateOpCreateDiscoverer) ID() string {
16	return "OperationInputValidation"
17}
18
19func (m *validateOpCreateDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
20	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
21) {
22	input, ok := in.Parameters.(*CreateDiscovererInput)
23	if !ok {
24		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
25	}
26	if err := validateOpCreateDiscovererInput(input); err != nil {
27		return out, metadata, err
28	}
29	return next.HandleInitialize(ctx, in)
30}
31
32type validateOpCreateRegistry struct {
33}
34
35func (*validateOpCreateRegistry) ID() string {
36	return "OperationInputValidation"
37}
38
39func (m *validateOpCreateRegistry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
40	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
41) {
42	input, ok := in.Parameters.(*CreateRegistryInput)
43	if !ok {
44		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
45	}
46	if err := validateOpCreateRegistryInput(input); err != nil {
47		return out, metadata, err
48	}
49	return next.HandleInitialize(ctx, in)
50}
51
52type validateOpCreateSchema struct {
53}
54
55func (*validateOpCreateSchema) ID() string {
56	return "OperationInputValidation"
57}
58
59func (m *validateOpCreateSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
60	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
61) {
62	input, ok := in.Parameters.(*CreateSchemaInput)
63	if !ok {
64		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
65	}
66	if err := validateOpCreateSchemaInput(input); err != nil {
67		return out, metadata, err
68	}
69	return next.HandleInitialize(ctx, in)
70}
71
72type validateOpDeleteDiscoverer struct {
73}
74
75func (*validateOpDeleteDiscoverer) ID() string {
76	return "OperationInputValidation"
77}
78
79func (m *validateOpDeleteDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
80	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
81) {
82	input, ok := in.Parameters.(*DeleteDiscovererInput)
83	if !ok {
84		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
85	}
86	if err := validateOpDeleteDiscovererInput(input); err != nil {
87		return out, metadata, err
88	}
89	return next.HandleInitialize(ctx, in)
90}
91
92type validateOpDeleteRegistry struct {
93}
94
95func (*validateOpDeleteRegistry) ID() string {
96	return "OperationInputValidation"
97}
98
99func (m *validateOpDeleteRegistry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
100	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
101) {
102	input, ok := in.Parameters.(*DeleteRegistryInput)
103	if !ok {
104		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
105	}
106	if err := validateOpDeleteRegistryInput(input); err != nil {
107		return out, metadata, err
108	}
109	return next.HandleInitialize(ctx, in)
110}
111
112type validateOpDeleteSchema struct {
113}
114
115func (*validateOpDeleteSchema) ID() string {
116	return "OperationInputValidation"
117}
118
119func (m *validateOpDeleteSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
120	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
121) {
122	input, ok := in.Parameters.(*DeleteSchemaInput)
123	if !ok {
124		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
125	}
126	if err := validateOpDeleteSchemaInput(input); err != nil {
127		return out, metadata, err
128	}
129	return next.HandleInitialize(ctx, in)
130}
131
132type validateOpDeleteSchemaVersion struct {
133}
134
135func (*validateOpDeleteSchemaVersion) ID() string {
136	return "OperationInputValidation"
137}
138
139func (m *validateOpDeleteSchemaVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
140	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
141) {
142	input, ok := in.Parameters.(*DeleteSchemaVersionInput)
143	if !ok {
144		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
145	}
146	if err := validateOpDeleteSchemaVersionInput(input); err != nil {
147		return out, metadata, err
148	}
149	return next.HandleInitialize(ctx, in)
150}
151
152type validateOpDescribeCodeBinding struct {
153}
154
155func (*validateOpDescribeCodeBinding) ID() string {
156	return "OperationInputValidation"
157}
158
159func (m *validateOpDescribeCodeBinding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
160	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
161) {
162	input, ok := in.Parameters.(*DescribeCodeBindingInput)
163	if !ok {
164		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
165	}
166	if err := validateOpDescribeCodeBindingInput(input); err != nil {
167		return out, metadata, err
168	}
169	return next.HandleInitialize(ctx, in)
170}
171
172type validateOpDescribeDiscoverer struct {
173}
174
175func (*validateOpDescribeDiscoverer) ID() string {
176	return "OperationInputValidation"
177}
178
179func (m *validateOpDescribeDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
180	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
181) {
182	input, ok := in.Parameters.(*DescribeDiscovererInput)
183	if !ok {
184		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
185	}
186	if err := validateOpDescribeDiscovererInput(input); err != nil {
187		return out, metadata, err
188	}
189	return next.HandleInitialize(ctx, in)
190}
191
192type validateOpDescribeRegistry struct {
193}
194
195func (*validateOpDescribeRegistry) ID() string {
196	return "OperationInputValidation"
197}
198
199func (m *validateOpDescribeRegistry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
200	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
201) {
202	input, ok := in.Parameters.(*DescribeRegistryInput)
203	if !ok {
204		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
205	}
206	if err := validateOpDescribeRegistryInput(input); err != nil {
207		return out, metadata, err
208	}
209	return next.HandleInitialize(ctx, in)
210}
211
212type validateOpDescribeSchema struct {
213}
214
215func (*validateOpDescribeSchema) ID() string {
216	return "OperationInputValidation"
217}
218
219func (m *validateOpDescribeSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
220	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
221) {
222	input, ok := in.Parameters.(*DescribeSchemaInput)
223	if !ok {
224		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
225	}
226	if err := validateOpDescribeSchemaInput(input); err != nil {
227		return out, metadata, err
228	}
229	return next.HandleInitialize(ctx, in)
230}
231
232type validateOpExportSchema struct {
233}
234
235func (*validateOpExportSchema) ID() string {
236	return "OperationInputValidation"
237}
238
239func (m *validateOpExportSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
240	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
241) {
242	input, ok := in.Parameters.(*ExportSchemaInput)
243	if !ok {
244		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
245	}
246	if err := validateOpExportSchemaInput(input); err != nil {
247		return out, metadata, err
248	}
249	return next.HandleInitialize(ctx, in)
250}
251
252type validateOpGetCodeBindingSource struct {
253}
254
255func (*validateOpGetCodeBindingSource) ID() string {
256	return "OperationInputValidation"
257}
258
259func (m *validateOpGetCodeBindingSource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
260	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
261) {
262	input, ok := in.Parameters.(*GetCodeBindingSourceInput)
263	if !ok {
264		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
265	}
266	if err := validateOpGetCodeBindingSourceInput(input); err != nil {
267		return out, metadata, err
268	}
269	return next.HandleInitialize(ctx, in)
270}
271
272type validateOpGetDiscoveredSchema struct {
273}
274
275func (*validateOpGetDiscoveredSchema) ID() string {
276	return "OperationInputValidation"
277}
278
279func (m *validateOpGetDiscoveredSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
280	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
281) {
282	input, ok := in.Parameters.(*GetDiscoveredSchemaInput)
283	if !ok {
284		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
285	}
286	if err := validateOpGetDiscoveredSchemaInput(input); err != nil {
287		return out, metadata, err
288	}
289	return next.HandleInitialize(ctx, in)
290}
291
292type validateOpListSchemas struct {
293}
294
295func (*validateOpListSchemas) ID() string {
296	return "OperationInputValidation"
297}
298
299func (m *validateOpListSchemas) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
300	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
301) {
302	input, ok := in.Parameters.(*ListSchemasInput)
303	if !ok {
304		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
305	}
306	if err := validateOpListSchemasInput(input); err != nil {
307		return out, metadata, err
308	}
309	return next.HandleInitialize(ctx, in)
310}
311
312type validateOpListSchemaVersions struct {
313}
314
315func (*validateOpListSchemaVersions) ID() string {
316	return "OperationInputValidation"
317}
318
319func (m *validateOpListSchemaVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
320	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
321) {
322	input, ok := in.Parameters.(*ListSchemaVersionsInput)
323	if !ok {
324		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
325	}
326	if err := validateOpListSchemaVersionsInput(input); err != nil {
327		return out, metadata, err
328	}
329	return next.HandleInitialize(ctx, in)
330}
331
332type validateOpListTagsForResource struct {
333}
334
335func (*validateOpListTagsForResource) ID() string {
336	return "OperationInputValidation"
337}
338
339func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
340	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
341) {
342	input, ok := in.Parameters.(*ListTagsForResourceInput)
343	if !ok {
344		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
345	}
346	if err := validateOpListTagsForResourceInput(input); err != nil {
347		return out, metadata, err
348	}
349	return next.HandleInitialize(ctx, in)
350}
351
352type validateOpPutCodeBinding struct {
353}
354
355func (*validateOpPutCodeBinding) ID() string {
356	return "OperationInputValidation"
357}
358
359func (m *validateOpPutCodeBinding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
360	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
361) {
362	input, ok := in.Parameters.(*PutCodeBindingInput)
363	if !ok {
364		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
365	}
366	if err := validateOpPutCodeBindingInput(input); err != nil {
367		return out, metadata, err
368	}
369	return next.HandleInitialize(ctx, in)
370}
371
372type validateOpPutResourcePolicy struct {
373}
374
375func (*validateOpPutResourcePolicy) ID() string {
376	return "OperationInputValidation"
377}
378
379func (m *validateOpPutResourcePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
380	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
381) {
382	input, ok := in.Parameters.(*PutResourcePolicyInput)
383	if !ok {
384		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
385	}
386	if err := validateOpPutResourcePolicyInput(input); err != nil {
387		return out, metadata, err
388	}
389	return next.HandleInitialize(ctx, in)
390}
391
392type validateOpSearchSchemas struct {
393}
394
395func (*validateOpSearchSchemas) ID() string {
396	return "OperationInputValidation"
397}
398
399func (m *validateOpSearchSchemas) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
400	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
401) {
402	input, ok := in.Parameters.(*SearchSchemasInput)
403	if !ok {
404		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
405	}
406	if err := validateOpSearchSchemasInput(input); err != nil {
407		return out, metadata, err
408	}
409	return next.HandleInitialize(ctx, in)
410}
411
412type validateOpStartDiscoverer struct {
413}
414
415func (*validateOpStartDiscoverer) ID() string {
416	return "OperationInputValidation"
417}
418
419func (m *validateOpStartDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
420	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
421) {
422	input, ok := in.Parameters.(*StartDiscovererInput)
423	if !ok {
424		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
425	}
426	if err := validateOpStartDiscovererInput(input); err != nil {
427		return out, metadata, err
428	}
429	return next.HandleInitialize(ctx, in)
430}
431
432type validateOpStopDiscoverer struct {
433}
434
435func (*validateOpStopDiscoverer) ID() string {
436	return "OperationInputValidation"
437}
438
439func (m *validateOpStopDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
440	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
441) {
442	input, ok := in.Parameters.(*StopDiscovererInput)
443	if !ok {
444		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
445	}
446	if err := validateOpStopDiscovererInput(input); err != nil {
447		return out, metadata, err
448	}
449	return next.HandleInitialize(ctx, in)
450}
451
452type validateOpTagResource struct {
453}
454
455func (*validateOpTagResource) ID() string {
456	return "OperationInputValidation"
457}
458
459func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
460	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
461) {
462	input, ok := in.Parameters.(*TagResourceInput)
463	if !ok {
464		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
465	}
466	if err := validateOpTagResourceInput(input); err != nil {
467		return out, metadata, err
468	}
469	return next.HandleInitialize(ctx, in)
470}
471
472type validateOpUntagResource struct {
473}
474
475func (*validateOpUntagResource) ID() string {
476	return "OperationInputValidation"
477}
478
479func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
480	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
481) {
482	input, ok := in.Parameters.(*UntagResourceInput)
483	if !ok {
484		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
485	}
486	if err := validateOpUntagResourceInput(input); err != nil {
487		return out, metadata, err
488	}
489	return next.HandleInitialize(ctx, in)
490}
491
492type validateOpUpdateDiscoverer struct {
493}
494
495func (*validateOpUpdateDiscoverer) ID() string {
496	return "OperationInputValidation"
497}
498
499func (m *validateOpUpdateDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
500	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
501) {
502	input, ok := in.Parameters.(*UpdateDiscovererInput)
503	if !ok {
504		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
505	}
506	if err := validateOpUpdateDiscovererInput(input); err != nil {
507		return out, metadata, err
508	}
509	return next.HandleInitialize(ctx, in)
510}
511
512type validateOpUpdateRegistry struct {
513}
514
515func (*validateOpUpdateRegistry) ID() string {
516	return "OperationInputValidation"
517}
518
519func (m *validateOpUpdateRegistry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
520	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
521) {
522	input, ok := in.Parameters.(*UpdateRegistryInput)
523	if !ok {
524		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
525	}
526	if err := validateOpUpdateRegistryInput(input); err != nil {
527		return out, metadata, err
528	}
529	return next.HandleInitialize(ctx, in)
530}
531
532type validateOpUpdateSchema struct {
533}
534
535func (*validateOpUpdateSchema) ID() string {
536	return "OperationInputValidation"
537}
538
539func (m *validateOpUpdateSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
540	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
541) {
542	input, ok := in.Parameters.(*UpdateSchemaInput)
543	if !ok {
544		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
545	}
546	if err := validateOpUpdateSchemaInput(input); err != nil {
547		return out, metadata, err
548	}
549	return next.HandleInitialize(ctx, in)
550}
551
552func addOpCreateDiscovererValidationMiddleware(stack *middleware.Stack) error {
553	return stack.Initialize.Add(&validateOpCreateDiscoverer{}, middleware.After)
554}
555
556func addOpCreateRegistryValidationMiddleware(stack *middleware.Stack) error {
557	return stack.Initialize.Add(&validateOpCreateRegistry{}, middleware.After)
558}
559
560func addOpCreateSchemaValidationMiddleware(stack *middleware.Stack) error {
561	return stack.Initialize.Add(&validateOpCreateSchema{}, middleware.After)
562}
563
564func addOpDeleteDiscovererValidationMiddleware(stack *middleware.Stack) error {
565	return stack.Initialize.Add(&validateOpDeleteDiscoverer{}, middleware.After)
566}
567
568func addOpDeleteRegistryValidationMiddleware(stack *middleware.Stack) error {
569	return stack.Initialize.Add(&validateOpDeleteRegistry{}, middleware.After)
570}
571
572func addOpDeleteSchemaValidationMiddleware(stack *middleware.Stack) error {
573	return stack.Initialize.Add(&validateOpDeleteSchema{}, middleware.After)
574}
575
576func addOpDeleteSchemaVersionValidationMiddleware(stack *middleware.Stack) error {
577	return stack.Initialize.Add(&validateOpDeleteSchemaVersion{}, middleware.After)
578}
579
580func addOpDescribeCodeBindingValidationMiddleware(stack *middleware.Stack) error {
581	return stack.Initialize.Add(&validateOpDescribeCodeBinding{}, middleware.After)
582}
583
584func addOpDescribeDiscovererValidationMiddleware(stack *middleware.Stack) error {
585	return stack.Initialize.Add(&validateOpDescribeDiscoverer{}, middleware.After)
586}
587
588func addOpDescribeRegistryValidationMiddleware(stack *middleware.Stack) error {
589	return stack.Initialize.Add(&validateOpDescribeRegistry{}, middleware.After)
590}
591
592func addOpDescribeSchemaValidationMiddleware(stack *middleware.Stack) error {
593	return stack.Initialize.Add(&validateOpDescribeSchema{}, middleware.After)
594}
595
596func addOpExportSchemaValidationMiddleware(stack *middleware.Stack) error {
597	return stack.Initialize.Add(&validateOpExportSchema{}, middleware.After)
598}
599
600func addOpGetCodeBindingSourceValidationMiddleware(stack *middleware.Stack) error {
601	return stack.Initialize.Add(&validateOpGetCodeBindingSource{}, middleware.After)
602}
603
604func addOpGetDiscoveredSchemaValidationMiddleware(stack *middleware.Stack) error {
605	return stack.Initialize.Add(&validateOpGetDiscoveredSchema{}, middleware.After)
606}
607
608func addOpListSchemasValidationMiddleware(stack *middleware.Stack) error {
609	return stack.Initialize.Add(&validateOpListSchemas{}, middleware.After)
610}
611
612func addOpListSchemaVersionsValidationMiddleware(stack *middleware.Stack) error {
613	return stack.Initialize.Add(&validateOpListSchemaVersions{}, middleware.After)
614}
615
616func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
617	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
618}
619
620func addOpPutCodeBindingValidationMiddleware(stack *middleware.Stack) error {
621	return stack.Initialize.Add(&validateOpPutCodeBinding{}, middleware.After)
622}
623
624func addOpPutResourcePolicyValidationMiddleware(stack *middleware.Stack) error {
625	return stack.Initialize.Add(&validateOpPutResourcePolicy{}, middleware.After)
626}
627
628func addOpSearchSchemasValidationMiddleware(stack *middleware.Stack) error {
629	return stack.Initialize.Add(&validateOpSearchSchemas{}, middleware.After)
630}
631
632func addOpStartDiscovererValidationMiddleware(stack *middleware.Stack) error {
633	return stack.Initialize.Add(&validateOpStartDiscoverer{}, middleware.After)
634}
635
636func addOpStopDiscovererValidationMiddleware(stack *middleware.Stack) error {
637	return stack.Initialize.Add(&validateOpStopDiscoverer{}, middleware.After)
638}
639
640func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
641	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
642}
643
644func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
645	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
646}
647
648func addOpUpdateDiscovererValidationMiddleware(stack *middleware.Stack) error {
649	return stack.Initialize.Add(&validateOpUpdateDiscoverer{}, middleware.After)
650}
651
652func addOpUpdateRegistryValidationMiddleware(stack *middleware.Stack) error {
653	return stack.Initialize.Add(&validateOpUpdateRegistry{}, middleware.After)
654}
655
656func addOpUpdateSchemaValidationMiddleware(stack *middleware.Stack) error {
657	return stack.Initialize.Add(&validateOpUpdateSchema{}, middleware.After)
658}
659
660func validateOpCreateDiscovererInput(v *CreateDiscovererInput) error {
661	if v == nil {
662		return nil
663	}
664	invalidParams := smithy.InvalidParamsError{Context: "CreateDiscovererInput"}
665	if v.SourceArn == nil {
666		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
667	}
668	if invalidParams.Len() > 0 {
669		return invalidParams
670	} else {
671		return nil
672	}
673}
674
675func validateOpCreateRegistryInput(v *CreateRegistryInput) error {
676	if v == nil {
677		return nil
678	}
679	invalidParams := smithy.InvalidParamsError{Context: "CreateRegistryInput"}
680	if v.RegistryName == nil {
681		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
682	}
683	if invalidParams.Len() > 0 {
684		return invalidParams
685	} else {
686		return nil
687	}
688}
689
690func validateOpCreateSchemaInput(v *CreateSchemaInput) error {
691	if v == nil {
692		return nil
693	}
694	invalidParams := smithy.InvalidParamsError{Context: "CreateSchemaInput"}
695	if v.Content == nil {
696		invalidParams.Add(smithy.NewErrParamRequired("Content"))
697	}
698	if v.RegistryName == nil {
699		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
700	}
701	if v.SchemaName == nil {
702		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
703	}
704	if len(v.Type) == 0 {
705		invalidParams.Add(smithy.NewErrParamRequired("Type"))
706	}
707	if invalidParams.Len() > 0 {
708		return invalidParams
709	} else {
710		return nil
711	}
712}
713
714func validateOpDeleteDiscovererInput(v *DeleteDiscovererInput) error {
715	if v == nil {
716		return nil
717	}
718	invalidParams := smithy.InvalidParamsError{Context: "DeleteDiscovererInput"}
719	if v.DiscovererId == nil {
720		invalidParams.Add(smithy.NewErrParamRequired("DiscovererId"))
721	}
722	if invalidParams.Len() > 0 {
723		return invalidParams
724	} else {
725		return nil
726	}
727}
728
729func validateOpDeleteRegistryInput(v *DeleteRegistryInput) error {
730	if v == nil {
731		return nil
732	}
733	invalidParams := smithy.InvalidParamsError{Context: "DeleteRegistryInput"}
734	if v.RegistryName == nil {
735		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
736	}
737	if invalidParams.Len() > 0 {
738		return invalidParams
739	} else {
740		return nil
741	}
742}
743
744func validateOpDeleteSchemaInput(v *DeleteSchemaInput) error {
745	if v == nil {
746		return nil
747	}
748	invalidParams := smithy.InvalidParamsError{Context: "DeleteSchemaInput"}
749	if v.RegistryName == nil {
750		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
751	}
752	if v.SchemaName == nil {
753		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
754	}
755	if invalidParams.Len() > 0 {
756		return invalidParams
757	} else {
758		return nil
759	}
760}
761
762func validateOpDeleteSchemaVersionInput(v *DeleteSchemaVersionInput) error {
763	if v == nil {
764		return nil
765	}
766	invalidParams := smithy.InvalidParamsError{Context: "DeleteSchemaVersionInput"}
767	if v.RegistryName == nil {
768		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
769	}
770	if v.SchemaName == nil {
771		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
772	}
773	if v.SchemaVersion == nil {
774		invalidParams.Add(smithy.NewErrParamRequired("SchemaVersion"))
775	}
776	if invalidParams.Len() > 0 {
777		return invalidParams
778	} else {
779		return nil
780	}
781}
782
783func validateOpDescribeCodeBindingInput(v *DescribeCodeBindingInput) error {
784	if v == nil {
785		return nil
786	}
787	invalidParams := smithy.InvalidParamsError{Context: "DescribeCodeBindingInput"}
788	if v.Language == nil {
789		invalidParams.Add(smithy.NewErrParamRequired("Language"))
790	}
791	if v.RegistryName == nil {
792		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
793	}
794	if v.SchemaName == nil {
795		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
796	}
797	if invalidParams.Len() > 0 {
798		return invalidParams
799	} else {
800		return nil
801	}
802}
803
804func validateOpDescribeDiscovererInput(v *DescribeDiscovererInput) error {
805	if v == nil {
806		return nil
807	}
808	invalidParams := smithy.InvalidParamsError{Context: "DescribeDiscovererInput"}
809	if v.DiscovererId == nil {
810		invalidParams.Add(smithy.NewErrParamRequired("DiscovererId"))
811	}
812	if invalidParams.Len() > 0 {
813		return invalidParams
814	} else {
815		return nil
816	}
817}
818
819func validateOpDescribeRegistryInput(v *DescribeRegistryInput) error {
820	if v == nil {
821		return nil
822	}
823	invalidParams := smithy.InvalidParamsError{Context: "DescribeRegistryInput"}
824	if v.RegistryName == nil {
825		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
826	}
827	if invalidParams.Len() > 0 {
828		return invalidParams
829	} else {
830		return nil
831	}
832}
833
834func validateOpDescribeSchemaInput(v *DescribeSchemaInput) error {
835	if v == nil {
836		return nil
837	}
838	invalidParams := smithy.InvalidParamsError{Context: "DescribeSchemaInput"}
839	if v.RegistryName == nil {
840		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
841	}
842	if v.SchemaName == nil {
843		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
844	}
845	if invalidParams.Len() > 0 {
846		return invalidParams
847	} else {
848		return nil
849	}
850}
851
852func validateOpExportSchemaInput(v *ExportSchemaInput) error {
853	if v == nil {
854		return nil
855	}
856	invalidParams := smithy.InvalidParamsError{Context: "ExportSchemaInput"}
857	if v.RegistryName == nil {
858		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
859	}
860	if v.SchemaName == nil {
861		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
862	}
863	if v.Type == nil {
864		invalidParams.Add(smithy.NewErrParamRequired("Type"))
865	}
866	if invalidParams.Len() > 0 {
867		return invalidParams
868	} else {
869		return nil
870	}
871}
872
873func validateOpGetCodeBindingSourceInput(v *GetCodeBindingSourceInput) error {
874	if v == nil {
875		return nil
876	}
877	invalidParams := smithy.InvalidParamsError{Context: "GetCodeBindingSourceInput"}
878	if v.Language == nil {
879		invalidParams.Add(smithy.NewErrParamRequired("Language"))
880	}
881	if v.RegistryName == nil {
882		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
883	}
884	if v.SchemaName == nil {
885		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
886	}
887	if invalidParams.Len() > 0 {
888		return invalidParams
889	} else {
890		return nil
891	}
892}
893
894func validateOpGetDiscoveredSchemaInput(v *GetDiscoveredSchemaInput) error {
895	if v == nil {
896		return nil
897	}
898	invalidParams := smithy.InvalidParamsError{Context: "GetDiscoveredSchemaInput"}
899	if v.Events == nil {
900		invalidParams.Add(smithy.NewErrParamRequired("Events"))
901	}
902	if len(v.Type) == 0 {
903		invalidParams.Add(smithy.NewErrParamRequired("Type"))
904	}
905	if invalidParams.Len() > 0 {
906		return invalidParams
907	} else {
908		return nil
909	}
910}
911
912func validateOpListSchemasInput(v *ListSchemasInput) error {
913	if v == nil {
914		return nil
915	}
916	invalidParams := smithy.InvalidParamsError{Context: "ListSchemasInput"}
917	if v.RegistryName == nil {
918		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
919	}
920	if invalidParams.Len() > 0 {
921		return invalidParams
922	} else {
923		return nil
924	}
925}
926
927func validateOpListSchemaVersionsInput(v *ListSchemaVersionsInput) error {
928	if v == nil {
929		return nil
930	}
931	invalidParams := smithy.InvalidParamsError{Context: "ListSchemaVersionsInput"}
932	if v.RegistryName == nil {
933		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
934	}
935	if v.SchemaName == nil {
936		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
937	}
938	if invalidParams.Len() > 0 {
939		return invalidParams
940	} else {
941		return nil
942	}
943}
944
945func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
946	if v == nil {
947		return nil
948	}
949	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
950	if v.ResourceArn == nil {
951		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
952	}
953	if invalidParams.Len() > 0 {
954		return invalidParams
955	} else {
956		return nil
957	}
958}
959
960func validateOpPutCodeBindingInput(v *PutCodeBindingInput) error {
961	if v == nil {
962		return nil
963	}
964	invalidParams := smithy.InvalidParamsError{Context: "PutCodeBindingInput"}
965	if v.Language == nil {
966		invalidParams.Add(smithy.NewErrParamRequired("Language"))
967	}
968	if v.RegistryName == nil {
969		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
970	}
971	if v.SchemaName == nil {
972		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
973	}
974	if invalidParams.Len() > 0 {
975		return invalidParams
976	} else {
977		return nil
978	}
979}
980
981func validateOpPutResourcePolicyInput(v *PutResourcePolicyInput) error {
982	if v == nil {
983		return nil
984	}
985	invalidParams := smithy.InvalidParamsError{Context: "PutResourcePolicyInput"}
986	if v.Policy == nil {
987		invalidParams.Add(smithy.NewErrParamRequired("Policy"))
988	}
989	if invalidParams.Len() > 0 {
990		return invalidParams
991	} else {
992		return nil
993	}
994}
995
996func validateOpSearchSchemasInput(v *SearchSchemasInput) error {
997	if v == nil {
998		return nil
999	}
1000	invalidParams := smithy.InvalidParamsError{Context: "SearchSchemasInput"}
1001	if v.Keywords == nil {
1002		invalidParams.Add(smithy.NewErrParamRequired("Keywords"))
1003	}
1004	if v.RegistryName == nil {
1005		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
1006	}
1007	if invalidParams.Len() > 0 {
1008		return invalidParams
1009	} else {
1010		return nil
1011	}
1012}
1013
1014func validateOpStartDiscovererInput(v *StartDiscovererInput) error {
1015	if v == nil {
1016		return nil
1017	}
1018	invalidParams := smithy.InvalidParamsError{Context: "StartDiscovererInput"}
1019	if v.DiscovererId == nil {
1020		invalidParams.Add(smithy.NewErrParamRequired("DiscovererId"))
1021	}
1022	if invalidParams.Len() > 0 {
1023		return invalidParams
1024	} else {
1025		return nil
1026	}
1027}
1028
1029func validateOpStopDiscovererInput(v *StopDiscovererInput) error {
1030	if v == nil {
1031		return nil
1032	}
1033	invalidParams := smithy.InvalidParamsError{Context: "StopDiscovererInput"}
1034	if v.DiscovererId == nil {
1035		invalidParams.Add(smithy.NewErrParamRequired("DiscovererId"))
1036	}
1037	if invalidParams.Len() > 0 {
1038		return invalidParams
1039	} else {
1040		return nil
1041	}
1042}
1043
1044func validateOpTagResourceInput(v *TagResourceInput) error {
1045	if v == nil {
1046		return nil
1047	}
1048	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1049	if v.ResourceArn == nil {
1050		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1051	}
1052	if v.Tags == nil {
1053		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1054	}
1055	if invalidParams.Len() > 0 {
1056		return invalidParams
1057	} else {
1058		return nil
1059	}
1060}
1061
1062func validateOpUntagResourceInput(v *UntagResourceInput) error {
1063	if v == nil {
1064		return nil
1065	}
1066	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1067	if v.ResourceArn == nil {
1068		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1069	}
1070	if v.TagKeys == nil {
1071		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1072	}
1073	if invalidParams.Len() > 0 {
1074		return invalidParams
1075	} else {
1076		return nil
1077	}
1078}
1079
1080func validateOpUpdateDiscovererInput(v *UpdateDiscovererInput) error {
1081	if v == nil {
1082		return nil
1083	}
1084	invalidParams := smithy.InvalidParamsError{Context: "UpdateDiscovererInput"}
1085	if v.DiscovererId == nil {
1086		invalidParams.Add(smithy.NewErrParamRequired("DiscovererId"))
1087	}
1088	if invalidParams.Len() > 0 {
1089		return invalidParams
1090	} else {
1091		return nil
1092	}
1093}
1094
1095func validateOpUpdateRegistryInput(v *UpdateRegistryInput) error {
1096	if v == nil {
1097		return nil
1098	}
1099	invalidParams := smithy.InvalidParamsError{Context: "UpdateRegistryInput"}
1100	if v.RegistryName == nil {
1101		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
1102	}
1103	if invalidParams.Len() > 0 {
1104		return invalidParams
1105	} else {
1106		return nil
1107	}
1108}
1109
1110func validateOpUpdateSchemaInput(v *UpdateSchemaInput) error {
1111	if v == nil {
1112		return nil
1113	}
1114	invalidParams := smithy.InvalidParamsError{Context: "UpdateSchemaInput"}
1115	if v.RegistryName == nil {
1116		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
1117	}
1118	if v.SchemaName == nil {
1119		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
1120	}
1121	if invalidParams.Len() > 0 {
1122		return invalidParams
1123	} else {
1124		return nil
1125	}
1126}
1127