1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package glue
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/glue/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpBatchCreatePartition struct {
14}
15
16func (*validateOpBatchCreatePartition) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpBatchCreatePartition) 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.(*BatchCreatePartitionInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpBatchCreatePartitionInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpBatchDeleteConnection struct {
34}
35
36func (*validateOpBatchDeleteConnection) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpBatchDeleteConnection) 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.(*BatchDeleteConnectionInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpBatchDeleteConnectionInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpBatchDeletePartition struct {
54}
55
56func (*validateOpBatchDeletePartition) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpBatchDeletePartition) 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.(*BatchDeletePartitionInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpBatchDeletePartitionInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpBatchDeleteTable struct {
74}
75
76func (*validateOpBatchDeleteTable) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpBatchDeleteTable) 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.(*BatchDeleteTableInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpBatchDeleteTableInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpBatchDeleteTableVersion struct {
94}
95
96func (*validateOpBatchDeleteTableVersion) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpBatchDeleteTableVersion) 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.(*BatchDeleteTableVersionInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpBatchDeleteTableVersionInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpBatchGetCrawlers struct {
114}
115
116func (*validateOpBatchGetCrawlers) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpBatchGetCrawlers) 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.(*BatchGetCrawlersInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpBatchGetCrawlersInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpBatchGetDevEndpoints struct {
134}
135
136func (*validateOpBatchGetDevEndpoints) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpBatchGetDevEndpoints) 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.(*BatchGetDevEndpointsInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpBatchGetDevEndpointsInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpBatchGetJobs struct {
154}
155
156func (*validateOpBatchGetJobs) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpBatchGetJobs) 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.(*BatchGetJobsInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpBatchGetJobsInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpBatchGetPartition struct {
174}
175
176func (*validateOpBatchGetPartition) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpBatchGetPartition) 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.(*BatchGetPartitionInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpBatchGetPartitionInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpBatchGetTriggers struct {
194}
195
196func (*validateOpBatchGetTriggers) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpBatchGetTriggers) 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.(*BatchGetTriggersInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpBatchGetTriggersInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpBatchGetWorkflows struct {
214}
215
216func (*validateOpBatchGetWorkflows) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpBatchGetWorkflows) 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.(*BatchGetWorkflowsInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpBatchGetWorkflowsInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpBatchStopJobRun struct {
234}
235
236func (*validateOpBatchStopJobRun) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpBatchStopJobRun) 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.(*BatchStopJobRunInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpBatchStopJobRunInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpBatchUpdatePartition struct {
254}
255
256func (*validateOpBatchUpdatePartition) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpBatchUpdatePartition) 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.(*BatchUpdatePartitionInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpBatchUpdatePartitionInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpCancelMLTaskRun struct {
274}
275
276func (*validateOpCancelMLTaskRun) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpCancelMLTaskRun) 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.(*CancelMLTaskRunInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpCancelMLTaskRunInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpCheckSchemaVersionValidity struct {
294}
295
296func (*validateOpCheckSchemaVersionValidity) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpCheckSchemaVersionValidity) 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.(*CheckSchemaVersionValidityInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpCheckSchemaVersionValidityInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpCreateClassifier struct {
314}
315
316func (*validateOpCreateClassifier) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpCreateClassifier) 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.(*CreateClassifierInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpCreateClassifierInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpCreateConnection struct {
334}
335
336func (*validateOpCreateConnection) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpCreateConnection) 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.(*CreateConnectionInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpCreateConnectionInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpCreateCrawler struct {
354}
355
356func (*validateOpCreateCrawler) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpCreateCrawler) 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.(*CreateCrawlerInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpCreateCrawlerInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpCreateDatabase struct {
374}
375
376func (*validateOpCreateDatabase) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpCreateDatabase) 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.(*CreateDatabaseInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpCreateDatabaseInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpCreateDevEndpoint struct {
394}
395
396func (*validateOpCreateDevEndpoint) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpCreateDevEndpoint) 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.(*CreateDevEndpointInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpCreateDevEndpointInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpCreateJob struct {
414}
415
416func (*validateOpCreateJob) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpCreateJob) 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.(*CreateJobInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpCreateJobInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpCreateMLTransform struct {
434}
435
436func (*validateOpCreateMLTransform) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpCreateMLTransform) 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.(*CreateMLTransformInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpCreateMLTransformInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpCreatePartitionIndex struct {
454}
455
456func (*validateOpCreatePartitionIndex) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpCreatePartitionIndex) 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.(*CreatePartitionIndexInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpCreatePartitionIndexInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpCreatePartition struct {
474}
475
476func (*validateOpCreatePartition) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpCreatePartition) 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.(*CreatePartitionInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpCreatePartitionInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpCreateRegistry struct {
494}
495
496func (*validateOpCreateRegistry) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpCreateRegistry) 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.(*CreateRegistryInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpCreateRegistryInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpCreateSchema struct {
514}
515
516func (*validateOpCreateSchema) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpCreateSchema) 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.(*CreateSchemaInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpCreateSchemaInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpCreateScript struct {
534}
535
536func (*validateOpCreateScript) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpCreateScript) 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.(*CreateScriptInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpCreateScriptInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpCreateSecurityConfiguration struct {
554}
555
556func (*validateOpCreateSecurityConfiguration) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpCreateSecurityConfiguration) 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.(*CreateSecurityConfigurationInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpCreateSecurityConfigurationInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpCreateTable struct {
574}
575
576func (*validateOpCreateTable) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpCreateTable) 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.(*CreateTableInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpCreateTableInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpCreateTrigger struct {
594}
595
596func (*validateOpCreateTrigger) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpCreateTrigger) 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.(*CreateTriggerInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpCreateTriggerInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpCreateUserDefinedFunction struct {
614}
615
616func (*validateOpCreateUserDefinedFunction) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpCreateUserDefinedFunction) 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.(*CreateUserDefinedFunctionInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpCreateUserDefinedFunctionInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpCreateWorkflow struct {
634}
635
636func (*validateOpCreateWorkflow) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpCreateWorkflow) 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.(*CreateWorkflowInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpCreateWorkflowInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpDeleteClassifier struct {
654}
655
656func (*validateOpDeleteClassifier) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpDeleteClassifier) 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.(*DeleteClassifierInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpDeleteClassifierInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpDeleteColumnStatisticsForPartition struct {
674}
675
676func (*validateOpDeleteColumnStatisticsForPartition) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpDeleteColumnStatisticsForPartition) 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.(*DeleteColumnStatisticsForPartitionInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpDeleteColumnStatisticsForPartitionInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpDeleteColumnStatisticsForTable struct {
694}
695
696func (*validateOpDeleteColumnStatisticsForTable) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpDeleteColumnStatisticsForTable) 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.(*DeleteColumnStatisticsForTableInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpDeleteColumnStatisticsForTableInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpDeleteConnection struct {
714}
715
716func (*validateOpDeleteConnection) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpDeleteConnection) 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.(*DeleteConnectionInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpDeleteConnectionInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpDeleteCrawler struct {
734}
735
736func (*validateOpDeleteCrawler) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpDeleteCrawler) 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.(*DeleteCrawlerInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpDeleteCrawlerInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpDeleteDatabase struct {
754}
755
756func (*validateOpDeleteDatabase) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpDeleteDatabase) 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.(*DeleteDatabaseInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpDeleteDatabaseInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpDeleteDevEndpoint struct {
774}
775
776func (*validateOpDeleteDevEndpoint) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpDeleteDevEndpoint) 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.(*DeleteDevEndpointInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpDeleteDevEndpointInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpDeleteJob struct {
794}
795
796func (*validateOpDeleteJob) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpDeleteJob) 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.(*DeleteJobInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpDeleteJobInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpDeleteMLTransform struct {
814}
815
816func (*validateOpDeleteMLTransform) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpDeleteMLTransform) 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.(*DeleteMLTransformInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpDeleteMLTransformInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpDeletePartitionIndex struct {
834}
835
836func (*validateOpDeletePartitionIndex) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpDeletePartitionIndex) 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.(*DeletePartitionIndexInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpDeletePartitionIndexInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpDeletePartition struct {
854}
855
856func (*validateOpDeletePartition) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpDeletePartition) 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.(*DeletePartitionInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpDeletePartitionInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpDeleteRegistry struct {
874}
875
876func (*validateOpDeleteRegistry) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpDeleteRegistry) 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.(*DeleteRegistryInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpDeleteRegistryInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpDeleteSchema struct {
894}
895
896func (*validateOpDeleteSchema) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpDeleteSchema) 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.(*DeleteSchemaInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpDeleteSchemaInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpDeleteSchemaVersions struct {
914}
915
916func (*validateOpDeleteSchemaVersions) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpDeleteSchemaVersions) 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.(*DeleteSchemaVersionsInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpDeleteSchemaVersionsInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpDeleteSecurityConfiguration struct {
934}
935
936func (*validateOpDeleteSecurityConfiguration) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpDeleteSecurityConfiguration) 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.(*DeleteSecurityConfigurationInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpDeleteSecurityConfigurationInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpDeleteTable struct {
954}
955
956func (*validateOpDeleteTable) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpDeleteTable) 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.(*DeleteTableInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpDeleteTableInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpDeleteTableVersion struct {
974}
975
976func (*validateOpDeleteTableVersion) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpDeleteTableVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
982) {
983	input, ok := in.Parameters.(*DeleteTableVersionInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpDeleteTableVersionInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpDeleteTrigger struct {
994}
995
996func (*validateOpDeleteTrigger) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpDeleteTrigger) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1002) {
1003	input, ok := in.Parameters.(*DeleteTriggerInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpDeleteTriggerInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpDeleteUserDefinedFunction struct {
1014}
1015
1016func (*validateOpDeleteUserDefinedFunction) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpDeleteUserDefinedFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1022) {
1023	input, ok := in.Parameters.(*DeleteUserDefinedFunctionInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpDeleteUserDefinedFunctionInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpDeleteWorkflow struct {
1034}
1035
1036func (*validateOpDeleteWorkflow) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpDeleteWorkflow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	input, ok := in.Parameters.(*DeleteWorkflowInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpDeleteWorkflowInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpGetClassifier struct {
1054}
1055
1056func (*validateOpGetClassifier) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpGetClassifier) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1062) {
1063	input, ok := in.Parameters.(*GetClassifierInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpGetClassifierInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpGetColumnStatisticsForPartition struct {
1074}
1075
1076func (*validateOpGetColumnStatisticsForPartition) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpGetColumnStatisticsForPartition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1082) {
1083	input, ok := in.Parameters.(*GetColumnStatisticsForPartitionInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpGetColumnStatisticsForPartitionInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpGetColumnStatisticsForTable struct {
1094}
1095
1096func (*validateOpGetColumnStatisticsForTable) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpGetColumnStatisticsForTable) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	input, ok := in.Parameters.(*GetColumnStatisticsForTableInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpGetColumnStatisticsForTableInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpGetConnection struct {
1114}
1115
1116func (*validateOpGetConnection) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpGetConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1122) {
1123	input, ok := in.Parameters.(*GetConnectionInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpGetConnectionInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133type validateOpGetCrawler struct {
1134}
1135
1136func (*validateOpGetCrawler) ID() string {
1137	return "OperationInputValidation"
1138}
1139
1140func (m *validateOpGetCrawler) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1142) {
1143	input, ok := in.Parameters.(*GetCrawlerInput)
1144	if !ok {
1145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146	}
1147	if err := validateOpGetCrawlerInput(input); err != nil {
1148		return out, metadata, err
1149	}
1150	return next.HandleInitialize(ctx, in)
1151}
1152
1153type validateOpGetDatabase struct {
1154}
1155
1156func (*validateOpGetDatabase) ID() string {
1157	return "OperationInputValidation"
1158}
1159
1160func (m *validateOpGetDatabase) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1162) {
1163	input, ok := in.Parameters.(*GetDatabaseInput)
1164	if !ok {
1165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1166	}
1167	if err := validateOpGetDatabaseInput(input); err != nil {
1168		return out, metadata, err
1169	}
1170	return next.HandleInitialize(ctx, in)
1171}
1172
1173type validateOpGetDevEndpoint struct {
1174}
1175
1176func (*validateOpGetDevEndpoint) ID() string {
1177	return "OperationInputValidation"
1178}
1179
1180func (m *validateOpGetDevEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1182) {
1183	input, ok := in.Parameters.(*GetDevEndpointInput)
1184	if !ok {
1185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1186	}
1187	if err := validateOpGetDevEndpointInput(input); err != nil {
1188		return out, metadata, err
1189	}
1190	return next.HandleInitialize(ctx, in)
1191}
1192
1193type validateOpGetJobBookmark struct {
1194}
1195
1196func (*validateOpGetJobBookmark) ID() string {
1197	return "OperationInputValidation"
1198}
1199
1200func (m *validateOpGetJobBookmark) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	input, ok := in.Parameters.(*GetJobBookmarkInput)
1204	if !ok {
1205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1206	}
1207	if err := validateOpGetJobBookmarkInput(input); err != nil {
1208		return out, metadata, err
1209	}
1210	return next.HandleInitialize(ctx, in)
1211}
1212
1213type validateOpGetJob struct {
1214}
1215
1216func (*validateOpGetJob) ID() string {
1217	return "OperationInputValidation"
1218}
1219
1220func (m *validateOpGetJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1222) {
1223	input, ok := in.Parameters.(*GetJobInput)
1224	if !ok {
1225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1226	}
1227	if err := validateOpGetJobInput(input); err != nil {
1228		return out, metadata, err
1229	}
1230	return next.HandleInitialize(ctx, in)
1231}
1232
1233type validateOpGetJobRun struct {
1234}
1235
1236func (*validateOpGetJobRun) ID() string {
1237	return "OperationInputValidation"
1238}
1239
1240func (m *validateOpGetJobRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1242) {
1243	input, ok := in.Parameters.(*GetJobRunInput)
1244	if !ok {
1245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1246	}
1247	if err := validateOpGetJobRunInput(input); err != nil {
1248		return out, metadata, err
1249	}
1250	return next.HandleInitialize(ctx, in)
1251}
1252
1253type validateOpGetJobRuns struct {
1254}
1255
1256func (*validateOpGetJobRuns) ID() string {
1257	return "OperationInputValidation"
1258}
1259
1260func (m *validateOpGetJobRuns) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1262) {
1263	input, ok := in.Parameters.(*GetJobRunsInput)
1264	if !ok {
1265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1266	}
1267	if err := validateOpGetJobRunsInput(input); err != nil {
1268		return out, metadata, err
1269	}
1270	return next.HandleInitialize(ctx, in)
1271}
1272
1273type validateOpGetMapping struct {
1274}
1275
1276func (*validateOpGetMapping) ID() string {
1277	return "OperationInputValidation"
1278}
1279
1280func (m *validateOpGetMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1282) {
1283	input, ok := in.Parameters.(*GetMappingInput)
1284	if !ok {
1285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1286	}
1287	if err := validateOpGetMappingInput(input); err != nil {
1288		return out, metadata, err
1289	}
1290	return next.HandleInitialize(ctx, in)
1291}
1292
1293type validateOpGetMLTaskRun struct {
1294}
1295
1296func (*validateOpGetMLTaskRun) ID() string {
1297	return "OperationInputValidation"
1298}
1299
1300func (m *validateOpGetMLTaskRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1302) {
1303	input, ok := in.Parameters.(*GetMLTaskRunInput)
1304	if !ok {
1305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1306	}
1307	if err := validateOpGetMLTaskRunInput(input); err != nil {
1308		return out, metadata, err
1309	}
1310	return next.HandleInitialize(ctx, in)
1311}
1312
1313type validateOpGetMLTaskRuns struct {
1314}
1315
1316func (*validateOpGetMLTaskRuns) ID() string {
1317	return "OperationInputValidation"
1318}
1319
1320func (m *validateOpGetMLTaskRuns) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1322) {
1323	input, ok := in.Parameters.(*GetMLTaskRunsInput)
1324	if !ok {
1325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1326	}
1327	if err := validateOpGetMLTaskRunsInput(input); err != nil {
1328		return out, metadata, err
1329	}
1330	return next.HandleInitialize(ctx, in)
1331}
1332
1333type validateOpGetMLTransform struct {
1334}
1335
1336func (*validateOpGetMLTransform) ID() string {
1337	return "OperationInputValidation"
1338}
1339
1340func (m *validateOpGetMLTransform) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	input, ok := in.Parameters.(*GetMLTransformInput)
1344	if !ok {
1345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1346	}
1347	if err := validateOpGetMLTransformInput(input); err != nil {
1348		return out, metadata, err
1349	}
1350	return next.HandleInitialize(ctx, in)
1351}
1352
1353type validateOpGetMLTransforms struct {
1354}
1355
1356func (*validateOpGetMLTransforms) ID() string {
1357	return "OperationInputValidation"
1358}
1359
1360func (m *validateOpGetMLTransforms) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1362) {
1363	input, ok := in.Parameters.(*GetMLTransformsInput)
1364	if !ok {
1365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1366	}
1367	if err := validateOpGetMLTransformsInput(input); err != nil {
1368		return out, metadata, err
1369	}
1370	return next.HandleInitialize(ctx, in)
1371}
1372
1373type validateOpGetPartitionIndexes struct {
1374}
1375
1376func (*validateOpGetPartitionIndexes) ID() string {
1377	return "OperationInputValidation"
1378}
1379
1380func (m *validateOpGetPartitionIndexes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1382) {
1383	input, ok := in.Parameters.(*GetPartitionIndexesInput)
1384	if !ok {
1385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1386	}
1387	if err := validateOpGetPartitionIndexesInput(input); err != nil {
1388		return out, metadata, err
1389	}
1390	return next.HandleInitialize(ctx, in)
1391}
1392
1393type validateOpGetPartition struct {
1394}
1395
1396func (*validateOpGetPartition) ID() string {
1397	return "OperationInputValidation"
1398}
1399
1400func (m *validateOpGetPartition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1402) {
1403	input, ok := in.Parameters.(*GetPartitionInput)
1404	if !ok {
1405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1406	}
1407	if err := validateOpGetPartitionInput(input); err != nil {
1408		return out, metadata, err
1409	}
1410	return next.HandleInitialize(ctx, in)
1411}
1412
1413type validateOpGetPartitions struct {
1414}
1415
1416func (*validateOpGetPartitions) ID() string {
1417	return "OperationInputValidation"
1418}
1419
1420func (m *validateOpGetPartitions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1422) {
1423	input, ok := in.Parameters.(*GetPartitionsInput)
1424	if !ok {
1425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1426	}
1427	if err := validateOpGetPartitionsInput(input); err != nil {
1428		return out, metadata, err
1429	}
1430	return next.HandleInitialize(ctx, in)
1431}
1432
1433type validateOpGetPlan struct {
1434}
1435
1436func (*validateOpGetPlan) ID() string {
1437	return "OperationInputValidation"
1438}
1439
1440func (m *validateOpGetPlan) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1442) {
1443	input, ok := in.Parameters.(*GetPlanInput)
1444	if !ok {
1445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1446	}
1447	if err := validateOpGetPlanInput(input); err != nil {
1448		return out, metadata, err
1449	}
1450	return next.HandleInitialize(ctx, in)
1451}
1452
1453type validateOpGetRegistry struct {
1454}
1455
1456func (*validateOpGetRegistry) ID() string {
1457	return "OperationInputValidation"
1458}
1459
1460func (m *validateOpGetRegistry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1462) {
1463	input, ok := in.Parameters.(*GetRegistryInput)
1464	if !ok {
1465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1466	}
1467	if err := validateOpGetRegistryInput(input); err != nil {
1468		return out, metadata, err
1469	}
1470	return next.HandleInitialize(ctx, in)
1471}
1472
1473type validateOpGetSchemaByDefinition struct {
1474}
1475
1476func (*validateOpGetSchemaByDefinition) ID() string {
1477	return "OperationInputValidation"
1478}
1479
1480func (m *validateOpGetSchemaByDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1482) {
1483	input, ok := in.Parameters.(*GetSchemaByDefinitionInput)
1484	if !ok {
1485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1486	}
1487	if err := validateOpGetSchemaByDefinitionInput(input); err != nil {
1488		return out, metadata, err
1489	}
1490	return next.HandleInitialize(ctx, in)
1491}
1492
1493type validateOpGetSchema struct {
1494}
1495
1496func (*validateOpGetSchema) ID() string {
1497	return "OperationInputValidation"
1498}
1499
1500func (m *validateOpGetSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1502) {
1503	input, ok := in.Parameters.(*GetSchemaInput)
1504	if !ok {
1505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1506	}
1507	if err := validateOpGetSchemaInput(input); err != nil {
1508		return out, metadata, err
1509	}
1510	return next.HandleInitialize(ctx, in)
1511}
1512
1513type validateOpGetSchemaVersionsDiff struct {
1514}
1515
1516func (*validateOpGetSchemaVersionsDiff) ID() string {
1517	return "OperationInputValidation"
1518}
1519
1520func (m *validateOpGetSchemaVersionsDiff) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1522) {
1523	input, ok := in.Parameters.(*GetSchemaVersionsDiffInput)
1524	if !ok {
1525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1526	}
1527	if err := validateOpGetSchemaVersionsDiffInput(input); err != nil {
1528		return out, metadata, err
1529	}
1530	return next.HandleInitialize(ctx, in)
1531}
1532
1533type validateOpGetSecurityConfiguration struct {
1534}
1535
1536func (*validateOpGetSecurityConfiguration) ID() string {
1537	return "OperationInputValidation"
1538}
1539
1540func (m *validateOpGetSecurityConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1542) {
1543	input, ok := in.Parameters.(*GetSecurityConfigurationInput)
1544	if !ok {
1545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1546	}
1547	if err := validateOpGetSecurityConfigurationInput(input); err != nil {
1548		return out, metadata, err
1549	}
1550	return next.HandleInitialize(ctx, in)
1551}
1552
1553type validateOpGetTable struct {
1554}
1555
1556func (*validateOpGetTable) ID() string {
1557	return "OperationInputValidation"
1558}
1559
1560func (m *validateOpGetTable) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1562) {
1563	input, ok := in.Parameters.(*GetTableInput)
1564	if !ok {
1565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1566	}
1567	if err := validateOpGetTableInput(input); err != nil {
1568		return out, metadata, err
1569	}
1570	return next.HandleInitialize(ctx, in)
1571}
1572
1573type validateOpGetTables struct {
1574}
1575
1576func (*validateOpGetTables) ID() string {
1577	return "OperationInputValidation"
1578}
1579
1580func (m *validateOpGetTables) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1582) {
1583	input, ok := in.Parameters.(*GetTablesInput)
1584	if !ok {
1585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1586	}
1587	if err := validateOpGetTablesInput(input); err != nil {
1588		return out, metadata, err
1589	}
1590	return next.HandleInitialize(ctx, in)
1591}
1592
1593type validateOpGetTableVersion struct {
1594}
1595
1596func (*validateOpGetTableVersion) ID() string {
1597	return "OperationInputValidation"
1598}
1599
1600func (m *validateOpGetTableVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1602) {
1603	input, ok := in.Parameters.(*GetTableVersionInput)
1604	if !ok {
1605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1606	}
1607	if err := validateOpGetTableVersionInput(input); err != nil {
1608		return out, metadata, err
1609	}
1610	return next.HandleInitialize(ctx, in)
1611}
1612
1613type validateOpGetTableVersions struct {
1614}
1615
1616func (*validateOpGetTableVersions) ID() string {
1617	return "OperationInputValidation"
1618}
1619
1620func (m *validateOpGetTableVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1622) {
1623	input, ok := in.Parameters.(*GetTableVersionsInput)
1624	if !ok {
1625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1626	}
1627	if err := validateOpGetTableVersionsInput(input); err != nil {
1628		return out, metadata, err
1629	}
1630	return next.HandleInitialize(ctx, in)
1631}
1632
1633type validateOpGetTags struct {
1634}
1635
1636func (*validateOpGetTags) ID() string {
1637	return "OperationInputValidation"
1638}
1639
1640func (m *validateOpGetTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1641	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1642) {
1643	input, ok := in.Parameters.(*GetTagsInput)
1644	if !ok {
1645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1646	}
1647	if err := validateOpGetTagsInput(input); err != nil {
1648		return out, metadata, err
1649	}
1650	return next.HandleInitialize(ctx, in)
1651}
1652
1653type validateOpGetTrigger struct {
1654}
1655
1656func (*validateOpGetTrigger) ID() string {
1657	return "OperationInputValidation"
1658}
1659
1660func (m *validateOpGetTrigger) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1661	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1662) {
1663	input, ok := in.Parameters.(*GetTriggerInput)
1664	if !ok {
1665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1666	}
1667	if err := validateOpGetTriggerInput(input); err != nil {
1668		return out, metadata, err
1669	}
1670	return next.HandleInitialize(ctx, in)
1671}
1672
1673type validateOpGetUserDefinedFunction struct {
1674}
1675
1676func (*validateOpGetUserDefinedFunction) ID() string {
1677	return "OperationInputValidation"
1678}
1679
1680func (m *validateOpGetUserDefinedFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1681	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1682) {
1683	input, ok := in.Parameters.(*GetUserDefinedFunctionInput)
1684	if !ok {
1685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1686	}
1687	if err := validateOpGetUserDefinedFunctionInput(input); err != nil {
1688		return out, metadata, err
1689	}
1690	return next.HandleInitialize(ctx, in)
1691}
1692
1693type validateOpGetUserDefinedFunctions struct {
1694}
1695
1696func (*validateOpGetUserDefinedFunctions) ID() string {
1697	return "OperationInputValidation"
1698}
1699
1700func (m *validateOpGetUserDefinedFunctions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1701	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1702) {
1703	input, ok := in.Parameters.(*GetUserDefinedFunctionsInput)
1704	if !ok {
1705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1706	}
1707	if err := validateOpGetUserDefinedFunctionsInput(input); err != nil {
1708		return out, metadata, err
1709	}
1710	return next.HandleInitialize(ctx, in)
1711}
1712
1713type validateOpGetWorkflow struct {
1714}
1715
1716func (*validateOpGetWorkflow) ID() string {
1717	return "OperationInputValidation"
1718}
1719
1720func (m *validateOpGetWorkflow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1721	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1722) {
1723	input, ok := in.Parameters.(*GetWorkflowInput)
1724	if !ok {
1725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1726	}
1727	if err := validateOpGetWorkflowInput(input); err != nil {
1728		return out, metadata, err
1729	}
1730	return next.HandleInitialize(ctx, in)
1731}
1732
1733type validateOpGetWorkflowRun struct {
1734}
1735
1736func (*validateOpGetWorkflowRun) ID() string {
1737	return "OperationInputValidation"
1738}
1739
1740func (m *validateOpGetWorkflowRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1741	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1742) {
1743	input, ok := in.Parameters.(*GetWorkflowRunInput)
1744	if !ok {
1745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1746	}
1747	if err := validateOpGetWorkflowRunInput(input); err != nil {
1748		return out, metadata, err
1749	}
1750	return next.HandleInitialize(ctx, in)
1751}
1752
1753type validateOpGetWorkflowRunProperties struct {
1754}
1755
1756func (*validateOpGetWorkflowRunProperties) ID() string {
1757	return "OperationInputValidation"
1758}
1759
1760func (m *validateOpGetWorkflowRunProperties) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1761	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1762) {
1763	input, ok := in.Parameters.(*GetWorkflowRunPropertiesInput)
1764	if !ok {
1765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1766	}
1767	if err := validateOpGetWorkflowRunPropertiesInput(input); err != nil {
1768		return out, metadata, err
1769	}
1770	return next.HandleInitialize(ctx, in)
1771}
1772
1773type validateOpGetWorkflowRuns struct {
1774}
1775
1776func (*validateOpGetWorkflowRuns) ID() string {
1777	return "OperationInputValidation"
1778}
1779
1780func (m *validateOpGetWorkflowRuns) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1781	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1782) {
1783	input, ok := in.Parameters.(*GetWorkflowRunsInput)
1784	if !ok {
1785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1786	}
1787	if err := validateOpGetWorkflowRunsInput(input); err != nil {
1788		return out, metadata, err
1789	}
1790	return next.HandleInitialize(ctx, in)
1791}
1792
1793type validateOpListMLTransforms struct {
1794}
1795
1796func (*validateOpListMLTransforms) ID() string {
1797	return "OperationInputValidation"
1798}
1799
1800func (m *validateOpListMLTransforms) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1802) {
1803	input, ok := in.Parameters.(*ListMLTransformsInput)
1804	if !ok {
1805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1806	}
1807	if err := validateOpListMLTransformsInput(input); err != nil {
1808		return out, metadata, err
1809	}
1810	return next.HandleInitialize(ctx, in)
1811}
1812
1813type validateOpListSchemaVersions struct {
1814}
1815
1816func (*validateOpListSchemaVersions) ID() string {
1817	return "OperationInputValidation"
1818}
1819
1820func (m *validateOpListSchemaVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1822) {
1823	input, ok := in.Parameters.(*ListSchemaVersionsInput)
1824	if !ok {
1825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1826	}
1827	if err := validateOpListSchemaVersionsInput(input); err != nil {
1828		return out, metadata, err
1829	}
1830	return next.HandleInitialize(ctx, in)
1831}
1832
1833type validateOpPutDataCatalogEncryptionSettings struct {
1834}
1835
1836func (*validateOpPutDataCatalogEncryptionSettings) ID() string {
1837	return "OperationInputValidation"
1838}
1839
1840func (m *validateOpPutDataCatalogEncryptionSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1842) {
1843	input, ok := in.Parameters.(*PutDataCatalogEncryptionSettingsInput)
1844	if !ok {
1845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1846	}
1847	if err := validateOpPutDataCatalogEncryptionSettingsInput(input); err != nil {
1848		return out, metadata, err
1849	}
1850	return next.HandleInitialize(ctx, in)
1851}
1852
1853type validateOpPutResourcePolicy struct {
1854}
1855
1856func (*validateOpPutResourcePolicy) ID() string {
1857	return "OperationInputValidation"
1858}
1859
1860func (m *validateOpPutResourcePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1862) {
1863	input, ok := in.Parameters.(*PutResourcePolicyInput)
1864	if !ok {
1865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1866	}
1867	if err := validateOpPutResourcePolicyInput(input); err != nil {
1868		return out, metadata, err
1869	}
1870	return next.HandleInitialize(ctx, in)
1871}
1872
1873type validateOpPutSchemaVersionMetadata struct {
1874}
1875
1876func (*validateOpPutSchemaVersionMetadata) ID() string {
1877	return "OperationInputValidation"
1878}
1879
1880func (m *validateOpPutSchemaVersionMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1882) {
1883	input, ok := in.Parameters.(*PutSchemaVersionMetadataInput)
1884	if !ok {
1885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1886	}
1887	if err := validateOpPutSchemaVersionMetadataInput(input); err != nil {
1888		return out, metadata, err
1889	}
1890	return next.HandleInitialize(ctx, in)
1891}
1892
1893type validateOpPutWorkflowRunProperties struct {
1894}
1895
1896func (*validateOpPutWorkflowRunProperties) ID() string {
1897	return "OperationInputValidation"
1898}
1899
1900func (m *validateOpPutWorkflowRunProperties) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1902) {
1903	input, ok := in.Parameters.(*PutWorkflowRunPropertiesInput)
1904	if !ok {
1905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1906	}
1907	if err := validateOpPutWorkflowRunPropertiesInput(input); err != nil {
1908		return out, metadata, err
1909	}
1910	return next.HandleInitialize(ctx, in)
1911}
1912
1913type validateOpRegisterSchemaVersion struct {
1914}
1915
1916func (*validateOpRegisterSchemaVersion) ID() string {
1917	return "OperationInputValidation"
1918}
1919
1920func (m *validateOpRegisterSchemaVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1922) {
1923	input, ok := in.Parameters.(*RegisterSchemaVersionInput)
1924	if !ok {
1925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1926	}
1927	if err := validateOpRegisterSchemaVersionInput(input); err != nil {
1928		return out, metadata, err
1929	}
1930	return next.HandleInitialize(ctx, in)
1931}
1932
1933type validateOpRemoveSchemaVersionMetadata struct {
1934}
1935
1936func (*validateOpRemoveSchemaVersionMetadata) ID() string {
1937	return "OperationInputValidation"
1938}
1939
1940func (m *validateOpRemoveSchemaVersionMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1942) {
1943	input, ok := in.Parameters.(*RemoveSchemaVersionMetadataInput)
1944	if !ok {
1945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1946	}
1947	if err := validateOpRemoveSchemaVersionMetadataInput(input); err != nil {
1948		return out, metadata, err
1949	}
1950	return next.HandleInitialize(ctx, in)
1951}
1952
1953type validateOpResetJobBookmark struct {
1954}
1955
1956func (*validateOpResetJobBookmark) ID() string {
1957	return "OperationInputValidation"
1958}
1959
1960func (m *validateOpResetJobBookmark) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1962) {
1963	input, ok := in.Parameters.(*ResetJobBookmarkInput)
1964	if !ok {
1965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1966	}
1967	if err := validateOpResetJobBookmarkInput(input); err != nil {
1968		return out, metadata, err
1969	}
1970	return next.HandleInitialize(ctx, in)
1971}
1972
1973type validateOpResumeWorkflowRun struct {
1974}
1975
1976func (*validateOpResumeWorkflowRun) ID() string {
1977	return "OperationInputValidation"
1978}
1979
1980func (m *validateOpResumeWorkflowRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1982) {
1983	input, ok := in.Parameters.(*ResumeWorkflowRunInput)
1984	if !ok {
1985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1986	}
1987	if err := validateOpResumeWorkflowRunInput(input); err != nil {
1988		return out, metadata, err
1989	}
1990	return next.HandleInitialize(ctx, in)
1991}
1992
1993type validateOpStartCrawler struct {
1994}
1995
1996func (*validateOpStartCrawler) ID() string {
1997	return "OperationInputValidation"
1998}
1999
2000func (m *validateOpStartCrawler) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2002) {
2003	input, ok := in.Parameters.(*StartCrawlerInput)
2004	if !ok {
2005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2006	}
2007	if err := validateOpStartCrawlerInput(input); err != nil {
2008		return out, metadata, err
2009	}
2010	return next.HandleInitialize(ctx, in)
2011}
2012
2013type validateOpStartCrawlerSchedule struct {
2014}
2015
2016func (*validateOpStartCrawlerSchedule) ID() string {
2017	return "OperationInputValidation"
2018}
2019
2020func (m *validateOpStartCrawlerSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2022) {
2023	input, ok := in.Parameters.(*StartCrawlerScheduleInput)
2024	if !ok {
2025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2026	}
2027	if err := validateOpStartCrawlerScheduleInput(input); err != nil {
2028		return out, metadata, err
2029	}
2030	return next.HandleInitialize(ctx, in)
2031}
2032
2033type validateOpStartExportLabelsTaskRun struct {
2034}
2035
2036func (*validateOpStartExportLabelsTaskRun) ID() string {
2037	return "OperationInputValidation"
2038}
2039
2040func (m *validateOpStartExportLabelsTaskRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2042) {
2043	input, ok := in.Parameters.(*StartExportLabelsTaskRunInput)
2044	if !ok {
2045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2046	}
2047	if err := validateOpStartExportLabelsTaskRunInput(input); err != nil {
2048		return out, metadata, err
2049	}
2050	return next.HandleInitialize(ctx, in)
2051}
2052
2053type validateOpStartImportLabelsTaskRun struct {
2054}
2055
2056func (*validateOpStartImportLabelsTaskRun) ID() string {
2057	return "OperationInputValidation"
2058}
2059
2060func (m *validateOpStartImportLabelsTaskRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2062) {
2063	input, ok := in.Parameters.(*StartImportLabelsTaskRunInput)
2064	if !ok {
2065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2066	}
2067	if err := validateOpStartImportLabelsTaskRunInput(input); err != nil {
2068		return out, metadata, err
2069	}
2070	return next.HandleInitialize(ctx, in)
2071}
2072
2073type validateOpStartJobRun struct {
2074}
2075
2076func (*validateOpStartJobRun) ID() string {
2077	return "OperationInputValidation"
2078}
2079
2080func (m *validateOpStartJobRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2082) {
2083	input, ok := in.Parameters.(*StartJobRunInput)
2084	if !ok {
2085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2086	}
2087	if err := validateOpStartJobRunInput(input); err != nil {
2088		return out, metadata, err
2089	}
2090	return next.HandleInitialize(ctx, in)
2091}
2092
2093type validateOpStartMLEvaluationTaskRun struct {
2094}
2095
2096func (*validateOpStartMLEvaluationTaskRun) ID() string {
2097	return "OperationInputValidation"
2098}
2099
2100func (m *validateOpStartMLEvaluationTaskRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2102) {
2103	input, ok := in.Parameters.(*StartMLEvaluationTaskRunInput)
2104	if !ok {
2105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2106	}
2107	if err := validateOpStartMLEvaluationTaskRunInput(input); err != nil {
2108		return out, metadata, err
2109	}
2110	return next.HandleInitialize(ctx, in)
2111}
2112
2113type validateOpStartMLLabelingSetGenerationTaskRun struct {
2114}
2115
2116func (*validateOpStartMLLabelingSetGenerationTaskRun) ID() string {
2117	return "OperationInputValidation"
2118}
2119
2120func (m *validateOpStartMLLabelingSetGenerationTaskRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2122) {
2123	input, ok := in.Parameters.(*StartMLLabelingSetGenerationTaskRunInput)
2124	if !ok {
2125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2126	}
2127	if err := validateOpStartMLLabelingSetGenerationTaskRunInput(input); err != nil {
2128		return out, metadata, err
2129	}
2130	return next.HandleInitialize(ctx, in)
2131}
2132
2133type validateOpStartTrigger struct {
2134}
2135
2136func (*validateOpStartTrigger) ID() string {
2137	return "OperationInputValidation"
2138}
2139
2140func (m *validateOpStartTrigger) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2142) {
2143	input, ok := in.Parameters.(*StartTriggerInput)
2144	if !ok {
2145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2146	}
2147	if err := validateOpStartTriggerInput(input); err != nil {
2148		return out, metadata, err
2149	}
2150	return next.HandleInitialize(ctx, in)
2151}
2152
2153type validateOpStartWorkflowRun struct {
2154}
2155
2156func (*validateOpStartWorkflowRun) ID() string {
2157	return "OperationInputValidation"
2158}
2159
2160func (m *validateOpStartWorkflowRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2162) {
2163	input, ok := in.Parameters.(*StartWorkflowRunInput)
2164	if !ok {
2165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2166	}
2167	if err := validateOpStartWorkflowRunInput(input); err != nil {
2168		return out, metadata, err
2169	}
2170	return next.HandleInitialize(ctx, in)
2171}
2172
2173type validateOpStopCrawler struct {
2174}
2175
2176func (*validateOpStopCrawler) ID() string {
2177	return "OperationInputValidation"
2178}
2179
2180func (m *validateOpStopCrawler) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2182) {
2183	input, ok := in.Parameters.(*StopCrawlerInput)
2184	if !ok {
2185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2186	}
2187	if err := validateOpStopCrawlerInput(input); err != nil {
2188		return out, metadata, err
2189	}
2190	return next.HandleInitialize(ctx, in)
2191}
2192
2193type validateOpStopCrawlerSchedule struct {
2194}
2195
2196func (*validateOpStopCrawlerSchedule) ID() string {
2197	return "OperationInputValidation"
2198}
2199
2200func (m *validateOpStopCrawlerSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2202) {
2203	input, ok := in.Parameters.(*StopCrawlerScheduleInput)
2204	if !ok {
2205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2206	}
2207	if err := validateOpStopCrawlerScheduleInput(input); err != nil {
2208		return out, metadata, err
2209	}
2210	return next.HandleInitialize(ctx, in)
2211}
2212
2213type validateOpStopTrigger struct {
2214}
2215
2216func (*validateOpStopTrigger) ID() string {
2217	return "OperationInputValidation"
2218}
2219
2220func (m *validateOpStopTrigger) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2222) {
2223	input, ok := in.Parameters.(*StopTriggerInput)
2224	if !ok {
2225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2226	}
2227	if err := validateOpStopTriggerInput(input); err != nil {
2228		return out, metadata, err
2229	}
2230	return next.HandleInitialize(ctx, in)
2231}
2232
2233type validateOpStopWorkflowRun struct {
2234}
2235
2236func (*validateOpStopWorkflowRun) ID() string {
2237	return "OperationInputValidation"
2238}
2239
2240func (m *validateOpStopWorkflowRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2242) {
2243	input, ok := in.Parameters.(*StopWorkflowRunInput)
2244	if !ok {
2245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2246	}
2247	if err := validateOpStopWorkflowRunInput(input); err != nil {
2248		return out, metadata, err
2249	}
2250	return next.HandleInitialize(ctx, in)
2251}
2252
2253type validateOpTagResource struct {
2254}
2255
2256func (*validateOpTagResource) ID() string {
2257	return "OperationInputValidation"
2258}
2259
2260func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2262) {
2263	input, ok := in.Parameters.(*TagResourceInput)
2264	if !ok {
2265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2266	}
2267	if err := validateOpTagResourceInput(input); err != nil {
2268		return out, metadata, err
2269	}
2270	return next.HandleInitialize(ctx, in)
2271}
2272
2273type validateOpUntagResource struct {
2274}
2275
2276func (*validateOpUntagResource) ID() string {
2277	return "OperationInputValidation"
2278}
2279
2280func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2282) {
2283	input, ok := in.Parameters.(*UntagResourceInput)
2284	if !ok {
2285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2286	}
2287	if err := validateOpUntagResourceInput(input); err != nil {
2288		return out, metadata, err
2289	}
2290	return next.HandleInitialize(ctx, in)
2291}
2292
2293type validateOpUpdateClassifier struct {
2294}
2295
2296func (*validateOpUpdateClassifier) ID() string {
2297	return "OperationInputValidation"
2298}
2299
2300func (m *validateOpUpdateClassifier) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2302) {
2303	input, ok := in.Parameters.(*UpdateClassifierInput)
2304	if !ok {
2305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2306	}
2307	if err := validateOpUpdateClassifierInput(input); err != nil {
2308		return out, metadata, err
2309	}
2310	return next.HandleInitialize(ctx, in)
2311}
2312
2313type validateOpUpdateColumnStatisticsForPartition struct {
2314}
2315
2316func (*validateOpUpdateColumnStatisticsForPartition) ID() string {
2317	return "OperationInputValidation"
2318}
2319
2320func (m *validateOpUpdateColumnStatisticsForPartition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2322) {
2323	input, ok := in.Parameters.(*UpdateColumnStatisticsForPartitionInput)
2324	if !ok {
2325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2326	}
2327	if err := validateOpUpdateColumnStatisticsForPartitionInput(input); err != nil {
2328		return out, metadata, err
2329	}
2330	return next.HandleInitialize(ctx, in)
2331}
2332
2333type validateOpUpdateColumnStatisticsForTable struct {
2334}
2335
2336func (*validateOpUpdateColumnStatisticsForTable) ID() string {
2337	return "OperationInputValidation"
2338}
2339
2340func (m *validateOpUpdateColumnStatisticsForTable) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2342) {
2343	input, ok := in.Parameters.(*UpdateColumnStatisticsForTableInput)
2344	if !ok {
2345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2346	}
2347	if err := validateOpUpdateColumnStatisticsForTableInput(input); err != nil {
2348		return out, metadata, err
2349	}
2350	return next.HandleInitialize(ctx, in)
2351}
2352
2353type validateOpUpdateConnection struct {
2354}
2355
2356func (*validateOpUpdateConnection) ID() string {
2357	return "OperationInputValidation"
2358}
2359
2360func (m *validateOpUpdateConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2362) {
2363	input, ok := in.Parameters.(*UpdateConnectionInput)
2364	if !ok {
2365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2366	}
2367	if err := validateOpUpdateConnectionInput(input); err != nil {
2368		return out, metadata, err
2369	}
2370	return next.HandleInitialize(ctx, in)
2371}
2372
2373type validateOpUpdateCrawler struct {
2374}
2375
2376func (*validateOpUpdateCrawler) ID() string {
2377	return "OperationInputValidation"
2378}
2379
2380func (m *validateOpUpdateCrawler) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2382) {
2383	input, ok := in.Parameters.(*UpdateCrawlerInput)
2384	if !ok {
2385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2386	}
2387	if err := validateOpUpdateCrawlerInput(input); err != nil {
2388		return out, metadata, err
2389	}
2390	return next.HandleInitialize(ctx, in)
2391}
2392
2393type validateOpUpdateCrawlerSchedule struct {
2394}
2395
2396func (*validateOpUpdateCrawlerSchedule) ID() string {
2397	return "OperationInputValidation"
2398}
2399
2400func (m *validateOpUpdateCrawlerSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2402) {
2403	input, ok := in.Parameters.(*UpdateCrawlerScheduleInput)
2404	if !ok {
2405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2406	}
2407	if err := validateOpUpdateCrawlerScheduleInput(input); err != nil {
2408		return out, metadata, err
2409	}
2410	return next.HandleInitialize(ctx, in)
2411}
2412
2413type validateOpUpdateDatabase struct {
2414}
2415
2416func (*validateOpUpdateDatabase) ID() string {
2417	return "OperationInputValidation"
2418}
2419
2420func (m *validateOpUpdateDatabase) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2422) {
2423	input, ok := in.Parameters.(*UpdateDatabaseInput)
2424	if !ok {
2425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2426	}
2427	if err := validateOpUpdateDatabaseInput(input); err != nil {
2428		return out, metadata, err
2429	}
2430	return next.HandleInitialize(ctx, in)
2431}
2432
2433type validateOpUpdateDevEndpoint struct {
2434}
2435
2436func (*validateOpUpdateDevEndpoint) ID() string {
2437	return "OperationInputValidation"
2438}
2439
2440func (m *validateOpUpdateDevEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2442) {
2443	input, ok := in.Parameters.(*UpdateDevEndpointInput)
2444	if !ok {
2445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2446	}
2447	if err := validateOpUpdateDevEndpointInput(input); err != nil {
2448		return out, metadata, err
2449	}
2450	return next.HandleInitialize(ctx, in)
2451}
2452
2453type validateOpUpdateJob struct {
2454}
2455
2456func (*validateOpUpdateJob) ID() string {
2457	return "OperationInputValidation"
2458}
2459
2460func (m *validateOpUpdateJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2462) {
2463	input, ok := in.Parameters.(*UpdateJobInput)
2464	if !ok {
2465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2466	}
2467	if err := validateOpUpdateJobInput(input); err != nil {
2468		return out, metadata, err
2469	}
2470	return next.HandleInitialize(ctx, in)
2471}
2472
2473type validateOpUpdateMLTransform struct {
2474}
2475
2476func (*validateOpUpdateMLTransform) ID() string {
2477	return "OperationInputValidation"
2478}
2479
2480func (m *validateOpUpdateMLTransform) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2482) {
2483	input, ok := in.Parameters.(*UpdateMLTransformInput)
2484	if !ok {
2485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2486	}
2487	if err := validateOpUpdateMLTransformInput(input); err != nil {
2488		return out, metadata, err
2489	}
2490	return next.HandleInitialize(ctx, in)
2491}
2492
2493type validateOpUpdatePartition struct {
2494}
2495
2496func (*validateOpUpdatePartition) ID() string {
2497	return "OperationInputValidation"
2498}
2499
2500func (m *validateOpUpdatePartition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2502) {
2503	input, ok := in.Parameters.(*UpdatePartitionInput)
2504	if !ok {
2505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2506	}
2507	if err := validateOpUpdatePartitionInput(input); err != nil {
2508		return out, metadata, err
2509	}
2510	return next.HandleInitialize(ctx, in)
2511}
2512
2513type validateOpUpdateRegistry struct {
2514}
2515
2516func (*validateOpUpdateRegistry) ID() string {
2517	return "OperationInputValidation"
2518}
2519
2520func (m *validateOpUpdateRegistry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2522) {
2523	input, ok := in.Parameters.(*UpdateRegistryInput)
2524	if !ok {
2525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2526	}
2527	if err := validateOpUpdateRegistryInput(input); err != nil {
2528		return out, metadata, err
2529	}
2530	return next.HandleInitialize(ctx, in)
2531}
2532
2533type validateOpUpdateSchema struct {
2534}
2535
2536func (*validateOpUpdateSchema) ID() string {
2537	return "OperationInputValidation"
2538}
2539
2540func (m *validateOpUpdateSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2542) {
2543	input, ok := in.Parameters.(*UpdateSchemaInput)
2544	if !ok {
2545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2546	}
2547	if err := validateOpUpdateSchemaInput(input); err != nil {
2548		return out, metadata, err
2549	}
2550	return next.HandleInitialize(ctx, in)
2551}
2552
2553type validateOpUpdateTable struct {
2554}
2555
2556func (*validateOpUpdateTable) ID() string {
2557	return "OperationInputValidation"
2558}
2559
2560func (m *validateOpUpdateTable) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2562) {
2563	input, ok := in.Parameters.(*UpdateTableInput)
2564	if !ok {
2565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2566	}
2567	if err := validateOpUpdateTableInput(input); err != nil {
2568		return out, metadata, err
2569	}
2570	return next.HandleInitialize(ctx, in)
2571}
2572
2573type validateOpUpdateTrigger struct {
2574}
2575
2576func (*validateOpUpdateTrigger) ID() string {
2577	return "OperationInputValidation"
2578}
2579
2580func (m *validateOpUpdateTrigger) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2582) {
2583	input, ok := in.Parameters.(*UpdateTriggerInput)
2584	if !ok {
2585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2586	}
2587	if err := validateOpUpdateTriggerInput(input); err != nil {
2588		return out, metadata, err
2589	}
2590	return next.HandleInitialize(ctx, in)
2591}
2592
2593type validateOpUpdateUserDefinedFunction struct {
2594}
2595
2596func (*validateOpUpdateUserDefinedFunction) ID() string {
2597	return "OperationInputValidation"
2598}
2599
2600func (m *validateOpUpdateUserDefinedFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2602) {
2603	input, ok := in.Parameters.(*UpdateUserDefinedFunctionInput)
2604	if !ok {
2605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2606	}
2607	if err := validateOpUpdateUserDefinedFunctionInput(input); err != nil {
2608		return out, metadata, err
2609	}
2610	return next.HandleInitialize(ctx, in)
2611}
2612
2613type validateOpUpdateWorkflow struct {
2614}
2615
2616func (*validateOpUpdateWorkflow) ID() string {
2617	return "OperationInputValidation"
2618}
2619
2620func (m *validateOpUpdateWorkflow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2622) {
2623	input, ok := in.Parameters.(*UpdateWorkflowInput)
2624	if !ok {
2625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2626	}
2627	if err := validateOpUpdateWorkflowInput(input); err != nil {
2628		return out, metadata, err
2629	}
2630	return next.HandleInitialize(ctx, in)
2631}
2632
2633func addOpBatchCreatePartitionValidationMiddleware(stack *middleware.Stack) error {
2634	return stack.Initialize.Add(&validateOpBatchCreatePartition{}, middleware.After)
2635}
2636
2637func addOpBatchDeleteConnectionValidationMiddleware(stack *middleware.Stack) error {
2638	return stack.Initialize.Add(&validateOpBatchDeleteConnection{}, middleware.After)
2639}
2640
2641func addOpBatchDeletePartitionValidationMiddleware(stack *middleware.Stack) error {
2642	return stack.Initialize.Add(&validateOpBatchDeletePartition{}, middleware.After)
2643}
2644
2645func addOpBatchDeleteTableValidationMiddleware(stack *middleware.Stack) error {
2646	return stack.Initialize.Add(&validateOpBatchDeleteTable{}, middleware.After)
2647}
2648
2649func addOpBatchDeleteTableVersionValidationMiddleware(stack *middleware.Stack) error {
2650	return stack.Initialize.Add(&validateOpBatchDeleteTableVersion{}, middleware.After)
2651}
2652
2653func addOpBatchGetCrawlersValidationMiddleware(stack *middleware.Stack) error {
2654	return stack.Initialize.Add(&validateOpBatchGetCrawlers{}, middleware.After)
2655}
2656
2657func addOpBatchGetDevEndpointsValidationMiddleware(stack *middleware.Stack) error {
2658	return stack.Initialize.Add(&validateOpBatchGetDevEndpoints{}, middleware.After)
2659}
2660
2661func addOpBatchGetJobsValidationMiddleware(stack *middleware.Stack) error {
2662	return stack.Initialize.Add(&validateOpBatchGetJobs{}, middleware.After)
2663}
2664
2665func addOpBatchGetPartitionValidationMiddleware(stack *middleware.Stack) error {
2666	return stack.Initialize.Add(&validateOpBatchGetPartition{}, middleware.After)
2667}
2668
2669func addOpBatchGetTriggersValidationMiddleware(stack *middleware.Stack) error {
2670	return stack.Initialize.Add(&validateOpBatchGetTriggers{}, middleware.After)
2671}
2672
2673func addOpBatchGetWorkflowsValidationMiddleware(stack *middleware.Stack) error {
2674	return stack.Initialize.Add(&validateOpBatchGetWorkflows{}, middleware.After)
2675}
2676
2677func addOpBatchStopJobRunValidationMiddleware(stack *middleware.Stack) error {
2678	return stack.Initialize.Add(&validateOpBatchStopJobRun{}, middleware.After)
2679}
2680
2681func addOpBatchUpdatePartitionValidationMiddleware(stack *middleware.Stack) error {
2682	return stack.Initialize.Add(&validateOpBatchUpdatePartition{}, middleware.After)
2683}
2684
2685func addOpCancelMLTaskRunValidationMiddleware(stack *middleware.Stack) error {
2686	return stack.Initialize.Add(&validateOpCancelMLTaskRun{}, middleware.After)
2687}
2688
2689func addOpCheckSchemaVersionValidityValidationMiddleware(stack *middleware.Stack) error {
2690	return stack.Initialize.Add(&validateOpCheckSchemaVersionValidity{}, middleware.After)
2691}
2692
2693func addOpCreateClassifierValidationMiddleware(stack *middleware.Stack) error {
2694	return stack.Initialize.Add(&validateOpCreateClassifier{}, middleware.After)
2695}
2696
2697func addOpCreateConnectionValidationMiddleware(stack *middleware.Stack) error {
2698	return stack.Initialize.Add(&validateOpCreateConnection{}, middleware.After)
2699}
2700
2701func addOpCreateCrawlerValidationMiddleware(stack *middleware.Stack) error {
2702	return stack.Initialize.Add(&validateOpCreateCrawler{}, middleware.After)
2703}
2704
2705func addOpCreateDatabaseValidationMiddleware(stack *middleware.Stack) error {
2706	return stack.Initialize.Add(&validateOpCreateDatabase{}, middleware.After)
2707}
2708
2709func addOpCreateDevEndpointValidationMiddleware(stack *middleware.Stack) error {
2710	return stack.Initialize.Add(&validateOpCreateDevEndpoint{}, middleware.After)
2711}
2712
2713func addOpCreateJobValidationMiddleware(stack *middleware.Stack) error {
2714	return stack.Initialize.Add(&validateOpCreateJob{}, middleware.After)
2715}
2716
2717func addOpCreateMLTransformValidationMiddleware(stack *middleware.Stack) error {
2718	return stack.Initialize.Add(&validateOpCreateMLTransform{}, middleware.After)
2719}
2720
2721func addOpCreatePartitionIndexValidationMiddleware(stack *middleware.Stack) error {
2722	return stack.Initialize.Add(&validateOpCreatePartitionIndex{}, middleware.After)
2723}
2724
2725func addOpCreatePartitionValidationMiddleware(stack *middleware.Stack) error {
2726	return stack.Initialize.Add(&validateOpCreatePartition{}, middleware.After)
2727}
2728
2729func addOpCreateRegistryValidationMiddleware(stack *middleware.Stack) error {
2730	return stack.Initialize.Add(&validateOpCreateRegistry{}, middleware.After)
2731}
2732
2733func addOpCreateSchemaValidationMiddleware(stack *middleware.Stack) error {
2734	return stack.Initialize.Add(&validateOpCreateSchema{}, middleware.After)
2735}
2736
2737func addOpCreateScriptValidationMiddleware(stack *middleware.Stack) error {
2738	return stack.Initialize.Add(&validateOpCreateScript{}, middleware.After)
2739}
2740
2741func addOpCreateSecurityConfigurationValidationMiddleware(stack *middleware.Stack) error {
2742	return stack.Initialize.Add(&validateOpCreateSecurityConfiguration{}, middleware.After)
2743}
2744
2745func addOpCreateTableValidationMiddleware(stack *middleware.Stack) error {
2746	return stack.Initialize.Add(&validateOpCreateTable{}, middleware.After)
2747}
2748
2749func addOpCreateTriggerValidationMiddleware(stack *middleware.Stack) error {
2750	return stack.Initialize.Add(&validateOpCreateTrigger{}, middleware.After)
2751}
2752
2753func addOpCreateUserDefinedFunctionValidationMiddleware(stack *middleware.Stack) error {
2754	return stack.Initialize.Add(&validateOpCreateUserDefinedFunction{}, middleware.After)
2755}
2756
2757func addOpCreateWorkflowValidationMiddleware(stack *middleware.Stack) error {
2758	return stack.Initialize.Add(&validateOpCreateWorkflow{}, middleware.After)
2759}
2760
2761func addOpDeleteClassifierValidationMiddleware(stack *middleware.Stack) error {
2762	return stack.Initialize.Add(&validateOpDeleteClassifier{}, middleware.After)
2763}
2764
2765func addOpDeleteColumnStatisticsForPartitionValidationMiddleware(stack *middleware.Stack) error {
2766	return stack.Initialize.Add(&validateOpDeleteColumnStatisticsForPartition{}, middleware.After)
2767}
2768
2769func addOpDeleteColumnStatisticsForTableValidationMiddleware(stack *middleware.Stack) error {
2770	return stack.Initialize.Add(&validateOpDeleteColumnStatisticsForTable{}, middleware.After)
2771}
2772
2773func addOpDeleteConnectionValidationMiddleware(stack *middleware.Stack) error {
2774	return stack.Initialize.Add(&validateOpDeleteConnection{}, middleware.After)
2775}
2776
2777func addOpDeleteCrawlerValidationMiddleware(stack *middleware.Stack) error {
2778	return stack.Initialize.Add(&validateOpDeleteCrawler{}, middleware.After)
2779}
2780
2781func addOpDeleteDatabaseValidationMiddleware(stack *middleware.Stack) error {
2782	return stack.Initialize.Add(&validateOpDeleteDatabase{}, middleware.After)
2783}
2784
2785func addOpDeleteDevEndpointValidationMiddleware(stack *middleware.Stack) error {
2786	return stack.Initialize.Add(&validateOpDeleteDevEndpoint{}, middleware.After)
2787}
2788
2789func addOpDeleteJobValidationMiddleware(stack *middleware.Stack) error {
2790	return stack.Initialize.Add(&validateOpDeleteJob{}, middleware.After)
2791}
2792
2793func addOpDeleteMLTransformValidationMiddleware(stack *middleware.Stack) error {
2794	return stack.Initialize.Add(&validateOpDeleteMLTransform{}, middleware.After)
2795}
2796
2797func addOpDeletePartitionIndexValidationMiddleware(stack *middleware.Stack) error {
2798	return stack.Initialize.Add(&validateOpDeletePartitionIndex{}, middleware.After)
2799}
2800
2801func addOpDeletePartitionValidationMiddleware(stack *middleware.Stack) error {
2802	return stack.Initialize.Add(&validateOpDeletePartition{}, middleware.After)
2803}
2804
2805func addOpDeleteRegistryValidationMiddleware(stack *middleware.Stack) error {
2806	return stack.Initialize.Add(&validateOpDeleteRegistry{}, middleware.After)
2807}
2808
2809func addOpDeleteSchemaValidationMiddleware(stack *middleware.Stack) error {
2810	return stack.Initialize.Add(&validateOpDeleteSchema{}, middleware.After)
2811}
2812
2813func addOpDeleteSchemaVersionsValidationMiddleware(stack *middleware.Stack) error {
2814	return stack.Initialize.Add(&validateOpDeleteSchemaVersions{}, middleware.After)
2815}
2816
2817func addOpDeleteSecurityConfigurationValidationMiddleware(stack *middleware.Stack) error {
2818	return stack.Initialize.Add(&validateOpDeleteSecurityConfiguration{}, middleware.After)
2819}
2820
2821func addOpDeleteTableValidationMiddleware(stack *middleware.Stack) error {
2822	return stack.Initialize.Add(&validateOpDeleteTable{}, middleware.After)
2823}
2824
2825func addOpDeleteTableVersionValidationMiddleware(stack *middleware.Stack) error {
2826	return stack.Initialize.Add(&validateOpDeleteTableVersion{}, middleware.After)
2827}
2828
2829func addOpDeleteTriggerValidationMiddleware(stack *middleware.Stack) error {
2830	return stack.Initialize.Add(&validateOpDeleteTrigger{}, middleware.After)
2831}
2832
2833func addOpDeleteUserDefinedFunctionValidationMiddleware(stack *middleware.Stack) error {
2834	return stack.Initialize.Add(&validateOpDeleteUserDefinedFunction{}, middleware.After)
2835}
2836
2837func addOpDeleteWorkflowValidationMiddleware(stack *middleware.Stack) error {
2838	return stack.Initialize.Add(&validateOpDeleteWorkflow{}, middleware.After)
2839}
2840
2841func addOpGetClassifierValidationMiddleware(stack *middleware.Stack) error {
2842	return stack.Initialize.Add(&validateOpGetClassifier{}, middleware.After)
2843}
2844
2845func addOpGetColumnStatisticsForPartitionValidationMiddleware(stack *middleware.Stack) error {
2846	return stack.Initialize.Add(&validateOpGetColumnStatisticsForPartition{}, middleware.After)
2847}
2848
2849func addOpGetColumnStatisticsForTableValidationMiddleware(stack *middleware.Stack) error {
2850	return stack.Initialize.Add(&validateOpGetColumnStatisticsForTable{}, middleware.After)
2851}
2852
2853func addOpGetConnectionValidationMiddleware(stack *middleware.Stack) error {
2854	return stack.Initialize.Add(&validateOpGetConnection{}, middleware.After)
2855}
2856
2857func addOpGetCrawlerValidationMiddleware(stack *middleware.Stack) error {
2858	return stack.Initialize.Add(&validateOpGetCrawler{}, middleware.After)
2859}
2860
2861func addOpGetDatabaseValidationMiddleware(stack *middleware.Stack) error {
2862	return stack.Initialize.Add(&validateOpGetDatabase{}, middleware.After)
2863}
2864
2865func addOpGetDevEndpointValidationMiddleware(stack *middleware.Stack) error {
2866	return stack.Initialize.Add(&validateOpGetDevEndpoint{}, middleware.After)
2867}
2868
2869func addOpGetJobBookmarkValidationMiddleware(stack *middleware.Stack) error {
2870	return stack.Initialize.Add(&validateOpGetJobBookmark{}, middleware.After)
2871}
2872
2873func addOpGetJobValidationMiddleware(stack *middleware.Stack) error {
2874	return stack.Initialize.Add(&validateOpGetJob{}, middleware.After)
2875}
2876
2877func addOpGetJobRunValidationMiddleware(stack *middleware.Stack) error {
2878	return stack.Initialize.Add(&validateOpGetJobRun{}, middleware.After)
2879}
2880
2881func addOpGetJobRunsValidationMiddleware(stack *middleware.Stack) error {
2882	return stack.Initialize.Add(&validateOpGetJobRuns{}, middleware.After)
2883}
2884
2885func addOpGetMappingValidationMiddleware(stack *middleware.Stack) error {
2886	return stack.Initialize.Add(&validateOpGetMapping{}, middleware.After)
2887}
2888
2889func addOpGetMLTaskRunValidationMiddleware(stack *middleware.Stack) error {
2890	return stack.Initialize.Add(&validateOpGetMLTaskRun{}, middleware.After)
2891}
2892
2893func addOpGetMLTaskRunsValidationMiddleware(stack *middleware.Stack) error {
2894	return stack.Initialize.Add(&validateOpGetMLTaskRuns{}, middleware.After)
2895}
2896
2897func addOpGetMLTransformValidationMiddleware(stack *middleware.Stack) error {
2898	return stack.Initialize.Add(&validateOpGetMLTransform{}, middleware.After)
2899}
2900
2901func addOpGetMLTransformsValidationMiddleware(stack *middleware.Stack) error {
2902	return stack.Initialize.Add(&validateOpGetMLTransforms{}, middleware.After)
2903}
2904
2905func addOpGetPartitionIndexesValidationMiddleware(stack *middleware.Stack) error {
2906	return stack.Initialize.Add(&validateOpGetPartitionIndexes{}, middleware.After)
2907}
2908
2909func addOpGetPartitionValidationMiddleware(stack *middleware.Stack) error {
2910	return stack.Initialize.Add(&validateOpGetPartition{}, middleware.After)
2911}
2912
2913func addOpGetPartitionsValidationMiddleware(stack *middleware.Stack) error {
2914	return stack.Initialize.Add(&validateOpGetPartitions{}, middleware.After)
2915}
2916
2917func addOpGetPlanValidationMiddleware(stack *middleware.Stack) error {
2918	return stack.Initialize.Add(&validateOpGetPlan{}, middleware.After)
2919}
2920
2921func addOpGetRegistryValidationMiddleware(stack *middleware.Stack) error {
2922	return stack.Initialize.Add(&validateOpGetRegistry{}, middleware.After)
2923}
2924
2925func addOpGetSchemaByDefinitionValidationMiddleware(stack *middleware.Stack) error {
2926	return stack.Initialize.Add(&validateOpGetSchemaByDefinition{}, middleware.After)
2927}
2928
2929func addOpGetSchemaValidationMiddleware(stack *middleware.Stack) error {
2930	return stack.Initialize.Add(&validateOpGetSchema{}, middleware.After)
2931}
2932
2933func addOpGetSchemaVersionsDiffValidationMiddleware(stack *middleware.Stack) error {
2934	return stack.Initialize.Add(&validateOpGetSchemaVersionsDiff{}, middleware.After)
2935}
2936
2937func addOpGetSecurityConfigurationValidationMiddleware(stack *middleware.Stack) error {
2938	return stack.Initialize.Add(&validateOpGetSecurityConfiguration{}, middleware.After)
2939}
2940
2941func addOpGetTableValidationMiddleware(stack *middleware.Stack) error {
2942	return stack.Initialize.Add(&validateOpGetTable{}, middleware.After)
2943}
2944
2945func addOpGetTablesValidationMiddleware(stack *middleware.Stack) error {
2946	return stack.Initialize.Add(&validateOpGetTables{}, middleware.After)
2947}
2948
2949func addOpGetTableVersionValidationMiddleware(stack *middleware.Stack) error {
2950	return stack.Initialize.Add(&validateOpGetTableVersion{}, middleware.After)
2951}
2952
2953func addOpGetTableVersionsValidationMiddleware(stack *middleware.Stack) error {
2954	return stack.Initialize.Add(&validateOpGetTableVersions{}, middleware.After)
2955}
2956
2957func addOpGetTagsValidationMiddleware(stack *middleware.Stack) error {
2958	return stack.Initialize.Add(&validateOpGetTags{}, middleware.After)
2959}
2960
2961func addOpGetTriggerValidationMiddleware(stack *middleware.Stack) error {
2962	return stack.Initialize.Add(&validateOpGetTrigger{}, middleware.After)
2963}
2964
2965func addOpGetUserDefinedFunctionValidationMiddleware(stack *middleware.Stack) error {
2966	return stack.Initialize.Add(&validateOpGetUserDefinedFunction{}, middleware.After)
2967}
2968
2969func addOpGetUserDefinedFunctionsValidationMiddleware(stack *middleware.Stack) error {
2970	return stack.Initialize.Add(&validateOpGetUserDefinedFunctions{}, middleware.After)
2971}
2972
2973func addOpGetWorkflowValidationMiddleware(stack *middleware.Stack) error {
2974	return stack.Initialize.Add(&validateOpGetWorkflow{}, middleware.After)
2975}
2976
2977func addOpGetWorkflowRunValidationMiddleware(stack *middleware.Stack) error {
2978	return stack.Initialize.Add(&validateOpGetWorkflowRun{}, middleware.After)
2979}
2980
2981func addOpGetWorkflowRunPropertiesValidationMiddleware(stack *middleware.Stack) error {
2982	return stack.Initialize.Add(&validateOpGetWorkflowRunProperties{}, middleware.After)
2983}
2984
2985func addOpGetWorkflowRunsValidationMiddleware(stack *middleware.Stack) error {
2986	return stack.Initialize.Add(&validateOpGetWorkflowRuns{}, middleware.After)
2987}
2988
2989func addOpListMLTransformsValidationMiddleware(stack *middleware.Stack) error {
2990	return stack.Initialize.Add(&validateOpListMLTransforms{}, middleware.After)
2991}
2992
2993func addOpListSchemaVersionsValidationMiddleware(stack *middleware.Stack) error {
2994	return stack.Initialize.Add(&validateOpListSchemaVersions{}, middleware.After)
2995}
2996
2997func addOpPutDataCatalogEncryptionSettingsValidationMiddleware(stack *middleware.Stack) error {
2998	return stack.Initialize.Add(&validateOpPutDataCatalogEncryptionSettings{}, middleware.After)
2999}
3000
3001func addOpPutResourcePolicyValidationMiddleware(stack *middleware.Stack) error {
3002	return stack.Initialize.Add(&validateOpPutResourcePolicy{}, middleware.After)
3003}
3004
3005func addOpPutSchemaVersionMetadataValidationMiddleware(stack *middleware.Stack) error {
3006	return stack.Initialize.Add(&validateOpPutSchemaVersionMetadata{}, middleware.After)
3007}
3008
3009func addOpPutWorkflowRunPropertiesValidationMiddleware(stack *middleware.Stack) error {
3010	return stack.Initialize.Add(&validateOpPutWorkflowRunProperties{}, middleware.After)
3011}
3012
3013func addOpRegisterSchemaVersionValidationMiddleware(stack *middleware.Stack) error {
3014	return stack.Initialize.Add(&validateOpRegisterSchemaVersion{}, middleware.After)
3015}
3016
3017func addOpRemoveSchemaVersionMetadataValidationMiddleware(stack *middleware.Stack) error {
3018	return stack.Initialize.Add(&validateOpRemoveSchemaVersionMetadata{}, middleware.After)
3019}
3020
3021func addOpResetJobBookmarkValidationMiddleware(stack *middleware.Stack) error {
3022	return stack.Initialize.Add(&validateOpResetJobBookmark{}, middleware.After)
3023}
3024
3025func addOpResumeWorkflowRunValidationMiddleware(stack *middleware.Stack) error {
3026	return stack.Initialize.Add(&validateOpResumeWorkflowRun{}, middleware.After)
3027}
3028
3029func addOpStartCrawlerValidationMiddleware(stack *middleware.Stack) error {
3030	return stack.Initialize.Add(&validateOpStartCrawler{}, middleware.After)
3031}
3032
3033func addOpStartCrawlerScheduleValidationMiddleware(stack *middleware.Stack) error {
3034	return stack.Initialize.Add(&validateOpStartCrawlerSchedule{}, middleware.After)
3035}
3036
3037func addOpStartExportLabelsTaskRunValidationMiddleware(stack *middleware.Stack) error {
3038	return stack.Initialize.Add(&validateOpStartExportLabelsTaskRun{}, middleware.After)
3039}
3040
3041func addOpStartImportLabelsTaskRunValidationMiddleware(stack *middleware.Stack) error {
3042	return stack.Initialize.Add(&validateOpStartImportLabelsTaskRun{}, middleware.After)
3043}
3044
3045func addOpStartJobRunValidationMiddleware(stack *middleware.Stack) error {
3046	return stack.Initialize.Add(&validateOpStartJobRun{}, middleware.After)
3047}
3048
3049func addOpStartMLEvaluationTaskRunValidationMiddleware(stack *middleware.Stack) error {
3050	return stack.Initialize.Add(&validateOpStartMLEvaluationTaskRun{}, middleware.After)
3051}
3052
3053func addOpStartMLLabelingSetGenerationTaskRunValidationMiddleware(stack *middleware.Stack) error {
3054	return stack.Initialize.Add(&validateOpStartMLLabelingSetGenerationTaskRun{}, middleware.After)
3055}
3056
3057func addOpStartTriggerValidationMiddleware(stack *middleware.Stack) error {
3058	return stack.Initialize.Add(&validateOpStartTrigger{}, middleware.After)
3059}
3060
3061func addOpStartWorkflowRunValidationMiddleware(stack *middleware.Stack) error {
3062	return stack.Initialize.Add(&validateOpStartWorkflowRun{}, middleware.After)
3063}
3064
3065func addOpStopCrawlerValidationMiddleware(stack *middleware.Stack) error {
3066	return stack.Initialize.Add(&validateOpStopCrawler{}, middleware.After)
3067}
3068
3069func addOpStopCrawlerScheduleValidationMiddleware(stack *middleware.Stack) error {
3070	return stack.Initialize.Add(&validateOpStopCrawlerSchedule{}, middleware.After)
3071}
3072
3073func addOpStopTriggerValidationMiddleware(stack *middleware.Stack) error {
3074	return stack.Initialize.Add(&validateOpStopTrigger{}, middleware.After)
3075}
3076
3077func addOpStopWorkflowRunValidationMiddleware(stack *middleware.Stack) error {
3078	return stack.Initialize.Add(&validateOpStopWorkflowRun{}, middleware.After)
3079}
3080
3081func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
3082	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
3083}
3084
3085func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
3086	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
3087}
3088
3089func addOpUpdateClassifierValidationMiddleware(stack *middleware.Stack) error {
3090	return stack.Initialize.Add(&validateOpUpdateClassifier{}, middleware.After)
3091}
3092
3093func addOpUpdateColumnStatisticsForPartitionValidationMiddleware(stack *middleware.Stack) error {
3094	return stack.Initialize.Add(&validateOpUpdateColumnStatisticsForPartition{}, middleware.After)
3095}
3096
3097func addOpUpdateColumnStatisticsForTableValidationMiddleware(stack *middleware.Stack) error {
3098	return stack.Initialize.Add(&validateOpUpdateColumnStatisticsForTable{}, middleware.After)
3099}
3100
3101func addOpUpdateConnectionValidationMiddleware(stack *middleware.Stack) error {
3102	return stack.Initialize.Add(&validateOpUpdateConnection{}, middleware.After)
3103}
3104
3105func addOpUpdateCrawlerValidationMiddleware(stack *middleware.Stack) error {
3106	return stack.Initialize.Add(&validateOpUpdateCrawler{}, middleware.After)
3107}
3108
3109func addOpUpdateCrawlerScheduleValidationMiddleware(stack *middleware.Stack) error {
3110	return stack.Initialize.Add(&validateOpUpdateCrawlerSchedule{}, middleware.After)
3111}
3112
3113func addOpUpdateDatabaseValidationMiddleware(stack *middleware.Stack) error {
3114	return stack.Initialize.Add(&validateOpUpdateDatabase{}, middleware.After)
3115}
3116
3117func addOpUpdateDevEndpointValidationMiddleware(stack *middleware.Stack) error {
3118	return stack.Initialize.Add(&validateOpUpdateDevEndpoint{}, middleware.After)
3119}
3120
3121func addOpUpdateJobValidationMiddleware(stack *middleware.Stack) error {
3122	return stack.Initialize.Add(&validateOpUpdateJob{}, middleware.After)
3123}
3124
3125func addOpUpdateMLTransformValidationMiddleware(stack *middleware.Stack) error {
3126	return stack.Initialize.Add(&validateOpUpdateMLTransform{}, middleware.After)
3127}
3128
3129func addOpUpdatePartitionValidationMiddleware(stack *middleware.Stack) error {
3130	return stack.Initialize.Add(&validateOpUpdatePartition{}, middleware.After)
3131}
3132
3133func addOpUpdateRegistryValidationMiddleware(stack *middleware.Stack) error {
3134	return stack.Initialize.Add(&validateOpUpdateRegistry{}, middleware.After)
3135}
3136
3137func addOpUpdateSchemaValidationMiddleware(stack *middleware.Stack) error {
3138	return stack.Initialize.Add(&validateOpUpdateSchema{}, middleware.After)
3139}
3140
3141func addOpUpdateTableValidationMiddleware(stack *middleware.Stack) error {
3142	return stack.Initialize.Add(&validateOpUpdateTable{}, middleware.After)
3143}
3144
3145func addOpUpdateTriggerValidationMiddleware(stack *middleware.Stack) error {
3146	return stack.Initialize.Add(&validateOpUpdateTrigger{}, middleware.After)
3147}
3148
3149func addOpUpdateUserDefinedFunctionValidationMiddleware(stack *middleware.Stack) error {
3150	return stack.Initialize.Add(&validateOpUpdateUserDefinedFunction{}, middleware.After)
3151}
3152
3153func addOpUpdateWorkflowValidationMiddleware(stack *middleware.Stack) error {
3154	return stack.Initialize.Add(&validateOpUpdateWorkflow{}, middleware.After)
3155}
3156
3157func validateBatchDeletePartitionValueList(v []types.PartitionValueList) error {
3158	if v == nil {
3159		return nil
3160	}
3161	invalidParams := smithy.InvalidParamsError{Context: "BatchDeletePartitionValueList"}
3162	for i := range v {
3163		if err := validatePartitionValueList(&v[i]); err != nil {
3164			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3165		}
3166	}
3167	if invalidParams.Len() > 0 {
3168		return invalidParams
3169	} else {
3170		return nil
3171	}
3172}
3173
3174func validateBatchGetPartitionValueList(v []types.PartitionValueList) error {
3175	if v == nil {
3176		return nil
3177	}
3178	invalidParams := smithy.InvalidParamsError{Context: "BatchGetPartitionValueList"}
3179	for i := range v {
3180		if err := validatePartitionValueList(&v[i]); err != nil {
3181			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3182		}
3183	}
3184	if invalidParams.Len() > 0 {
3185		return invalidParams
3186	} else {
3187		return nil
3188	}
3189}
3190
3191func validateBatchUpdatePartitionRequestEntry(v *types.BatchUpdatePartitionRequestEntry) error {
3192	if v == nil {
3193		return nil
3194	}
3195	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdatePartitionRequestEntry"}
3196	if v.PartitionValueList == nil {
3197		invalidParams.Add(smithy.NewErrParamRequired("PartitionValueList"))
3198	}
3199	if v.PartitionInput == nil {
3200		invalidParams.Add(smithy.NewErrParamRequired("PartitionInput"))
3201	} else if v.PartitionInput != nil {
3202		if err := validatePartitionInput(v.PartitionInput); err != nil {
3203			invalidParams.AddNested("PartitionInput", err.(smithy.InvalidParamsError))
3204		}
3205	}
3206	if invalidParams.Len() > 0 {
3207		return invalidParams
3208	} else {
3209		return nil
3210	}
3211}
3212
3213func validateBatchUpdatePartitionRequestEntryList(v []types.BatchUpdatePartitionRequestEntry) error {
3214	if v == nil {
3215		return nil
3216	}
3217	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdatePartitionRequestEntryList"}
3218	for i := range v {
3219		if err := validateBatchUpdatePartitionRequestEntry(&v[i]); err != nil {
3220			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3221		}
3222	}
3223	if invalidParams.Len() > 0 {
3224		return invalidParams
3225	} else {
3226		return nil
3227	}
3228}
3229
3230func validateBinaryColumnStatisticsData(v *types.BinaryColumnStatisticsData) error {
3231	if v == nil {
3232		return nil
3233	}
3234	invalidParams := smithy.InvalidParamsError{Context: "BinaryColumnStatisticsData"}
3235	if invalidParams.Len() > 0 {
3236		return invalidParams
3237	} else {
3238		return nil
3239	}
3240}
3241
3242func validateBooleanColumnStatisticsData(v *types.BooleanColumnStatisticsData) error {
3243	if v == nil {
3244		return nil
3245	}
3246	invalidParams := smithy.InvalidParamsError{Context: "BooleanColumnStatisticsData"}
3247	if invalidParams.Len() > 0 {
3248		return invalidParams
3249	} else {
3250		return nil
3251	}
3252}
3253
3254func validateCatalogEntries(v []types.CatalogEntry) error {
3255	if v == nil {
3256		return nil
3257	}
3258	invalidParams := smithy.InvalidParamsError{Context: "CatalogEntries"}
3259	for i := range v {
3260		if err := validateCatalogEntry(&v[i]); err != nil {
3261			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3262		}
3263	}
3264	if invalidParams.Len() > 0 {
3265		return invalidParams
3266	} else {
3267		return nil
3268	}
3269}
3270
3271func validateCatalogEntry(v *types.CatalogEntry) error {
3272	if v == nil {
3273		return nil
3274	}
3275	invalidParams := smithy.InvalidParamsError{Context: "CatalogEntry"}
3276	if v.DatabaseName == nil {
3277		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
3278	}
3279	if v.TableName == nil {
3280		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
3281	}
3282	if invalidParams.Len() > 0 {
3283		return invalidParams
3284	} else {
3285		return nil
3286	}
3287}
3288
3289func validateCatalogTarget(v *types.CatalogTarget) error {
3290	if v == nil {
3291		return nil
3292	}
3293	invalidParams := smithy.InvalidParamsError{Context: "CatalogTarget"}
3294	if v.DatabaseName == nil {
3295		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
3296	}
3297	if v.Tables == nil {
3298		invalidParams.Add(smithy.NewErrParamRequired("Tables"))
3299	}
3300	if invalidParams.Len() > 0 {
3301		return invalidParams
3302	} else {
3303		return nil
3304	}
3305}
3306
3307func validateCatalogTargetList(v []types.CatalogTarget) error {
3308	if v == nil {
3309		return nil
3310	}
3311	invalidParams := smithy.InvalidParamsError{Context: "CatalogTargetList"}
3312	for i := range v {
3313		if err := validateCatalogTarget(&v[i]); err != nil {
3314			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3315		}
3316	}
3317	if invalidParams.Len() > 0 {
3318		return invalidParams
3319	} else {
3320		return nil
3321	}
3322}
3323
3324func validateCodeGenEdge(v *types.CodeGenEdge) error {
3325	if v == nil {
3326		return nil
3327	}
3328	invalidParams := smithy.InvalidParamsError{Context: "CodeGenEdge"}
3329	if v.Source == nil {
3330		invalidParams.Add(smithy.NewErrParamRequired("Source"))
3331	}
3332	if v.Target == nil {
3333		invalidParams.Add(smithy.NewErrParamRequired("Target"))
3334	}
3335	if invalidParams.Len() > 0 {
3336		return invalidParams
3337	} else {
3338		return nil
3339	}
3340}
3341
3342func validateCodeGenNode(v *types.CodeGenNode) error {
3343	if v == nil {
3344		return nil
3345	}
3346	invalidParams := smithy.InvalidParamsError{Context: "CodeGenNode"}
3347	if v.Id == nil {
3348		invalidParams.Add(smithy.NewErrParamRequired("Id"))
3349	}
3350	if v.NodeType == nil {
3351		invalidParams.Add(smithy.NewErrParamRequired("NodeType"))
3352	}
3353	if v.Args == nil {
3354		invalidParams.Add(smithy.NewErrParamRequired("Args"))
3355	} else if v.Args != nil {
3356		if err := validateCodeGenNodeArgs(v.Args); err != nil {
3357			invalidParams.AddNested("Args", err.(smithy.InvalidParamsError))
3358		}
3359	}
3360	if invalidParams.Len() > 0 {
3361		return invalidParams
3362	} else {
3363		return nil
3364	}
3365}
3366
3367func validateCodeGenNodeArg(v *types.CodeGenNodeArg) error {
3368	if v == nil {
3369		return nil
3370	}
3371	invalidParams := smithy.InvalidParamsError{Context: "CodeGenNodeArg"}
3372	if v.Name == nil {
3373		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3374	}
3375	if v.Value == nil {
3376		invalidParams.Add(smithy.NewErrParamRequired("Value"))
3377	}
3378	if invalidParams.Len() > 0 {
3379		return invalidParams
3380	} else {
3381		return nil
3382	}
3383}
3384
3385func validateCodeGenNodeArgs(v []types.CodeGenNodeArg) error {
3386	if v == nil {
3387		return nil
3388	}
3389	invalidParams := smithy.InvalidParamsError{Context: "CodeGenNodeArgs"}
3390	for i := range v {
3391		if err := validateCodeGenNodeArg(&v[i]); err != nil {
3392			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3393		}
3394	}
3395	if invalidParams.Len() > 0 {
3396		return invalidParams
3397	} else {
3398		return nil
3399	}
3400}
3401
3402func validateColumn(v *types.Column) error {
3403	if v == nil {
3404		return nil
3405	}
3406	invalidParams := smithy.InvalidParamsError{Context: "Column"}
3407	if v.Name == nil {
3408		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3409	}
3410	if invalidParams.Len() > 0 {
3411		return invalidParams
3412	} else {
3413		return nil
3414	}
3415}
3416
3417func validateColumnList(v []types.Column) error {
3418	if v == nil {
3419		return nil
3420	}
3421	invalidParams := smithy.InvalidParamsError{Context: "ColumnList"}
3422	for i := range v {
3423		if err := validateColumn(&v[i]); err != nil {
3424			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3425		}
3426	}
3427	if invalidParams.Len() > 0 {
3428		return invalidParams
3429	} else {
3430		return nil
3431	}
3432}
3433
3434func validateColumnStatistics(v *types.ColumnStatistics) error {
3435	if v == nil {
3436		return nil
3437	}
3438	invalidParams := smithy.InvalidParamsError{Context: "ColumnStatistics"}
3439	if v.ColumnName == nil {
3440		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
3441	}
3442	if v.ColumnType == nil {
3443		invalidParams.Add(smithy.NewErrParamRequired("ColumnType"))
3444	}
3445	if v.AnalyzedTime == nil {
3446		invalidParams.Add(smithy.NewErrParamRequired("AnalyzedTime"))
3447	}
3448	if v.StatisticsData == nil {
3449		invalidParams.Add(smithy.NewErrParamRequired("StatisticsData"))
3450	} else if v.StatisticsData != nil {
3451		if err := validateColumnStatisticsData(v.StatisticsData); err != nil {
3452			invalidParams.AddNested("StatisticsData", err.(smithy.InvalidParamsError))
3453		}
3454	}
3455	if invalidParams.Len() > 0 {
3456		return invalidParams
3457	} else {
3458		return nil
3459	}
3460}
3461
3462func validateColumnStatisticsData(v *types.ColumnStatisticsData) error {
3463	if v == nil {
3464		return nil
3465	}
3466	invalidParams := smithy.InvalidParamsError{Context: "ColumnStatisticsData"}
3467	if len(v.Type) == 0 {
3468		invalidParams.Add(smithy.NewErrParamRequired("Type"))
3469	}
3470	if v.BooleanColumnStatisticsData != nil {
3471		if err := validateBooleanColumnStatisticsData(v.BooleanColumnStatisticsData); err != nil {
3472			invalidParams.AddNested("BooleanColumnStatisticsData", err.(smithy.InvalidParamsError))
3473		}
3474	}
3475	if v.DateColumnStatisticsData != nil {
3476		if err := validateDateColumnStatisticsData(v.DateColumnStatisticsData); err != nil {
3477			invalidParams.AddNested("DateColumnStatisticsData", err.(smithy.InvalidParamsError))
3478		}
3479	}
3480	if v.DecimalColumnStatisticsData != nil {
3481		if err := validateDecimalColumnStatisticsData(v.DecimalColumnStatisticsData); err != nil {
3482			invalidParams.AddNested("DecimalColumnStatisticsData", err.(smithy.InvalidParamsError))
3483		}
3484	}
3485	if v.DoubleColumnStatisticsData != nil {
3486		if err := validateDoubleColumnStatisticsData(v.DoubleColumnStatisticsData); err != nil {
3487			invalidParams.AddNested("DoubleColumnStatisticsData", err.(smithy.InvalidParamsError))
3488		}
3489	}
3490	if v.LongColumnStatisticsData != nil {
3491		if err := validateLongColumnStatisticsData(v.LongColumnStatisticsData); err != nil {
3492			invalidParams.AddNested("LongColumnStatisticsData", err.(smithy.InvalidParamsError))
3493		}
3494	}
3495	if v.StringColumnStatisticsData != nil {
3496		if err := validateStringColumnStatisticsData(v.StringColumnStatisticsData); err != nil {
3497			invalidParams.AddNested("StringColumnStatisticsData", err.(smithy.InvalidParamsError))
3498		}
3499	}
3500	if v.BinaryColumnStatisticsData != nil {
3501		if err := validateBinaryColumnStatisticsData(v.BinaryColumnStatisticsData); err != nil {
3502			invalidParams.AddNested("BinaryColumnStatisticsData", err.(smithy.InvalidParamsError))
3503		}
3504	}
3505	if invalidParams.Len() > 0 {
3506		return invalidParams
3507	} else {
3508		return nil
3509	}
3510}
3511
3512func validateConnectionInput(v *types.ConnectionInput) error {
3513	if v == nil {
3514		return nil
3515	}
3516	invalidParams := smithy.InvalidParamsError{Context: "ConnectionInput"}
3517	if v.Name == nil {
3518		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3519	}
3520	if len(v.ConnectionType) == 0 {
3521		invalidParams.Add(smithy.NewErrParamRequired("ConnectionType"))
3522	}
3523	if v.ConnectionProperties == nil {
3524		invalidParams.Add(smithy.NewErrParamRequired("ConnectionProperties"))
3525	}
3526	if invalidParams.Len() > 0 {
3527		return invalidParams
3528	} else {
3529		return nil
3530	}
3531}
3532
3533func validateConnectionPasswordEncryption(v *types.ConnectionPasswordEncryption) error {
3534	if v == nil {
3535		return nil
3536	}
3537	invalidParams := smithy.InvalidParamsError{Context: "ConnectionPasswordEncryption"}
3538	if invalidParams.Len() > 0 {
3539		return invalidParams
3540	} else {
3541		return nil
3542	}
3543}
3544
3545func validateCrawlerTargets(v *types.CrawlerTargets) error {
3546	if v == nil {
3547		return nil
3548	}
3549	invalidParams := smithy.InvalidParamsError{Context: "CrawlerTargets"}
3550	if v.CatalogTargets != nil {
3551		if err := validateCatalogTargetList(v.CatalogTargets); err != nil {
3552			invalidParams.AddNested("CatalogTargets", err.(smithy.InvalidParamsError))
3553		}
3554	}
3555	if invalidParams.Len() > 0 {
3556		return invalidParams
3557	} else {
3558		return nil
3559	}
3560}
3561
3562func validateCreateCsvClassifierRequest(v *types.CreateCsvClassifierRequest) error {
3563	if v == nil {
3564		return nil
3565	}
3566	invalidParams := smithy.InvalidParamsError{Context: "CreateCsvClassifierRequest"}
3567	if v.Name == nil {
3568		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3569	}
3570	if invalidParams.Len() > 0 {
3571		return invalidParams
3572	} else {
3573		return nil
3574	}
3575}
3576
3577func validateCreateGrokClassifierRequest(v *types.CreateGrokClassifierRequest) error {
3578	if v == nil {
3579		return nil
3580	}
3581	invalidParams := smithy.InvalidParamsError{Context: "CreateGrokClassifierRequest"}
3582	if v.Classification == nil {
3583		invalidParams.Add(smithy.NewErrParamRequired("Classification"))
3584	}
3585	if v.Name == nil {
3586		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3587	}
3588	if v.GrokPattern == nil {
3589		invalidParams.Add(smithy.NewErrParamRequired("GrokPattern"))
3590	}
3591	if invalidParams.Len() > 0 {
3592		return invalidParams
3593	} else {
3594		return nil
3595	}
3596}
3597
3598func validateCreateJsonClassifierRequest(v *types.CreateJsonClassifierRequest) error {
3599	if v == nil {
3600		return nil
3601	}
3602	invalidParams := smithy.InvalidParamsError{Context: "CreateJsonClassifierRequest"}
3603	if v.Name == nil {
3604		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3605	}
3606	if v.JsonPath == nil {
3607		invalidParams.Add(smithy.NewErrParamRequired("JsonPath"))
3608	}
3609	if invalidParams.Len() > 0 {
3610		return invalidParams
3611	} else {
3612		return nil
3613	}
3614}
3615
3616func validateCreateXMLClassifierRequest(v *types.CreateXMLClassifierRequest) error {
3617	if v == nil {
3618		return nil
3619	}
3620	invalidParams := smithy.InvalidParamsError{Context: "CreateXMLClassifierRequest"}
3621	if v.Classification == nil {
3622		invalidParams.Add(smithy.NewErrParamRequired("Classification"))
3623	}
3624	if v.Name == nil {
3625		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3626	}
3627	if invalidParams.Len() > 0 {
3628		return invalidParams
3629	} else {
3630		return nil
3631	}
3632}
3633
3634func validateDagEdges(v []types.CodeGenEdge) error {
3635	if v == nil {
3636		return nil
3637	}
3638	invalidParams := smithy.InvalidParamsError{Context: "DagEdges"}
3639	for i := range v {
3640		if err := validateCodeGenEdge(&v[i]); err != nil {
3641			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3642		}
3643	}
3644	if invalidParams.Len() > 0 {
3645		return invalidParams
3646	} else {
3647		return nil
3648	}
3649}
3650
3651func validateDagNodes(v []types.CodeGenNode) error {
3652	if v == nil {
3653		return nil
3654	}
3655	invalidParams := smithy.InvalidParamsError{Context: "DagNodes"}
3656	for i := range v {
3657		if err := validateCodeGenNode(&v[i]); err != nil {
3658			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3659		}
3660	}
3661	if invalidParams.Len() > 0 {
3662		return invalidParams
3663	} else {
3664		return nil
3665	}
3666}
3667
3668func validateDatabaseInput(v *types.DatabaseInput) error {
3669	if v == nil {
3670		return nil
3671	}
3672	invalidParams := smithy.InvalidParamsError{Context: "DatabaseInput"}
3673	if v.Name == nil {
3674		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3675	}
3676	if invalidParams.Len() > 0 {
3677		return invalidParams
3678	} else {
3679		return nil
3680	}
3681}
3682
3683func validateDataCatalogEncryptionSettings(v *types.DataCatalogEncryptionSettings) error {
3684	if v == nil {
3685		return nil
3686	}
3687	invalidParams := smithy.InvalidParamsError{Context: "DataCatalogEncryptionSettings"}
3688	if v.EncryptionAtRest != nil {
3689		if err := validateEncryptionAtRest(v.EncryptionAtRest); err != nil {
3690			invalidParams.AddNested("EncryptionAtRest", err.(smithy.InvalidParamsError))
3691		}
3692	}
3693	if v.ConnectionPasswordEncryption != nil {
3694		if err := validateConnectionPasswordEncryption(v.ConnectionPasswordEncryption); err != nil {
3695			invalidParams.AddNested("ConnectionPasswordEncryption", err.(smithy.InvalidParamsError))
3696		}
3697	}
3698	if invalidParams.Len() > 0 {
3699		return invalidParams
3700	} else {
3701		return nil
3702	}
3703}
3704
3705func validateDateColumnStatisticsData(v *types.DateColumnStatisticsData) error {
3706	if v == nil {
3707		return nil
3708	}
3709	invalidParams := smithy.InvalidParamsError{Context: "DateColumnStatisticsData"}
3710	if invalidParams.Len() > 0 {
3711		return invalidParams
3712	} else {
3713		return nil
3714	}
3715}
3716
3717func validateDecimalColumnStatisticsData(v *types.DecimalColumnStatisticsData) error {
3718	if v == nil {
3719		return nil
3720	}
3721	invalidParams := smithy.InvalidParamsError{Context: "DecimalColumnStatisticsData"}
3722	if v.MinimumValue != nil {
3723		if err := validateDecimalNumber(v.MinimumValue); err != nil {
3724			invalidParams.AddNested("MinimumValue", err.(smithy.InvalidParamsError))
3725		}
3726	}
3727	if v.MaximumValue != nil {
3728		if err := validateDecimalNumber(v.MaximumValue); err != nil {
3729			invalidParams.AddNested("MaximumValue", err.(smithy.InvalidParamsError))
3730		}
3731	}
3732	if invalidParams.Len() > 0 {
3733		return invalidParams
3734	} else {
3735		return nil
3736	}
3737}
3738
3739func validateDecimalNumber(v *types.DecimalNumber) error {
3740	if v == nil {
3741		return nil
3742	}
3743	invalidParams := smithy.InvalidParamsError{Context: "DecimalNumber"}
3744	if v.UnscaledValue == nil {
3745		invalidParams.Add(smithy.NewErrParamRequired("UnscaledValue"))
3746	}
3747	if invalidParams.Len() > 0 {
3748		return invalidParams
3749	} else {
3750		return nil
3751	}
3752}
3753
3754func validateDoubleColumnStatisticsData(v *types.DoubleColumnStatisticsData) error {
3755	if v == nil {
3756		return nil
3757	}
3758	invalidParams := smithy.InvalidParamsError{Context: "DoubleColumnStatisticsData"}
3759	if invalidParams.Len() > 0 {
3760		return invalidParams
3761	} else {
3762		return nil
3763	}
3764}
3765
3766func validateEncryptionAtRest(v *types.EncryptionAtRest) error {
3767	if v == nil {
3768		return nil
3769	}
3770	invalidParams := smithy.InvalidParamsError{Context: "EncryptionAtRest"}
3771	if len(v.CatalogEncryptionMode) == 0 {
3772		invalidParams.Add(smithy.NewErrParamRequired("CatalogEncryptionMode"))
3773	}
3774	if invalidParams.Len() > 0 {
3775		return invalidParams
3776	} else {
3777		return nil
3778	}
3779}
3780
3781func validateGlueTable(v *types.GlueTable) error {
3782	if v == nil {
3783		return nil
3784	}
3785	invalidParams := smithy.InvalidParamsError{Context: "GlueTable"}
3786	if v.DatabaseName == nil {
3787		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
3788	}
3789	if v.TableName == nil {
3790		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
3791	}
3792	if invalidParams.Len() > 0 {
3793		return invalidParams
3794	} else {
3795		return nil
3796	}
3797}
3798
3799func validateGlueTables(v []types.GlueTable) error {
3800	if v == nil {
3801		return nil
3802	}
3803	invalidParams := smithy.InvalidParamsError{Context: "GlueTables"}
3804	for i := range v {
3805		if err := validateGlueTable(&v[i]); err != nil {
3806			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3807		}
3808	}
3809	if invalidParams.Len() > 0 {
3810		return invalidParams
3811	} else {
3812		return nil
3813	}
3814}
3815
3816func validateLocation(v *types.Location) error {
3817	if v == nil {
3818		return nil
3819	}
3820	invalidParams := smithy.InvalidParamsError{Context: "Location"}
3821	if v.Jdbc != nil {
3822		if err := validateCodeGenNodeArgs(v.Jdbc); err != nil {
3823			invalidParams.AddNested("Jdbc", err.(smithy.InvalidParamsError))
3824		}
3825	}
3826	if v.S3 != nil {
3827		if err := validateCodeGenNodeArgs(v.S3); err != nil {
3828			invalidParams.AddNested("S3", err.(smithy.InvalidParamsError))
3829		}
3830	}
3831	if v.DynamoDB != nil {
3832		if err := validateCodeGenNodeArgs(v.DynamoDB); err != nil {
3833			invalidParams.AddNested("DynamoDB", err.(smithy.InvalidParamsError))
3834		}
3835	}
3836	if invalidParams.Len() > 0 {
3837		return invalidParams
3838	} else {
3839		return nil
3840	}
3841}
3842
3843func validateLongColumnStatisticsData(v *types.LongColumnStatisticsData) error {
3844	if v == nil {
3845		return nil
3846	}
3847	invalidParams := smithy.InvalidParamsError{Context: "LongColumnStatisticsData"}
3848	if invalidParams.Len() > 0 {
3849		return invalidParams
3850	} else {
3851		return nil
3852	}
3853}
3854
3855func validateMLUserDataEncryption(v *types.MLUserDataEncryption) error {
3856	if v == nil {
3857		return nil
3858	}
3859	invalidParams := smithy.InvalidParamsError{Context: "MLUserDataEncryption"}
3860	if len(v.MlUserDataEncryptionMode) == 0 {
3861		invalidParams.Add(smithy.NewErrParamRequired("MlUserDataEncryptionMode"))
3862	}
3863	if invalidParams.Len() > 0 {
3864		return invalidParams
3865	} else {
3866		return nil
3867	}
3868}
3869
3870func validateOrder(v *types.Order) error {
3871	if v == nil {
3872		return nil
3873	}
3874	invalidParams := smithy.InvalidParamsError{Context: "Order"}
3875	if v.Column == nil {
3876		invalidParams.Add(smithy.NewErrParamRequired("Column"))
3877	}
3878	if invalidParams.Len() > 0 {
3879		return invalidParams
3880	} else {
3881		return nil
3882	}
3883}
3884
3885func validateOrderList(v []types.Order) error {
3886	if v == nil {
3887		return nil
3888	}
3889	invalidParams := smithy.InvalidParamsError{Context: "OrderList"}
3890	for i := range v {
3891		if err := validateOrder(&v[i]); err != nil {
3892			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3893		}
3894	}
3895	if invalidParams.Len() > 0 {
3896		return invalidParams
3897	} else {
3898		return nil
3899	}
3900}
3901
3902func validatePartitionIndex(v *types.PartitionIndex) error {
3903	if v == nil {
3904		return nil
3905	}
3906	invalidParams := smithy.InvalidParamsError{Context: "PartitionIndex"}
3907	if v.Keys == nil {
3908		invalidParams.Add(smithy.NewErrParamRequired("Keys"))
3909	}
3910	if v.IndexName == nil {
3911		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
3912	}
3913	if invalidParams.Len() > 0 {
3914		return invalidParams
3915	} else {
3916		return nil
3917	}
3918}
3919
3920func validatePartitionIndexList(v []types.PartitionIndex) error {
3921	if v == nil {
3922		return nil
3923	}
3924	invalidParams := smithy.InvalidParamsError{Context: "PartitionIndexList"}
3925	for i := range v {
3926		if err := validatePartitionIndex(&v[i]); err != nil {
3927			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3928		}
3929	}
3930	if invalidParams.Len() > 0 {
3931		return invalidParams
3932	} else {
3933		return nil
3934	}
3935}
3936
3937func validatePartitionInput(v *types.PartitionInput) error {
3938	if v == nil {
3939		return nil
3940	}
3941	invalidParams := smithy.InvalidParamsError{Context: "PartitionInput"}
3942	if v.StorageDescriptor != nil {
3943		if err := validateStorageDescriptor(v.StorageDescriptor); err != nil {
3944			invalidParams.AddNested("StorageDescriptor", err.(smithy.InvalidParamsError))
3945		}
3946	}
3947	if invalidParams.Len() > 0 {
3948		return invalidParams
3949	} else {
3950		return nil
3951	}
3952}
3953
3954func validatePartitionInputList(v []types.PartitionInput) error {
3955	if v == nil {
3956		return nil
3957	}
3958	invalidParams := smithy.InvalidParamsError{Context: "PartitionInputList"}
3959	for i := range v {
3960		if err := validatePartitionInput(&v[i]); err != nil {
3961			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3962		}
3963	}
3964	if invalidParams.Len() > 0 {
3965		return invalidParams
3966	} else {
3967		return nil
3968	}
3969}
3970
3971func validatePartitionValueList(v *types.PartitionValueList) error {
3972	if v == nil {
3973		return nil
3974	}
3975	invalidParams := smithy.InvalidParamsError{Context: "PartitionValueList"}
3976	if v.Values == nil {
3977		invalidParams.Add(smithy.NewErrParamRequired("Values"))
3978	}
3979	if invalidParams.Len() > 0 {
3980		return invalidParams
3981	} else {
3982		return nil
3983	}
3984}
3985
3986func validateSegment(v *types.Segment) error {
3987	if v == nil {
3988		return nil
3989	}
3990	invalidParams := smithy.InvalidParamsError{Context: "Segment"}
3991	if invalidParams.Len() > 0 {
3992		return invalidParams
3993	} else {
3994		return nil
3995	}
3996}
3997
3998func validateStorageDescriptor(v *types.StorageDescriptor) error {
3999	if v == nil {
4000		return nil
4001	}
4002	invalidParams := smithy.InvalidParamsError{Context: "StorageDescriptor"}
4003	if v.Columns != nil {
4004		if err := validateColumnList(v.Columns); err != nil {
4005			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
4006		}
4007	}
4008	if v.SortColumns != nil {
4009		if err := validateOrderList(v.SortColumns); err != nil {
4010			invalidParams.AddNested("SortColumns", err.(smithy.InvalidParamsError))
4011		}
4012	}
4013	if invalidParams.Len() > 0 {
4014		return invalidParams
4015	} else {
4016		return nil
4017	}
4018}
4019
4020func validateStringColumnStatisticsData(v *types.StringColumnStatisticsData) error {
4021	if v == nil {
4022		return nil
4023	}
4024	invalidParams := smithy.InvalidParamsError{Context: "StringColumnStatisticsData"}
4025	if invalidParams.Len() > 0 {
4026		return invalidParams
4027	} else {
4028		return nil
4029	}
4030}
4031
4032func validateTableInput(v *types.TableInput) error {
4033	if v == nil {
4034		return nil
4035	}
4036	invalidParams := smithy.InvalidParamsError{Context: "TableInput"}
4037	if v.Name == nil {
4038		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4039	}
4040	if v.StorageDescriptor != nil {
4041		if err := validateStorageDescriptor(v.StorageDescriptor); err != nil {
4042			invalidParams.AddNested("StorageDescriptor", err.(smithy.InvalidParamsError))
4043		}
4044	}
4045	if v.PartitionKeys != nil {
4046		if err := validateColumnList(v.PartitionKeys); err != nil {
4047			invalidParams.AddNested("PartitionKeys", err.(smithy.InvalidParamsError))
4048		}
4049	}
4050	if invalidParams.Len() > 0 {
4051		return invalidParams
4052	} else {
4053		return nil
4054	}
4055}
4056
4057func validateTaskRunSortCriteria(v *types.TaskRunSortCriteria) error {
4058	if v == nil {
4059		return nil
4060	}
4061	invalidParams := smithy.InvalidParamsError{Context: "TaskRunSortCriteria"}
4062	if len(v.Column) == 0 {
4063		invalidParams.Add(smithy.NewErrParamRequired("Column"))
4064	}
4065	if len(v.SortDirection) == 0 {
4066		invalidParams.Add(smithy.NewErrParamRequired("SortDirection"))
4067	}
4068	if invalidParams.Len() > 0 {
4069		return invalidParams
4070	} else {
4071		return nil
4072	}
4073}
4074
4075func validateTransformEncryption(v *types.TransformEncryption) error {
4076	if v == nil {
4077		return nil
4078	}
4079	invalidParams := smithy.InvalidParamsError{Context: "TransformEncryption"}
4080	if v.MlUserDataEncryption != nil {
4081		if err := validateMLUserDataEncryption(v.MlUserDataEncryption); err != nil {
4082			invalidParams.AddNested("MlUserDataEncryption", err.(smithy.InvalidParamsError))
4083		}
4084	}
4085	if invalidParams.Len() > 0 {
4086		return invalidParams
4087	} else {
4088		return nil
4089	}
4090}
4091
4092func validateTransformParameters(v *types.TransformParameters) error {
4093	if v == nil {
4094		return nil
4095	}
4096	invalidParams := smithy.InvalidParamsError{Context: "TransformParameters"}
4097	if len(v.TransformType) == 0 {
4098		invalidParams.Add(smithy.NewErrParamRequired("TransformType"))
4099	}
4100	if invalidParams.Len() > 0 {
4101		return invalidParams
4102	} else {
4103		return nil
4104	}
4105}
4106
4107func validateTransformSortCriteria(v *types.TransformSortCriteria) error {
4108	if v == nil {
4109		return nil
4110	}
4111	invalidParams := smithy.InvalidParamsError{Context: "TransformSortCriteria"}
4112	if len(v.Column) == 0 {
4113		invalidParams.Add(smithy.NewErrParamRequired("Column"))
4114	}
4115	if len(v.SortDirection) == 0 {
4116		invalidParams.Add(smithy.NewErrParamRequired("SortDirection"))
4117	}
4118	if invalidParams.Len() > 0 {
4119		return invalidParams
4120	} else {
4121		return nil
4122	}
4123}
4124
4125func validateUpdateColumnStatisticsList(v []types.ColumnStatistics) error {
4126	if v == nil {
4127		return nil
4128	}
4129	invalidParams := smithy.InvalidParamsError{Context: "UpdateColumnStatisticsList"}
4130	for i := range v {
4131		if err := validateColumnStatistics(&v[i]); err != nil {
4132			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
4133		}
4134	}
4135	if invalidParams.Len() > 0 {
4136		return invalidParams
4137	} else {
4138		return nil
4139	}
4140}
4141
4142func validateUpdateCsvClassifierRequest(v *types.UpdateCsvClassifierRequest) error {
4143	if v == nil {
4144		return nil
4145	}
4146	invalidParams := smithy.InvalidParamsError{Context: "UpdateCsvClassifierRequest"}
4147	if v.Name == nil {
4148		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4149	}
4150	if invalidParams.Len() > 0 {
4151		return invalidParams
4152	} else {
4153		return nil
4154	}
4155}
4156
4157func validateUpdateGrokClassifierRequest(v *types.UpdateGrokClassifierRequest) error {
4158	if v == nil {
4159		return nil
4160	}
4161	invalidParams := smithy.InvalidParamsError{Context: "UpdateGrokClassifierRequest"}
4162	if v.Name == nil {
4163		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4164	}
4165	if invalidParams.Len() > 0 {
4166		return invalidParams
4167	} else {
4168		return nil
4169	}
4170}
4171
4172func validateUpdateJsonClassifierRequest(v *types.UpdateJsonClassifierRequest) error {
4173	if v == nil {
4174		return nil
4175	}
4176	invalidParams := smithy.InvalidParamsError{Context: "UpdateJsonClassifierRequest"}
4177	if v.Name == nil {
4178		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4179	}
4180	if invalidParams.Len() > 0 {
4181		return invalidParams
4182	} else {
4183		return nil
4184	}
4185}
4186
4187func validateUpdateXMLClassifierRequest(v *types.UpdateXMLClassifierRequest) error {
4188	if v == nil {
4189		return nil
4190	}
4191	invalidParams := smithy.InvalidParamsError{Context: "UpdateXMLClassifierRequest"}
4192	if v.Name == nil {
4193		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4194	}
4195	if invalidParams.Len() > 0 {
4196		return invalidParams
4197	} else {
4198		return nil
4199	}
4200}
4201
4202func validateOpBatchCreatePartitionInput(v *BatchCreatePartitionInput) error {
4203	if v == nil {
4204		return nil
4205	}
4206	invalidParams := smithy.InvalidParamsError{Context: "BatchCreatePartitionInput"}
4207	if v.DatabaseName == nil {
4208		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4209	}
4210	if v.TableName == nil {
4211		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
4212	}
4213	if v.PartitionInputList == nil {
4214		invalidParams.Add(smithy.NewErrParamRequired("PartitionInputList"))
4215	} else if v.PartitionInputList != nil {
4216		if err := validatePartitionInputList(v.PartitionInputList); err != nil {
4217			invalidParams.AddNested("PartitionInputList", err.(smithy.InvalidParamsError))
4218		}
4219	}
4220	if invalidParams.Len() > 0 {
4221		return invalidParams
4222	} else {
4223		return nil
4224	}
4225}
4226
4227func validateOpBatchDeleteConnectionInput(v *BatchDeleteConnectionInput) error {
4228	if v == nil {
4229		return nil
4230	}
4231	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteConnectionInput"}
4232	if v.ConnectionNameList == nil {
4233		invalidParams.Add(smithy.NewErrParamRequired("ConnectionNameList"))
4234	}
4235	if invalidParams.Len() > 0 {
4236		return invalidParams
4237	} else {
4238		return nil
4239	}
4240}
4241
4242func validateOpBatchDeletePartitionInput(v *BatchDeletePartitionInput) error {
4243	if v == nil {
4244		return nil
4245	}
4246	invalidParams := smithy.InvalidParamsError{Context: "BatchDeletePartitionInput"}
4247	if v.DatabaseName == nil {
4248		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4249	}
4250	if v.TableName == nil {
4251		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
4252	}
4253	if v.PartitionsToDelete == nil {
4254		invalidParams.Add(smithy.NewErrParamRequired("PartitionsToDelete"))
4255	} else if v.PartitionsToDelete != nil {
4256		if err := validateBatchDeletePartitionValueList(v.PartitionsToDelete); err != nil {
4257			invalidParams.AddNested("PartitionsToDelete", err.(smithy.InvalidParamsError))
4258		}
4259	}
4260	if invalidParams.Len() > 0 {
4261		return invalidParams
4262	} else {
4263		return nil
4264	}
4265}
4266
4267func validateOpBatchDeleteTableInput(v *BatchDeleteTableInput) error {
4268	if v == nil {
4269		return nil
4270	}
4271	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteTableInput"}
4272	if v.DatabaseName == nil {
4273		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4274	}
4275	if v.TablesToDelete == nil {
4276		invalidParams.Add(smithy.NewErrParamRequired("TablesToDelete"))
4277	}
4278	if invalidParams.Len() > 0 {
4279		return invalidParams
4280	} else {
4281		return nil
4282	}
4283}
4284
4285func validateOpBatchDeleteTableVersionInput(v *BatchDeleteTableVersionInput) error {
4286	if v == nil {
4287		return nil
4288	}
4289	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteTableVersionInput"}
4290	if v.DatabaseName == nil {
4291		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4292	}
4293	if v.TableName == nil {
4294		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
4295	}
4296	if v.VersionIds == nil {
4297		invalidParams.Add(smithy.NewErrParamRequired("VersionIds"))
4298	}
4299	if invalidParams.Len() > 0 {
4300		return invalidParams
4301	} else {
4302		return nil
4303	}
4304}
4305
4306func validateOpBatchGetCrawlersInput(v *BatchGetCrawlersInput) error {
4307	if v == nil {
4308		return nil
4309	}
4310	invalidParams := smithy.InvalidParamsError{Context: "BatchGetCrawlersInput"}
4311	if v.CrawlerNames == nil {
4312		invalidParams.Add(smithy.NewErrParamRequired("CrawlerNames"))
4313	}
4314	if invalidParams.Len() > 0 {
4315		return invalidParams
4316	} else {
4317		return nil
4318	}
4319}
4320
4321func validateOpBatchGetDevEndpointsInput(v *BatchGetDevEndpointsInput) error {
4322	if v == nil {
4323		return nil
4324	}
4325	invalidParams := smithy.InvalidParamsError{Context: "BatchGetDevEndpointsInput"}
4326	if v.DevEndpointNames == nil {
4327		invalidParams.Add(smithy.NewErrParamRequired("DevEndpointNames"))
4328	}
4329	if invalidParams.Len() > 0 {
4330		return invalidParams
4331	} else {
4332		return nil
4333	}
4334}
4335
4336func validateOpBatchGetJobsInput(v *BatchGetJobsInput) error {
4337	if v == nil {
4338		return nil
4339	}
4340	invalidParams := smithy.InvalidParamsError{Context: "BatchGetJobsInput"}
4341	if v.JobNames == nil {
4342		invalidParams.Add(smithy.NewErrParamRequired("JobNames"))
4343	}
4344	if invalidParams.Len() > 0 {
4345		return invalidParams
4346	} else {
4347		return nil
4348	}
4349}
4350
4351func validateOpBatchGetPartitionInput(v *BatchGetPartitionInput) error {
4352	if v == nil {
4353		return nil
4354	}
4355	invalidParams := smithy.InvalidParamsError{Context: "BatchGetPartitionInput"}
4356	if v.DatabaseName == nil {
4357		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4358	}
4359	if v.TableName == nil {
4360		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
4361	}
4362	if v.PartitionsToGet == nil {
4363		invalidParams.Add(smithy.NewErrParamRequired("PartitionsToGet"))
4364	} else if v.PartitionsToGet != nil {
4365		if err := validateBatchGetPartitionValueList(v.PartitionsToGet); err != nil {
4366			invalidParams.AddNested("PartitionsToGet", err.(smithy.InvalidParamsError))
4367		}
4368	}
4369	if invalidParams.Len() > 0 {
4370		return invalidParams
4371	} else {
4372		return nil
4373	}
4374}
4375
4376func validateOpBatchGetTriggersInput(v *BatchGetTriggersInput) error {
4377	if v == nil {
4378		return nil
4379	}
4380	invalidParams := smithy.InvalidParamsError{Context: "BatchGetTriggersInput"}
4381	if v.TriggerNames == nil {
4382		invalidParams.Add(smithy.NewErrParamRequired("TriggerNames"))
4383	}
4384	if invalidParams.Len() > 0 {
4385		return invalidParams
4386	} else {
4387		return nil
4388	}
4389}
4390
4391func validateOpBatchGetWorkflowsInput(v *BatchGetWorkflowsInput) error {
4392	if v == nil {
4393		return nil
4394	}
4395	invalidParams := smithy.InvalidParamsError{Context: "BatchGetWorkflowsInput"}
4396	if v.Names == nil {
4397		invalidParams.Add(smithy.NewErrParamRequired("Names"))
4398	}
4399	if invalidParams.Len() > 0 {
4400		return invalidParams
4401	} else {
4402		return nil
4403	}
4404}
4405
4406func validateOpBatchStopJobRunInput(v *BatchStopJobRunInput) error {
4407	if v == nil {
4408		return nil
4409	}
4410	invalidParams := smithy.InvalidParamsError{Context: "BatchStopJobRunInput"}
4411	if v.JobName == nil {
4412		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
4413	}
4414	if v.JobRunIds == nil {
4415		invalidParams.Add(smithy.NewErrParamRequired("JobRunIds"))
4416	}
4417	if invalidParams.Len() > 0 {
4418		return invalidParams
4419	} else {
4420		return nil
4421	}
4422}
4423
4424func validateOpBatchUpdatePartitionInput(v *BatchUpdatePartitionInput) error {
4425	if v == nil {
4426		return nil
4427	}
4428	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdatePartitionInput"}
4429	if v.DatabaseName == nil {
4430		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4431	}
4432	if v.TableName == nil {
4433		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
4434	}
4435	if v.Entries == nil {
4436		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
4437	} else if v.Entries != nil {
4438		if err := validateBatchUpdatePartitionRequestEntryList(v.Entries); err != nil {
4439			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
4440		}
4441	}
4442	if invalidParams.Len() > 0 {
4443		return invalidParams
4444	} else {
4445		return nil
4446	}
4447}
4448
4449func validateOpCancelMLTaskRunInput(v *CancelMLTaskRunInput) error {
4450	if v == nil {
4451		return nil
4452	}
4453	invalidParams := smithy.InvalidParamsError{Context: "CancelMLTaskRunInput"}
4454	if v.TransformId == nil {
4455		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
4456	}
4457	if v.TaskRunId == nil {
4458		invalidParams.Add(smithy.NewErrParamRequired("TaskRunId"))
4459	}
4460	if invalidParams.Len() > 0 {
4461		return invalidParams
4462	} else {
4463		return nil
4464	}
4465}
4466
4467func validateOpCheckSchemaVersionValidityInput(v *CheckSchemaVersionValidityInput) error {
4468	if v == nil {
4469		return nil
4470	}
4471	invalidParams := smithy.InvalidParamsError{Context: "CheckSchemaVersionValidityInput"}
4472	if len(v.DataFormat) == 0 {
4473		invalidParams.Add(smithy.NewErrParamRequired("DataFormat"))
4474	}
4475	if v.SchemaDefinition == nil {
4476		invalidParams.Add(smithy.NewErrParamRequired("SchemaDefinition"))
4477	}
4478	if invalidParams.Len() > 0 {
4479		return invalidParams
4480	} else {
4481		return nil
4482	}
4483}
4484
4485func validateOpCreateClassifierInput(v *CreateClassifierInput) error {
4486	if v == nil {
4487		return nil
4488	}
4489	invalidParams := smithy.InvalidParamsError{Context: "CreateClassifierInput"}
4490	if v.GrokClassifier != nil {
4491		if err := validateCreateGrokClassifierRequest(v.GrokClassifier); err != nil {
4492			invalidParams.AddNested("GrokClassifier", err.(smithy.InvalidParamsError))
4493		}
4494	}
4495	if v.XMLClassifier != nil {
4496		if err := validateCreateXMLClassifierRequest(v.XMLClassifier); err != nil {
4497			invalidParams.AddNested("XMLClassifier", err.(smithy.InvalidParamsError))
4498		}
4499	}
4500	if v.JsonClassifier != nil {
4501		if err := validateCreateJsonClassifierRequest(v.JsonClassifier); err != nil {
4502			invalidParams.AddNested("JsonClassifier", err.(smithy.InvalidParamsError))
4503		}
4504	}
4505	if v.CsvClassifier != nil {
4506		if err := validateCreateCsvClassifierRequest(v.CsvClassifier); err != nil {
4507			invalidParams.AddNested("CsvClassifier", err.(smithy.InvalidParamsError))
4508		}
4509	}
4510	if invalidParams.Len() > 0 {
4511		return invalidParams
4512	} else {
4513		return nil
4514	}
4515}
4516
4517func validateOpCreateConnectionInput(v *CreateConnectionInput) error {
4518	if v == nil {
4519		return nil
4520	}
4521	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionInput"}
4522	if v.ConnectionInput == nil {
4523		invalidParams.Add(smithy.NewErrParamRequired("ConnectionInput"))
4524	} else if v.ConnectionInput != nil {
4525		if err := validateConnectionInput(v.ConnectionInput); err != nil {
4526			invalidParams.AddNested("ConnectionInput", err.(smithy.InvalidParamsError))
4527		}
4528	}
4529	if invalidParams.Len() > 0 {
4530		return invalidParams
4531	} else {
4532		return nil
4533	}
4534}
4535
4536func validateOpCreateCrawlerInput(v *CreateCrawlerInput) error {
4537	if v == nil {
4538		return nil
4539	}
4540	invalidParams := smithy.InvalidParamsError{Context: "CreateCrawlerInput"}
4541	if v.Name == nil {
4542		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4543	}
4544	if v.Role == nil {
4545		invalidParams.Add(smithy.NewErrParamRequired("Role"))
4546	}
4547	if v.Targets == nil {
4548		invalidParams.Add(smithy.NewErrParamRequired("Targets"))
4549	} else if v.Targets != nil {
4550		if err := validateCrawlerTargets(v.Targets); err != nil {
4551			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
4552		}
4553	}
4554	if invalidParams.Len() > 0 {
4555		return invalidParams
4556	} else {
4557		return nil
4558	}
4559}
4560
4561func validateOpCreateDatabaseInput(v *CreateDatabaseInput) error {
4562	if v == nil {
4563		return nil
4564	}
4565	invalidParams := smithy.InvalidParamsError{Context: "CreateDatabaseInput"}
4566	if v.DatabaseInput == nil {
4567		invalidParams.Add(smithy.NewErrParamRequired("DatabaseInput"))
4568	} else if v.DatabaseInput != nil {
4569		if err := validateDatabaseInput(v.DatabaseInput); err != nil {
4570			invalidParams.AddNested("DatabaseInput", err.(smithy.InvalidParamsError))
4571		}
4572	}
4573	if invalidParams.Len() > 0 {
4574		return invalidParams
4575	} else {
4576		return nil
4577	}
4578}
4579
4580func validateOpCreateDevEndpointInput(v *CreateDevEndpointInput) error {
4581	if v == nil {
4582		return nil
4583	}
4584	invalidParams := smithy.InvalidParamsError{Context: "CreateDevEndpointInput"}
4585	if v.EndpointName == nil {
4586		invalidParams.Add(smithy.NewErrParamRequired("EndpointName"))
4587	}
4588	if v.RoleArn == nil {
4589		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
4590	}
4591	if invalidParams.Len() > 0 {
4592		return invalidParams
4593	} else {
4594		return nil
4595	}
4596}
4597
4598func validateOpCreateJobInput(v *CreateJobInput) error {
4599	if v == nil {
4600		return nil
4601	}
4602	invalidParams := smithy.InvalidParamsError{Context: "CreateJobInput"}
4603	if v.Name == nil {
4604		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4605	}
4606	if v.Role == nil {
4607		invalidParams.Add(smithy.NewErrParamRequired("Role"))
4608	}
4609	if v.Command == nil {
4610		invalidParams.Add(smithy.NewErrParamRequired("Command"))
4611	}
4612	if invalidParams.Len() > 0 {
4613		return invalidParams
4614	} else {
4615		return nil
4616	}
4617}
4618
4619func validateOpCreateMLTransformInput(v *CreateMLTransformInput) error {
4620	if v == nil {
4621		return nil
4622	}
4623	invalidParams := smithy.InvalidParamsError{Context: "CreateMLTransformInput"}
4624	if v.Name == nil {
4625		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4626	}
4627	if v.InputRecordTables == nil {
4628		invalidParams.Add(smithy.NewErrParamRequired("InputRecordTables"))
4629	} else if v.InputRecordTables != nil {
4630		if err := validateGlueTables(v.InputRecordTables); err != nil {
4631			invalidParams.AddNested("InputRecordTables", err.(smithy.InvalidParamsError))
4632		}
4633	}
4634	if v.Parameters == nil {
4635		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
4636	} else if v.Parameters != nil {
4637		if err := validateTransformParameters(v.Parameters); err != nil {
4638			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
4639		}
4640	}
4641	if v.Role == nil {
4642		invalidParams.Add(smithy.NewErrParamRequired("Role"))
4643	}
4644	if v.TransformEncryption != nil {
4645		if err := validateTransformEncryption(v.TransformEncryption); err != nil {
4646			invalidParams.AddNested("TransformEncryption", err.(smithy.InvalidParamsError))
4647		}
4648	}
4649	if invalidParams.Len() > 0 {
4650		return invalidParams
4651	} else {
4652		return nil
4653	}
4654}
4655
4656func validateOpCreatePartitionIndexInput(v *CreatePartitionIndexInput) error {
4657	if v == nil {
4658		return nil
4659	}
4660	invalidParams := smithy.InvalidParamsError{Context: "CreatePartitionIndexInput"}
4661	if v.DatabaseName == nil {
4662		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4663	}
4664	if v.TableName == nil {
4665		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
4666	}
4667	if v.PartitionIndex == nil {
4668		invalidParams.Add(smithy.NewErrParamRequired("PartitionIndex"))
4669	} else if v.PartitionIndex != nil {
4670		if err := validatePartitionIndex(v.PartitionIndex); err != nil {
4671			invalidParams.AddNested("PartitionIndex", err.(smithy.InvalidParamsError))
4672		}
4673	}
4674	if invalidParams.Len() > 0 {
4675		return invalidParams
4676	} else {
4677		return nil
4678	}
4679}
4680
4681func validateOpCreatePartitionInput(v *CreatePartitionInput) error {
4682	if v == nil {
4683		return nil
4684	}
4685	invalidParams := smithy.InvalidParamsError{Context: "CreatePartitionInput"}
4686	if v.DatabaseName == nil {
4687		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4688	}
4689	if v.TableName == nil {
4690		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
4691	}
4692	if v.PartitionInput == nil {
4693		invalidParams.Add(smithy.NewErrParamRequired("PartitionInput"))
4694	} else if v.PartitionInput != nil {
4695		if err := validatePartitionInput(v.PartitionInput); err != nil {
4696			invalidParams.AddNested("PartitionInput", err.(smithy.InvalidParamsError))
4697		}
4698	}
4699	if invalidParams.Len() > 0 {
4700		return invalidParams
4701	} else {
4702		return nil
4703	}
4704}
4705
4706func validateOpCreateRegistryInput(v *CreateRegistryInput) error {
4707	if v == nil {
4708		return nil
4709	}
4710	invalidParams := smithy.InvalidParamsError{Context: "CreateRegistryInput"}
4711	if v.RegistryName == nil {
4712		invalidParams.Add(smithy.NewErrParamRequired("RegistryName"))
4713	}
4714	if invalidParams.Len() > 0 {
4715		return invalidParams
4716	} else {
4717		return nil
4718	}
4719}
4720
4721func validateOpCreateSchemaInput(v *CreateSchemaInput) error {
4722	if v == nil {
4723		return nil
4724	}
4725	invalidParams := smithy.InvalidParamsError{Context: "CreateSchemaInput"}
4726	if v.SchemaName == nil {
4727		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
4728	}
4729	if len(v.DataFormat) == 0 {
4730		invalidParams.Add(smithy.NewErrParamRequired("DataFormat"))
4731	}
4732	if invalidParams.Len() > 0 {
4733		return invalidParams
4734	} else {
4735		return nil
4736	}
4737}
4738
4739func validateOpCreateScriptInput(v *CreateScriptInput) error {
4740	if v == nil {
4741		return nil
4742	}
4743	invalidParams := smithy.InvalidParamsError{Context: "CreateScriptInput"}
4744	if v.DagNodes != nil {
4745		if err := validateDagNodes(v.DagNodes); err != nil {
4746			invalidParams.AddNested("DagNodes", err.(smithy.InvalidParamsError))
4747		}
4748	}
4749	if v.DagEdges != nil {
4750		if err := validateDagEdges(v.DagEdges); err != nil {
4751			invalidParams.AddNested("DagEdges", err.(smithy.InvalidParamsError))
4752		}
4753	}
4754	if invalidParams.Len() > 0 {
4755		return invalidParams
4756	} else {
4757		return nil
4758	}
4759}
4760
4761func validateOpCreateSecurityConfigurationInput(v *CreateSecurityConfigurationInput) error {
4762	if v == nil {
4763		return nil
4764	}
4765	invalidParams := smithy.InvalidParamsError{Context: "CreateSecurityConfigurationInput"}
4766	if v.Name == nil {
4767		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4768	}
4769	if v.EncryptionConfiguration == nil {
4770		invalidParams.Add(smithy.NewErrParamRequired("EncryptionConfiguration"))
4771	}
4772	if invalidParams.Len() > 0 {
4773		return invalidParams
4774	} else {
4775		return nil
4776	}
4777}
4778
4779func validateOpCreateTableInput(v *CreateTableInput) error {
4780	if v == nil {
4781		return nil
4782	}
4783	invalidParams := smithy.InvalidParamsError{Context: "CreateTableInput"}
4784	if v.DatabaseName == nil {
4785		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4786	}
4787	if v.TableInput == nil {
4788		invalidParams.Add(smithy.NewErrParamRequired("TableInput"))
4789	} else if v.TableInput != nil {
4790		if err := validateTableInput(v.TableInput); err != nil {
4791			invalidParams.AddNested("TableInput", err.(smithy.InvalidParamsError))
4792		}
4793	}
4794	if v.PartitionIndexes != nil {
4795		if err := validatePartitionIndexList(v.PartitionIndexes); err != nil {
4796			invalidParams.AddNested("PartitionIndexes", err.(smithy.InvalidParamsError))
4797		}
4798	}
4799	if invalidParams.Len() > 0 {
4800		return invalidParams
4801	} else {
4802		return nil
4803	}
4804}
4805
4806func validateOpCreateTriggerInput(v *CreateTriggerInput) error {
4807	if v == nil {
4808		return nil
4809	}
4810	invalidParams := smithy.InvalidParamsError{Context: "CreateTriggerInput"}
4811	if v.Name == nil {
4812		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4813	}
4814	if len(v.Type) == 0 {
4815		invalidParams.Add(smithy.NewErrParamRequired("Type"))
4816	}
4817	if v.Actions == nil {
4818		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
4819	}
4820	if invalidParams.Len() > 0 {
4821		return invalidParams
4822	} else {
4823		return nil
4824	}
4825}
4826
4827func validateOpCreateUserDefinedFunctionInput(v *CreateUserDefinedFunctionInput) error {
4828	if v == nil {
4829		return nil
4830	}
4831	invalidParams := smithy.InvalidParamsError{Context: "CreateUserDefinedFunctionInput"}
4832	if v.DatabaseName == nil {
4833		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4834	}
4835	if v.FunctionInput == nil {
4836		invalidParams.Add(smithy.NewErrParamRequired("FunctionInput"))
4837	}
4838	if invalidParams.Len() > 0 {
4839		return invalidParams
4840	} else {
4841		return nil
4842	}
4843}
4844
4845func validateOpCreateWorkflowInput(v *CreateWorkflowInput) error {
4846	if v == nil {
4847		return nil
4848	}
4849	invalidParams := smithy.InvalidParamsError{Context: "CreateWorkflowInput"}
4850	if v.Name == nil {
4851		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4852	}
4853	if invalidParams.Len() > 0 {
4854		return invalidParams
4855	} else {
4856		return nil
4857	}
4858}
4859
4860func validateOpDeleteClassifierInput(v *DeleteClassifierInput) error {
4861	if v == nil {
4862		return nil
4863	}
4864	invalidParams := smithy.InvalidParamsError{Context: "DeleteClassifierInput"}
4865	if v.Name == nil {
4866		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4867	}
4868	if invalidParams.Len() > 0 {
4869		return invalidParams
4870	} else {
4871		return nil
4872	}
4873}
4874
4875func validateOpDeleteColumnStatisticsForPartitionInput(v *DeleteColumnStatisticsForPartitionInput) error {
4876	if v == nil {
4877		return nil
4878	}
4879	invalidParams := smithy.InvalidParamsError{Context: "DeleteColumnStatisticsForPartitionInput"}
4880	if v.DatabaseName == nil {
4881		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4882	}
4883	if v.TableName == nil {
4884		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
4885	}
4886	if v.PartitionValues == nil {
4887		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
4888	}
4889	if v.ColumnName == nil {
4890		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
4891	}
4892	if invalidParams.Len() > 0 {
4893		return invalidParams
4894	} else {
4895		return nil
4896	}
4897}
4898
4899func validateOpDeleteColumnStatisticsForTableInput(v *DeleteColumnStatisticsForTableInput) error {
4900	if v == nil {
4901		return nil
4902	}
4903	invalidParams := smithy.InvalidParamsError{Context: "DeleteColumnStatisticsForTableInput"}
4904	if v.DatabaseName == nil {
4905		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
4906	}
4907	if v.TableName == nil {
4908		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
4909	}
4910	if v.ColumnName == nil {
4911		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
4912	}
4913	if invalidParams.Len() > 0 {
4914		return invalidParams
4915	} else {
4916		return nil
4917	}
4918}
4919
4920func validateOpDeleteConnectionInput(v *DeleteConnectionInput) error {
4921	if v == nil {
4922		return nil
4923	}
4924	invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionInput"}
4925	if v.ConnectionName == nil {
4926		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
4927	}
4928	if invalidParams.Len() > 0 {
4929		return invalidParams
4930	} else {
4931		return nil
4932	}
4933}
4934
4935func validateOpDeleteCrawlerInput(v *DeleteCrawlerInput) error {
4936	if v == nil {
4937		return nil
4938	}
4939	invalidParams := smithy.InvalidParamsError{Context: "DeleteCrawlerInput"}
4940	if v.Name == nil {
4941		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4942	}
4943	if invalidParams.Len() > 0 {
4944		return invalidParams
4945	} else {
4946		return nil
4947	}
4948}
4949
4950func validateOpDeleteDatabaseInput(v *DeleteDatabaseInput) error {
4951	if v == nil {
4952		return nil
4953	}
4954	invalidParams := smithy.InvalidParamsError{Context: "DeleteDatabaseInput"}
4955	if v.Name == nil {
4956		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4957	}
4958	if invalidParams.Len() > 0 {
4959		return invalidParams
4960	} else {
4961		return nil
4962	}
4963}
4964
4965func validateOpDeleteDevEndpointInput(v *DeleteDevEndpointInput) error {
4966	if v == nil {
4967		return nil
4968	}
4969	invalidParams := smithy.InvalidParamsError{Context: "DeleteDevEndpointInput"}
4970	if v.EndpointName == nil {
4971		invalidParams.Add(smithy.NewErrParamRequired("EndpointName"))
4972	}
4973	if invalidParams.Len() > 0 {
4974		return invalidParams
4975	} else {
4976		return nil
4977	}
4978}
4979
4980func validateOpDeleteJobInput(v *DeleteJobInput) error {
4981	if v == nil {
4982		return nil
4983	}
4984	invalidParams := smithy.InvalidParamsError{Context: "DeleteJobInput"}
4985	if v.JobName == nil {
4986		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
4987	}
4988	if invalidParams.Len() > 0 {
4989		return invalidParams
4990	} else {
4991		return nil
4992	}
4993}
4994
4995func validateOpDeleteMLTransformInput(v *DeleteMLTransformInput) error {
4996	if v == nil {
4997		return nil
4998	}
4999	invalidParams := smithy.InvalidParamsError{Context: "DeleteMLTransformInput"}
5000	if v.TransformId == nil {
5001		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
5002	}
5003	if invalidParams.Len() > 0 {
5004		return invalidParams
5005	} else {
5006		return nil
5007	}
5008}
5009
5010func validateOpDeletePartitionIndexInput(v *DeletePartitionIndexInput) error {
5011	if v == nil {
5012		return nil
5013	}
5014	invalidParams := smithy.InvalidParamsError{Context: "DeletePartitionIndexInput"}
5015	if v.DatabaseName == nil {
5016		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5017	}
5018	if v.TableName == nil {
5019		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
5020	}
5021	if v.IndexName == nil {
5022		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
5023	}
5024	if invalidParams.Len() > 0 {
5025		return invalidParams
5026	} else {
5027		return nil
5028	}
5029}
5030
5031func validateOpDeletePartitionInput(v *DeletePartitionInput) error {
5032	if v == nil {
5033		return nil
5034	}
5035	invalidParams := smithy.InvalidParamsError{Context: "DeletePartitionInput"}
5036	if v.DatabaseName == nil {
5037		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5038	}
5039	if v.TableName == nil {
5040		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
5041	}
5042	if v.PartitionValues == nil {
5043		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
5044	}
5045	if invalidParams.Len() > 0 {
5046		return invalidParams
5047	} else {
5048		return nil
5049	}
5050}
5051
5052func validateOpDeleteRegistryInput(v *DeleteRegistryInput) error {
5053	if v == nil {
5054		return nil
5055	}
5056	invalidParams := smithy.InvalidParamsError{Context: "DeleteRegistryInput"}
5057	if v.RegistryId == nil {
5058		invalidParams.Add(smithy.NewErrParamRequired("RegistryId"))
5059	}
5060	if invalidParams.Len() > 0 {
5061		return invalidParams
5062	} else {
5063		return nil
5064	}
5065}
5066
5067func validateOpDeleteSchemaInput(v *DeleteSchemaInput) error {
5068	if v == nil {
5069		return nil
5070	}
5071	invalidParams := smithy.InvalidParamsError{Context: "DeleteSchemaInput"}
5072	if v.SchemaId == nil {
5073		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
5074	}
5075	if invalidParams.Len() > 0 {
5076		return invalidParams
5077	} else {
5078		return nil
5079	}
5080}
5081
5082func validateOpDeleteSchemaVersionsInput(v *DeleteSchemaVersionsInput) error {
5083	if v == nil {
5084		return nil
5085	}
5086	invalidParams := smithy.InvalidParamsError{Context: "DeleteSchemaVersionsInput"}
5087	if v.SchemaId == nil {
5088		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
5089	}
5090	if v.Versions == nil {
5091		invalidParams.Add(smithy.NewErrParamRequired("Versions"))
5092	}
5093	if invalidParams.Len() > 0 {
5094		return invalidParams
5095	} else {
5096		return nil
5097	}
5098}
5099
5100func validateOpDeleteSecurityConfigurationInput(v *DeleteSecurityConfigurationInput) error {
5101	if v == nil {
5102		return nil
5103	}
5104	invalidParams := smithy.InvalidParamsError{Context: "DeleteSecurityConfigurationInput"}
5105	if v.Name == nil {
5106		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5107	}
5108	if invalidParams.Len() > 0 {
5109		return invalidParams
5110	} else {
5111		return nil
5112	}
5113}
5114
5115func validateOpDeleteTableInput(v *DeleteTableInput) error {
5116	if v == nil {
5117		return nil
5118	}
5119	invalidParams := smithy.InvalidParamsError{Context: "DeleteTableInput"}
5120	if v.DatabaseName == nil {
5121		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5122	}
5123	if v.Name == nil {
5124		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5125	}
5126	if invalidParams.Len() > 0 {
5127		return invalidParams
5128	} else {
5129		return nil
5130	}
5131}
5132
5133func validateOpDeleteTableVersionInput(v *DeleteTableVersionInput) error {
5134	if v == nil {
5135		return nil
5136	}
5137	invalidParams := smithy.InvalidParamsError{Context: "DeleteTableVersionInput"}
5138	if v.DatabaseName == nil {
5139		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5140	}
5141	if v.TableName == nil {
5142		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
5143	}
5144	if v.VersionId == nil {
5145		invalidParams.Add(smithy.NewErrParamRequired("VersionId"))
5146	}
5147	if invalidParams.Len() > 0 {
5148		return invalidParams
5149	} else {
5150		return nil
5151	}
5152}
5153
5154func validateOpDeleteTriggerInput(v *DeleteTriggerInput) error {
5155	if v == nil {
5156		return nil
5157	}
5158	invalidParams := smithy.InvalidParamsError{Context: "DeleteTriggerInput"}
5159	if v.Name == nil {
5160		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5161	}
5162	if invalidParams.Len() > 0 {
5163		return invalidParams
5164	} else {
5165		return nil
5166	}
5167}
5168
5169func validateOpDeleteUserDefinedFunctionInput(v *DeleteUserDefinedFunctionInput) error {
5170	if v == nil {
5171		return nil
5172	}
5173	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserDefinedFunctionInput"}
5174	if v.DatabaseName == nil {
5175		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5176	}
5177	if v.FunctionName == nil {
5178		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
5179	}
5180	if invalidParams.Len() > 0 {
5181		return invalidParams
5182	} else {
5183		return nil
5184	}
5185}
5186
5187func validateOpDeleteWorkflowInput(v *DeleteWorkflowInput) error {
5188	if v == nil {
5189		return nil
5190	}
5191	invalidParams := smithy.InvalidParamsError{Context: "DeleteWorkflowInput"}
5192	if v.Name == nil {
5193		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5194	}
5195	if invalidParams.Len() > 0 {
5196		return invalidParams
5197	} else {
5198		return nil
5199	}
5200}
5201
5202func validateOpGetClassifierInput(v *GetClassifierInput) error {
5203	if v == nil {
5204		return nil
5205	}
5206	invalidParams := smithy.InvalidParamsError{Context: "GetClassifierInput"}
5207	if v.Name == nil {
5208		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5209	}
5210	if invalidParams.Len() > 0 {
5211		return invalidParams
5212	} else {
5213		return nil
5214	}
5215}
5216
5217func validateOpGetColumnStatisticsForPartitionInput(v *GetColumnStatisticsForPartitionInput) error {
5218	if v == nil {
5219		return nil
5220	}
5221	invalidParams := smithy.InvalidParamsError{Context: "GetColumnStatisticsForPartitionInput"}
5222	if v.DatabaseName == nil {
5223		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5224	}
5225	if v.TableName == nil {
5226		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
5227	}
5228	if v.PartitionValues == nil {
5229		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
5230	}
5231	if v.ColumnNames == nil {
5232		invalidParams.Add(smithy.NewErrParamRequired("ColumnNames"))
5233	}
5234	if invalidParams.Len() > 0 {
5235		return invalidParams
5236	} else {
5237		return nil
5238	}
5239}
5240
5241func validateOpGetColumnStatisticsForTableInput(v *GetColumnStatisticsForTableInput) error {
5242	if v == nil {
5243		return nil
5244	}
5245	invalidParams := smithy.InvalidParamsError{Context: "GetColumnStatisticsForTableInput"}
5246	if v.DatabaseName == nil {
5247		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5248	}
5249	if v.TableName == nil {
5250		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
5251	}
5252	if v.ColumnNames == nil {
5253		invalidParams.Add(smithy.NewErrParamRequired("ColumnNames"))
5254	}
5255	if invalidParams.Len() > 0 {
5256		return invalidParams
5257	} else {
5258		return nil
5259	}
5260}
5261
5262func validateOpGetConnectionInput(v *GetConnectionInput) error {
5263	if v == nil {
5264		return nil
5265	}
5266	invalidParams := smithy.InvalidParamsError{Context: "GetConnectionInput"}
5267	if v.Name == nil {
5268		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5269	}
5270	if invalidParams.Len() > 0 {
5271		return invalidParams
5272	} else {
5273		return nil
5274	}
5275}
5276
5277func validateOpGetCrawlerInput(v *GetCrawlerInput) error {
5278	if v == nil {
5279		return nil
5280	}
5281	invalidParams := smithy.InvalidParamsError{Context: "GetCrawlerInput"}
5282	if v.Name == nil {
5283		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5284	}
5285	if invalidParams.Len() > 0 {
5286		return invalidParams
5287	} else {
5288		return nil
5289	}
5290}
5291
5292func validateOpGetDatabaseInput(v *GetDatabaseInput) error {
5293	if v == nil {
5294		return nil
5295	}
5296	invalidParams := smithy.InvalidParamsError{Context: "GetDatabaseInput"}
5297	if v.Name == nil {
5298		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5299	}
5300	if invalidParams.Len() > 0 {
5301		return invalidParams
5302	} else {
5303		return nil
5304	}
5305}
5306
5307func validateOpGetDevEndpointInput(v *GetDevEndpointInput) error {
5308	if v == nil {
5309		return nil
5310	}
5311	invalidParams := smithy.InvalidParamsError{Context: "GetDevEndpointInput"}
5312	if v.EndpointName == nil {
5313		invalidParams.Add(smithy.NewErrParamRequired("EndpointName"))
5314	}
5315	if invalidParams.Len() > 0 {
5316		return invalidParams
5317	} else {
5318		return nil
5319	}
5320}
5321
5322func validateOpGetJobBookmarkInput(v *GetJobBookmarkInput) error {
5323	if v == nil {
5324		return nil
5325	}
5326	invalidParams := smithy.InvalidParamsError{Context: "GetJobBookmarkInput"}
5327	if v.JobName == nil {
5328		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
5329	}
5330	if invalidParams.Len() > 0 {
5331		return invalidParams
5332	} else {
5333		return nil
5334	}
5335}
5336
5337func validateOpGetJobInput(v *GetJobInput) error {
5338	if v == nil {
5339		return nil
5340	}
5341	invalidParams := smithy.InvalidParamsError{Context: "GetJobInput"}
5342	if v.JobName == nil {
5343		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
5344	}
5345	if invalidParams.Len() > 0 {
5346		return invalidParams
5347	} else {
5348		return nil
5349	}
5350}
5351
5352func validateOpGetJobRunInput(v *GetJobRunInput) error {
5353	if v == nil {
5354		return nil
5355	}
5356	invalidParams := smithy.InvalidParamsError{Context: "GetJobRunInput"}
5357	if v.JobName == nil {
5358		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
5359	}
5360	if v.RunId == nil {
5361		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
5362	}
5363	if invalidParams.Len() > 0 {
5364		return invalidParams
5365	} else {
5366		return nil
5367	}
5368}
5369
5370func validateOpGetJobRunsInput(v *GetJobRunsInput) error {
5371	if v == nil {
5372		return nil
5373	}
5374	invalidParams := smithy.InvalidParamsError{Context: "GetJobRunsInput"}
5375	if v.JobName == nil {
5376		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
5377	}
5378	if invalidParams.Len() > 0 {
5379		return invalidParams
5380	} else {
5381		return nil
5382	}
5383}
5384
5385func validateOpGetMappingInput(v *GetMappingInput) error {
5386	if v == nil {
5387		return nil
5388	}
5389	invalidParams := smithy.InvalidParamsError{Context: "GetMappingInput"}
5390	if v.Source == nil {
5391		invalidParams.Add(smithy.NewErrParamRequired("Source"))
5392	} else if v.Source != nil {
5393		if err := validateCatalogEntry(v.Source); err != nil {
5394			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
5395		}
5396	}
5397	if v.Sinks != nil {
5398		if err := validateCatalogEntries(v.Sinks); err != nil {
5399			invalidParams.AddNested("Sinks", err.(smithy.InvalidParamsError))
5400		}
5401	}
5402	if v.Location != nil {
5403		if err := validateLocation(v.Location); err != nil {
5404			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
5405		}
5406	}
5407	if invalidParams.Len() > 0 {
5408		return invalidParams
5409	} else {
5410		return nil
5411	}
5412}
5413
5414func validateOpGetMLTaskRunInput(v *GetMLTaskRunInput) error {
5415	if v == nil {
5416		return nil
5417	}
5418	invalidParams := smithy.InvalidParamsError{Context: "GetMLTaskRunInput"}
5419	if v.TransformId == nil {
5420		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
5421	}
5422	if v.TaskRunId == nil {
5423		invalidParams.Add(smithy.NewErrParamRequired("TaskRunId"))
5424	}
5425	if invalidParams.Len() > 0 {
5426		return invalidParams
5427	} else {
5428		return nil
5429	}
5430}
5431
5432func validateOpGetMLTaskRunsInput(v *GetMLTaskRunsInput) error {
5433	if v == nil {
5434		return nil
5435	}
5436	invalidParams := smithy.InvalidParamsError{Context: "GetMLTaskRunsInput"}
5437	if v.TransformId == nil {
5438		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
5439	}
5440	if v.Sort != nil {
5441		if err := validateTaskRunSortCriteria(v.Sort); err != nil {
5442			invalidParams.AddNested("Sort", err.(smithy.InvalidParamsError))
5443		}
5444	}
5445	if invalidParams.Len() > 0 {
5446		return invalidParams
5447	} else {
5448		return nil
5449	}
5450}
5451
5452func validateOpGetMLTransformInput(v *GetMLTransformInput) error {
5453	if v == nil {
5454		return nil
5455	}
5456	invalidParams := smithy.InvalidParamsError{Context: "GetMLTransformInput"}
5457	if v.TransformId == nil {
5458		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
5459	}
5460	if invalidParams.Len() > 0 {
5461		return invalidParams
5462	} else {
5463		return nil
5464	}
5465}
5466
5467func validateOpGetMLTransformsInput(v *GetMLTransformsInput) error {
5468	if v == nil {
5469		return nil
5470	}
5471	invalidParams := smithy.InvalidParamsError{Context: "GetMLTransformsInput"}
5472	if v.Sort != nil {
5473		if err := validateTransformSortCriteria(v.Sort); err != nil {
5474			invalidParams.AddNested("Sort", err.(smithy.InvalidParamsError))
5475		}
5476	}
5477	if invalidParams.Len() > 0 {
5478		return invalidParams
5479	} else {
5480		return nil
5481	}
5482}
5483
5484func validateOpGetPartitionIndexesInput(v *GetPartitionIndexesInput) error {
5485	if v == nil {
5486		return nil
5487	}
5488	invalidParams := smithy.InvalidParamsError{Context: "GetPartitionIndexesInput"}
5489	if v.DatabaseName == nil {
5490		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5491	}
5492	if v.TableName == nil {
5493		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
5494	}
5495	if invalidParams.Len() > 0 {
5496		return invalidParams
5497	} else {
5498		return nil
5499	}
5500}
5501
5502func validateOpGetPartitionInput(v *GetPartitionInput) error {
5503	if v == nil {
5504		return nil
5505	}
5506	invalidParams := smithy.InvalidParamsError{Context: "GetPartitionInput"}
5507	if v.DatabaseName == nil {
5508		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5509	}
5510	if v.TableName == nil {
5511		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
5512	}
5513	if v.PartitionValues == nil {
5514		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
5515	}
5516	if invalidParams.Len() > 0 {
5517		return invalidParams
5518	} else {
5519		return nil
5520	}
5521}
5522
5523func validateOpGetPartitionsInput(v *GetPartitionsInput) error {
5524	if v == nil {
5525		return nil
5526	}
5527	invalidParams := smithy.InvalidParamsError{Context: "GetPartitionsInput"}
5528	if v.DatabaseName == nil {
5529		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5530	}
5531	if v.TableName == nil {
5532		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
5533	}
5534	if v.Segment != nil {
5535		if err := validateSegment(v.Segment); err != nil {
5536			invalidParams.AddNested("Segment", err.(smithy.InvalidParamsError))
5537		}
5538	}
5539	if invalidParams.Len() > 0 {
5540		return invalidParams
5541	} else {
5542		return nil
5543	}
5544}
5545
5546func validateOpGetPlanInput(v *GetPlanInput) error {
5547	if v == nil {
5548		return nil
5549	}
5550	invalidParams := smithy.InvalidParamsError{Context: "GetPlanInput"}
5551	if v.Mapping == nil {
5552		invalidParams.Add(smithy.NewErrParamRequired("Mapping"))
5553	}
5554	if v.Source == nil {
5555		invalidParams.Add(smithy.NewErrParamRequired("Source"))
5556	} else if v.Source != nil {
5557		if err := validateCatalogEntry(v.Source); err != nil {
5558			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
5559		}
5560	}
5561	if v.Sinks != nil {
5562		if err := validateCatalogEntries(v.Sinks); err != nil {
5563			invalidParams.AddNested("Sinks", err.(smithy.InvalidParamsError))
5564		}
5565	}
5566	if v.Location != nil {
5567		if err := validateLocation(v.Location); err != nil {
5568			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
5569		}
5570	}
5571	if invalidParams.Len() > 0 {
5572		return invalidParams
5573	} else {
5574		return nil
5575	}
5576}
5577
5578func validateOpGetRegistryInput(v *GetRegistryInput) error {
5579	if v == nil {
5580		return nil
5581	}
5582	invalidParams := smithy.InvalidParamsError{Context: "GetRegistryInput"}
5583	if v.RegistryId == nil {
5584		invalidParams.Add(smithy.NewErrParamRequired("RegistryId"))
5585	}
5586	if invalidParams.Len() > 0 {
5587		return invalidParams
5588	} else {
5589		return nil
5590	}
5591}
5592
5593func validateOpGetSchemaByDefinitionInput(v *GetSchemaByDefinitionInput) error {
5594	if v == nil {
5595		return nil
5596	}
5597	invalidParams := smithy.InvalidParamsError{Context: "GetSchemaByDefinitionInput"}
5598	if v.SchemaId == nil {
5599		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
5600	}
5601	if v.SchemaDefinition == nil {
5602		invalidParams.Add(smithy.NewErrParamRequired("SchemaDefinition"))
5603	}
5604	if invalidParams.Len() > 0 {
5605		return invalidParams
5606	} else {
5607		return nil
5608	}
5609}
5610
5611func validateOpGetSchemaInput(v *GetSchemaInput) error {
5612	if v == nil {
5613		return nil
5614	}
5615	invalidParams := smithy.InvalidParamsError{Context: "GetSchemaInput"}
5616	if v.SchemaId == nil {
5617		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
5618	}
5619	if invalidParams.Len() > 0 {
5620		return invalidParams
5621	} else {
5622		return nil
5623	}
5624}
5625
5626func validateOpGetSchemaVersionsDiffInput(v *GetSchemaVersionsDiffInput) error {
5627	if v == nil {
5628		return nil
5629	}
5630	invalidParams := smithy.InvalidParamsError{Context: "GetSchemaVersionsDiffInput"}
5631	if v.SchemaId == nil {
5632		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
5633	}
5634	if v.FirstSchemaVersionNumber == nil {
5635		invalidParams.Add(smithy.NewErrParamRequired("FirstSchemaVersionNumber"))
5636	}
5637	if v.SecondSchemaVersionNumber == nil {
5638		invalidParams.Add(smithy.NewErrParamRequired("SecondSchemaVersionNumber"))
5639	}
5640	if len(v.SchemaDiffType) == 0 {
5641		invalidParams.Add(smithy.NewErrParamRequired("SchemaDiffType"))
5642	}
5643	if invalidParams.Len() > 0 {
5644		return invalidParams
5645	} else {
5646		return nil
5647	}
5648}
5649
5650func validateOpGetSecurityConfigurationInput(v *GetSecurityConfigurationInput) error {
5651	if v == nil {
5652		return nil
5653	}
5654	invalidParams := smithy.InvalidParamsError{Context: "GetSecurityConfigurationInput"}
5655	if v.Name == nil {
5656		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5657	}
5658	if invalidParams.Len() > 0 {
5659		return invalidParams
5660	} else {
5661		return nil
5662	}
5663}
5664
5665func validateOpGetTableInput(v *GetTableInput) error {
5666	if v == nil {
5667		return nil
5668	}
5669	invalidParams := smithy.InvalidParamsError{Context: "GetTableInput"}
5670	if v.DatabaseName == nil {
5671		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5672	}
5673	if v.Name == nil {
5674		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5675	}
5676	if invalidParams.Len() > 0 {
5677		return invalidParams
5678	} else {
5679		return nil
5680	}
5681}
5682
5683func validateOpGetTablesInput(v *GetTablesInput) error {
5684	if v == nil {
5685		return nil
5686	}
5687	invalidParams := smithy.InvalidParamsError{Context: "GetTablesInput"}
5688	if v.DatabaseName == nil {
5689		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5690	}
5691	if invalidParams.Len() > 0 {
5692		return invalidParams
5693	} else {
5694		return nil
5695	}
5696}
5697
5698func validateOpGetTableVersionInput(v *GetTableVersionInput) error {
5699	if v == nil {
5700		return nil
5701	}
5702	invalidParams := smithy.InvalidParamsError{Context: "GetTableVersionInput"}
5703	if v.DatabaseName == nil {
5704		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5705	}
5706	if v.TableName == nil {
5707		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
5708	}
5709	if invalidParams.Len() > 0 {
5710		return invalidParams
5711	} else {
5712		return nil
5713	}
5714}
5715
5716func validateOpGetTableVersionsInput(v *GetTableVersionsInput) error {
5717	if v == nil {
5718		return nil
5719	}
5720	invalidParams := smithy.InvalidParamsError{Context: "GetTableVersionsInput"}
5721	if v.DatabaseName == nil {
5722		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5723	}
5724	if v.TableName == nil {
5725		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
5726	}
5727	if invalidParams.Len() > 0 {
5728		return invalidParams
5729	} else {
5730		return nil
5731	}
5732}
5733
5734func validateOpGetTagsInput(v *GetTagsInput) error {
5735	if v == nil {
5736		return nil
5737	}
5738	invalidParams := smithy.InvalidParamsError{Context: "GetTagsInput"}
5739	if v.ResourceArn == nil {
5740		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
5741	}
5742	if invalidParams.Len() > 0 {
5743		return invalidParams
5744	} else {
5745		return nil
5746	}
5747}
5748
5749func validateOpGetTriggerInput(v *GetTriggerInput) error {
5750	if v == nil {
5751		return nil
5752	}
5753	invalidParams := smithy.InvalidParamsError{Context: "GetTriggerInput"}
5754	if v.Name == nil {
5755		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5756	}
5757	if invalidParams.Len() > 0 {
5758		return invalidParams
5759	} else {
5760		return nil
5761	}
5762}
5763
5764func validateOpGetUserDefinedFunctionInput(v *GetUserDefinedFunctionInput) error {
5765	if v == nil {
5766		return nil
5767	}
5768	invalidParams := smithy.InvalidParamsError{Context: "GetUserDefinedFunctionInput"}
5769	if v.DatabaseName == nil {
5770		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
5771	}
5772	if v.FunctionName == nil {
5773		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
5774	}
5775	if invalidParams.Len() > 0 {
5776		return invalidParams
5777	} else {
5778		return nil
5779	}
5780}
5781
5782func validateOpGetUserDefinedFunctionsInput(v *GetUserDefinedFunctionsInput) error {
5783	if v == nil {
5784		return nil
5785	}
5786	invalidParams := smithy.InvalidParamsError{Context: "GetUserDefinedFunctionsInput"}
5787	if v.Pattern == nil {
5788		invalidParams.Add(smithy.NewErrParamRequired("Pattern"))
5789	}
5790	if invalidParams.Len() > 0 {
5791		return invalidParams
5792	} else {
5793		return nil
5794	}
5795}
5796
5797func validateOpGetWorkflowInput(v *GetWorkflowInput) error {
5798	if v == nil {
5799		return nil
5800	}
5801	invalidParams := smithy.InvalidParamsError{Context: "GetWorkflowInput"}
5802	if v.Name == nil {
5803		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5804	}
5805	if invalidParams.Len() > 0 {
5806		return invalidParams
5807	} else {
5808		return nil
5809	}
5810}
5811
5812func validateOpGetWorkflowRunInput(v *GetWorkflowRunInput) error {
5813	if v == nil {
5814		return nil
5815	}
5816	invalidParams := smithy.InvalidParamsError{Context: "GetWorkflowRunInput"}
5817	if v.Name == nil {
5818		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5819	}
5820	if v.RunId == nil {
5821		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
5822	}
5823	if invalidParams.Len() > 0 {
5824		return invalidParams
5825	} else {
5826		return nil
5827	}
5828}
5829
5830func validateOpGetWorkflowRunPropertiesInput(v *GetWorkflowRunPropertiesInput) error {
5831	if v == nil {
5832		return nil
5833	}
5834	invalidParams := smithy.InvalidParamsError{Context: "GetWorkflowRunPropertiesInput"}
5835	if v.Name == nil {
5836		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5837	}
5838	if v.RunId == nil {
5839		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
5840	}
5841	if invalidParams.Len() > 0 {
5842		return invalidParams
5843	} else {
5844		return nil
5845	}
5846}
5847
5848func validateOpGetWorkflowRunsInput(v *GetWorkflowRunsInput) error {
5849	if v == nil {
5850		return nil
5851	}
5852	invalidParams := smithy.InvalidParamsError{Context: "GetWorkflowRunsInput"}
5853	if v.Name == nil {
5854		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5855	}
5856	if invalidParams.Len() > 0 {
5857		return invalidParams
5858	} else {
5859		return nil
5860	}
5861}
5862
5863func validateOpListMLTransformsInput(v *ListMLTransformsInput) error {
5864	if v == nil {
5865		return nil
5866	}
5867	invalidParams := smithy.InvalidParamsError{Context: "ListMLTransformsInput"}
5868	if v.Sort != nil {
5869		if err := validateTransformSortCriteria(v.Sort); err != nil {
5870			invalidParams.AddNested("Sort", err.(smithy.InvalidParamsError))
5871		}
5872	}
5873	if invalidParams.Len() > 0 {
5874		return invalidParams
5875	} else {
5876		return nil
5877	}
5878}
5879
5880func validateOpListSchemaVersionsInput(v *ListSchemaVersionsInput) error {
5881	if v == nil {
5882		return nil
5883	}
5884	invalidParams := smithy.InvalidParamsError{Context: "ListSchemaVersionsInput"}
5885	if v.SchemaId == nil {
5886		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
5887	}
5888	if invalidParams.Len() > 0 {
5889		return invalidParams
5890	} else {
5891		return nil
5892	}
5893}
5894
5895func validateOpPutDataCatalogEncryptionSettingsInput(v *PutDataCatalogEncryptionSettingsInput) error {
5896	if v == nil {
5897		return nil
5898	}
5899	invalidParams := smithy.InvalidParamsError{Context: "PutDataCatalogEncryptionSettingsInput"}
5900	if v.DataCatalogEncryptionSettings == nil {
5901		invalidParams.Add(smithy.NewErrParamRequired("DataCatalogEncryptionSettings"))
5902	} else if v.DataCatalogEncryptionSettings != nil {
5903		if err := validateDataCatalogEncryptionSettings(v.DataCatalogEncryptionSettings); err != nil {
5904			invalidParams.AddNested("DataCatalogEncryptionSettings", err.(smithy.InvalidParamsError))
5905		}
5906	}
5907	if invalidParams.Len() > 0 {
5908		return invalidParams
5909	} else {
5910		return nil
5911	}
5912}
5913
5914func validateOpPutResourcePolicyInput(v *PutResourcePolicyInput) error {
5915	if v == nil {
5916		return nil
5917	}
5918	invalidParams := smithy.InvalidParamsError{Context: "PutResourcePolicyInput"}
5919	if v.PolicyInJson == nil {
5920		invalidParams.Add(smithy.NewErrParamRequired("PolicyInJson"))
5921	}
5922	if invalidParams.Len() > 0 {
5923		return invalidParams
5924	} else {
5925		return nil
5926	}
5927}
5928
5929func validateOpPutSchemaVersionMetadataInput(v *PutSchemaVersionMetadataInput) error {
5930	if v == nil {
5931		return nil
5932	}
5933	invalidParams := smithy.InvalidParamsError{Context: "PutSchemaVersionMetadataInput"}
5934	if v.MetadataKeyValue == nil {
5935		invalidParams.Add(smithy.NewErrParamRequired("MetadataKeyValue"))
5936	}
5937	if invalidParams.Len() > 0 {
5938		return invalidParams
5939	} else {
5940		return nil
5941	}
5942}
5943
5944func validateOpPutWorkflowRunPropertiesInput(v *PutWorkflowRunPropertiesInput) error {
5945	if v == nil {
5946		return nil
5947	}
5948	invalidParams := smithy.InvalidParamsError{Context: "PutWorkflowRunPropertiesInput"}
5949	if v.Name == nil {
5950		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5951	}
5952	if v.RunId == nil {
5953		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
5954	}
5955	if v.RunProperties == nil {
5956		invalidParams.Add(smithy.NewErrParamRequired("RunProperties"))
5957	}
5958	if invalidParams.Len() > 0 {
5959		return invalidParams
5960	} else {
5961		return nil
5962	}
5963}
5964
5965func validateOpRegisterSchemaVersionInput(v *RegisterSchemaVersionInput) error {
5966	if v == nil {
5967		return nil
5968	}
5969	invalidParams := smithy.InvalidParamsError{Context: "RegisterSchemaVersionInput"}
5970	if v.SchemaId == nil {
5971		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
5972	}
5973	if v.SchemaDefinition == nil {
5974		invalidParams.Add(smithy.NewErrParamRequired("SchemaDefinition"))
5975	}
5976	if invalidParams.Len() > 0 {
5977		return invalidParams
5978	} else {
5979		return nil
5980	}
5981}
5982
5983func validateOpRemoveSchemaVersionMetadataInput(v *RemoveSchemaVersionMetadataInput) error {
5984	if v == nil {
5985		return nil
5986	}
5987	invalidParams := smithy.InvalidParamsError{Context: "RemoveSchemaVersionMetadataInput"}
5988	if v.MetadataKeyValue == nil {
5989		invalidParams.Add(smithy.NewErrParamRequired("MetadataKeyValue"))
5990	}
5991	if invalidParams.Len() > 0 {
5992		return invalidParams
5993	} else {
5994		return nil
5995	}
5996}
5997
5998func validateOpResetJobBookmarkInput(v *ResetJobBookmarkInput) error {
5999	if v == nil {
6000		return nil
6001	}
6002	invalidParams := smithy.InvalidParamsError{Context: "ResetJobBookmarkInput"}
6003	if v.JobName == nil {
6004		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
6005	}
6006	if invalidParams.Len() > 0 {
6007		return invalidParams
6008	} else {
6009		return nil
6010	}
6011}
6012
6013func validateOpResumeWorkflowRunInput(v *ResumeWorkflowRunInput) error {
6014	if v == nil {
6015		return nil
6016	}
6017	invalidParams := smithy.InvalidParamsError{Context: "ResumeWorkflowRunInput"}
6018	if v.Name == nil {
6019		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6020	}
6021	if v.RunId == nil {
6022		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
6023	}
6024	if v.NodeIds == nil {
6025		invalidParams.Add(smithy.NewErrParamRequired("NodeIds"))
6026	}
6027	if invalidParams.Len() > 0 {
6028		return invalidParams
6029	} else {
6030		return nil
6031	}
6032}
6033
6034func validateOpStartCrawlerInput(v *StartCrawlerInput) error {
6035	if v == nil {
6036		return nil
6037	}
6038	invalidParams := smithy.InvalidParamsError{Context: "StartCrawlerInput"}
6039	if v.Name == nil {
6040		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6041	}
6042	if invalidParams.Len() > 0 {
6043		return invalidParams
6044	} else {
6045		return nil
6046	}
6047}
6048
6049func validateOpStartCrawlerScheduleInput(v *StartCrawlerScheduleInput) error {
6050	if v == nil {
6051		return nil
6052	}
6053	invalidParams := smithy.InvalidParamsError{Context: "StartCrawlerScheduleInput"}
6054	if v.CrawlerName == nil {
6055		invalidParams.Add(smithy.NewErrParamRequired("CrawlerName"))
6056	}
6057	if invalidParams.Len() > 0 {
6058		return invalidParams
6059	} else {
6060		return nil
6061	}
6062}
6063
6064func validateOpStartExportLabelsTaskRunInput(v *StartExportLabelsTaskRunInput) error {
6065	if v == nil {
6066		return nil
6067	}
6068	invalidParams := smithy.InvalidParamsError{Context: "StartExportLabelsTaskRunInput"}
6069	if v.TransformId == nil {
6070		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
6071	}
6072	if v.OutputS3Path == nil {
6073		invalidParams.Add(smithy.NewErrParamRequired("OutputS3Path"))
6074	}
6075	if invalidParams.Len() > 0 {
6076		return invalidParams
6077	} else {
6078		return nil
6079	}
6080}
6081
6082func validateOpStartImportLabelsTaskRunInput(v *StartImportLabelsTaskRunInput) error {
6083	if v == nil {
6084		return nil
6085	}
6086	invalidParams := smithy.InvalidParamsError{Context: "StartImportLabelsTaskRunInput"}
6087	if v.TransformId == nil {
6088		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
6089	}
6090	if v.InputS3Path == nil {
6091		invalidParams.Add(smithy.NewErrParamRequired("InputS3Path"))
6092	}
6093	if invalidParams.Len() > 0 {
6094		return invalidParams
6095	} else {
6096		return nil
6097	}
6098}
6099
6100func validateOpStartJobRunInput(v *StartJobRunInput) error {
6101	if v == nil {
6102		return nil
6103	}
6104	invalidParams := smithy.InvalidParamsError{Context: "StartJobRunInput"}
6105	if v.JobName == nil {
6106		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
6107	}
6108	if invalidParams.Len() > 0 {
6109		return invalidParams
6110	} else {
6111		return nil
6112	}
6113}
6114
6115func validateOpStartMLEvaluationTaskRunInput(v *StartMLEvaluationTaskRunInput) error {
6116	if v == nil {
6117		return nil
6118	}
6119	invalidParams := smithy.InvalidParamsError{Context: "StartMLEvaluationTaskRunInput"}
6120	if v.TransformId == nil {
6121		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
6122	}
6123	if invalidParams.Len() > 0 {
6124		return invalidParams
6125	} else {
6126		return nil
6127	}
6128}
6129
6130func validateOpStartMLLabelingSetGenerationTaskRunInput(v *StartMLLabelingSetGenerationTaskRunInput) error {
6131	if v == nil {
6132		return nil
6133	}
6134	invalidParams := smithy.InvalidParamsError{Context: "StartMLLabelingSetGenerationTaskRunInput"}
6135	if v.TransformId == nil {
6136		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
6137	}
6138	if v.OutputS3Path == nil {
6139		invalidParams.Add(smithy.NewErrParamRequired("OutputS3Path"))
6140	}
6141	if invalidParams.Len() > 0 {
6142		return invalidParams
6143	} else {
6144		return nil
6145	}
6146}
6147
6148func validateOpStartTriggerInput(v *StartTriggerInput) error {
6149	if v == nil {
6150		return nil
6151	}
6152	invalidParams := smithy.InvalidParamsError{Context: "StartTriggerInput"}
6153	if v.Name == nil {
6154		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6155	}
6156	if invalidParams.Len() > 0 {
6157		return invalidParams
6158	} else {
6159		return nil
6160	}
6161}
6162
6163func validateOpStartWorkflowRunInput(v *StartWorkflowRunInput) error {
6164	if v == nil {
6165		return nil
6166	}
6167	invalidParams := smithy.InvalidParamsError{Context: "StartWorkflowRunInput"}
6168	if v.Name == nil {
6169		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6170	}
6171	if invalidParams.Len() > 0 {
6172		return invalidParams
6173	} else {
6174		return nil
6175	}
6176}
6177
6178func validateOpStopCrawlerInput(v *StopCrawlerInput) error {
6179	if v == nil {
6180		return nil
6181	}
6182	invalidParams := smithy.InvalidParamsError{Context: "StopCrawlerInput"}
6183	if v.Name == nil {
6184		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6185	}
6186	if invalidParams.Len() > 0 {
6187		return invalidParams
6188	} else {
6189		return nil
6190	}
6191}
6192
6193func validateOpStopCrawlerScheduleInput(v *StopCrawlerScheduleInput) error {
6194	if v == nil {
6195		return nil
6196	}
6197	invalidParams := smithy.InvalidParamsError{Context: "StopCrawlerScheduleInput"}
6198	if v.CrawlerName == nil {
6199		invalidParams.Add(smithy.NewErrParamRequired("CrawlerName"))
6200	}
6201	if invalidParams.Len() > 0 {
6202		return invalidParams
6203	} else {
6204		return nil
6205	}
6206}
6207
6208func validateOpStopTriggerInput(v *StopTriggerInput) error {
6209	if v == nil {
6210		return nil
6211	}
6212	invalidParams := smithy.InvalidParamsError{Context: "StopTriggerInput"}
6213	if v.Name == nil {
6214		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6215	}
6216	if invalidParams.Len() > 0 {
6217		return invalidParams
6218	} else {
6219		return nil
6220	}
6221}
6222
6223func validateOpStopWorkflowRunInput(v *StopWorkflowRunInput) error {
6224	if v == nil {
6225		return nil
6226	}
6227	invalidParams := smithy.InvalidParamsError{Context: "StopWorkflowRunInput"}
6228	if v.Name == nil {
6229		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6230	}
6231	if v.RunId == nil {
6232		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
6233	}
6234	if invalidParams.Len() > 0 {
6235		return invalidParams
6236	} else {
6237		return nil
6238	}
6239}
6240
6241func validateOpTagResourceInput(v *TagResourceInput) error {
6242	if v == nil {
6243		return nil
6244	}
6245	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
6246	if v.ResourceArn == nil {
6247		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
6248	}
6249	if v.TagsToAdd == nil {
6250		invalidParams.Add(smithy.NewErrParamRequired("TagsToAdd"))
6251	}
6252	if invalidParams.Len() > 0 {
6253		return invalidParams
6254	} else {
6255		return nil
6256	}
6257}
6258
6259func validateOpUntagResourceInput(v *UntagResourceInput) error {
6260	if v == nil {
6261		return nil
6262	}
6263	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
6264	if v.ResourceArn == nil {
6265		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
6266	}
6267	if v.TagsToRemove == nil {
6268		invalidParams.Add(smithy.NewErrParamRequired("TagsToRemove"))
6269	}
6270	if invalidParams.Len() > 0 {
6271		return invalidParams
6272	} else {
6273		return nil
6274	}
6275}
6276
6277func validateOpUpdateClassifierInput(v *UpdateClassifierInput) error {
6278	if v == nil {
6279		return nil
6280	}
6281	invalidParams := smithy.InvalidParamsError{Context: "UpdateClassifierInput"}
6282	if v.GrokClassifier != nil {
6283		if err := validateUpdateGrokClassifierRequest(v.GrokClassifier); err != nil {
6284			invalidParams.AddNested("GrokClassifier", err.(smithy.InvalidParamsError))
6285		}
6286	}
6287	if v.XMLClassifier != nil {
6288		if err := validateUpdateXMLClassifierRequest(v.XMLClassifier); err != nil {
6289			invalidParams.AddNested("XMLClassifier", err.(smithy.InvalidParamsError))
6290		}
6291	}
6292	if v.JsonClassifier != nil {
6293		if err := validateUpdateJsonClassifierRequest(v.JsonClassifier); err != nil {
6294			invalidParams.AddNested("JsonClassifier", err.(smithy.InvalidParamsError))
6295		}
6296	}
6297	if v.CsvClassifier != nil {
6298		if err := validateUpdateCsvClassifierRequest(v.CsvClassifier); err != nil {
6299			invalidParams.AddNested("CsvClassifier", err.(smithy.InvalidParamsError))
6300		}
6301	}
6302	if invalidParams.Len() > 0 {
6303		return invalidParams
6304	} else {
6305		return nil
6306	}
6307}
6308
6309func validateOpUpdateColumnStatisticsForPartitionInput(v *UpdateColumnStatisticsForPartitionInput) error {
6310	if v == nil {
6311		return nil
6312	}
6313	invalidParams := smithy.InvalidParamsError{Context: "UpdateColumnStatisticsForPartitionInput"}
6314	if v.DatabaseName == nil {
6315		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
6316	}
6317	if v.TableName == nil {
6318		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
6319	}
6320	if v.PartitionValues == nil {
6321		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
6322	}
6323	if v.ColumnStatisticsList == nil {
6324		invalidParams.Add(smithy.NewErrParamRequired("ColumnStatisticsList"))
6325	} else if v.ColumnStatisticsList != nil {
6326		if err := validateUpdateColumnStatisticsList(v.ColumnStatisticsList); err != nil {
6327			invalidParams.AddNested("ColumnStatisticsList", err.(smithy.InvalidParamsError))
6328		}
6329	}
6330	if invalidParams.Len() > 0 {
6331		return invalidParams
6332	} else {
6333		return nil
6334	}
6335}
6336
6337func validateOpUpdateColumnStatisticsForTableInput(v *UpdateColumnStatisticsForTableInput) error {
6338	if v == nil {
6339		return nil
6340	}
6341	invalidParams := smithy.InvalidParamsError{Context: "UpdateColumnStatisticsForTableInput"}
6342	if v.DatabaseName == nil {
6343		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
6344	}
6345	if v.TableName == nil {
6346		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
6347	}
6348	if v.ColumnStatisticsList == nil {
6349		invalidParams.Add(smithy.NewErrParamRequired("ColumnStatisticsList"))
6350	} else if v.ColumnStatisticsList != nil {
6351		if err := validateUpdateColumnStatisticsList(v.ColumnStatisticsList); err != nil {
6352			invalidParams.AddNested("ColumnStatisticsList", err.(smithy.InvalidParamsError))
6353		}
6354	}
6355	if invalidParams.Len() > 0 {
6356		return invalidParams
6357	} else {
6358		return nil
6359	}
6360}
6361
6362func validateOpUpdateConnectionInput(v *UpdateConnectionInput) error {
6363	if v == nil {
6364		return nil
6365	}
6366	invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectionInput"}
6367	if v.Name == nil {
6368		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6369	}
6370	if v.ConnectionInput == nil {
6371		invalidParams.Add(smithy.NewErrParamRequired("ConnectionInput"))
6372	} else if v.ConnectionInput != nil {
6373		if err := validateConnectionInput(v.ConnectionInput); err != nil {
6374			invalidParams.AddNested("ConnectionInput", err.(smithy.InvalidParamsError))
6375		}
6376	}
6377	if invalidParams.Len() > 0 {
6378		return invalidParams
6379	} else {
6380		return nil
6381	}
6382}
6383
6384func validateOpUpdateCrawlerInput(v *UpdateCrawlerInput) error {
6385	if v == nil {
6386		return nil
6387	}
6388	invalidParams := smithy.InvalidParamsError{Context: "UpdateCrawlerInput"}
6389	if v.Name == nil {
6390		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6391	}
6392	if v.Targets != nil {
6393		if err := validateCrawlerTargets(v.Targets); err != nil {
6394			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
6395		}
6396	}
6397	if invalidParams.Len() > 0 {
6398		return invalidParams
6399	} else {
6400		return nil
6401	}
6402}
6403
6404func validateOpUpdateCrawlerScheduleInput(v *UpdateCrawlerScheduleInput) error {
6405	if v == nil {
6406		return nil
6407	}
6408	invalidParams := smithy.InvalidParamsError{Context: "UpdateCrawlerScheduleInput"}
6409	if v.CrawlerName == nil {
6410		invalidParams.Add(smithy.NewErrParamRequired("CrawlerName"))
6411	}
6412	if invalidParams.Len() > 0 {
6413		return invalidParams
6414	} else {
6415		return nil
6416	}
6417}
6418
6419func validateOpUpdateDatabaseInput(v *UpdateDatabaseInput) error {
6420	if v == nil {
6421		return nil
6422	}
6423	invalidParams := smithy.InvalidParamsError{Context: "UpdateDatabaseInput"}
6424	if v.Name == nil {
6425		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6426	}
6427	if v.DatabaseInput == nil {
6428		invalidParams.Add(smithy.NewErrParamRequired("DatabaseInput"))
6429	} else if v.DatabaseInput != nil {
6430		if err := validateDatabaseInput(v.DatabaseInput); err != nil {
6431			invalidParams.AddNested("DatabaseInput", err.(smithy.InvalidParamsError))
6432		}
6433	}
6434	if invalidParams.Len() > 0 {
6435		return invalidParams
6436	} else {
6437		return nil
6438	}
6439}
6440
6441func validateOpUpdateDevEndpointInput(v *UpdateDevEndpointInput) error {
6442	if v == nil {
6443		return nil
6444	}
6445	invalidParams := smithy.InvalidParamsError{Context: "UpdateDevEndpointInput"}
6446	if v.EndpointName == nil {
6447		invalidParams.Add(smithy.NewErrParamRequired("EndpointName"))
6448	}
6449	if invalidParams.Len() > 0 {
6450		return invalidParams
6451	} else {
6452		return nil
6453	}
6454}
6455
6456func validateOpUpdateJobInput(v *UpdateJobInput) error {
6457	if v == nil {
6458		return nil
6459	}
6460	invalidParams := smithy.InvalidParamsError{Context: "UpdateJobInput"}
6461	if v.JobName == nil {
6462		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
6463	}
6464	if v.JobUpdate == nil {
6465		invalidParams.Add(smithy.NewErrParamRequired("JobUpdate"))
6466	}
6467	if invalidParams.Len() > 0 {
6468		return invalidParams
6469	} else {
6470		return nil
6471	}
6472}
6473
6474func validateOpUpdateMLTransformInput(v *UpdateMLTransformInput) error {
6475	if v == nil {
6476		return nil
6477	}
6478	invalidParams := smithy.InvalidParamsError{Context: "UpdateMLTransformInput"}
6479	if v.TransformId == nil {
6480		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
6481	}
6482	if v.Parameters != nil {
6483		if err := validateTransformParameters(v.Parameters); err != nil {
6484			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
6485		}
6486	}
6487	if invalidParams.Len() > 0 {
6488		return invalidParams
6489	} else {
6490		return nil
6491	}
6492}
6493
6494func validateOpUpdatePartitionInput(v *UpdatePartitionInput) error {
6495	if v == nil {
6496		return nil
6497	}
6498	invalidParams := smithy.InvalidParamsError{Context: "UpdatePartitionInput"}
6499	if v.DatabaseName == nil {
6500		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
6501	}
6502	if v.TableName == nil {
6503		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
6504	}
6505	if v.PartitionValueList == nil {
6506		invalidParams.Add(smithy.NewErrParamRequired("PartitionValueList"))
6507	}
6508	if v.PartitionInput == nil {
6509		invalidParams.Add(smithy.NewErrParamRequired("PartitionInput"))
6510	} else if v.PartitionInput != nil {
6511		if err := validatePartitionInput(v.PartitionInput); err != nil {
6512			invalidParams.AddNested("PartitionInput", err.(smithy.InvalidParamsError))
6513		}
6514	}
6515	if invalidParams.Len() > 0 {
6516		return invalidParams
6517	} else {
6518		return nil
6519	}
6520}
6521
6522func validateOpUpdateRegistryInput(v *UpdateRegistryInput) error {
6523	if v == nil {
6524		return nil
6525	}
6526	invalidParams := smithy.InvalidParamsError{Context: "UpdateRegistryInput"}
6527	if v.RegistryId == nil {
6528		invalidParams.Add(smithy.NewErrParamRequired("RegistryId"))
6529	}
6530	if v.Description == nil {
6531		invalidParams.Add(smithy.NewErrParamRequired("Description"))
6532	}
6533	if invalidParams.Len() > 0 {
6534		return invalidParams
6535	} else {
6536		return nil
6537	}
6538}
6539
6540func validateOpUpdateSchemaInput(v *UpdateSchemaInput) error {
6541	if v == nil {
6542		return nil
6543	}
6544	invalidParams := smithy.InvalidParamsError{Context: "UpdateSchemaInput"}
6545	if v.SchemaId == nil {
6546		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
6547	}
6548	if invalidParams.Len() > 0 {
6549		return invalidParams
6550	} else {
6551		return nil
6552	}
6553}
6554
6555func validateOpUpdateTableInput(v *UpdateTableInput) error {
6556	if v == nil {
6557		return nil
6558	}
6559	invalidParams := smithy.InvalidParamsError{Context: "UpdateTableInput"}
6560	if v.DatabaseName == nil {
6561		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
6562	}
6563	if v.TableInput == nil {
6564		invalidParams.Add(smithy.NewErrParamRequired("TableInput"))
6565	} else if v.TableInput != nil {
6566		if err := validateTableInput(v.TableInput); err != nil {
6567			invalidParams.AddNested("TableInput", err.(smithy.InvalidParamsError))
6568		}
6569	}
6570	if invalidParams.Len() > 0 {
6571		return invalidParams
6572	} else {
6573		return nil
6574	}
6575}
6576
6577func validateOpUpdateTriggerInput(v *UpdateTriggerInput) error {
6578	if v == nil {
6579		return nil
6580	}
6581	invalidParams := smithy.InvalidParamsError{Context: "UpdateTriggerInput"}
6582	if v.Name == nil {
6583		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6584	}
6585	if v.TriggerUpdate == nil {
6586		invalidParams.Add(smithy.NewErrParamRequired("TriggerUpdate"))
6587	}
6588	if invalidParams.Len() > 0 {
6589		return invalidParams
6590	} else {
6591		return nil
6592	}
6593}
6594
6595func validateOpUpdateUserDefinedFunctionInput(v *UpdateUserDefinedFunctionInput) error {
6596	if v == nil {
6597		return nil
6598	}
6599	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserDefinedFunctionInput"}
6600	if v.DatabaseName == nil {
6601		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
6602	}
6603	if v.FunctionName == nil {
6604		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
6605	}
6606	if v.FunctionInput == nil {
6607		invalidParams.Add(smithy.NewErrParamRequired("FunctionInput"))
6608	}
6609	if invalidParams.Len() > 0 {
6610		return invalidParams
6611	} else {
6612		return nil
6613	}
6614}
6615
6616func validateOpUpdateWorkflowInput(v *UpdateWorkflowInput) error {
6617	if v == nil {
6618		return nil
6619	}
6620	invalidParams := smithy.InvalidParamsError{Context: "UpdateWorkflowInput"}
6621	if v.Name == nil {
6622		invalidParams.Add(smithy.NewErrParamRequired("Name"))
6623	}
6624	if invalidParams.Len() > 0 {
6625		return invalidParams
6626	} else {
6627		return nil
6628	}
6629}
6630