1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package quicksight
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCancelIngestion struct {
14}
15
16func (*validateOpCancelIngestion) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCancelIngestion) 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.(*CancelIngestionInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCancelIngestionInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateAccountCustomization struct {
34}
35
36func (*validateOpCreateAccountCustomization) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateAccountCustomization) 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.(*CreateAccountCustomizationInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateAccountCustomizationInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateAnalysis struct {
54}
55
56func (*validateOpCreateAnalysis) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateAnalysis) 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.(*CreateAnalysisInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateAnalysisInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateDashboard struct {
74}
75
76func (*validateOpCreateDashboard) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateDashboard) 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.(*CreateDashboardInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateDashboardInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateDataSet struct {
94}
95
96func (*validateOpCreateDataSet) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateDataSet) 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.(*CreateDataSetInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateDataSetInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateDataSource struct {
114}
115
116func (*validateOpCreateDataSource) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateDataSource) 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.(*CreateDataSourceInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateDataSourceInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateGroup struct {
134}
135
136func (*validateOpCreateGroup) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateGroup) 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.(*CreateGroupInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateGroupInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateGroupMembership struct {
154}
155
156func (*validateOpCreateGroupMembership) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateGroupMembership) 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.(*CreateGroupMembershipInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateGroupMembershipInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateIAMPolicyAssignment struct {
174}
175
176func (*validateOpCreateIAMPolicyAssignment) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateIAMPolicyAssignment) 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.(*CreateIAMPolicyAssignmentInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateIAMPolicyAssignmentInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreateIngestion struct {
194}
195
196func (*validateOpCreateIngestion) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreateIngestion) 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.(*CreateIngestionInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreateIngestionInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateNamespace struct {
214}
215
216func (*validateOpCreateNamespace) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateNamespace) 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.(*CreateNamespaceInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateNamespaceInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpCreateTemplateAlias struct {
234}
235
236func (*validateOpCreateTemplateAlias) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpCreateTemplateAlias) 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.(*CreateTemplateAliasInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpCreateTemplateAliasInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpCreateTemplate struct {
254}
255
256func (*validateOpCreateTemplate) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpCreateTemplate) 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.(*CreateTemplateInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpCreateTemplateInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpCreateThemeAlias struct {
274}
275
276func (*validateOpCreateThemeAlias) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpCreateThemeAlias) 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.(*CreateThemeAliasInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpCreateThemeAliasInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpCreateTheme struct {
294}
295
296func (*validateOpCreateTheme) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpCreateTheme) 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.(*CreateThemeInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpCreateThemeInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDeleteAccountCustomization struct {
314}
315
316func (*validateOpDeleteAccountCustomization) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDeleteAccountCustomization) 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.(*DeleteAccountCustomizationInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDeleteAccountCustomizationInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDeleteAnalysis struct {
334}
335
336func (*validateOpDeleteAnalysis) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDeleteAnalysis) 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.(*DeleteAnalysisInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDeleteAnalysisInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDeleteDashboard struct {
354}
355
356func (*validateOpDeleteDashboard) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDeleteDashboard) 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.(*DeleteDashboardInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDeleteDashboardInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDeleteDataSet struct {
374}
375
376func (*validateOpDeleteDataSet) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDeleteDataSet) 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.(*DeleteDataSetInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDeleteDataSetInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDeleteDataSource struct {
394}
395
396func (*validateOpDeleteDataSource) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDeleteDataSource) 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.(*DeleteDataSourceInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDeleteDataSourceInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDeleteGroup struct {
414}
415
416func (*validateOpDeleteGroup) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDeleteGroup) 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.(*DeleteGroupInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDeleteGroupInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDeleteGroupMembership struct {
434}
435
436func (*validateOpDeleteGroupMembership) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDeleteGroupMembership) 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.(*DeleteGroupMembershipInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDeleteGroupMembershipInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDeleteIAMPolicyAssignment struct {
454}
455
456func (*validateOpDeleteIAMPolicyAssignment) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDeleteIAMPolicyAssignment) 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.(*DeleteIAMPolicyAssignmentInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDeleteIAMPolicyAssignmentInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDeleteNamespace struct {
474}
475
476func (*validateOpDeleteNamespace) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDeleteNamespace) 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.(*DeleteNamespaceInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDeleteNamespaceInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDeleteTemplateAlias struct {
494}
495
496func (*validateOpDeleteTemplateAlias) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDeleteTemplateAlias) 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.(*DeleteTemplateAliasInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDeleteTemplateAliasInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDeleteTemplate struct {
514}
515
516func (*validateOpDeleteTemplate) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDeleteTemplate) 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.(*DeleteTemplateInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDeleteTemplateInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDeleteThemeAlias struct {
534}
535
536func (*validateOpDeleteThemeAlias) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDeleteThemeAlias) 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.(*DeleteThemeAliasInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDeleteThemeAliasInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDeleteTheme struct {
554}
555
556func (*validateOpDeleteTheme) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDeleteTheme) 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.(*DeleteThemeInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDeleteThemeInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpDeleteUserByPrincipalId struct {
574}
575
576func (*validateOpDeleteUserByPrincipalId) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpDeleteUserByPrincipalId) 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.(*DeleteUserByPrincipalIdInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpDeleteUserByPrincipalIdInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpDeleteUser struct {
594}
595
596func (*validateOpDeleteUser) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpDeleteUser) 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.(*DeleteUserInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpDeleteUserInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpDescribeAccountCustomization struct {
614}
615
616func (*validateOpDescribeAccountCustomization) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpDescribeAccountCustomization) 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.(*DescribeAccountCustomizationInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpDescribeAccountCustomizationInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpDescribeAccountSettings struct {
634}
635
636func (*validateOpDescribeAccountSettings) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpDescribeAccountSettings) 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.(*DescribeAccountSettingsInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpDescribeAccountSettingsInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpDescribeAnalysis struct {
654}
655
656func (*validateOpDescribeAnalysis) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpDescribeAnalysis) 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.(*DescribeAnalysisInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpDescribeAnalysisInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpDescribeAnalysisPermissions struct {
674}
675
676func (*validateOpDescribeAnalysisPermissions) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpDescribeAnalysisPermissions) 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.(*DescribeAnalysisPermissionsInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpDescribeAnalysisPermissionsInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpDescribeDashboard struct {
694}
695
696func (*validateOpDescribeDashboard) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpDescribeDashboard) 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.(*DescribeDashboardInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpDescribeDashboardInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpDescribeDashboardPermissions struct {
714}
715
716func (*validateOpDescribeDashboardPermissions) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpDescribeDashboardPermissions) 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.(*DescribeDashboardPermissionsInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpDescribeDashboardPermissionsInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpDescribeDataSet struct {
734}
735
736func (*validateOpDescribeDataSet) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpDescribeDataSet) 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.(*DescribeDataSetInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpDescribeDataSetInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpDescribeDataSetPermissions struct {
754}
755
756func (*validateOpDescribeDataSetPermissions) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpDescribeDataSetPermissions) 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.(*DescribeDataSetPermissionsInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpDescribeDataSetPermissionsInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpDescribeDataSource struct {
774}
775
776func (*validateOpDescribeDataSource) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpDescribeDataSource) 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.(*DescribeDataSourceInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpDescribeDataSourceInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpDescribeDataSourcePermissions struct {
794}
795
796func (*validateOpDescribeDataSourcePermissions) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpDescribeDataSourcePermissions) 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.(*DescribeDataSourcePermissionsInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpDescribeDataSourcePermissionsInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpDescribeGroup struct {
814}
815
816func (*validateOpDescribeGroup) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpDescribeGroup) 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.(*DescribeGroupInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpDescribeGroupInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpDescribeIAMPolicyAssignment struct {
834}
835
836func (*validateOpDescribeIAMPolicyAssignment) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpDescribeIAMPolicyAssignment) 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.(*DescribeIAMPolicyAssignmentInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpDescribeIAMPolicyAssignmentInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpDescribeIngestion struct {
854}
855
856func (*validateOpDescribeIngestion) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpDescribeIngestion) 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.(*DescribeIngestionInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpDescribeIngestionInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpDescribeNamespace struct {
874}
875
876func (*validateOpDescribeNamespace) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpDescribeNamespace) 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.(*DescribeNamespaceInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpDescribeNamespaceInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpDescribeTemplateAlias struct {
894}
895
896func (*validateOpDescribeTemplateAlias) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpDescribeTemplateAlias) 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.(*DescribeTemplateAliasInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpDescribeTemplateAliasInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpDescribeTemplate struct {
914}
915
916func (*validateOpDescribeTemplate) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpDescribeTemplate) 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.(*DescribeTemplateInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpDescribeTemplateInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpDescribeTemplatePermissions struct {
934}
935
936func (*validateOpDescribeTemplatePermissions) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpDescribeTemplatePermissions) 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.(*DescribeTemplatePermissionsInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpDescribeTemplatePermissionsInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpDescribeThemeAlias struct {
954}
955
956func (*validateOpDescribeThemeAlias) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpDescribeThemeAlias) 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.(*DescribeThemeAliasInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpDescribeThemeAliasInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpDescribeTheme struct {
974}
975
976func (*validateOpDescribeTheme) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpDescribeTheme) 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.(*DescribeThemeInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpDescribeThemeInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpDescribeThemePermissions struct {
994}
995
996func (*validateOpDescribeThemePermissions) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpDescribeThemePermissions) 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.(*DescribeThemePermissionsInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpDescribeThemePermissionsInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpDescribeUser struct {
1014}
1015
1016func (*validateOpDescribeUser) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpDescribeUser) 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.(*DescribeUserInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpDescribeUserInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpGetDashboardEmbedUrl struct {
1034}
1035
1036func (*validateOpGetDashboardEmbedUrl) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpGetDashboardEmbedUrl) 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.(*GetDashboardEmbedUrlInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpGetDashboardEmbedUrlInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpGetSessionEmbedUrl struct {
1054}
1055
1056func (*validateOpGetSessionEmbedUrl) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpGetSessionEmbedUrl) 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.(*GetSessionEmbedUrlInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpGetSessionEmbedUrlInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpListAnalyses struct {
1074}
1075
1076func (*validateOpListAnalyses) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpListAnalyses) 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.(*ListAnalysesInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpListAnalysesInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpListDashboards struct {
1094}
1095
1096func (*validateOpListDashboards) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpListDashboards) 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.(*ListDashboardsInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpListDashboardsInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpListDashboardVersions struct {
1114}
1115
1116func (*validateOpListDashboardVersions) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpListDashboardVersions) 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.(*ListDashboardVersionsInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpListDashboardVersionsInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133type validateOpListDataSets struct {
1134}
1135
1136func (*validateOpListDataSets) ID() string {
1137	return "OperationInputValidation"
1138}
1139
1140func (m *validateOpListDataSets) 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.(*ListDataSetsInput)
1144	if !ok {
1145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146	}
1147	if err := validateOpListDataSetsInput(input); err != nil {
1148		return out, metadata, err
1149	}
1150	return next.HandleInitialize(ctx, in)
1151}
1152
1153type validateOpListDataSources struct {
1154}
1155
1156func (*validateOpListDataSources) ID() string {
1157	return "OperationInputValidation"
1158}
1159
1160func (m *validateOpListDataSources) 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.(*ListDataSourcesInput)
1164	if !ok {
1165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1166	}
1167	if err := validateOpListDataSourcesInput(input); err != nil {
1168		return out, metadata, err
1169	}
1170	return next.HandleInitialize(ctx, in)
1171}
1172
1173type validateOpListGroupMemberships struct {
1174}
1175
1176func (*validateOpListGroupMemberships) ID() string {
1177	return "OperationInputValidation"
1178}
1179
1180func (m *validateOpListGroupMemberships) 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.(*ListGroupMembershipsInput)
1184	if !ok {
1185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1186	}
1187	if err := validateOpListGroupMembershipsInput(input); err != nil {
1188		return out, metadata, err
1189	}
1190	return next.HandleInitialize(ctx, in)
1191}
1192
1193type validateOpListGroups struct {
1194}
1195
1196func (*validateOpListGroups) ID() string {
1197	return "OperationInputValidation"
1198}
1199
1200func (m *validateOpListGroups) 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.(*ListGroupsInput)
1204	if !ok {
1205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1206	}
1207	if err := validateOpListGroupsInput(input); err != nil {
1208		return out, metadata, err
1209	}
1210	return next.HandleInitialize(ctx, in)
1211}
1212
1213type validateOpListIAMPolicyAssignmentsForUser struct {
1214}
1215
1216func (*validateOpListIAMPolicyAssignmentsForUser) ID() string {
1217	return "OperationInputValidation"
1218}
1219
1220func (m *validateOpListIAMPolicyAssignmentsForUser) 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.(*ListIAMPolicyAssignmentsForUserInput)
1224	if !ok {
1225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1226	}
1227	if err := validateOpListIAMPolicyAssignmentsForUserInput(input); err != nil {
1228		return out, metadata, err
1229	}
1230	return next.HandleInitialize(ctx, in)
1231}
1232
1233type validateOpListIAMPolicyAssignments struct {
1234}
1235
1236func (*validateOpListIAMPolicyAssignments) ID() string {
1237	return "OperationInputValidation"
1238}
1239
1240func (m *validateOpListIAMPolicyAssignments) 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.(*ListIAMPolicyAssignmentsInput)
1244	if !ok {
1245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1246	}
1247	if err := validateOpListIAMPolicyAssignmentsInput(input); err != nil {
1248		return out, metadata, err
1249	}
1250	return next.HandleInitialize(ctx, in)
1251}
1252
1253type validateOpListIngestions struct {
1254}
1255
1256func (*validateOpListIngestions) ID() string {
1257	return "OperationInputValidation"
1258}
1259
1260func (m *validateOpListIngestions) 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.(*ListIngestionsInput)
1264	if !ok {
1265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1266	}
1267	if err := validateOpListIngestionsInput(input); err != nil {
1268		return out, metadata, err
1269	}
1270	return next.HandleInitialize(ctx, in)
1271}
1272
1273type validateOpListNamespaces struct {
1274}
1275
1276func (*validateOpListNamespaces) ID() string {
1277	return "OperationInputValidation"
1278}
1279
1280func (m *validateOpListNamespaces) 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.(*ListNamespacesInput)
1284	if !ok {
1285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1286	}
1287	if err := validateOpListNamespacesInput(input); err != nil {
1288		return out, metadata, err
1289	}
1290	return next.HandleInitialize(ctx, in)
1291}
1292
1293type validateOpListTagsForResource struct {
1294}
1295
1296func (*validateOpListTagsForResource) ID() string {
1297	return "OperationInputValidation"
1298}
1299
1300func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
1304	if !ok {
1305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1306	}
1307	if err := validateOpListTagsForResourceInput(input); err != nil {
1308		return out, metadata, err
1309	}
1310	return next.HandleInitialize(ctx, in)
1311}
1312
1313type validateOpListTemplateAliases struct {
1314}
1315
1316func (*validateOpListTemplateAliases) ID() string {
1317	return "OperationInputValidation"
1318}
1319
1320func (m *validateOpListTemplateAliases) 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.(*ListTemplateAliasesInput)
1324	if !ok {
1325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1326	}
1327	if err := validateOpListTemplateAliasesInput(input); err != nil {
1328		return out, metadata, err
1329	}
1330	return next.HandleInitialize(ctx, in)
1331}
1332
1333type validateOpListTemplates struct {
1334}
1335
1336func (*validateOpListTemplates) ID() string {
1337	return "OperationInputValidation"
1338}
1339
1340func (m *validateOpListTemplates) 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.(*ListTemplatesInput)
1344	if !ok {
1345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1346	}
1347	if err := validateOpListTemplatesInput(input); err != nil {
1348		return out, metadata, err
1349	}
1350	return next.HandleInitialize(ctx, in)
1351}
1352
1353type validateOpListTemplateVersions struct {
1354}
1355
1356func (*validateOpListTemplateVersions) ID() string {
1357	return "OperationInputValidation"
1358}
1359
1360func (m *validateOpListTemplateVersions) 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.(*ListTemplateVersionsInput)
1364	if !ok {
1365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1366	}
1367	if err := validateOpListTemplateVersionsInput(input); err != nil {
1368		return out, metadata, err
1369	}
1370	return next.HandleInitialize(ctx, in)
1371}
1372
1373type validateOpListThemeAliases struct {
1374}
1375
1376func (*validateOpListThemeAliases) ID() string {
1377	return "OperationInputValidation"
1378}
1379
1380func (m *validateOpListThemeAliases) 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.(*ListThemeAliasesInput)
1384	if !ok {
1385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1386	}
1387	if err := validateOpListThemeAliasesInput(input); err != nil {
1388		return out, metadata, err
1389	}
1390	return next.HandleInitialize(ctx, in)
1391}
1392
1393type validateOpListThemes struct {
1394}
1395
1396func (*validateOpListThemes) ID() string {
1397	return "OperationInputValidation"
1398}
1399
1400func (m *validateOpListThemes) 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.(*ListThemesInput)
1404	if !ok {
1405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1406	}
1407	if err := validateOpListThemesInput(input); err != nil {
1408		return out, metadata, err
1409	}
1410	return next.HandleInitialize(ctx, in)
1411}
1412
1413type validateOpListThemeVersions struct {
1414}
1415
1416func (*validateOpListThemeVersions) ID() string {
1417	return "OperationInputValidation"
1418}
1419
1420func (m *validateOpListThemeVersions) 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.(*ListThemeVersionsInput)
1424	if !ok {
1425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1426	}
1427	if err := validateOpListThemeVersionsInput(input); err != nil {
1428		return out, metadata, err
1429	}
1430	return next.HandleInitialize(ctx, in)
1431}
1432
1433type validateOpListUserGroups struct {
1434}
1435
1436func (*validateOpListUserGroups) ID() string {
1437	return "OperationInputValidation"
1438}
1439
1440func (m *validateOpListUserGroups) 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.(*ListUserGroupsInput)
1444	if !ok {
1445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1446	}
1447	if err := validateOpListUserGroupsInput(input); err != nil {
1448		return out, metadata, err
1449	}
1450	return next.HandleInitialize(ctx, in)
1451}
1452
1453type validateOpListUsers struct {
1454}
1455
1456func (*validateOpListUsers) ID() string {
1457	return "OperationInputValidation"
1458}
1459
1460func (m *validateOpListUsers) 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.(*ListUsersInput)
1464	if !ok {
1465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1466	}
1467	if err := validateOpListUsersInput(input); err != nil {
1468		return out, metadata, err
1469	}
1470	return next.HandleInitialize(ctx, in)
1471}
1472
1473type validateOpRegisterUser struct {
1474}
1475
1476func (*validateOpRegisterUser) ID() string {
1477	return "OperationInputValidation"
1478}
1479
1480func (m *validateOpRegisterUser) 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.(*RegisterUserInput)
1484	if !ok {
1485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1486	}
1487	if err := validateOpRegisterUserInput(input); err != nil {
1488		return out, metadata, err
1489	}
1490	return next.HandleInitialize(ctx, in)
1491}
1492
1493type validateOpRestoreAnalysis struct {
1494}
1495
1496func (*validateOpRestoreAnalysis) ID() string {
1497	return "OperationInputValidation"
1498}
1499
1500func (m *validateOpRestoreAnalysis) 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.(*RestoreAnalysisInput)
1504	if !ok {
1505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1506	}
1507	if err := validateOpRestoreAnalysisInput(input); err != nil {
1508		return out, metadata, err
1509	}
1510	return next.HandleInitialize(ctx, in)
1511}
1512
1513type validateOpSearchAnalyses struct {
1514}
1515
1516func (*validateOpSearchAnalyses) ID() string {
1517	return "OperationInputValidation"
1518}
1519
1520func (m *validateOpSearchAnalyses) 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.(*SearchAnalysesInput)
1524	if !ok {
1525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1526	}
1527	if err := validateOpSearchAnalysesInput(input); err != nil {
1528		return out, metadata, err
1529	}
1530	return next.HandleInitialize(ctx, in)
1531}
1532
1533type validateOpSearchDashboards struct {
1534}
1535
1536func (*validateOpSearchDashboards) ID() string {
1537	return "OperationInputValidation"
1538}
1539
1540func (m *validateOpSearchDashboards) 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.(*SearchDashboardsInput)
1544	if !ok {
1545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1546	}
1547	if err := validateOpSearchDashboardsInput(input); err != nil {
1548		return out, metadata, err
1549	}
1550	return next.HandleInitialize(ctx, in)
1551}
1552
1553type validateOpTagResource struct {
1554}
1555
1556func (*validateOpTagResource) ID() string {
1557	return "OperationInputValidation"
1558}
1559
1560func (m *validateOpTagResource) 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.(*TagResourceInput)
1564	if !ok {
1565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1566	}
1567	if err := validateOpTagResourceInput(input); err != nil {
1568		return out, metadata, err
1569	}
1570	return next.HandleInitialize(ctx, in)
1571}
1572
1573type validateOpUntagResource struct {
1574}
1575
1576func (*validateOpUntagResource) ID() string {
1577	return "OperationInputValidation"
1578}
1579
1580func (m *validateOpUntagResource) 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.(*UntagResourceInput)
1584	if !ok {
1585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1586	}
1587	if err := validateOpUntagResourceInput(input); err != nil {
1588		return out, metadata, err
1589	}
1590	return next.HandleInitialize(ctx, in)
1591}
1592
1593type validateOpUpdateAccountCustomization struct {
1594}
1595
1596func (*validateOpUpdateAccountCustomization) ID() string {
1597	return "OperationInputValidation"
1598}
1599
1600func (m *validateOpUpdateAccountCustomization) 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.(*UpdateAccountCustomizationInput)
1604	if !ok {
1605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1606	}
1607	if err := validateOpUpdateAccountCustomizationInput(input); err != nil {
1608		return out, metadata, err
1609	}
1610	return next.HandleInitialize(ctx, in)
1611}
1612
1613type validateOpUpdateAccountSettings struct {
1614}
1615
1616func (*validateOpUpdateAccountSettings) ID() string {
1617	return "OperationInputValidation"
1618}
1619
1620func (m *validateOpUpdateAccountSettings) 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.(*UpdateAccountSettingsInput)
1624	if !ok {
1625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1626	}
1627	if err := validateOpUpdateAccountSettingsInput(input); err != nil {
1628		return out, metadata, err
1629	}
1630	return next.HandleInitialize(ctx, in)
1631}
1632
1633type validateOpUpdateAnalysis struct {
1634}
1635
1636func (*validateOpUpdateAnalysis) ID() string {
1637	return "OperationInputValidation"
1638}
1639
1640func (m *validateOpUpdateAnalysis) 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.(*UpdateAnalysisInput)
1644	if !ok {
1645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1646	}
1647	if err := validateOpUpdateAnalysisInput(input); err != nil {
1648		return out, metadata, err
1649	}
1650	return next.HandleInitialize(ctx, in)
1651}
1652
1653type validateOpUpdateAnalysisPermissions struct {
1654}
1655
1656func (*validateOpUpdateAnalysisPermissions) ID() string {
1657	return "OperationInputValidation"
1658}
1659
1660func (m *validateOpUpdateAnalysisPermissions) 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.(*UpdateAnalysisPermissionsInput)
1664	if !ok {
1665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1666	}
1667	if err := validateOpUpdateAnalysisPermissionsInput(input); err != nil {
1668		return out, metadata, err
1669	}
1670	return next.HandleInitialize(ctx, in)
1671}
1672
1673type validateOpUpdateDashboard struct {
1674}
1675
1676func (*validateOpUpdateDashboard) ID() string {
1677	return "OperationInputValidation"
1678}
1679
1680func (m *validateOpUpdateDashboard) 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.(*UpdateDashboardInput)
1684	if !ok {
1685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1686	}
1687	if err := validateOpUpdateDashboardInput(input); err != nil {
1688		return out, metadata, err
1689	}
1690	return next.HandleInitialize(ctx, in)
1691}
1692
1693type validateOpUpdateDashboardPermissions struct {
1694}
1695
1696func (*validateOpUpdateDashboardPermissions) ID() string {
1697	return "OperationInputValidation"
1698}
1699
1700func (m *validateOpUpdateDashboardPermissions) 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.(*UpdateDashboardPermissionsInput)
1704	if !ok {
1705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1706	}
1707	if err := validateOpUpdateDashboardPermissionsInput(input); err != nil {
1708		return out, metadata, err
1709	}
1710	return next.HandleInitialize(ctx, in)
1711}
1712
1713type validateOpUpdateDashboardPublishedVersion struct {
1714}
1715
1716func (*validateOpUpdateDashboardPublishedVersion) ID() string {
1717	return "OperationInputValidation"
1718}
1719
1720func (m *validateOpUpdateDashboardPublishedVersion) 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.(*UpdateDashboardPublishedVersionInput)
1724	if !ok {
1725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1726	}
1727	if err := validateOpUpdateDashboardPublishedVersionInput(input); err != nil {
1728		return out, metadata, err
1729	}
1730	return next.HandleInitialize(ctx, in)
1731}
1732
1733type validateOpUpdateDataSet struct {
1734}
1735
1736func (*validateOpUpdateDataSet) ID() string {
1737	return "OperationInputValidation"
1738}
1739
1740func (m *validateOpUpdateDataSet) 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.(*UpdateDataSetInput)
1744	if !ok {
1745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1746	}
1747	if err := validateOpUpdateDataSetInput(input); err != nil {
1748		return out, metadata, err
1749	}
1750	return next.HandleInitialize(ctx, in)
1751}
1752
1753type validateOpUpdateDataSetPermissions struct {
1754}
1755
1756func (*validateOpUpdateDataSetPermissions) ID() string {
1757	return "OperationInputValidation"
1758}
1759
1760func (m *validateOpUpdateDataSetPermissions) 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.(*UpdateDataSetPermissionsInput)
1764	if !ok {
1765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1766	}
1767	if err := validateOpUpdateDataSetPermissionsInput(input); err != nil {
1768		return out, metadata, err
1769	}
1770	return next.HandleInitialize(ctx, in)
1771}
1772
1773type validateOpUpdateDataSource struct {
1774}
1775
1776func (*validateOpUpdateDataSource) ID() string {
1777	return "OperationInputValidation"
1778}
1779
1780func (m *validateOpUpdateDataSource) 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.(*UpdateDataSourceInput)
1784	if !ok {
1785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1786	}
1787	if err := validateOpUpdateDataSourceInput(input); err != nil {
1788		return out, metadata, err
1789	}
1790	return next.HandleInitialize(ctx, in)
1791}
1792
1793type validateOpUpdateDataSourcePermissions struct {
1794}
1795
1796func (*validateOpUpdateDataSourcePermissions) ID() string {
1797	return "OperationInputValidation"
1798}
1799
1800func (m *validateOpUpdateDataSourcePermissions) 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.(*UpdateDataSourcePermissionsInput)
1804	if !ok {
1805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1806	}
1807	if err := validateOpUpdateDataSourcePermissionsInput(input); err != nil {
1808		return out, metadata, err
1809	}
1810	return next.HandleInitialize(ctx, in)
1811}
1812
1813type validateOpUpdateGroup struct {
1814}
1815
1816func (*validateOpUpdateGroup) ID() string {
1817	return "OperationInputValidation"
1818}
1819
1820func (m *validateOpUpdateGroup) 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.(*UpdateGroupInput)
1824	if !ok {
1825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1826	}
1827	if err := validateOpUpdateGroupInput(input); err != nil {
1828		return out, metadata, err
1829	}
1830	return next.HandleInitialize(ctx, in)
1831}
1832
1833type validateOpUpdateIAMPolicyAssignment struct {
1834}
1835
1836func (*validateOpUpdateIAMPolicyAssignment) ID() string {
1837	return "OperationInputValidation"
1838}
1839
1840func (m *validateOpUpdateIAMPolicyAssignment) 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.(*UpdateIAMPolicyAssignmentInput)
1844	if !ok {
1845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1846	}
1847	if err := validateOpUpdateIAMPolicyAssignmentInput(input); err != nil {
1848		return out, metadata, err
1849	}
1850	return next.HandleInitialize(ctx, in)
1851}
1852
1853type validateOpUpdateTemplateAlias struct {
1854}
1855
1856func (*validateOpUpdateTemplateAlias) ID() string {
1857	return "OperationInputValidation"
1858}
1859
1860func (m *validateOpUpdateTemplateAlias) 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.(*UpdateTemplateAliasInput)
1864	if !ok {
1865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1866	}
1867	if err := validateOpUpdateTemplateAliasInput(input); err != nil {
1868		return out, metadata, err
1869	}
1870	return next.HandleInitialize(ctx, in)
1871}
1872
1873type validateOpUpdateTemplate struct {
1874}
1875
1876func (*validateOpUpdateTemplate) ID() string {
1877	return "OperationInputValidation"
1878}
1879
1880func (m *validateOpUpdateTemplate) 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.(*UpdateTemplateInput)
1884	if !ok {
1885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1886	}
1887	if err := validateOpUpdateTemplateInput(input); err != nil {
1888		return out, metadata, err
1889	}
1890	return next.HandleInitialize(ctx, in)
1891}
1892
1893type validateOpUpdateTemplatePermissions struct {
1894}
1895
1896func (*validateOpUpdateTemplatePermissions) ID() string {
1897	return "OperationInputValidation"
1898}
1899
1900func (m *validateOpUpdateTemplatePermissions) 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.(*UpdateTemplatePermissionsInput)
1904	if !ok {
1905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1906	}
1907	if err := validateOpUpdateTemplatePermissionsInput(input); err != nil {
1908		return out, metadata, err
1909	}
1910	return next.HandleInitialize(ctx, in)
1911}
1912
1913type validateOpUpdateThemeAlias struct {
1914}
1915
1916func (*validateOpUpdateThemeAlias) ID() string {
1917	return "OperationInputValidation"
1918}
1919
1920func (m *validateOpUpdateThemeAlias) 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.(*UpdateThemeAliasInput)
1924	if !ok {
1925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1926	}
1927	if err := validateOpUpdateThemeAliasInput(input); err != nil {
1928		return out, metadata, err
1929	}
1930	return next.HandleInitialize(ctx, in)
1931}
1932
1933type validateOpUpdateTheme struct {
1934}
1935
1936func (*validateOpUpdateTheme) ID() string {
1937	return "OperationInputValidation"
1938}
1939
1940func (m *validateOpUpdateTheme) 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.(*UpdateThemeInput)
1944	if !ok {
1945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1946	}
1947	if err := validateOpUpdateThemeInput(input); err != nil {
1948		return out, metadata, err
1949	}
1950	return next.HandleInitialize(ctx, in)
1951}
1952
1953type validateOpUpdateThemePermissions struct {
1954}
1955
1956func (*validateOpUpdateThemePermissions) ID() string {
1957	return "OperationInputValidation"
1958}
1959
1960func (m *validateOpUpdateThemePermissions) 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.(*UpdateThemePermissionsInput)
1964	if !ok {
1965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1966	}
1967	if err := validateOpUpdateThemePermissionsInput(input); err != nil {
1968		return out, metadata, err
1969	}
1970	return next.HandleInitialize(ctx, in)
1971}
1972
1973type validateOpUpdateUser struct {
1974}
1975
1976func (*validateOpUpdateUser) ID() string {
1977	return "OperationInputValidation"
1978}
1979
1980func (m *validateOpUpdateUser) 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.(*UpdateUserInput)
1984	if !ok {
1985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1986	}
1987	if err := validateOpUpdateUserInput(input); err != nil {
1988		return out, metadata, err
1989	}
1990	return next.HandleInitialize(ctx, in)
1991}
1992
1993func addOpCancelIngestionValidationMiddleware(stack *middleware.Stack) error {
1994	return stack.Initialize.Add(&validateOpCancelIngestion{}, middleware.After)
1995}
1996
1997func addOpCreateAccountCustomizationValidationMiddleware(stack *middleware.Stack) error {
1998	return stack.Initialize.Add(&validateOpCreateAccountCustomization{}, middleware.After)
1999}
2000
2001func addOpCreateAnalysisValidationMiddleware(stack *middleware.Stack) error {
2002	return stack.Initialize.Add(&validateOpCreateAnalysis{}, middleware.After)
2003}
2004
2005func addOpCreateDashboardValidationMiddleware(stack *middleware.Stack) error {
2006	return stack.Initialize.Add(&validateOpCreateDashboard{}, middleware.After)
2007}
2008
2009func addOpCreateDataSetValidationMiddleware(stack *middleware.Stack) error {
2010	return stack.Initialize.Add(&validateOpCreateDataSet{}, middleware.After)
2011}
2012
2013func addOpCreateDataSourceValidationMiddleware(stack *middleware.Stack) error {
2014	return stack.Initialize.Add(&validateOpCreateDataSource{}, middleware.After)
2015}
2016
2017func addOpCreateGroupValidationMiddleware(stack *middleware.Stack) error {
2018	return stack.Initialize.Add(&validateOpCreateGroup{}, middleware.After)
2019}
2020
2021func addOpCreateGroupMembershipValidationMiddleware(stack *middleware.Stack) error {
2022	return stack.Initialize.Add(&validateOpCreateGroupMembership{}, middleware.After)
2023}
2024
2025func addOpCreateIAMPolicyAssignmentValidationMiddleware(stack *middleware.Stack) error {
2026	return stack.Initialize.Add(&validateOpCreateIAMPolicyAssignment{}, middleware.After)
2027}
2028
2029func addOpCreateIngestionValidationMiddleware(stack *middleware.Stack) error {
2030	return stack.Initialize.Add(&validateOpCreateIngestion{}, middleware.After)
2031}
2032
2033func addOpCreateNamespaceValidationMiddleware(stack *middleware.Stack) error {
2034	return stack.Initialize.Add(&validateOpCreateNamespace{}, middleware.After)
2035}
2036
2037func addOpCreateTemplateAliasValidationMiddleware(stack *middleware.Stack) error {
2038	return stack.Initialize.Add(&validateOpCreateTemplateAlias{}, middleware.After)
2039}
2040
2041func addOpCreateTemplateValidationMiddleware(stack *middleware.Stack) error {
2042	return stack.Initialize.Add(&validateOpCreateTemplate{}, middleware.After)
2043}
2044
2045func addOpCreateThemeAliasValidationMiddleware(stack *middleware.Stack) error {
2046	return stack.Initialize.Add(&validateOpCreateThemeAlias{}, middleware.After)
2047}
2048
2049func addOpCreateThemeValidationMiddleware(stack *middleware.Stack) error {
2050	return stack.Initialize.Add(&validateOpCreateTheme{}, middleware.After)
2051}
2052
2053func addOpDeleteAccountCustomizationValidationMiddleware(stack *middleware.Stack) error {
2054	return stack.Initialize.Add(&validateOpDeleteAccountCustomization{}, middleware.After)
2055}
2056
2057func addOpDeleteAnalysisValidationMiddleware(stack *middleware.Stack) error {
2058	return stack.Initialize.Add(&validateOpDeleteAnalysis{}, middleware.After)
2059}
2060
2061func addOpDeleteDashboardValidationMiddleware(stack *middleware.Stack) error {
2062	return stack.Initialize.Add(&validateOpDeleteDashboard{}, middleware.After)
2063}
2064
2065func addOpDeleteDataSetValidationMiddleware(stack *middleware.Stack) error {
2066	return stack.Initialize.Add(&validateOpDeleteDataSet{}, middleware.After)
2067}
2068
2069func addOpDeleteDataSourceValidationMiddleware(stack *middleware.Stack) error {
2070	return stack.Initialize.Add(&validateOpDeleteDataSource{}, middleware.After)
2071}
2072
2073func addOpDeleteGroupValidationMiddleware(stack *middleware.Stack) error {
2074	return stack.Initialize.Add(&validateOpDeleteGroup{}, middleware.After)
2075}
2076
2077func addOpDeleteGroupMembershipValidationMiddleware(stack *middleware.Stack) error {
2078	return stack.Initialize.Add(&validateOpDeleteGroupMembership{}, middleware.After)
2079}
2080
2081func addOpDeleteIAMPolicyAssignmentValidationMiddleware(stack *middleware.Stack) error {
2082	return stack.Initialize.Add(&validateOpDeleteIAMPolicyAssignment{}, middleware.After)
2083}
2084
2085func addOpDeleteNamespaceValidationMiddleware(stack *middleware.Stack) error {
2086	return stack.Initialize.Add(&validateOpDeleteNamespace{}, middleware.After)
2087}
2088
2089func addOpDeleteTemplateAliasValidationMiddleware(stack *middleware.Stack) error {
2090	return stack.Initialize.Add(&validateOpDeleteTemplateAlias{}, middleware.After)
2091}
2092
2093func addOpDeleteTemplateValidationMiddleware(stack *middleware.Stack) error {
2094	return stack.Initialize.Add(&validateOpDeleteTemplate{}, middleware.After)
2095}
2096
2097func addOpDeleteThemeAliasValidationMiddleware(stack *middleware.Stack) error {
2098	return stack.Initialize.Add(&validateOpDeleteThemeAlias{}, middleware.After)
2099}
2100
2101func addOpDeleteThemeValidationMiddleware(stack *middleware.Stack) error {
2102	return stack.Initialize.Add(&validateOpDeleteTheme{}, middleware.After)
2103}
2104
2105func addOpDeleteUserByPrincipalIdValidationMiddleware(stack *middleware.Stack) error {
2106	return stack.Initialize.Add(&validateOpDeleteUserByPrincipalId{}, middleware.After)
2107}
2108
2109func addOpDeleteUserValidationMiddleware(stack *middleware.Stack) error {
2110	return stack.Initialize.Add(&validateOpDeleteUser{}, middleware.After)
2111}
2112
2113func addOpDescribeAccountCustomizationValidationMiddleware(stack *middleware.Stack) error {
2114	return stack.Initialize.Add(&validateOpDescribeAccountCustomization{}, middleware.After)
2115}
2116
2117func addOpDescribeAccountSettingsValidationMiddleware(stack *middleware.Stack) error {
2118	return stack.Initialize.Add(&validateOpDescribeAccountSettings{}, middleware.After)
2119}
2120
2121func addOpDescribeAnalysisValidationMiddleware(stack *middleware.Stack) error {
2122	return stack.Initialize.Add(&validateOpDescribeAnalysis{}, middleware.After)
2123}
2124
2125func addOpDescribeAnalysisPermissionsValidationMiddleware(stack *middleware.Stack) error {
2126	return stack.Initialize.Add(&validateOpDescribeAnalysisPermissions{}, middleware.After)
2127}
2128
2129func addOpDescribeDashboardValidationMiddleware(stack *middleware.Stack) error {
2130	return stack.Initialize.Add(&validateOpDescribeDashboard{}, middleware.After)
2131}
2132
2133func addOpDescribeDashboardPermissionsValidationMiddleware(stack *middleware.Stack) error {
2134	return stack.Initialize.Add(&validateOpDescribeDashboardPermissions{}, middleware.After)
2135}
2136
2137func addOpDescribeDataSetValidationMiddleware(stack *middleware.Stack) error {
2138	return stack.Initialize.Add(&validateOpDescribeDataSet{}, middleware.After)
2139}
2140
2141func addOpDescribeDataSetPermissionsValidationMiddleware(stack *middleware.Stack) error {
2142	return stack.Initialize.Add(&validateOpDescribeDataSetPermissions{}, middleware.After)
2143}
2144
2145func addOpDescribeDataSourceValidationMiddleware(stack *middleware.Stack) error {
2146	return stack.Initialize.Add(&validateOpDescribeDataSource{}, middleware.After)
2147}
2148
2149func addOpDescribeDataSourcePermissionsValidationMiddleware(stack *middleware.Stack) error {
2150	return stack.Initialize.Add(&validateOpDescribeDataSourcePermissions{}, middleware.After)
2151}
2152
2153func addOpDescribeGroupValidationMiddleware(stack *middleware.Stack) error {
2154	return stack.Initialize.Add(&validateOpDescribeGroup{}, middleware.After)
2155}
2156
2157func addOpDescribeIAMPolicyAssignmentValidationMiddleware(stack *middleware.Stack) error {
2158	return stack.Initialize.Add(&validateOpDescribeIAMPolicyAssignment{}, middleware.After)
2159}
2160
2161func addOpDescribeIngestionValidationMiddleware(stack *middleware.Stack) error {
2162	return stack.Initialize.Add(&validateOpDescribeIngestion{}, middleware.After)
2163}
2164
2165func addOpDescribeNamespaceValidationMiddleware(stack *middleware.Stack) error {
2166	return stack.Initialize.Add(&validateOpDescribeNamespace{}, middleware.After)
2167}
2168
2169func addOpDescribeTemplateAliasValidationMiddleware(stack *middleware.Stack) error {
2170	return stack.Initialize.Add(&validateOpDescribeTemplateAlias{}, middleware.After)
2171}
2172
2173func addOpDescribeTemplateValidationMiddleware(stack *middleware.Stack) error {
2174	return stack.Initialize.Add(&validateOpDescribeTemplate{}, middleware.After)
2175}
2176
2177func addOpDescribeTemplatePermissionsValidationMiddleware(stack *middleware.Stack) error {
2178	return stack.Initialize.Add(&validateOpDescribeTemplatePermissions{}, middleware.After)
2179}
2180
2181func addOpDescribeThemeAliasValidationMiddleware(stack *middleware.Stack) error {
2182	return stack.Initialize.Add(&validateOpDescribeThemeAlias{}, middleware.After)
2183}
2184
2185func addOpDescribeThemeValidationMiddleware(stack *middleware.Stack) error {
2186	return stack.Initialize.Add(&validateOpDescribeTheme{}, middleware.After)
2187}
2188
2189func addOpDescribeThemePermissionsValidationMiddleware(stack *middleware.Stack) error {
2190	return stack.Initialize.Add(&validateOpDescribeThemePermissions{}, middleware.After)
2191}
2192
2193func addOpDescribeUserValidationMiddleware(stack *middleware.Stack) error {
2194	return stack.Initialize.Add(&validateOpDescribeUser{}, middleware.After)
2195}
2196
2197func addOpGetDashboardEmbedUrlValidationMiddleware(stack *middleware.Stack) error {
2198	return stack.Initialize.Add(&validateOpGetDashboardEmbedUrl{}, middleware.After)
2199}
2200
2201func addOpGetSessionEmbedUrlValidationMiddleware(stack *middleware.Stack) error {
2202	return stack.Initialize.Add(&validateOpGetSessionEmbedUrl{}, middleware.After)
2203}
2204
2205func addOpListAnalysesValidationMiddleware(stack *middleware.Stack) error {
2206	return stack.Initialize.Add(&validateOpListAnalyses{}, middleware.After)
2207}
2208
2209func addOpListDashboardsValidationMiddleware(stack *middleware.Stack) error {
2210	return stack.Initialize.Add(&validateOpListDashboards{}, middleware.After)
2211}
2212
2213func addOpListDashboardVersionsValidationMiddleware(stack *middleware.Stack) error {
2214	return stack.Initialize.Add(&validateOpListDashboardVersions{}, middleware.After)
2215}
2216
2217func addOpListDataSetsValidationMiddleware(stack *middleware.Stack) error {
2218	return stack.Initialize.Add(&validateOpListDataSets{}, middleware.After)
2219}
2220
2221func addOpListDataSourcesValidationMiddleware(stack *middleware.Stack) error {
2222	return stack.Initialize.Add(&validateOpListDataSources{}, middleware.After)
2223}
2224
2225func addOpListGroupMembershipsValidationMiddleware(stack *middleware.Stack) error {
2226	return stack.Initialize.Add(&validateOpListGroupMemberships{}, middleware.After)
2227}
2228
2229func addOpListGroupsValidationMiddleware(stack *middleware.Stack) error {
2230	return stack.Initialize.Add(&validateOpListGroups{}, middleware.After)
2231}
2232
2233func addOpListIAMPolicyAssignmentsForUserValidationMiddleware(stack *middleware.Stack) error {
2234	return stack.Initialize.Add(&validateOpListIAMPolicyAssignmentsForUser{}, middleware.After)
2235}
2236
2237func addOpListIAMPolicyAssignmentsValidationMiddleware(stack *middleware.Stack) error {
2238	return stack.Initialize.Add(&validateOpListIAMPolicyAssignments{}, middleware.After)
2239}
2240
2241func addOpListIngestionsValidationMiddleware(stack *middleware.Stack) error {
2242	return stack.Initialize.Add(&validateOpListIngestions{}, middleware.After)
2243}
2244
2245func addOpListNamespacesValidationMiddleware(stack *middleware.Stack) error {
2246	return stack.Initialize.Add(&validateOpListNamespaces{}, middleware.After)
2247}
2248
2249func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
2250	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
2251}
2252
2253func addOpListTemplateAliasesValidationMiddleware(stack *middleware.Stack) error {
2254	return stack.Initialize.Add(&validateOpListTemplateAliases{}, middleware.After)
2255}
2256
2257func addOpListTemplatesValidationMiddleware(stack *middleware.Stack) error {
2258	return stack.Initialize.Add(&validateOpListTemplates{}, middleware.After)
2259}
2260
2261func addOpListTemplateVersionsValidationMiddleware(stack *middleware.Stack) error {
2262	return stack.Initialize.Add(&validateOpListTemplateVersions{}, middleware.After)
2263}
2264
2265func addOpListThemeAliasesValidationMiddleware(stack *middleware.Stack) error {
2266	return stack.Initialize.Add(&validateOpListThemeAliases{}, middleware.After)
2267}
2268
2269func addOpListThemesValidationMiddleware(stack *middleware.Stack) error {
2270	return stack.Initialize.Add(&validateOpListThemes{}, middleware.After)
2271}
2272
2273func addOpListThemeVersionsValidationMiddleware(stack *middleware.Stack) error {
2274	return stack.Initialize.Add(&validateOpListThemeVersions{}, middleware.After)
2275}
2276
2277func addOpListUserGroupsValidationMiddleware(stack *middleware.Stack) error {
2278	return stack.Initialize.Add(&validateOpListUserGroups{}, middleware.After)
2279}
2280
2281func addOpListUsersValidationMiddleware(stack *middleware.Stack) error {
2282	return stack.Initialize.Add(&validateOpListUsers{}, middleware.After)
2283}
2284
2285func addOpRegisterUserValidationMiddleware(stack *middleware.Stack) error {
2286	return stack.Initialize.Add(&validateOpRegisterUser{}, middleware.After)
2287}
2288
2289func addOpRestoreAnalysisValidationMiddleware(stack *middleware.Stack) error {
2290	return stack.Initialize.Add(&validateOpRestoreAnalysis{}, middleware.After)
2291}
2292
2293func addOpSearchAnalysesValidationMiddleware(stack *middleware.Stack) error {
2294	return stack.Initialize.Add(&validateOpSearchAnalyses{}, middleware.After)
2295}
2296
2297func addOpSearchDashboardsValidationMiddleware(stack *middleware.Stack) error {
2298	return stack.Initialize.Add(&validateOpSearchDashboards{}, middleware.After)
2299}
2300
2301func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
2302	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
2303}
2304
2305func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
2306	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
2307}
2308
2309func addOpUpdateAccountCustomizationValidationMiddleware(stack *middleware.Stack) error {
2310	return stack.Initialize.Add(&validateOpUpdateAccountCustomization{}, middleware.After)
2311}
2312
2313func addOpUpdateAccountSettingsValidationMiddleware(stack *middleware.Stack) error {
2314	return stack.Initialize.Add(&validateOpUpdateAccountSettings{}, middleware.After)
2315}
2316
2317func addOpUpdateAnalysisValidationMiddleware(stack *middleware.Stack) error {
2318	return stack.Initialize.Add(&validateOpUpdateAnalysis{}, middleware.After)
2319}
2320
2321func addOpUpdateAnalysisPermissionsValidationMiddleware(stack *middleware.Stack) error {
2322	return stack.Initialize.Add(&validateOpUpdateAnalysisPermissions{}, middleware.After)
2323}
2324
2325func addOpUpdateDashboardValidationMiddleware(stack *middleware.Stack) error {
2326	return stack.Initialize.Add(&validateOpUpdateDashboard{}, middleware.After)
2327}
2328
2329func addOpUpdateDashboardPermissionsValidationMiddleware(stack *middleware.Stack) error {
2330	return stack.Initialize.Add(&validateOpUpdateDashboardPermissions{}, middleware.After)
2331}
2332
2333func addOpUpdateDashboardPublishedVersionValidationMiddleware(stack *middleware.Stack) error {
2334	return stack.Initialize.Add(&validateOpUpdateDashboardPublishedVersion{}, middleware.After)
2335}
2336
2337func addOpUpdateDataSetValidationMiddleware(stack *middleware.Stack) error {
2338	return stack.Initialize.Add(&validateOpUpdateDataSet{}, middleware.After)
2339}
2340
2341func addOpUpdateDataSetPermissionsValidationMiddleware(stack *middleware.Stack) error {
2342	return stack.Initialize.Add(&validateOpUpdateDataSetPermissions{}, middleware.After)
2343}
2344
2345func addOpUpdateDataSourceValidationMiddleware(stack *middleware.Stack) error {
2346	return stack.Initialize.Add(&validateOpUpdateDataSource{}, middleware.After)
2347}
2348
2349func addOpUpdateDataSourcePermissionsValidationMiddleware(stack *middleware.Stack) error {
2350	return stack.Initialize.Add(&validateOpUpdateDataSourcePermissions{}, middleware.After)
2351}
2352
2353func addOpUpdateGroupValidationMiddleware(stack *middleware.Stack) error {
2354	return stack.Initialize.Add(&validateOpUpdateGroup{}, middleware.After)
2355}
2356
2357func addOpUpdateIAMPolicyAssignmentValidationMiddleware(stack *middleware.Stack) error {
2358	return stack.Initialize.Add(&validateOpUpdateIAMPolicyAssignment{}, middleware.After)
2359}
2360
2361func addOpUpdateTemplateAliasValidationMiddleware(stack *middleware.Stack) error {
2362	return stack.Initialize.Add(&validateOpUpdateTemplateAlias{}, middleware.After)
2363}
2364
2365func addOpUpdateTemplateValidationMiddleware(stack *middleware.Stack) error {
2366	return stack.Initialize.Add(&validateOpUpdateTemplate{}, middleware.After)
2367}
2368
2369func addOpUpdateTemplatePermissionsValidationMiddleware(stack *middleware.Stack) error {
2370	return stack.Initialize.Add(&validateOpUpdateTemplatePermissions{}, middleware.After)
2371}
2372
2373func addOpUpdateThemeAliasValidationMiddleware(stack *middleware.Stack) error {
2374	return stack.Initialize.Add(&validateOpUpdateThemeAlias{}, middleware.After)
2375}
2376
2377func addOpUpdateThemeValidationMiddleware(stack *middleware.Stack) error {
2378	return stack.Initialize.Add(&validateOpUpdateTheme{}, middleware.After)
2379}
2380
2381func addOpUpdateThemePermissionsValidationMiddleware(stack *middleware.Stack) error {
2382	return stack.Initialize.Add(&validateOpUpdateThemePermissions{}, middleware.After)
2383}
2384
2385func addOpUpdateUserValidationMiddleware(stack *middleware.Stack) error {
2386	return stack.Initialize.Add(&validateOpUpdateUser{}, middleware.After)
2387}
2388
2389func validateAmazonElasticsearchParameters(v *types.AmazonElasticsearchParameters) error {
2390	if v == nil {
2391		return nil
2392	}
2393	invalidParams := smithy.InvalidParamsError{Context: "AmazonElasticsearchParameters"}
2394	if v.Domain == nil {
2395		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
2396	}
2397	if invalidParams.Len() > 0 {
2398		return invalidParams
2399	} else {
2400		return nil
2401	}
2402}
2403
2404func validateAnalysisSourceEntity(v *types.AnalysisSourceEntity) error {
2405	if v == nil {
2406		return nil
2407	}
2408	invalidParams := smithy.InvalidParamsError{Context: "AnalysisSourceEntity"}
2409	if v.SourceTemplate != nil {
2410		if err := validateAnalysisSourceTemplate(v.SourceTemplate); err != nil {
2411			invalidParams.AddNested("SourceTemplate", err.(smithy.InvalidParamsError))
2412		}
2413	}
2414	if invalidParams.Len() > 0 {
2415		return invalidParams
2416	} else {
2417		return nil
2418	}
2419}
2420
2421func validateAnalysisSourceTemplate(v *types.AnalysisSourceTemplate) error {
2422	if v == nil {
2423		return nil
2424	}
2425	invalidParams := smithy.InvalidParamsError{Context: "AnalysisSourceTemplate"}
2426	if v.DataSetReferences == nil {
2427		invalidParams.Add(smithy.NewErrParamRequired("DataSetReferences"))
2428	} else if v.DataSetReferences != nil {
2429		if err := validateDataSetReferenceList(v.DataSetReferences); err != nil {
2430			invalidParams.AddNested("DataSetReferences", err.(smithy.InvalidParamsError))
2431		}
2432	}
2433	if v.Arn == nil {
2434		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
2435	}
2436	if invalidParams.Len() > 0 {
2437		return invalidParams
2438	} else {
2439		return nil
2440	}
2441}
2442
2443func validateAuroraParameters(v *types.AuroraParameters) error {
2444	if v == nil {
2445		return nil
2446	}
2447	invalidParams := smithy.InvalidParamsError{Context: "AuroraParameters"}
2448	if v.Host == nil {
2449		invalidParams.Add(smithy.NewErrParamRequired("Host"))
2450	}
2451	if v.Database == nil {
2452		invalidParams.Add(smithy.NewErrParamRequired("Database"))
2453	}
2454	if invalidParams.Len() > 0 {
2455		return invalidParams
2456	} else {
2457		return nil
2458	}
2459}
2460
2461func validateAuroraPostgreSqlParameters(v *types.AuroraPostgreSqlParameters) error {
2462	if v == nil {
2463		return nil
2464	}
2465	invalidParams := smithy.InvalidParamsError{Context: "AuroraPostgreSqlParameters"}
2466	if v.Host == nil {
2467		invalidParams.Add(smithy.NewErrParamRequired("Host"))
2468	}
2469	if v.Database == nil {
2470		invalidParams.Add(smithy.NewErrParamRequired("Database"))
2471	}
2472	if invalidParams.Len() > 0 {
2473		return invalidParams
2474	} else {
2475		return nil
2476	}
2477}
2478
2479func validateAwsIotAnalyticsParameters(v *types.AwsIotAnalyticsParameters) error {
2480	if v == nil {
2481		return nil
2482	}
2483	invalidParams := smithy.InvalidParamsError{Context: "AwsIotAnalyticsParameters"}
2484	if v.DataSetName == nil {
2485		invalidParams.Add(smithy.NewErrParamRequired("DataSetName"))
2486	}
2487	if invalidParams.Len() > 0 {
2488		return invalidParams
2489	} else {
2490		return nil
2491	}
2492}
2493
2494func validateCalculatedColumn(v *types.CalculatedColumn) error {
2495	if v == nil {
2496		return nil
2497	}
2498	invalidParams := smithy.InvalidParamsError{Context: "CalculatedColumn"}
2499	if v.ColumnName == nil {
2500		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
2501	}
2502	if v.ColumnId == nil {
2503		invalidParams.Add(smithy.NewErrParamRequired("ColumnId"))
2504	}
2505	if v.Expression == nil {
2506		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
2507	}
2508	if invalidParams.Len() > 0 {
2509		return invalidParams
2510	} else {
2511		return nil
2512	}
2513}
2514
2515func validateCalculatedColumnList(v []types.CalculatedColumn) error {
2516	if v == nil {
2517		return nil
2518	}
2519	invalidParams := smithy.InvalidParamsError{Context: "CalculatedColumnList"}
2520	for i := range v {
2521		if err := validateCalculatedColumn(&v[i]); err != nil {
2522			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2523		}
2524	}
2525	if invalidParams.Len() > 0 {
2526		return invalidParams
2527	} else {
2528		return nil
2529	}
2530}
2531
2532func validateCastColumnTypeOperation(v *types.CastColumnTypeOperation) error {
2533	if v == nil {
2534		return nil
2535	}
2536	invalidParams := smithy.InvalidParamsError{Context: "CastColumnTypeOperation"}
2537	if v.ColumnName == nil {
2538		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
2539	}
2540	if len(v.NewColumnType) == 0 {
2541		invalidParams.Add(smithy.NewErrParamRequired("NewColumnType"))
2542	}
2543	if invalidParams.Len() > 0 {
2544		return invalidParams
2545	} else {
2546		return nil
2547	}
2548}
2549
2550func validateColumnGroup(v *types.ColumnGroup) error {
2551	if v == nil {
2552		return nil
2553	}
2554	invalidParams := smithy.InvalidParamsError{Context: "ColumnGroup"}
2555	if v.GeoSpatialColumnGroup != nil {
2556		if err := validateGeoSpatialColumnGroup(v.GeoSpatialColumnGroup); err != nil {
2557			invalidParams.AddNested("GeoSpatialColumnGroup", err.(smithy.InvalidParamsError))
2558		}
2559	}
2560	if invalidParams.Len() > 0 {
2561		return invalidParams
2562	} else {
2563		return nil
2564	}
2565}
2566
2567func validateColumnGroupList(v []types.ColumnGroup) error {
2568	if v == nil {
2569		return nil
2570	}
2571	invalidParams := smithy.InvalidParamsError{Context: "ColumnGroupList"}
2572	for i := range v {
2573		if err := validateColumnGroup(&v[i]); err != nil {
2574			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2575		}
2576	}
2577	if invalidParams.Len() > 0 {
2578		return invalidParams
2579	} else {
2580		return nil
2581	}
2582}
2583
2584func validateCreateColumnsOperation(v *types.CreateColumnsOperation) error {
2585	if v == nil {
2586		return nil
2587	}
2588	invalidParams := smithy.InvalidParamsError{Context: "CreateColumnsOperation"}
2589	if v.Columns == nil {
2590		invalidParams.Add(smithy.NewErrParamRequired("Columns"))
2591	} else if v.Columns != nil {
2592		if err := validateCalculatedColumnList(v.Columns); err != nil {
2593			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
2594		}
2595	}
2596	if invalidParams.Len() > 0 {
2597		return invalidParams
2598	} else {
2599		return nil
2600	}
2601}
2602
2603func validateCredentialPair(v *types.CredentialPair) error {
2604	if v == nil {
2605		return nil
2606	}
2607	invalidParams := smithy.InvalidParamsError{Context: "CredentialPair"}
2608	if v.Username == nil {
2609		invalidParams.Add(smithy.NewErrParamRequired("Username"))
2610	}
2611	if v.Password == nil {
2612		invalidParams.Add(smithy.NewErrParamRequired("Password"))
2613	}
2614	if v.AlternateDataSourceParameters != nil {
2615		if err := validateDataSourceParametersList(v.AlternateDataSourceParameters); err != nil {
2616			invalidParams.AddNested("AlternateDataSourceParameters", err.(smithy.InvalidParamsError))
2617		}
2618	}
2619	if invalidParams.Len() > 0 {
2620		return invalidParams
2621	} else {
2622		return nil
2623	}
2624}
2625
2626func validateCustomSql(v *types.CustomSql) error {
2627	if v == nil {
2628		return nil
2629	}
2630	invalidParams := smithy.InvalidParamsError{Context: "CustomSql"}
2631	if v.DataSourceArn == nil {
2632		invalidParams.Add(smithy.NewErrParamRequired("DataSourceArn"))
2633	}
2634	if v.Name == nil {
2635		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2636	}
2637	if v.SqlQuery == nil {
2638		invalidParams.Add(smithy.NewErrParamRequired("SqlQuery"))
2639	}
2640	if v.Columns != nil {
2641		if err := validateInputColumnList(v.Columns); err != nil {
2642			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
2643		}
2644	}
2645	if invalidParams.Len() > 0 {
2646		return invalidParams
2647	} else {
2648		return nil
2649	}
2650}
2651
2652func validateDashboardSearchFilter(v *types.DashboardSearchFilter) error {
2653	if v == nil {
2654		return nil
2655	}
2656	invalidParams := smithy.InvalidParamsError{Context: "DashboardSearchFilter"}
2657	if len(v.Operator) == 0 {
2658		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
2659	}
2660	if invalidParams.Len() > 0 {
2661		return invalidParams
2662	} else {
2663		return nil
2664	}
2665}
2666
2667func validateDashboardSearchFilterList(v []types.DashboardSearchFilter) error {
2668	if v == nil {
2669		return nil
2670	}
2671	invalidParams := smithy.InvalidParamsError{Context: "DashboardSearchFilterList"}
2672	for i := range v {
2673		if err := validateDashboardSearchFilter(&v[i]); err != nil {
2674			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2675		}
2676	}
2677	if invalidParams.Len() > 0 {
2678		return invalidParams
2679	} else {
2680		return nil
2681	}
2682}
2683
2684func validateDashboardSourceEntity(v *types.DashboardSourceEntity) error {
2685	if v == nil {
2686		return nil
2687	}
2688	invalidParams := smithy.InvalidParamsError{Context: "DashboardSourceEntity"}
2689	if v.SourceTemplate != nil {
2690		if err := validateDashboardSourceTemplate(v.SourceTemplate); err != nil {
2691			invalidParams.AddNested("SourceTemplate", err.(smithy.InvalidParamsError))
2692		}
2693	}
2694	if invalidParams.Len() > 0 {
2695		return invalidParams
2696	} else {
2697		return nil
2698	}
2699}
2700
2701func validateDashboardSourceTemplate(v *types.DashboardSourceTemplate) error {
2702	if v == nil {
2703		return nil
2704	}
2705	invalidParams := smithy.InvalidParamsError{Context: "DashboardSourceTemplate"}
2706	if v.DataSetReferences == nil {
2707		invalidParams.Add(smithy.NewErrParamRequired("DataSetReferences"))
2708	} else if v.DataSetReferences != nil {
2709		if err := validateDataSetReferenceList(v.DataSetReferences); err != nil {
2710			invalidParams.AddNested("DataSetReferences", err.(smithy.InvalidParamsError))
2711		}
2712	}
2713	if v.Arn == nil {
2714		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
2715	}
2716	if invalidParams.Len() > 0 {
2717		return invalidParams
2718	} else {
2719		return nil
2720	}
2721}
2722
2723func validateDataSetReference(v *types.DataSetReference) error {
2724	if v == nil {
2725		return nil
2726	}
2727	invalidParams := smithy.InvalidParamsError{Context: "DataSetReference"}
2728	if v.DataSetPlaceholder == nil {
2729		invalidParams.Add(smithy.NewErrParamRequired("DataSetPlaceholder"))
2730	}
2731	if v.DataSetArn == nil {
2732		invalidParams.Add(smithy.NewErrParamRequired("DataSetArn"))
2733	}
2734	if invalidParams.Len() > 0 {
2735		return invalidParams
2736	} else {
2737		return nil
2738	}
2739}
2740
2741func validateDataSetReferenceList(v []types.DataSetReference) error {
2742	if v == nil {
2743		return nil
2744	}
2745	invalidParams := smithy.InvalidParamsError{Context: "DataSetReferenceList"}
2746	for i := range v {
2747		if err := validateDataSetReference(&v[i]); err != nil {
2748			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2749		}
2750	}
2751	if invalidParams.Len() > 0 {
2752		return invalidParams
2753	} else {
2754		return nil
2755	}
2756}
2757
2758func validateDataSourceCredentials(v *types.DataSourceCredentials) error {
2759	if v == nil {
2760		return nil
2761	}
2762	invalidParams := smithy.InvalidParamsError{Context: "DataSourceCredentials"}
2763	if v.CredentialPair != nil {
2764		if err := validateCredentialPair(v.CredentialPair); err != nil {
2765			invalidParams.AddNested("CredentialPair", err.(smithy.InvalidParamsError))
2766		}
2767	}
2768	if invalidParams.Len() > 0 {
2769		return invalidParams
2770	} else {
2771		return nil
2772	}
2773}
2774
2775func validateDataSourceParameters(v types.DataSourceParameters) error {
2776	if v == nil {
2777		return nil
2778	}
2779	invalidParams := smithy.InvalidParamsError{Context: "DataSourceParameters"}
2780	switch uv := v.(type) {
2781	case *types.DataSourceParametersMemberAmazonElasticsearchParameters:
2782		if err := validateAmazonElasticsearchParameters(&uv.Value); err != nil {
2783			invalidParams.AddNested("[AmazonElasticsearchParameters]", err.(smithy.InvalidParamsError))
2784		}
2785
2786	case *types.DataSourceParametersMemberAuroraParameters:
2787		if err := validateAuroraParameters(&uv.Value); err != nil {
2788			invalidParams.AddNested("[AuroraParameters]", err.(smithy.InvalidParamsError))
2789		}
2790
2791	case *types.DataSourceParametersMemberAuroraPostgreSqlParameters:
2792		if err := validateAuroraPostgreSqlParameters(&uv.Value); err != nil {
2793			invalidParams.AddNested("[AuroraPostgreSqlParameters]", err.(smithy.InvalidParamsError))
2794		}
2795
2796	case *types.DataSourceParametersMemberAwsIotAnalyticsParameters:
2797		if err := validateAwsIotAnalyticsParameters(&uv.Value); err != nil {
2798			invalidParams.AddNested("[AwsIotAnalyticsParameters]", err.(smithy.InvalidParamsError))
2799		}
2800
2801	case *types.DataSourceParametersMemberJiraParameters:
2802		if err := validateJiraParameters(&uv.Value); err != nil {
2803			invalidParams.AddNested("[JiraParameters]", err.(smithy.InvalidParamsError))
2804		}
2805
2806	case *types.DataSourceParametersMemberMariaDbParameters:
2807		if err := validateMariaDbParameters(&uv.Value); err != nil {
2808			invalidParams.AddNested("[MariaDbParameters]", err.(smithy.InvalidParamsError))
2809		}
2810
2811	case *types.DataSourceParametersMemberMySqlParameters:
2812		if err := validateMySqlParameters(&uv.Value); err != nil {
2813			invalidParams.AddNested("[MySqlParameters]", err.(smithy.InvalidParamsError))
2814		}
2815
2816	case *types.DataSourceParametersMemberOracleParameters:
2817		if err := validateOracleParameters(&uv.Value); err != nil {
2818			invalidParams.AddNested("[OracleParameters]", err.(smithy.InvalidParamsError))
2819		}
2820
2821	case *types.DataSourceParametersMemberPostgreSqlParameters:
2822		if err := validatePostgreSqlParameters(&uv.Value); err != nil {
2823			invalidParams.AddNested("[PostgreSqlParameters]", err.(smithy.InvalidParamsError))
2824		}
2825
2826	case *types.DataSourceParametersMemberPrestoParameters:
2827		if err := validatePrestoParameters(&uv.Value); err != nil {
2828			invalidParams.AddNested("[PrestoParameters]", err.(smithy.InvalidParamsError))
2829		}
2830
2831	case *types.DataSourceParametersMemberRdsParameters:
2832		if err := validateRdsParameters(&uv.Value); err != nil {
2833			invalidParams.AddNested("[RdsParameters]", err.(smithy.InvalidParamsError))
2834		}
2835
2836	case *types.DataSourceParametersMemberRedshiftParameters:
2837		if err := validateRedshiftParameters(&uv.Value); err != nil {
2838			invalidParams.AddNested("[RedshiftParameters]", err.(smithy.InvalidParamsError))
2839		}
2840
2841	case *types.DataSourceParametersMemberS3Parameters:
2842		if err := validateS3Parameters(&uv.Value); err != nil {
2843			invalidParams.AddNested("[S3Parameters]", err.(smithy.InvalidParamsError))
2844		}
2845
2846	case *types.DataSourceParametersMemberServiceNowParameters:
2847		if err := validateServiceNowParameters(&uv.Value); err != nil {
2848			invalidParams.AddNested("[ServiceNowParameters]", err.(smithy.InvalidParamsError))
2849		}
2850
2851	case *types.DataSourceParametersMemberSnowflakeParameters:
2852		if err := validateSnowflakeParameters(&uv.Value); err != nil {
2853			invalidParams.AddNested("[SnowflakeParameters]", err.(smithy.InvalidParamsError))
2854		}
2855
2856	case *types.DataSourceParametersMemberSparkParameters:
2857		if err := validateSparkParameters(&uv.Value); err != nil {
2858			invalidParams.AddNested("[SparkParameters]", err.(smithy.InvalidParamsError))
2859		}
2860
2861	case *types.DataSourceParametersMemberSqlServerParameters:
2862		if err := validateSqlServerParameters(&uv.Value); err != nil {
2863			invalidParams.AddNested("[SqlServerParameters]", err.(smithy.InvalidParamsError))
2864		}
2865
2866	case *types.DataSourceParametersMemberTeradataParameters:
2867		if err := validateTeradataParameters(&uv.Value); err != nil {
2868			invalidParams.AddNested("[TeradataParameters]", err.(smithy.InvalidParamsError))
2869		}
2870
2871	case *types.DataSourceParametersMemberTwitterParameters:
2872		if err := validateTwitterParameters(&uv.Value); err != nil {
2873			invalidParams.AddNested("[TwitterParameters]", err.(smithy.InvalidParamsError))
2874		}
2875
2876	}
2877	if invalidParams.Len() > 0 {
2878		return invalidParams
2879	} else {
2880		return nil
2881	}
2882}
2883
2884func validateDataSourceParametersList(v []types.DataSourceParameters) error {
2885	if v == nil {
2886		return nil
2887	}
2888	invalidParams := smithy.InvalidParamsError{Context: "DataSourceParametersList"}
2889	for i := range v {
2890		if err := validateDataSourceParameters(v[i]); err != nil {
2891			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2892		}
2893	}
2894	if invalidParams.Len() > 0 {
2895		return invalidParams
2896	} else {
2897		return nil
2898	}
2899}
2900
2901func validateDateTimeParameter(v *types.DateTimeParameter) error {
2902	if v == nil {
2903		return nil
2904	}
2905	invalidParams := smithy.InvalidParamsError{Context: "DateTimeParameter"}
2906	if v.Name == nil {
2907		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2908	}
2909	if v.Values == nil {
2910		invalidParams.Add(smithy.NewErrParamRequired("Values"))
2911	}
2912	if invalidParams.Len() > 0 {
2913		return invalidParams
2914	} else {
2915		return nil
2916	}
2917}
2918
2919func validateDateTimeParameterList(v []types.DateTimeParameter) error {
2920	if v == nil {
2921		return nil
2922	}
2923	invalidParams := smithy.InvalidParamsError{Context: "DateTimeParameterList"}
2924	for i := range v {
2925		if err := validateDateTimeParameter(&v[i]); err != nil {
2926			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2927		}
2928	}
2929	if invalidParams.Len() > 0 {
2930		return invalidParams
2931	} else {
2932		return nil
2933	}
2934}
2935
2936func validateDecimalParameter(v *types.DecimalParameter) error {
2937	if v == nil {
2938		return nil
2939	}
2940	invalidParams := smithy.InvalidParamsError{Context: "DecimalParameter"}
2941	if v.Name == nil {
2942		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2943	}
2944	if v.Values == nil {
2945		invalidParams.Add(smithy.NewErrParamRequired("Values"))
2946	}
2947	if invalidParams.Len() > 0 {
2948		return invalidParams
2949	} else {
2950		return nil
2951	}
2952}
2953
2954func validateDecimalParameterList(v []types.DecimalParameter) error {
2955	if v == nil {
2956		return nil
2957	}
2958	invalidParams := smithy.InvalidParamsError{Context: "DecimalParameterList"}
2959	for i := range v {
2960		if err := validateDecimalParameter(&v[i]); err != nil {
2961			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2962		}
2963	}
2964	if invalidParams.Len() > 0 {
2965		return invalidParams
2966	} else {
2967		return nil
2968	}
2969}
2970
2971func validateFilterOperation(v *types.FilterOperation) error {
2972	if v == nil {
2973		return nil
2974	}
2975	invalidParams := smithy.InvalidParamsError{Context: "FilterOperation"}
2976	if v.ConditionExpression == nil {
2977		invalidParams.Add(smithy.NewErrParamRequired("ConditionExpression"))
2978	}
2979	if invalidParams.Len() > 0 {
2980		return invalidParams
2981	} else {
2982		return nil
2983	}
2984}
2985
2986func validateGeoSpatialColumnGroup(v *types.GeoSpatialColumnGroup) error {
2987	if v == nil {
2988		return nil
2989	}
2990	invalidParams := smithy.InvalidParamsError{Context: "GeoSpatialColumnGroup"}
2991	if v.Name == nil {
2992		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2993	}
2994	if len(v.CountryCode) == 0 {
2995		invalidParams.Add(smithy.NewErrParamRequired("CountryCode"))
2996	}
2997	if v.Columns == nil {
2998		invalidParams.Add(smithy.NewErrParamRequired("Columns"))
2999	}
3000	if invalidParams.Len() > 0 {
3001		return invalidParams
3002	} else {
3003		return nil
3004	}
3005}
3006
3007func validateInputColumn(v *types.InputColumn) error {
3008	if v == nil {
3009		return nil
3010	}
3011	invalidParams := smithy.InvalidParamsError{Context: "InputColumn"}
3012	if v.Name == nil {
3013		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3014	}
3015	if len(v.Type) == 0 {
3016		invalidParams.Add(smithy.NewErrParamRequired("Type"))
3017	}
3018	if invalidParams.Len() > 0 {
3019		return invalidParams
3020	} else {
3021		return nil
3022	}
3023}
3024
3025func validateInputColumnList(v []types.InputColumn) error {
3026	if v == nil {
3027		return nil
3028	}
3029	invalidParams := smithy.InvalidParamsError{Context: "InputColumnList"}
3030	for i := range v {
3031		if err := validateInputColumn(&v[i]); err != nil {
3032			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3033		}
3034	}
3035	if invalidParams.Len() > 0 {
3036		return invalidParams
3037	} else {
3038		return nil
3039	}
3040}
3041
3042func validateIntegerParameter(v *types.IntegerParameter) error {
3043	if v == nil {
3044		return nil
3045	}
3046	invalidParams := smithy.InvalidParamsError{Context: "IntegerParameter"}
3047	if v.Name == nil {
3048		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3049	}
3050	if v.Values == nil {
3051		invalidParams.Add(smithy.NewErrParamRequired("Values"))
3052	}
3053	if invalidParams.Len() > 0 {
3054		return invalidParams
3055	} else {
3056		return nil
3057	}
3058}
3059
3060func validateIntegerParameterList(v []types.IntegerParameter) error {
3061	if v == nil {
3062		return nil
3063	}
3064	invalidParams := smithy.InvalidParamsError{Context: "IntegerParameterList"}
3065	for i := range v {
3066		if err := validateIntegerParameter(&v[i]); err != nil {
3067			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3068		}
3069	}
3070	if invalidParams.Len() > 0 {
3071		return invalidParams
3072	} else {
3073		return nil
3074	}
3075}
3076
3077func validateJiraParameters(v *types.JiraParameters) error {
3078	if v == nil {
3079		return nil
3080	}
3081	invalidParams := smithy.InvalidParamsError{Context: "JiraParameters"}
3082	if v.SiteBaseUrl == nil {
3083		invalidParams.Add(smithy.NewErrParamRequired("SiteBaseUrl"))
3084	}
3085	if invalidParams.Len() > 0 {
3086		return invalidParams
3087	} else {
3088		return nil
3089	}
3090}
3091
3092func validateJoinInstruction(v *types.JoinInstruction) error {
3093	if v == nil {
3094		return nil
3095	}
3096	invalidParams := smithy.InvalidParamsError{Context: "JoinInstruction"}
3097	if v.LeftOperand == nil {
3098		invalidParams.Add(smithy.NewErrParamRequired("LeftOperand"))
3099	}
3100	if v.RightOperand == nil {
3101		invalidParams.Add(smithy.NewErrParamRequired("RightOperand"))
3102	}
3103	if len(v.Type) == 0 {
3104		invalidParams.Add(smithy.NewErrParamRequired("Type"))
3105	}
3106	if v.OnClause == nil {
3107		invalidParams.Add(smithy.NewErrParamRequired("OnClause"))
3108	}
3109	if invalidParams.Len() > 0 {
3110		return invalidParams
3111	} else {
3112		return nil
3113	}
3114}
3115
3116func validateLogicalTable(v *types.LogicalTable) error {
3117	if v == nil {
3118		return nil
3119	}
3120	invalidParams := smithy.InvalidParamsError{Context: "LogicalTable"}
3121	if v.Alias == nil {
3122		invalidParams.Add(smithy.NewErrParamRequired("Alias"))
3123	}
3124	if v.DataTransforms != nil {
3125		if err := validateTransformOperationList(v.DataTransforms); err != nil {
3126			invalidParams.AddNested("DataTransforms", err.(smithy.InvalidParamsError))
3127		}
3128	}
3129	if v.Source == nil {
3130		invalidParams.Add(smithy.NewErrParamRequired("Source"))
3131	} else if v.Source != nil {
3132		if err := validateLogicalTableSource(v.Source); err != nil {
3133			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
3134		}
3135	}
3136	if invalidParams.Len() > 0 {
3137		return invalidParams
3138	} else {
3139		return nil
3140	}
3141}
3142
3143func validateLogicalTableMap(v map[string]types.LogicalTable) error {
3144	if v == nil {
3145		return nil
3146	}
3147	invalidParams := smithy.InvalidParamsError{Context: "LogicalTableMap"}
3148	for key := range v {
3149		value := v[key]
3150		if err := validateLogicalTable(&value); err != nil {
3151			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
3152		}
3153	}
3154	if invalidParams.Len() > 0 {
3155		return invalidParams
3156	} else {
3157		return nil
3158	}
3159}
3160
3161func validateLogicalTableSource(v *types.LogicalTableSource) error {
3162	if v == nil {
3163		return nil
3164	}
3165	invalidParams := smithy.InvalidParamsError{Context: "LogicalTableSource"}
3166	if v.JoinInstruction != nil {
3167		if err := validateJoinInstruction(v.JoinInstruction); err != nil {
3168			invalidParams.AddNested("JoinInstruction", err.(smithy.InvalidParamsError))
3169		}
3170	}
3171	if invalidParams.Len() > 0 {
3172		return invalidParams
3173	} else {
3174		return nil
3175	}
3176}
3177
3178func validateManifestFileLocation(v *types.ManifestFileLocation) error {
3179	if v == nil {
3180		return nil
3181	}
3182	invalidParams := smithy.InvalidParamsError{Context: "ManifestFileLocation"}
3183	if v.Bucket == nil {
3184		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
3185	}
3186	if v.Key == nil {
3187		invalidParams.Add(smithy.NewErrParamRequired("Key"))
3188	}
3189	if invalidParams.Len() > 0 {
3190		return invalidParams
3191	} else {
3192		return nil
3193	}
3194}
3195
3196func validateMariaDbParameters(v *types.MariaDbParameters) error {
3197	if v == nil {
3198		return nil
3199	}
3200	invalidParams := smithy.InvalidParamsError{Context: "MariaDbParameters"}
3201	if v.Host == nil {
3202		invalidParams.Add(smithy.NewErrParamRequired("Host"))
3203	}
3204	if v.Database == nil {
3205		invalidParams.Add(smithy.NewErrParamRequired("Database"))
3206	}
3207	if invalidParams.Len() > 0 {
3208		return invalidParams
3209	} else {
3210		return nil
3211	}
3212}
3213
3214func validateMySqlParameters(v *types.MySqlParameters) error {
3215	if v == nil {
3216		return nil
3217	}
3218	invalidParams := smithy.InvalidParamsError{Context: "MySqlParameters"}
3219	if v.Host == nil {
3220		invalidParams.Add(smithy.NewErrParamRequired("Host"))
3221	}
3222	if v.Database == nil {
3223		invalidParams.Add(smithy.NewErrParamRequired("Database"))
3224	}
3225	if invalidParams.Len() > 0 {
3226		return invalidParams
3227	} else {
3228		return nil
3229	}
3230}
3231
3232func validateOracleParameters(v *types.OracleParameters) error {
3233	if v == nil {
3234		return nil
3235	}
3236	invalidParams := smithy.InvalidParamsError{Context: "OracleParameters"}
3237	if v.Host == nil {
3238		invalidParams.Add(smithy.NewErrParamRequired("Host"))
3239	}
3240	if v.Database == nil {
3241		invalidParams.Add(smithy.NewErrParamRequired("Database"))
3242	}
3243	if invalidParams.Len() > 0 {
3244		return invalidParams
3245	} else {
3246		return nil
3247	}
3248}
3249
3250func validateParameters(v *types.Parameters) error {
3251	if v == nil {
3252		return nil
3253	}
3254	invalidParams := smithy.InvalidParamsError{Context: "Parameters"}
3255	if v.StringParameters != nil {
3256		if err := validateStringParameterList(v.StringParameters); err != nil {
3257			invalidParams.AddNested("StringParameters", err.(smithy.InvalidParamsError))
3258		}
3259	}
3260	if v.IntegerParameters != nil {
3261		if err := validateIntegerParameterList(v.IntegerParameters); err != nil {
3262			invalidParams.AddNested("IntegerParameters", err.(smithy.InvalidParamsError))
3263		}
3264	}
3265	if v.DecimalParameters != nil {
3266		if err := validateDecimalParameterList(v.DecimalParameters); err != nil {
3267			invalidParams.AddNested("DecimalParameters", err.(smithy.InvalidParamsError))
3268		}
3269	}
3270	if v.DateTimeParameters != nil {
3271		if err := validateDateTimeParameterList(v.DateTimeParameters); err != nil {
3272			invalidParams.AddNested("DateTimeParameters", err.(smithy.InvalidParamsError))
3273		}
3274	}
3275	if invalidParams.Len() > 0 {
3276		return invalidParams
3277	} else {
3278		return nil
3279	}
3280}
3281
3282func validatePhysicalTable(v types.PhysicalTable) error {
3283	if v == nil {
3284		return nil
3285	}
3286	invalidParams := smithy.InvalidParamsError{Context: "PhysicalTable"}
3287	switch uv := v.(type) {
3288	case *types.PhysicalTableMemberCustomSql:
3289		if err := validateCustomSql(&uv.Value); err != nil {
3290			invalidParams.AddNested("[CustomSql]", err.(smithy.InvalidParamsError))
3291		}
3292
3293	case *types.PhysicalTableMemberRelationalTable:
3294		if err := validateRelationalTable(&uv.Value); err != nil {
3295			invalidParams.AddNested("[RelationalTable]", err.(smithy.InvalidParamsError))
3296		}
3297
3298	case *types.PhysicalTableMemberS3Source:
3299		if err := validateS3Source(&uv.Value); err != nil {
3300			invalidParams.AddNested("[S3Source]", err.(smithy.InvalidParamsError))
3301		}
3302
3303	}
3304	if invalidParams.Len() > 0 {
3305		return invalidParams
3306	} else {
3307		return nil
3308	}
3309}
3310
3311func validatePhysicalTableMap(v map[string]types.PhysicalTable) error {
3312	if v == nil {
3313		return nil
3314	}
3315	invalidParams := smithy.InvalidParamsError{Context: "PhysicalTableMap"}
3316	for key := range v {
3317		if err := validatePhysicalTable(v[key]); err != nil {
3318			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
3319		}
3320	}
3321	if invalidParams.Len() > 0 {
3322		return invalidParams
3323	} else {
3324		return nil
3325	}
3326}
3327
3328func validatePostgreSqlParameters(v *types.PostgreSqlParameters) error {
3329	if v == nil {
3330		return nil
3331	}
3332	invalidParams := smithy.InvalidParamsError{Context: "PostgreSqlParameters"}
3333	if v.Host == nil {
3334		invalidParams.Add(smithy.NewErrParamRequired("Host"))
3335	}
3336	if v.Database == nil {
3337		invalidParams.Add(smithy.NewErrParamRequired("Database"))
3338	}
3339	if invalidParams.Len() > 0 {
3340		return invalidParams
3341	} else {
3342		return nil
3343	}
3344}
3345
3346func validatePrestoParameters(v *types.PrestoParameters) error {
3347	if v == nil {
3348		return nil
3349	}
3350	invalidParams := smithy.InvalidParamsError{Context: "PrestoParameters"}
3351	if v.Host == nil {
3352		invalidParams.Add(smithy.NewErrParamRequired("Host"))
3353	}
3354	if v.Catalog == nil {
3355		invalidParams.Add(smithy.NewErrParamRequired("Catalog"))
3356	}
3357	if invalidParams.Len() > 0 {
3358		return invalidParams
3359	} else {
3360		return nil
3361	}
3362}
3363
3364func validateProjectOperation(v *types.ProjectOperation) error {
3365	if v == nil {
3366		return nil
3367	}
3368	invalidParams := smithy.InvalidParamsError{Context: "ProjectOperation"}
3369	if v.ProjectedColumns == nil {
3370		invalidParams.Add(smithy.NewErrParamRequired("ProjectedColumns"))
3371	}
3372	if invalidParams.Len() > 0 {
3373		return invalidParams
3374	} else {
3375		return nil
3376	}
3377}
3378
3379func validateRdsParameters(v *types.RdsParameters) error {
3380	if v == nil {
3381		return nil
3382	}
3383	invalidParams := smithy.InvalidParamsError{Context: "RdsParameters"}
3384	if v.InstanceId == nil {
3385		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3386	}
3387	if v.Database == nil {
3388		invalidParams.Add(smithy.NewErrParamRequired("Database"))
3389	}
3390	if invalidParams.Len() > 0 {
3391		return invalidParams
3392	} else {
3393		return nil
3394	}
3395}
3396
3397func validateRedshiftParameters(v *types.RedshiftParameters) error {
3398	if v == nil {
3399		return nil
3400	}
3401	invalidParams := smithy.InvalidParamsError{Context: "RedshiftParameters"}
3402	if v.Database == nil {
3403		invalidParams.Add(smithy.NewErrParamRequired("Database"))
3404	}
3405	if invalidParams.Len() > 0 {
3406		return invalidParams
3407	} else {
3408		return nil
3409	}
3410}
3411
3412func validateRelationalTable(v *types.RelationalTable) error {
3413	if v == nil {
3414		return nil
3415	}
3416	invalidParams := smithy.InvalidParamsError{Context: "RelationalTable"}
3417	if v.DataSourceArn == nil {
3418		invalidParams.Add(smithy.NewErrParamRequired("DataSourceArn"))
3419	}
3420	if v.Name == nil {
3421		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3422	}
3423	if v.InputColumns == nil {
3424		invalidParams.Add(smithy.NewErrParamRequired("InputColumns"))
3425	} else if v.InputColumns != nil {
3426		if err := validateInputColumnList(v.InputColumns); err != nil {
3427			invalidParams.AddNested("InputColumns", err.(smithy.InvalidParamsError))
3428		}
3429	}
3430	if invalidParams.Len() > 0 {
3431		return invalidParams
3432	} else {
3433		return nil
3434	}
3435}
3436
3437func validateRenameColumnOperation(v *types.RenameColumnOperation) error {
3438	if v == nil {
3439		return nil
3440	}
3441	invalidParams := smithy.InvalidParamsError{Context: "RenameColumnOperation"}
3442	if v.ColumnName == nil {
3443		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
3444	}
3445	if v.NewColumnName == nil {
3446		invalidParams.Add(smithy.NewErrParamRequired("NewColumnName"))
3447	}
3448	if invalidParams.Len() > 0 {
3449		return invalidParams
3450	} else {
3451		return nil
3452	}
3453}
3454
3455func validateResourcePermission(v *types.ResourcePermission) error {
3456	if v == nil {
3457		return nil
3458	}
3459	invalidParams := smithy.InvalidParamsError{Context: "ResourcePermission"}
3460	if v.Principal == nil {
3461		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
3462	}
3463	if v.Actions == nil {
3464		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
3465	}
3466	if invalidParams.Len() > 0 {
3467		return invalidParams
3468	} else {
3469		return nil
3470	}
3471}
3472
3473func validateResourcePermissionList(v []types.ResourcePermission) error {
3474	if v == nil {
3475		return nil
3476	}
3477	invalidParams := smithy.InvalidParamsError{Context: "ResourcePermissionList"}
3478	for i := range v {
3479		if err := validateResourcePermission(&v[i]); err != nil {
3480			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3481		}
3482	}
3483	if invalidParams.Len() > 0 {
3484		return invalidParams
3485	} else {
3486		return nil
3487	}
3488}
3489
3490func validateRowLevelPermissionDataSet(v *types.RowLevelPermissionDataSet) error {
3491	if v == nil {
3492		return nil
3493	}
3494	invalidParams := smithy.InvalidParamsError{Context: "RowLevelPermissionDataSet"}
3495	if v.Arn == nil {
3496		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
3497	}
3498	if len(v.PermissionPolicy) == 0 {
3499		invalidParams.Add(smithy.NewErrParamRequired("PermissionPolicy"))
3500	}
3501	if invalidParams.Len() > 0 {
3502		return invalidParams
3503	} else {
3504		return nil
3505	}
3506}
3507
3508func validateS3Parameters(v *types.S3Parameters) error {
3509	if v == nil {
3510		return nil
3511	}
3512	invalidParams := smithy.InvalidParamsError{Context: "S3Parameters"}
3513	if v.ManifestFileLocation == nil {
3514		invalidParams.Add(smithy.NewErrParamRequired("ManifestFileLocation"))
3515	} else if v.ManifestFileLocation != nil {
3516		if err := validateManifestFileLocation(v.ManifestFileLocation); err != nil {
3517			invalidParams.AddNested("ManifestFileLocation", err.(smithy.InvalidParamsError))
3518		}
3519	}
3520	if invalidParams.Len() > 0 {
3521		return invalidParams
3522	} else {
3523		return nil
3524	}
3525}
3526
3527func validateS3Source(v *types.S3Source) error {
3528	if v == nil {
3529		return nil
3530	}
3531	invalidParams := smithy.InvalidParamsError{Context: "S3Source"}
3532	if v.DataSourceArn == nil {
3533		invalidParams.Add(smithy.NewErrParamRequired("DataSourceArn"))
3534	}
3535	if v.InputColumns == nil {
3536		invalidParams.Add(smithy.NewErrParamRequired("InputColumns"))
3537	} else if v.InputColumns != nil {
3538		if err := validateInputColumnList(v.InputColumns); err != nil {
3539			invalidParams.AddNested("InputColumns", err.(smithy.InvalidParamsError))
3540		}
3541	}
3542	if invalidParams.Len() > 0 {
3543		return invalidParams
3544	} else {
3545		return nil
3546	}
3547}
3548
3549func validateServiceNowParameters(v *types.ServiceNowParameters) error {
3550	if v == nil {
3551		return nil
3552	}
3553	invalidParams := smithy.InvalidParamsError{Context: "ServiceNowParameters"}
3554	if v.SiteBaseUrl == nil {
3555		invalidParams.Add(smithy.NewErrParamRequired("SiteBaseUrl"))
3556	}
3557	if invalidParams.Len() > 0 {
3558		return invalidParams
3559	} else {
3560		return nil
3561	}
3562}
3563
3564func validateSnowflakeParameters(v *types.SnowflakeParameters) error {
3565	if v == nil {
3566		return nil
3567	}
3568	invalidParams := smithy.InvalidParamsError{Context: "SnowflakeParameters"}
3569	if v.Host == nil {
3570		invalidParams.Add(smithy.NewErrParamRequired("Host"))
3571	}
3572	if v.Database == nil {
3573		invalidParams.Add(smithy.NewErrParamRequired("Database"))
3574	}
3575	if v.Warehouse == nil {
3576		invalidParams.Add(smithy.NewErrParamRequired("Warehouse"))
3577	}
3578	if invalidParams.Len() > 0 {
3579		return invalidParams
3580	} else {
3581		return nil
3582	}
3583}
3584
3585func validateSparkParameters(v *types.SparkParameters) error {
3586	if v == nil {
3587		return nil
3588	}
3589	invalidParams := smithy.InvalidParamsError{Context: "SparkParameters"}
3590	if v.Host == nil {
3591		invalidParams.Add(smithy.NewErrParamRequired("Host"))
3592	}
3593	if invalidParams.Len() > 0 {
3594		return invalidParams
3595	} else {
3596		return nil
3597	}
3598}
3599
3600func validateSqlServerParameters(v *types.SqlServerParameters) error {
3601	if v == nil {
3602		return nil
3603	}
3604	invalidParams := smithy.InvalidParamsError{Context: "SqlServerParameters"}
3605	if v.Host == nil {
3606		invalidParams.Add(smithy.NewErrParamRequired("Host"))
3607	}
3608	if v.Database == nil {
3609		invalidParams.Add(smithy.NewErrParamRequired("Database"))
3610	}
3611	if invalidParams.Len() > 0 {
3612		return invalidParams
3613	} else {
3614		return nil
3615	}
3616}
3617
3618func validateStringParameter(v *types.StringParameter) error {
3619	if v == nil {
3620		return nil
3621	}
3622	invalidParams := smithy.InvalidParamsError{Context: "StringParameter"}
3623	if v.Name == nil {
3624		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3625	}
3626	if v.Values == nil {
3627		invalidParams.Add(smithy.NewErrParamRequired("Values"))
3628	}
3629	if invalidParams.Len() > 0 {
3630		return invalidParams
3631	} else {
3632		return nil
3633	}
3634}
3635
3636func validateStringParameterList(v []types.StringParameter) error {
3637	if v == nil {
3638		return nil
3639	}
3640	invalidParams := smithy.InvalidParamsError{Context: "StringParameterList"}
3641	for i := range v {
3642		if err := validateStringParameter(&v[i]); err != nil {
3643			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3644		}
3645	}
3646	if invalidParams.Len() > 0 {
3647		return invalidParams
3648	} else {
3649		return nil
3650	}
3651}
3652
3653func validateTag(v *types.Tag) error {
3654	if v == nil {
3655		return nil
3656	}
3657	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
3658	if v.Key == nil {
3659		invalidParams.Add(smithy.NewErrParamRequired("Key"))
3660	}
3661	if v.Value == nil {
3662		invalidParams.Add(smithy.NewErrParamRequired("Value"))
3663	}
3664	if invalidParams.Len() > 0 {
3665		return invalidParams
3666	} else {
3667		return nil
3668	}
3669}
3670
3671func validateTagColumnOperation(v *types.TagColumnOperation) error {
3672	if v == nil {
3673		return nil
3674	}
3675	invalidParams := smithy.InvalidParamsError{Context: "TagColumnOperation"}
3676	if v.ColumnName == nil {
3677		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
3678	}
3679	if v.Tags == nil {
3680		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
3681	}
3682	if invalidParams.Len() > 0 {
3683		return invalidParams
3684	} else {
3685		return nil
3686	}
3687}
3688
3689func validateTagList(v []types.Tag) error {
3690	if v == nil {
3691		return nil
3692	}
3693	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
3694	for i := range v {
3695		if err := validateTag(&v[i]); err != nil {
3696			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3697		}
3698	}
3699	if invalidParams.Len() > 0 {
3700		return invalidParams
3701	} else {
3702		return nil
3703	}
3704}
3705
3706func validateTemplateSourceAnalysis(v *types.TemplateSourceAnalysis) error {
3707	if v == nil {
3708		return nil
3709	}
3710	invalidParams := smithy.InvalidParamsError{Context: "TemplateSourceAnalysis"}
3711	if v.Arn == nil {
3712		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
3713	}
3714	if v.DataSetReferences == nil {
3715		invalidParams.Add(smithy.NewErrParamRequired("DataSetReferences"))
3716	} else if v.DataSetReferences != nil {
3717		if err := validateDataSetReferenceList(v.DataSetReferences); err != nil {
3718			invalidParams.AddNested("DataSetReferences", err.(smithy.InvalidParamsError))
3719		}
3720	}
3721	if invalidParams.Len() > 0 {
3722		return invalidParams
3723	} else {
3724		return nil
3725	}
3726}
3727
3728func validateTemplateSourceEntity(v *types.TemplateSourceEntity) error {
3729	if v == nil {
3730		return nil
3731	}
3732	invalidParams := smithy.InvalidParamsError{Context: "TemplateSourceEntity"}
3733	if v.SourceAnalysis != nil {
3734		if err := validateTemplateSourceAnalysis(v.SourceAnalysis); err != nil {
3735			invalidParams.AddNested("SourceAnalysis", err.(smithy.InvalidParamsError))
3736		}
3737	}
3738	if v.SourceTemplate != nil {
3739		if err := validateTemplateSourceTemplate(v.SourceTemplate); err != nil {
3740			invalidParams.AddNested("SourceTemplate", err.(smithy.InvalidParamsError))
3741		}
3742	}
3743	if invalidParams.Len() > 0 {
3744		return invalidParams
3745	} else {
3746		return nil
3747	}
3748}
3749
3750func validateTemplateSourceTemplate(v *types.TemplateSourceTemplate) error {
3751	if v == nil {
3752		return nil
3753	}
3754	invalidParams := smithy.InvalidParamsError{Context: "TemplateSourceTemplate"}
3755	if v.Arn == nil {
3756		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
3757	}
3758	if invalidParams.Len() > 0 {
3759		return invalidParams
3760	} else {
3761		return nil
3762	}
3763}
3764
3765func validateTeradataParameters(v *types.TeradataParameters) error {
3766	if v == nil {
3767		return nil
3768	}
3769	invalidParams := smithy.InvalidParamsError{Context: "TeradataParameters"}
3770	if v.Host == nil {
3771		invalidParams.Add(smithy.NewErrParamRequired("Host"))
3772	}
3773	if v.Database == nil {
3774		invalidParams.Add(smithy.NewErrParamRequired("Database"))
3775	}
3776	if invalidParams.Len() > 0 {
3777		return invalidParams
3778	} else {
3779		return nil
3780	}
3781}
3782
3783func validateTransformOperation(v types.TransformOperation) error {
3784	if v == nil {
3785		return nil
3786	}
3787	invalidParams := smithy.InvalidParamsError{Context: "TransformOperation"}
3788	switch uv := v.(type) {
3789	case *types.TransformOperationMemberCastColumnTypeOperation:
3790		if err := validateCastColumnTypeOperation(&uv.Value); err != nil {
3791			invalidParams.AddNested("[CastColumnTypeOperation]", err.(smithy.InvalidParamsError))
3792		}
3793
3794	case *types.TransformOperationMemberCreateColumnsOperation:
3795		if err := validateCreateColumnsOperation(&uv.Value); err != nil {
3796			invalidParams.AddNested("[CreateColumnsOperation]", err.(smithy.InvalidParamsError))
3797		}
3798
3799	case *types.TransformOperationMemberFilterOperation:
3800		if err := validateFilterOperation(&uv.Value); err != nil {
3801			invalidParams.AddNested("[FilterOperation]", err.(smithy.InvalidParamsError))
3802		}
3803
3804	case *types.TransformOperationMemberProjectOperation:
3805		if err := validateProjectOperation(&uv.Value); err != nil {
3806			invalidParams.AddNested("[ProjectOperation]", err.(smithy.InvalidParamsError))
3807		}
3808
3809	case *types.TransformOperationMemberRenameColumnOperation:
3810		if err := validateRenameColumnOperation(&uv.Value); err != nil {
3811			invalidParams.AddNested("[RenameColumnOperation]", err.(smithy.InvalidParamsError))
3812		}
3813
3814	case *types.TransformOperationMemberTagColumnOperation:
3815		if err := validateTagColumnOperation(&uv.Value); err != nil {
3816			invalidParams.AddNested("[TagColumnOperation]", err.(smithy.InvalidParamsError))
3817		}
3818
3819	}
3820	if invalidParams.Len() > 0 {
3821		return invalidParams
3822	} else {
3823		return nil
3824	}
3825}
3826
3827func validateTransformOperationList(v []types.TransformOperation) error {
3828	if v == nil {
3829		return nil
3830	}
3831	invalidParams := smithy.InvalidParamsError{Context: "TransformOperationList"}
3832	for i := range v {
3833		if err := validateTransformOperation(v[i]); err != nil {
3834			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3835		}
3836	}
3837	if invalidParams.Len() > 0 {
3838		return invalidParams
3839	} else {
3840		return nil
3841	}
3842}
3843
3844func validateTwitterParameters(v *types.TwitterParameters) error {
3845	if v == nil {
3846		return nil
3847	}
3848	invalidParams := smithy.InvalidParamsError{Context: "TwitterParameters"}
3849	if v.Query == nil {
3850		invalidParams.Add(smithy.NewErrParamRequired("Query"))
3851	}
3852	if invalidParams.Len() > 0 {
3853		return invalidParams
3854	} else {
3855		return nil
3856	}
3857}
3858
3859func validateUpdateResourcePermissionList(v []types.ResourcePermission) error {
3860	if v == nil {
3861		return nil
3862	}
3863	invalidParams := smithy.InvalidParamsError{Context: "UpdateResourcePermissionList"}
3864	for i := range v {
3865		if err := validateResourcePermission(&v[i]); err != nil {
3866			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3867		}
3868	}
3869	if invalidParams.Len() > 0 {
3870		return invalidParams
3871	} else {
3872		return nil
3873	}
3874}
3875
3876func validateVpcConnectionProperties(v *types.VpcConnectionProperties) error {
3877	if v == nil {
3878		return nil
3879	}
3880	invalidParams := smithy.InvalidParamsError{Context: "VpcConnectionProperties"}
3881	if v.VpcConnectionArn == nil {
3882		invalidParams.Add(smithy.NewErrParamRequired("VpcConnectionArn"))
3883	}
3884	if invalidParams.Len() > 0 {
3885		return invalidParams
3886	} else {
3887		return nil
3888	}
3889}
3890
3891func validateOpCancelIngestionInput(v *CancelIngestionInput) error {
3892	if v == nil {
3893		return nil
3894	}
3895	invalidParams := smithy.InvalidParamsError{Context: "CancelIngestionInput"}
3896	if v.AwsAccountId == nil {
3897		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
3898	}
3899	if v.DataSetId == nil {
3900		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
3901	}
3902	if v.IngestionId == nil {
3903		invalidParams.Add(smithy.NewErrParamRequired("IngestionId"))
3904	}
3905	if invalidParams.Len() > 0 {
3906		return invalidParams
3907	} else {
3908		return nil
3909	}
3910}
3911
3912func validateOpCreateAccountCustomizationInput(v *CreateAccountCustomizationInput) error {
3913	if v == nil {
3914		return nil
3915	}
3916	invalidParams := smithy.InvalidParamsError{Context: "CreateAccountCustomizationInput"}
3917	if v.AwsAccountId == nil {
3918		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
3919	}
3920	if v.AccountCustomization == nil {
3921		invalidParams.Add(smithy.NewErrParamRequired("AccountCustomization"))
3922	}
3923	if v.Tags != nil {
3924		if err := validateTagList(v.Tags); err != nil {
3925			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3926		}
3927	}
3928	if invalidParams.Len() > 0 {
3929		return invalidParams
3930	} else {
3931		return nil
3932	}
3933}
3934
3935func validateOpCreateAnalysisInput(v *CreateAnalysisInput) error {
3936	if v == nil {
3937		return nil
3938	}
3939	invalidParams := smithy.InvalidParamsError{Context: "CreateAnalysisInput"}
3940	if v.AwsAccountId == nil {
3941		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
3942	}
3943	if v.AnalysisId == nil {
3944		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
3945	}
3946	if v.Name == nil {
3947		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3948	}
3949	if v.Parameters != nil {
3950		if err := validateParameters(v.Parameters); err != nil {
3951			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
3952		}
3953	}
3954	if v.Permissions != nil {
3955		if err := validateResourcePermissionList(v.Permissions); err != nil {
3956			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
3957		}
3958	}
3959	if v.SourceEntity == nil {
3960		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
3961	} else if v.SourceEntity != nil {
3962		if err := validateAnalysisSourceEntity(v.SourceEntity); err != nil {
3963			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
3964		}
3965	}
3966	if v.Tags != nil {
3967		if err := validateTagList(v.Tags); err != nil {
3968			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3969		}
3970	}
3971	if invalidParams.Len() > 0 {
3972		return invalidParams
3973	} else {
3974		return nil
3975	}
3976}
3977
3978func validateOpCreateDashboardInput(v *CreateDashboardInput) error {
3979	if v == nil {
3980		return nil
3981	}
3982	invalidParams := smithy.InvalidParamsError{Context: "CreateDashboardInput"}
3983	if v.AwsAccountId == nil {
3984		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
3985	}
3986	if v.DashboardId == nil {
3987		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
3988	}
3989	if v.Name == nil {
3990		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3991	}
3992	if v.Parameters != nil {
3993		if err := validateParameters(v.Parameters); err != nil {
3994			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
3995		}
3996	}
3997	if v.Permissions != nil {
3998		if err := validateResourcePermissionList(v.Permissions); err != nil {
3999			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
4000		}
4001	}
4002	if v.SourceEntity == nil {
4003		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
4004	} else if v.SourceEntity != nil {
4005		if err := validateDashboardSourceEntity(v.SourceEntity); err != nil {
4006			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
4007		}
4008	}
4009	if v.Tags != nil {
4010		if err := validateTagList(v.Tags); err != nil {
4011			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
4012		}
4013	}
4014	if invalidParams.Len() > 0 {
4015		return invalidParams
4016	} else {
4017		return nil
4018	}
4019}
4020
4021func validateOpCreateDataSetInput(v *CreateDataSetInput) error {
4022	if v == nil {
4023		return nil
4024	}
4025	invalidParams := smithy.InvalidParamsError{Context: "CreateDataSetInput"}
4026	if v.AwsAccountId == nil {
4027		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4028	}
4029	if v.DataSetId == nil {
4030		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
4031	}
4032	if v.Name == nil {
4033		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4034	}
4035	if v.PhysicalTableMap == nil {
4036		invalidParams.Add(smithy.NewErrParamRequired("PhysicalTableMap"))
4037	} else if v.PhysicalTableMap != nil {
4038		if err := validatePhysicalTableMap(v.PhysicalTableMap); err != nil {
4039			invalidParams.AddNested("PhysicalTableMap", err.(smithy.InvalidParamsError))
4040		}
4041	}
4042	if v.LogicalTableMap != nil {
4043		if err := validateLogicalTableMap(v.LogicalTableMap); err != nil {
4044			invalidParams.AddNested("LogicalTableMap", err.(smithy.InvalidParamsError))
4045		}
4046	}
4047	if len(v.ImportMode) == 0 {
4048		invalidParams.Add(smithy.NewErrParamRequired("ImportMode"))
4049	}
4050	if v.ColumnGroups != nil {
4051		if err := validateColumnGroupList(v.ColumnGroups); err != nil {
4052			invalidParams.AddNested("ColumnGroups", err.(smithy.InvalidParamsError))
4053		}
4054	}
4055	if v.Permissions != nil {
4056		if err := validateResourcePermissionList(v.Permissions); err != nil {
4057			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
4058		}
4059	}
4060	if v.RowLevelPermissionDataSet != nil {
4061		if err := validateRowLevelPermissionDataSet(v.RowLevelPermissionDataSet); err != nil {
4062			invalidParams.AddNested("RowLevelPermissionDataSet", err.(smithy.InvalidParamsError))
4063		}
4064	}
4065	if v.Tags != nil {
4066		if err := validateTagList(v.Tags); err != nil {
4067			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
4068		}
4069	}
4070	if invalidParams.Len() > 0 {
4071		return invalidParams
4072	} else {
4073		return nil
4074	}
4075}
4076
4077func validateOpCreateDataSourceInput(v *CreateDataSourceInput) error {
4078	if v == nil {
4079		return nil
4080	}
4081	invalidParams := smithy.InvalidParamsError{Context: "CreateDataSourceInput"}
4082	if v.AwsAccountId == nil {
4083		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4084	}
4085	if v.DataSourceId == nil {
4086		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
4087	}
4088	if v.Name == nil {
4089		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4090	}
4091	if len(v.Type) == 0 {
4092		invalidParams.Add(smithy.NewErrParamRequired("Type"))
4093	}
4094	if v.DataSourceParameters != nil {
4095		if err := validateDataSourceParameters(v.DataSourceParameters); err != nil {
4096			invalidParams.AddNested("DataSourceParameters", err.(smithy.InvalidParamsError))
4097		}
4098	}
4099	if v.Credentials != nil {
4100		if err := validateDataSourceCredentials(v.Credentials); err != nil {
4101			invalidParams.AddNested("Credentials", err.(smithy.InvalidParamsError))
4102		}
4103	}
4104	if v.Permissions != nil {
4105		if err := validateResourcePermissionList(v.Permissions); err != nil {
4106			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
4107		}
4108	}
4109	if v.VpcConnectionProperties != nil {
4110		if err := validateVpcConnectionProperties(v.VpcConnectionProperties); err != nil {
4111			invalidParams.AddNested("VpcConnectionProperties", err.(smithy.InvalidParamsError))
4112		}
4113	}
4114	if v.Tags != nil {
4115		if err := validateTagList(v.Tags); err != nil {
4116			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
4117		}
4118	}
4119	if invalidParams.Len() > 0 {
4120		return invalidParams
4121	} else {
4122		return nil
4123	}
4124}
4125
4126func validateOpCreateGroupInput(v *CreateGroupInput) error {
4127	if v == nil {
4128		return nil
4129	}
4130	invalidParams := smithy.InvalidParamsError{Context: "CreateGroupInput"}
4131	if v.GroupName == nil {
4132		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
4133	}
4134	if v.AwsAccountId == nil {
4135		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4136	}
4137	if v.Namespace == nil {
4138		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4139	}
4140	if invalidParams.Len() > 0 {
4141		return invalidParams
4142	} else {
4143		return nil
4144	}
4145}
4146
4147func validateOpCreateGroupMembershipInput(v *CreateGroupMembershipInput) error {
4148	if v == nil {
4149		return nil
4150	}
4151	invalidParams := smithy.InvalidParamsError{Context: "CreateGroupMembershipInput"}
4152	if v.MemberName == nil {
4153		invalidParams.Add(smithy.NewErrParamRequired("MemberName"))
4154	}
4155	if v.GroupName == nil {
4156		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
4157	}
4158	if v.AwsAccountId == nil {
4159		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4160	}
4161	if v.Namespace == nil {
4162		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4163	}
4164	if invalidParams.Len() > 0 {
4165		return invalidParams
4166	} else {
4167		return nil
4168	}
4169}
4170
4171func validateOpCreateIAMPolicyAssignmentInput(v *CreateIAMPolicyAssignmentInput) error {
4172	if v == nil {
4173		return nil
4174	}
4175	invalidParams := smithy.InvalidParamsError{Context: "CreateIAMPolicyAssignmentInput"}
4176	if v.AwsAccountId == nil {
4177		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4178	}
4179	if v.AssignmentName == nil {
4180		invalidParams.Add(smithy.NewErrParamRequired("AssignmentName"))
4181	}
4182	if len(v.AssignmentStatus) == 0 {
4183		invalidParams.Add(smithy.NewErrParamRequired("AssignmentStatus"))
4184	}
4185	if v.Namespace == nil {
4186		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4187	}
4188	if invalidParams.Len() > 0 {
4189		return invalidParams
4190	} else {
4191		return nil
4192	}
4193}
4194
4195func validateOpCreateIngestionInput(v *CreateIngestionInput) error {
4196	if v == nil {
4197		return nil
4198	}
4199	invalidParams := smithy.InvalidParamsError{Context: "CreateIngestionInput"}
4200	if v.DataSetId == nil {
4201		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
4202	}
4203	if v.IngestionId == nil {
4204		invalidParams.Add(smithy.NewErrParamRequired("IngestionId"))
4205	}
4206	if v.AwsAccountId == nil {
4207		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4208	}
4209	if invalidParams.Len() > 0 {
4210		return invalidParams
4211	} else {
4212		return nil
4213	}
4214}
4215
4216func validateOpCreateNamespaceInput(v *CreateNamespaceInput) error {
4217	if v == nil {
4218		return nil
4219	}
4220	invalidParams := smithy.InvalidParamsError{Context: "CreateNamespaceInput"}
4221	if v.AwsAccountId == nil {
4222		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4223	}
4224	if v.Namespace == nil {
4225		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4226	}
4227	if len(v.IdentityStore) == 0 {
4228		invalidParams.Add(smithy.NewErrParamRequired("IdentityStore"))
4229	}
4230	if v.Tags != nil {
4231		if err := validateTagList(v.Tags); err != nil {
4232			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
4233		}
4234	}
4235	if invalidParams.Len() > 0 {
4236		return invalidParams
4237	} else {
4238		return nil
4239	}
4240}
4241
4242func validateOpCreateTemplateAliasInput(v *CreateTemplateAliasInput) error {
4243	if v == nil {
4244		return nil
4245	}
4246	invalidParams := smithy.InvalidParamsError{Context: "CreateTemplateAliasInput"}
4247	if v.AwsAccountId == nil {
4248		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4249	}
4250	if v.TemplateId == nil {
4251		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
4252	}
4253	if v.AliasName == nil {
4254		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
4255	}
4256	if v.TemplateVersionNumber == nil {
4257		invalidParams.Add(smithy.NewErrParamRequired("TemplateVersionNumber"))
4258	}
4259	if invalidParams.Len() > 0 {
4260		return invalidParams
4261	} else {
4262		return nil
4263	}
4264}
4265
4266func validateOpCreateTemplateInput(v *CreateTemplateInput) error {
4267	if v == nil {
4268		return nil
4269	}
4270	invalidParams := smithy.InvalidParamsError{Context: "CreateTemplateInput"}
4271	if v.AwsAccountId == nil {
4272		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4273	}
4274	if v.TemplateId == nil {
4275		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
4276	}
4277	if v.Permissions != nil {
4278		if err := validateResourcePermissionList(v.Permissions); err != nil {
4279			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
4280		}
4281	}
4282	if v.SourceEntity == nil {
4283		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
4284	} else if v.SourceEntity != nil {
4285		if err := validateTemplateSourceEntity(v.SourceEntity); err != nil {
4286			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
4287		}
4288	}
4289	if v.Tags != nil {
4290		if err := validateTagList(v.Tags); err != nil {
4291			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
4292		}
4293	}
4294	if invalidParams.Len() > 0 {
4295		return invalidParams
4296	} else {
4297		return nil
4298	}
4299}
4300
4301func validateOpCreateThemeAliasInput(v *CreateThemeAliasInput) error {
4302	if v == nil {
4303		return nil
4304	}
4305	invalidParams := smithy.InvalidParamsError{Context: "CreateThemeAliasInput"}
4306	if v.AwsAccountId == nil {
4307		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4308	}
4309	if v.ThemeId == nil {
4310		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
4311	}
4312	if v.AliasName == nil {
4313		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
4314	}
4315	if v.ThemeVersionNumber == nil {
4316		invalidParams.Add(smithy.NewErrParamRequired("ThemeVersionNumber"))
4317	}
4318	if invalidParams.Len() > 0 {
4319		return invalidParams
4320	} else {
4321		return nil
4322	}
4323}
4324
4325func validateOpCreateThemeInput(v *CreateThemeInput) error {
4326	if v == nil {
4327		return nil
4328	}
4329	invalidParams := smithy.InvalidParamsError{Context: "CreateThemeInput"}
4330	if v.AwsAccountId == nil {
4331		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4332	}
4333	if v.ThemeId == nil {
4334		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
4335	}
4336	if v.Name == nil {
4337		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4338	}
4339	if v.BaseThemeId == nil {
4340		invalidParams.Add(smithy.NewErrParamRequired("BaseThemeId"))
4341	}
4342	if v.Configuration == nil {
4343		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
4344	}
4345	if v.Permissions != nil {
4346		if err := validateResourcePermissionList(v.Permissions); err != nil {
4347			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
4348		}
4349	}
4350	if v.Tags != nil {
4351		if err := validateTagList(v.Tags); err != nil {
4352			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
4353		}
4354	}
4355	if invalidParams.Len() > 0 {
4356		return invalidParams
4357	} else {
4358		return nil
4359	}
4360}
4361
4362func validateOpDeleteAccountCustomizationInput(v *DeleteAccountCustomizationInput) error {
4363	if v == nil {
4364		return nil
4365	}
4366	invalidParams := smithy.InvalidParamsError{Context: "DeleteAccountCustomizationInput"}
4367	if v.AwsAccountId == nil {
4368		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4369	}
4370	if invalidParams.Len() > 0 {
4371		return invalidParams
4372	} else {
4373		return nil
4374	}
4375}
4376
4377func validateOpDeleteAnalysisInput(v *DeleteAnalysisInput) error {
4378	if v == nil {
4379		return nil
4380	}
4381	invalidParams := smithy.InvalidParamsError{Context: "DeleteAnalysisInput"}
4382	if v.AwsAccountId == nil {
4383		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4384	}
4385	if v.AnalysisId == nil {
4386		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
4387	}
4388	if invalidParams.Len() > 0 {
4389		return invalidParams
4390	} else {
4391		return nil
4392	}
4393}
4394
4395func validateOpDeleteDashboardInput(v *DeleteDashboardInput) error {
4396	if v == nil {
4397		return nil
4398	}
4399	invalidParams := smithy.InvalidParamsError{Context: "DeleteDashboardInput"}
4400	if v.AwsAccountId == nil {
4401		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4402	}
4403	if v.DashboardId == nil {
4404		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
4405	}
4406	if invalidParams.Len() > 0 {
4407		return invalidParams
4408	} else {
4409		return nil
4410	}
4411}
4412
4413func validateOpDeleteDataSetInput(v *DeleteDataSetInput) error {
4414	if v == nil {
4415		return nil
4416	}
4417	invalidParams := smithy.InvalidParamsError{Context: "DeleteDataSetInput"}
4418	if v.AwsAccountId == nil {
4419		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4420	}
4421	if v.DataSetId == nil {
4422		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
4423	}
4424	if invalidParams.Len() > 0 {
4425		return invalidParams
4426	} else {
4427		return nil
4428	}
4429}
4430
4431func validateOpDeleteDataSourceInput(v *DeleteDataSourceInput) error {
4432	if v == nil {
4433		return nil
4434	}
4435	invalidParams := smithy.InvalidParamsError{Context: "DeleteDataSourceInput"}
4436	if v.AwsAccountId == nil {
4437		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4438	}
4439	if v.DataSourceId == nil {
4440		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
4441	}
4442	if invalidParams.Len() > 0 {
4443		return invalidParams
4444	} else {
4445		return nil
4446	}
4447}
4448
4449func validateOpDeleteGroupInput(v *DeleteGroupInput) error {
4450	if v == nil {
4451		return nil
4452	}
4453	invalidParams := smithy.InvalidParamsError{Context: "DeleteGroupInput"}
4454	if v.GroupName == nil {
4455		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
4456	}
4457	if v.AwsAccountId == nil {
4458		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4459	}
4460	if v.Namespace == nil {
4461		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4462	}
4463	if invalidParams.Len() > 0 {
4464		return invalidParams
4465	} else {
4466		return nil
4467	}
4468}
4469
4470func validateOpDeleteGroupMembershipInput(v *DeleteGroupMembershipInput) error {
4471	if v == nil {
4472		return nil
4473	}
4474	invalidParams := smithy.InvalidParamsError{Context: "DeleteGroupMembershipInput"}
4475	if v.MemberName == nil {
4476		invalidParams.Add(smithy.NewErrParamRequired("MemberName"))
4477	}
4478	if v.GroupName == nil {
4479		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
4480	}
4481	if v.AwsAccountId == nil {
4482		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4483	}
4484	if v.Namespace == nil {
4485		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4486	}
4487	if invalidParams.Len() > 0 {
4488		return invalidParams
4489	} else {
4490		return nil
4491	}
4492}
4493
4494func validateOpDeleteIAMPolicyAssignmentInput(v *DeleteIAMPolicyAssignmentInput) error {
4495	if v == nil {
4496		return nil
4497	}
4498	invalidParams := smithy.InvalidParamsError{Context: "DeleteIAMPolicyAssignmentInput"}
4499	if v.AwsAccountId == nil {
4500		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4501	}
4502	if v.AssignmentName == nil {
4503		invalidParams.Add(smithy.NewErrParamRequired("AssignmentName"))
4504	}
4505	if v.Namespace == nil {
4506		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4507	}
4508	if invalidParams.Len() > 0 {
4509		return invalidParams
4510	} else {
4511		return nil
4512	}
4513}
4514
4515func validateOpDeleteNamespaceInput(v *DeleteNamespaceInput) error {
4516	if v == nil {
4517		return nil
4518	}
4519	invalidParams := smithy.InvalidParamsError{Context: "DeleteNamespaceInput"}
4520	if v.AwsAccountId == nil {
4521		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4522	}
4523	if v.Namespace == nil {
4524		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4525	}
4526	if invalidParams.Len() > 0 {
4527		return invalidParams
4528	} else {
4529		return nil
4530	}
4531}
4532
4533func validateOpDeleteTemplateAliasInput(v *DeleteTemplateAliasInput) error {
4534	if v == nil {
4535		return nil
4536	}
4537	invalidParams := smithy.InvalidParamsError{Context: "DeleteTemplateAliasInput"}
4538	if v.AwsAccountId == nil {
4539		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4540	}
4541	if v.TemplateId == nil {
4542		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
4543	}
4544	if v.AliasName == nil {
4545		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
4546	}
4547	if invalidParams.Len() > 0 {
4548		return invalidParams
4549	} else {
4550		return nil
4551	}
4552}
4553
4554func validateOpDeleteTemplateInput(v *DeleteTemplateInput) error {
4555	if v == nil {
4556		return nil
4557	}
4558	invalidParams := smithy.InvalidParamsError{Context: "DeleteTemplateInput"}
4559	if v.AwsAccountId == nil {
4560		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4561	}
4562	if v.TemplateId == nil {
4563		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
4564	}
4565	if invalidParams.Len() > 0 {
4566		return invalidParams
4567	} else {
4568		return nil
4569	}
4570}
4571
4572func validateOpDeleteThemeAliasInput(v *DeleteThemeAliasInput) error {
4573	if v == nil {
4574		return nil
4575	}
4576	invalidParams := smithy.InvalidParamsError{Context: "DeleteThemeAliasInput"}
4577	if v.AwsAccountId == nil {
4578		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4579	}
4580	if v.ThemeId == nil {
4581		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
4582	}
4583	if v.AliasName == nil {
4584		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
4585	}
4586	if invalidParams.Len() > 0 {
4587		return invalidParams
4588	} else {
4589		return nil
4590	}
4591}
4592
4593func validateOpDeleteThemeInput(v *DeleteThemeInput) error {
4594	if v == nil {
4595		return nil
4596	}
4597	invalidParams := smithy.InvalidParamsError{Context: "DeleteThemeInput"}
4598	if v.AwsAccountId == nil {
4599		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4600	}
4601	if v.ThemeId == nil {
4602		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
4603	}
4604	if invalidParams.Len() > 0 {
4605		return invalidParams
4606	} else {
4607		return nil
4608	}
4609}
4610
4611func validateOpDeleteUserByPrincipalIdInput(v *DeleteUserByPrincipalIdInput) error {
4612	if v == nil {
4613		return nil
4614	}
4615	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserByPrincipalIdInput"}
4616	if v.PrincipalId == nil {
4617		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
4618	}
4619	if v.AwsAccountId == nil {
4620		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4621	}
4622	if v.Namespace == nil {
4623		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4624	}
4625	if invalidParams.Len() > 0 {
4626		return invalidParams
4627	} else {
4628		return nil
4629	}
4630}
4631
4632func validateOpDeleteUserInput(v *DeleteUserInput) error {
4633	if v == nil {
4634		return nil
4635	}
4636	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"}
4637	if v.UserName == nil {
4638		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
4639	}
4640	if v.AwsAccountId == nil {
4641		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4642	}
4643	if v.Namespace == nil {
4644		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4645	}
4646	if invalidParams.Len() > 0 {
4647		return invalidParams
4648	} else {
4649		return nil
4650	}
4651}
4652
4653func validateOpDescribeAccountCustomizationInput(v *DescribeAccountCustomizationInput) error {
4654	if v == nil {
4655		return nil
4656	}
4657	invalidParams := smithy.InvalidParamsError{Context: "DescribeAccountCustomizationInput"}
4658	if v.AwsAccountId == nil {
4659		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4660	}
4661	if invalidParams.Len() > 0 {
4662		return invalidParams
4663	} else {
4664		return nil
4665	}
4666}
4667
4668func validateOpDescribeAccountSettingsInput(v *DescribeAccountSettingsInput) error {
4669	if v == nil {
4670		return nil
4671	}
4672	invalidParams := smithy.InvalidParamsError{Context: "DescribeAccountSettingsInput"}
4673	if v.AwsAccountId == nil {
4674		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4675	}
4676	if invalidParams.Len() > 0 {
4677		return invalidParams
4678	} else {
4679		return nil
4680	}
4681}
4682
4683func validateOpDescribeAnalysisInput(v *DescribeAnalysisInput) error {
4684	if v == nil {
4685		return nil
4686	}
4687	invalidParams := smithy.InvalidParamsError{Context: "DescribeAnalysisInput"}
4688	if v.AwsAccountId == nil {
4689		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4690	}
4691	if v.AnalysisId == nil {
4692		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
4693	}
4694	if invalidParams.Len() > 0 {
4695		return invalidParams
4696	} else {
4697		return nil
4698	}
4699}
4700
4701func validateOpDescribeAnalysisPermissionsInput(v *DescribeAnalysisPermissionsInput) error {
4702	if v == nil {
4703		return nil
4704	}
4705	invalidParams := smithy.InvalidParamsError{Context: "DescribeAnalysisPermissionsInput"}
4706	if v.AwsAccountId == nil {
4707		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4708	}
4709	if v.AnalysisId == nil {
4710		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
4711	}
4712	if invalidParams.Len() > 0 {
4713		return invalidParams
4714	} else {
4715		return nil
4716	}
4717}
4718
4719func validateOpDescribeDashboardInput(v *DescribeDashboardInput) error {
4720	if v == nil {
4721		return nil
4722	}
4723	invalidParams := smithy.InvalidParamsError{Context: "DescribeDashboardInput"}
4724	if v.AwsAccountId == nil {
4725		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4726	}
4727	if v.DashboardId == nil {
4728		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
4729	}
4730	if invalidParams.Len() > 0 {
4731		return invalidParams
4732	} else {
4733		return nil
4734	}
4735}
4736
4737func validateOpDescribeDashboardPermissionsInput(v *DescribeDashboardPermissionsInput) error {
4738	if v == nil {
4739		return nil
4740	}
4741	invalidParams := smithy.InvalidParamsError{Context: "DescribeDashboardPermissionsInput"}
4742	if v.AwsAccountId == nil {
4743		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4744	}
4745	if v.DashboardId == nil {
4746		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
4747	}
4748	if invalidParams.Len() > 0 {
4749		return invalidParams
4750	} else {
4751		return nil
4752	}
4753}
4754
4755func validateOpDescribeDataSetInput(v *DescribeDataSetInput) error {
4756	if v == nil {
4757		return nil
4758	}
4759	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataSetInput"}
4760	if v.AwsAccountId == nil {
4761		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4762	}
4763	if v.DataSetId == nil {
4764		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
4765	}
4766	if invalidParams.Len() > 0 {
4767		return invalidParams
4768	} else {
4769		return nil
4770	}
4771}
4772
4773func validateOpDescribeDataSetPermissionsInput(v *DescribeDataSetPermissionsInput) error {
4774	if v == nil {
4775		return nil
4776	}
4777	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataSetPermissionsInput"}
4778	if v.AwsAccountId == nil {
4779		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4780	}
4781	if v.DataSetId == nil {
4782		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
4783	}
4784	if invalidParams.Len() > 0 {
4785		return invalidParams
4786	} else {
4787		return nil
4788	}
4789}
4790
4791func validateOpDescribeDataSourceInput(v *DescribeDataSourceInput) error {
4792	if v == nil {
4793		return nil
4794	}
4795	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataSourceInput"}
4796	if v.AwsAccountId == nil {
4797		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4798	}
4799	if v.DataSourceId == nil {
4800		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
4801	}
4802	if invalidParams.Len() > 0 {
4803		return invalidParams
4804	} else {
4805		return nil
4806	}
4807}
4808
4809func validateOpDescribeDataSourcePermissionsInput(v *DescribeDataSourcePermissionsInput) error {
4810	if v == nil {
4811		return nil
4812	}
4813	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataSourcePermissionsInput"}
4814	if v.AwsAccountId == nil {
4815		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4816	}
4817	if v.DataSourceId == nil {
4818		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
4819	}
4820	if invalidParams.Len() > 0 {
4821		return invalidParams
4822	} else {
4823		return nil
4824	}
4825}
4826
4827func validateOpDescribeGroupInput(v *DescribeGroupInput) error {
4828	if v == nil {
4829		return nil
4830	}
4831	invalidParams := smithy.InvalidParamsError{Context: "DescribeGroupInput"}
4832	if v.GroupName == nil {
4833		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
4834	}
4835	if v.AwsAccountId == nil {
4836		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4837	}
4838	if v.Namespace == nil {
4839		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4840	}
4841	if invalidParams.Len() > 0 {
4842		return invalidParams
4843	} else {
4844		return nil
4845	}
4846}
4847
4848func validateOpDescribeIAMPolicyAssignmentInput(v *DescribeIAMPolicyAssignmentInput) error {
4849	if v == nil {
4850		return nil
4851	}
4852	invalidParams := smithy.InvalidParamsError{Context: "DescribeIAMPolicyAssignmentInput"}
4853	if v.AwsAccountId == nil {
4854		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4855	}
4856	if v.AssignmentName == nil {
4857		invalidParams.Add(smithy.NewErrParamRequired("AssignmentName"))
4858	}
4859	if v.Namespace == nil {
4860		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4861	}
4862	if invalidParams.Len() > 0 {
4863		return invalidParams
4864	} else {
4865		return nil
4866	}
4867}
4868
4869func validateOpDescribeIngestionInput(v *DescribeIngestionInput) error {
4870	if v == nil {
4871		return nil
4872	}
4873	invalidParams := smithy.InvalidParamsError{Context: "DescribeIngestionInput"}
4874	if v.AwsAccountId == nil {
4875		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4876	}
4877	if v.DataSetId == nil {
4878		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
4879	}
4880	if v.IngestionId == nil {
4881		invalidParams.Add(smithy.NewErrParamRequired("IngestionId"))
4882	}
4883	if invalidParams.Len() > 0 {
4884		return invalidParams
4885	} else {
4886		return nil
4887	}
4888}
4889
4890func validateOpDescribeNamespaceInput(v *DescribeNamespaceInput) error {
4891	if v == nil {
4892		return nil
4893	}
4894	invalidParams := smithy.InvalidParamsError{Context: "DescribeNamespaceInput"}
4895	if v.AwsAccountId == nil {
4896		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4897	}
4898	if v.Namespace == nil {
4899		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
4900	}
4901	if invalidParams.Len() > 0 {
4902		return invalidParams
4903	} else {
4904		return nil
4905	}
4906}
4907
4908func validateOpDescribeTemplateAliasInput(v *DescribeTemplateAliasInput) error {
4909	if v == nil {
4910		return nil
4911	}
4912	invalidParams := smithy.InvalidParamsError{Context: "DescribeTemplateAliasInput"}
4913	if v.AwsAccountId == nil {
4914		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4915	}
4916	if v.TemplateId == nil {
4917		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
4918	}
4919	if v.AliasName == nil {
4920		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
4921	}
4922	if invalidParams.Len() > 0 {
4923		return invalidParams
4924	} else {
4925		return nil
4926	}
4927}
4928
4929func validateOpDescribeTemplateInput(v *DescribeTemplateInput) error {
4930	if v == nil {
4931		return nil
4932	}
4933	invalidParams := smithy.InvalidParamsError{Context: "DescribeTemplateInput"}
4934	if v.AwsAccountId == nil {
4935		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4936	}
4937	if v.TemplateId == nil {
4938		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
4939	}
4940	if invalidParams.Len() > 0 {
4941		return invalidParams
4942	} else {
4943		return nil
4944	}
4945}
4946
4947func validateOpDescribeTemplatePermissionsInput(v *DescribeTemplatePermissionsInput) error {
4948	if v == nil {
4949		return nil
4950	}
4951	invalidParams := smithy.InvalidParamsError{Context: "DescribeTemplatePermissionsInput"}
4952	if v.AwsAccountId == nil {
4953		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4954	}
4955	if v.TemplateId == nil {
4956		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
4957	}
4958	if invalidParams.Len() > 0 {
4959		return invalidParams
4960	} else {
4961		return nil
4962	}
4963}
4964
4965func validateOpDescribeThemeAliasInput(v *DescribeThemeAliasInput) error {
4966	if v == nil {
4967		return nil
4968	}
4969	invalidParams := smithy.InvalidParamsError{Context: "DescribeThemeAliasInput"}
4970	if v.AwsAccountId == nil {
4971		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4972	}
4973	if v.ThemeId == nil {
4974		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
4975	}
4976	if v.AliasName == nil {
4977		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
4978	}
4979	if invalidParams.Len() > 0 {
4980		return invalidParams
4981	} else {
4982		return nil
4983	}
4984}
4985
4986func validateOpDescribeThemeInput(v *DescribeThemeInput) error {
4987	if v == nil {
4988		return nil
4989	}
4990	invalidParams := smithy.InvalidParamsError{Context: "DescribeThemeInput"}
4991	if v.AwsAccountId == nil {
4992		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
4993	}
4994	if v.ThemeId == nil {
4995		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
4996	}
4997	if invalidParams.Len() > 0 {
4998		return invalidParams
4999	} else {
5000		return nil
5001	}
5002}
5003
5004func validateOpDescribeThemePermissionsInput(v *DescribeThemePermissionsInput) error {
5005	if v == nil {
5006		return nil
5007	}
5008	invalidParams := smithy.InvalidParamsError{Context: "DescribeThemePermissionsInput"}
5009	if v.AwsAccountId == nil {
5010		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5011	}
5012	if v.ThemeId == nil {
5013		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
5014	}
5015	if invalidParams.Len() > 0 {
5016		return invalidParams
5017	} else {
5018		return nil
5019	}
5020}
5021
5022func validateOpDescribeUserInput(v *DescribeUserInput) error {
5023	if v == nil {
5024		return nil
5025	}
5026	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserInput"}
5027	if v.UserName == nil {
5028		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
5029	}
5030	if v.AwsAccountId == nil {
5031		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5032	}
5033	if v.Namespace == nil {
5034		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
5035	}
5036	if invalidParams.Len() > 0 {
5037		return invalidParams
5038	} else {
5039		return nil
5040	}
5041}
5042
5043func validateOpGetDashboardEmbedUrlInput(v *GetDashboardEmbedUrlInput) error {
5044	if v == nil {
5045		return nil
5046	}
5047	invalidParams := smithy.InvalidParamsError{Context: "GetDashboardEmbedUrlInput"}
5048	if v.AwsAccountId == nil {
5049		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5050	}
5051	if v.DashboardId == nil {
5052		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
5053	}
5054	if len(v.IdentityType) == 0 {
5055		invalidParams.Add(smithy.NewErrParamRequired("IdentityType"))
5056	}
5057	if invalidParams.Len() > 0 {
5058		return invalidParams
5059	} else {
5060		return nil
5061	}
5062}
5063
5064func validateOpGetSessionEmbedUrlInput(v *GetSessionEmbedUrlInput) error {
5065	if v == nil {
5066		return nil
5067	}
5068	invalidParams := smithy.InvalidParamsError{Context: "GetSessionEmbedUrlInput"}
5069	if v.AwsAccountId == nil {
5070		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5071	}
5072	if invalidParams.Len() > 0 {
5073		return invalidParams
5074	} else {
5075		return nil
5076	}
5077}
5078
5079func validateOpListAnalysesInput(v *ListAnalysesInput) error {
5080	if v == nil {
5081		return nil
5082	}
5083	invalidParams := smithy.InvalidParamsError{Context: "ListAnalysesInput"}
5084	if v.AwsAccountId == nil {
5085		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5086	}
5087	if invalidParams.Len() > 0 {
5088		return invalidParams
5089	} else {
5090		return nil
5091	}
5092}
5093
5094func validateOpListDashboardsInput(v *ListDashboardsInput) error {
5095	if v == nil {
5096		return nil
5097	}
5098	invalidParams := smithy.InvalidParamsError{Context: "ListDashboardsInput"}
5099	if v.AwsAccountId == nil {
5100		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5101	}
5102	if invalidParams.Len() > 0 {
5103		return invalidParams
5104	} else {
5105		return nil
5106	}
5107}
5108
5109func validateOpListDashboardVersionsInput(v *ListDashboardVersionsInput) error {
5110	if v == nil {
5111		return nil
5112	}
5113	invalidParams := smithy.InvalidParamsError{Context: "ListDashboardVersionsInput"}
5114	if v.AwsAccountId == nil {
5115		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5116	}
5117	if v.DashboardId == nil {
5118		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
5119	}
5120	if invalidParams.Len() > 0 {
5121		return invalidParams
5122	} else {
5123		return nil
5124	}
5125}
5126
5127func validateOpListDataSetsInput(v *ListDataSetsInput) error {
5128	if v == nil {
5129		return nil
5130	}
5131	invalidParams := smithy.InvalidParamsError{Context: "ListDataSetsInput"}
5132	if v.AwsAccountId == nil {
5133		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5134	}
5135	if invalidParams.Len() > 0 {
5136		return invalidParams
5137	} else {
5138		return nil
5139	}
5140}
5141
5142func validateOpListDataSourcesInput(v *ListDataSourcesInput) error {
5143	if v == nil {
5144		return nil
5145	}
5146	invalidParams := smithy.InvalidParamsError{Context: "ListDataSourcesInput"}
5147	if v.AwsAccountId == nil {
5148		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5149	}
5150	if invalidParams.Len() > 0 {
5151		return invalidParams
5152	} else {
5153		return nil
5154	}
5155}
5156
5157func validateOpListGroupMembershipsInput(v *ListGroupMembershipsInput) error {
5158	if v == nil {
5159		return nil
5160	}
5161	invalidParams := smithy.InvalidParamsError{Context: "ListGroupMembershipsInput"}
5162	if v.GroupName == nil {
5163		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
5164	}
5165	if v.AwsAccountId == nil {
5166		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5167	}
5168	if v.Namespace == nil {
5169		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
5170	}
5171	if invalidParams.Len() > 0 {
5172		return invalidParams
5173	} else {
5174		return nil
5175	}
5176}
5177
5178func validateOpListGroupsInput(v *ListGroupsInput) error {
5179	if v == nil {
5180		return nil
5181	}
5182	invalidParams := smithy.InvalidParamsError{Context: "ListGroupsInput"}
5183	if v.AwsAccountId == nil {
5184		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5185	}
5186	if v.Namespace == nil {
5187		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
5188	}
5189	if invalidParams.Len() > 0 {
5190		return invalidParams
5191	} else {
5192		return nil
5193	}
5194}
5195
5196func validateOpListIAMPolicyAssignmentsForUserInput(v *ListIAMPolicyAssignmentsForUserInput) error {
5197	if v == nil {
5198		return nil
5199	}
5200	invalidParams := smithy.InvalidParamsError{Context: "ListIAMPolicyAssignmentsForUserInput"}
5201	if v.AwsAccountId == nil {
5202		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5203	}
5204	if v.UserName == nil {
5205		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
5206	}
5207	if v.Namespace == nil {
5208		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
5209	}
5210	if invalidParams.Len() > 0 {
5211		return invalidParams
5212	} else {
5213		return nil
5214	}
5215}
5216
5217func validateOpListIAMPolicyAssignmentsInput(v *ListIAMPolicyAssignmentsInput) error {
5218	if v == nil {
5219		return nil
5220	}
5221	invalidParams := smithy.InvalidParamsError{Context: "ListIAMPolicyAssignmentsInput"}
5222	if v.AwsAccountId == nil {
5223		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5224	}
5225	if v.Namespace == nil {
5226		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
5227	}
5228	if invalidParams.Len() > 0 {
5229		return invalidParams
5230	} else {
5231		return nil
5232	}
5233}
5234
5235func validateOpListIngestionsInput(v *ListIngestionsInput) error {
5236	if v == nil {
5237		return nil
5238	}
5239	invalidParams := smithy.InvalidParamsError{Context: "ListIngestionsInput"}
5240	if v.DataSetId == nil {
5241		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
5242	}
5243	if v.AwsAccountId == nil {
5244		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5245	}
5246	if invalidParams.Len() > 0 {
5247		return invalidParams
5248	} else {
5249		return nil
5250	}
5251}
5252
5253func validateOpListNamespacesInput(v *ListNamespacesInput) error {
5254	if v == nil {
5255		return nil
5256	}
5257	invalidParams := smithy.InvalidParamsError{Context: "ListNamespacesInput"}
5258	if v.AwsAccountId == nil {
5259		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5260	}
5261	if invalidParams.Len() > 0 {
5262		return invalidParams
5263	} else {
5264		return nil
5265	}
5266}
5267
5268func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
5269	if v == nil {
5270		return nil
5271	}
5272	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
5273	if v.ResourceArn == nil {
5274		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
5275	}
5276	if invalidParams.Len() > 0 {
5277		return invalidParams
5278	} else {
5279		return nil
5280	}
5281}
5282
5283func validateOpListTemplateAliasesInput(v *ListTemplateAliasesInput) error {
5284	if v == nil {
5285		return nil
5286	}
5287	invalidParams := smithy.InvalidParamsError{Context: "ListTemplateAliasesInput"}
5288	if v.AwsAccountId == nil {
5289		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5290	}
5291	if v.TemplateId == nil {
5292		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
5293	}
5294	if invalidParams.Len() > 0 {
5295		return invalidParams
5296	} else {
5297		return nil
5298	}
5299}
5300
5301func validateOpListTemplatesInput(v *ListTemplatesInput) error {
5302	if v == nil {
5303		return nil
5304	}
5305	invalidParams := smithy.InvalidParamsError{Context: "ListTemplatesInput"}
5306	if v.AwsAccountId == nil {
5307		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5308	}
5309	if invalidParams.Len() > 0 {
5310		return invalidParams
5311	} else {
5312		return nil
5313	}
5314}
5315
5316func validateOpListTemplateVersionsInput(v *ListTemplateVersionsInput) error {
5317	if v == nil {
5318		return nil
5319	}
5320	invalidParams := smithy.InvalidParamsError{Context: "ListTemplateVersionsInput"}
5321	if v.AwsAccountId == nil {
5322		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5323	}
5324	if v.TemplateId == nil {
5325		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
5326	}
5327	if invalidParams.Len() > 0 {
5328		return invalidParams
5329	} else {
5330		return nil
5331	}
5332}
5333
5334func validateOpListThemeAliasesInput(v *ListThemeAliasesInput) error {
5335	if v == nil {
5336		return nil
5337	}
5338	invalidParams := smithy.InvalidParamsError{Context: "ListThemeAliasesInput"}
5339	if v.AwsAccountId == nil {
5340		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5341	}
5342	if v.ThemeId == nil {
5343		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
5344	}
5345	if invalidParams.Len() > 0 {
5346		return invalidParams
5347	} else {
5348		return nil
5349	}
5350}
5351
5352func validateOpListThemesInput(v *ListThemesInput) error {
5353	if v == nil {
5354		return nil
5355	}
5356	invalidParams := smithy.InvalidParamsError{Context: "ListThemesInput"}
5357	if v.AwsAccountId == nil {
5358		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5359	}
5360	if invalidParams.Len() > 0 {
5361		return invalidParams
5362	} else {
5363		return nil
5364	}
5365}
5366
5367func validateOpListThemeVersionsInput(v *ListThemeVersionsInput) error {
5368	if v == nil {
5369		return nil
5370	}
5371	invalidParams := smithy.InvalidParamsError{Context: "ListThemeVersionsInput"}
5372	if v.AwsAccountId == nil {
5373		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5374	}
5375	if v.ThemeId == nil {
5376		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
5377	}
5378	if invalidParams.Len() > 0 {
5379		return invalidParams
5380	} else {
5381		return nil
5382	}
5383}
5384
5385func validateOpListUserGroupsInput(v *ListUserGroupsInput) error {
5386	if v == nil {
5387		return nil
5388	}
5389	invalidParams := smithy.InvalidParamsError{Context: "ListUserGroupsInput"}
5390	if v.UserName == nil {
5391		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
5392	}
5393	if v.AwsAccountId == nil {
5394		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5395	}
5396	if v.Namespace == nil {
5397		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
5398	}
5399	if invalidParams.Len() > 0 {
5400		return invalidParams
5401	} else {
5402		return nil
5403	}
5404}
5405
5406func validateOpListUsersInput(v *ListUsersInput) error {
5407	if v == nil {
5408		return nil
5409	}
5410	invalidParams := smithy.InvalidParamsError{Context: "ListUsersInput"}
5411	if v.AwsAccountId == nil {
5412		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5413	}
5414	if v.Namespace == nil {
5415		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
5416	}
5417	if invalidParams.Len() > 0 {
5418		return invalidParams
5419	} else {
5420		return nil
5421	}
5422}
5423
5424func validateOpRegisterUserInput(v *RegisterUserInput) error {
5425	if v == nil {
5426		return nil
5427	}
5428	invalidParams := smithy.InvalidParamsError{Context: "RegisterUserInput"}
5429	if len(v.IdentityType) == 0 {
5430		invalidParams.Add(smithy.NewErrParamRequired("IdentityType"))
5431	}
5432	if v.Email == nil {
5433		invalidParams.Add(smithy.NewErrParamRequired("Email"))
5434	}
5435	if len(v.UserRole) == 0 {
5436		invalidParams.Add(smithy.NewErrParamRequired("UserRole"))
5437	}
5438	if v.AwsAccountId == nil {
5439		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5440	}
5441	if v.Namespace == nil {
5442		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
5443	}
5444	if invalidParams.Len() > 0 {
5445		return invalidParams
5446	} else {
5447		return nil
5448	}
5449}
5450
5451func validateOpRestoreAnalysisInput(v *RestoreAnalysisInput) error {
5452	if v == nil {
5453		return nil
5454	}
5455	invalidParams := smithy.InvalidParamsError{Context: "RestoreAnalysisInput"}
5456	if v.AwsAccountId == nil {
5457		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5458	}
5459	if v.AnalysisId == nil {
5460		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
5461	}
5462	if invalidParams.Len() > 0 {
5463		return invalidParams
5464	} else {
5465		return nil
5466	}
5467}
5468
5469func validateOpSearchAnalysesInput(v *SearchAnalysesInput) error {
5470	if v == nil {
5471		return nil
5472	}
5473	invalidParams := smithy.InvalidParamsError{Context: "SearchAnalysesInput"}
5474	if v.AwsAccountId == nil {
5475		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5476	}
5477	if v.Filters == nil {
5478		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
5479	}
5480	if invalidParams.Len() > 0 {
5481		return invalidParams
5482	} else {
5483		return nil
5484	}
5485}
5486
5487func validateOpSearchDashboardsInput(v *SearchDashboardsInput) error {
5488	if v == nil {
5489		return nil
5490	}
5491	invalidParams := smithy.InvalidParamsError{Context: "SearchDashboardsInput"}
5492	if v.AwsAccountId == nil {
5493		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5494	}
5495	if v.Filters == nil {
5496		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
5497	} else if v.Filters != nil {
5498		if err := validateDashboardSearchFilterList(v.Filters); err != nil {
5499			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
5500		}
5501	}
5502	if invalidParams.Len() > 0 {
5503		return invalidParams
5504	} else {
5505		return nil
5506	}
5507}
5508
5509func validateOpTagResourceInput(v *TagResourceInput) error {
5510	if v == nil {
5511		return nil
5512	}
5513	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
5514	if v.ResourceArn == nil {
5515		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
5516	}
5517	if v.Tags == nil {
5518		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
5519	} else if v.Tags != nil {
5520		if err := validateTagList(v.Tags); err != nil {
5521			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
5522		}
5523	}
5524	if invalidParams.Len() > 0 {
5525		return invalidParams
5526	} else {
5527		return nil
5528	}
5529}
5530
5531func validateOpUntagResourceInput(v *UntagResourceInput) error {
5532	if v == nil {
5533		return nil
5534	}
5535	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
5536	if v.ResourceArn == nil {
5537		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
5538	}
5539	if v.TagKeys == nil {
5540		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
5541	}
5542	if invalidParams.Len() > 0 {
5543		return invalidParams
5544	} else {
5545		return nil
5546	}
5547}
5548
5549func validateOpUpdateAccountCustomizationInput(v *UpdateAccountCustomizationInput) error {
5550	if v == nil {
5551		return nil
5552	}
5553	invalidParams := smithy.InvalidParamsError{Context: "UpdateAccountCustomizationInput"}
5554	if v.AwsAccountId == nil {
5555		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5556	}
5557	if v.AccountCustomization == nil {
5558		invalidParams.Add(smithy.NewErrParamRequired("AccountCustomization"))
5559	}
5560	if invalidParams.Len() > 0 {
5561		return invalidParams
5562	} else {
5563		return nil
5564	}
5565}
5566
5567func validateOpUpdateAccountSettingsInput(v *UpdateAccountSettingsInput) error {
5568	if v == nil {
5569		return nil
5570	}
5571	invalidParams := smithy.InvalidParamsError{Context: "UpdateAccountSettingsInput"}
5572	if v.AwsAccountId == nil {
5573		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5574	}
5575	if v.DefaultNamespace == nil {
5576		invalidParams.Add(smithy.NewErrParamRequired("DefaultNamespace"))
5577	}
5578	if invalidParams.Len() > 0 {
5579		return invalidParams
5580	} else {
5581		return nil
5582	}
5583}
5584
5585func validateOpUpdateAnalysisInput(v *UpdateAnalysisInput) error {
5586	if v == nil {
5587		return nil
5588	}
5589	invalidParams := smithy.InvalidParamsError{Context: "UpdateAnalysisInput"}
5590	if v.AwsAccountId == nil {
5591		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5592	}
5593	if v.AnalysisId == nil {
5594		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
5595	}
5596	if v.Name == nil {
5597		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5598	}
5599	if v.Parameters != nil {
5600		if err := validateParameters(v.Parameters); err != nil {
5601			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
5602		}
5603	}
5604	if v.SourceEntity == nil {
5605		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
5606	} else if v.SourceEntity != nil {
5607		if err := validateAnalysisSourceEntity(v.SourceEntity); err != nil {
5608			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
5609		}
5610	}
5611	if invalidParams.Len() > 0 {
5612		return invalidParams
5613	} else {
5614		return nil
5615	}
5616}
5617
5618func validateOpUpdateAnalysisPermissionsInput(v *UpdateAnalysisPermissionsInput) error {
5619	if v == nil {
5620		return nil
5621	}
5622	invalidParams := smithy.InvalidParamsError{Context: "UpdateAnalysisPermissionsInput"}
5623	if v.AwsAccountId == nil {
5624		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5625	}
5626	if v.AnalysisId == nil {
5627		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
5628	}
5629	if v.GrantPermissions != nil {
5630		if err := validateUpdateResourcePermissionList(v.GrantPermissions); err != nil {
5631			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
5632		}
5633	}
5634	if v.RevokePermissions != nil {
5635		if err := validateUpdateResourcePermissionList(v.RevokePermissions); err != nil {
5636			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
5637		}
5638	}
5639	if invalidParams.Len() > 0 {
5640		return invalidParams
5641	} else {
5642		return nil
5643	}
5644}
5645
5646func validateOpUpdateDashboardInput(v *UpdateDashboardInput) error {
5647	if v == nil {
5648		return nil
5649	}
5650	invalidParams := smithy.InvalidParamsError{Context: "UpdateDashboardInput"}
5651	if v.AwsAccountId == nil {
5652		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5653	}
5654	if v.DashboardId == nil {
5655		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
5656	}
5657	if v.Name == nil {
5658		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5659	}
5660	if v.SourceEntity == nil {
5661		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
5662	} else if v.SourceEntity != nil {
5663		if err := validateDashboardSourceEntity(v.SourceEntity); err != nil {
5664			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
5665		}
5666	}
5667	if v.Parameters != nil {
5668		if err := validateParameters(v.Parameters); err != nil {
5669			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
5670		}
5671	}
5672	if invalidParams.Len() > 0 {
5673		return invalidParams
5674	} else {
5675		return nil
5676	}
5677}
5678
5679func validateOpUpdateDashboardPermissionsInput(v *UpdateDashboardPermissionsInput) error {
5680	if v == nil {
5681		return nil
5682	}
5683	invalidParams := smithy.InvalidParamsError{Context: "UpdateDashboardPermissionsInput"}
5684	if v.AwsAccountId == nil {
5685		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5686	}
5687	if v.DashboardId == nil {
5688		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
5689	}
5690	if v.GrantPermissions != nil {
5691		if err := validateUpdateResourcePermissionList(v.GrantPermissions); err != nil {
5692			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
5693		}
5694	}
5695	if v.RevokePermissions != nil {
5696		if err := validateUpdateResourcePermissionList(v.RevokePermissions); err != nil {
5697			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
5698		}
5699	}
5700	if invalidParams.Len() > 0 {
5701		return invalidParams
5702	} else {
5703		return nil
5704	}
5705}
5706
5707func validateOpUpdateDashboardPublishedVersionInput(v *UpdateDashboardPublishedVersionInput) error {
5708	if v == nil {
5709		return nil
5710	}
5711	invalidParams := smithy.InvalidParamsError{Context: "UpdateDashboardPublishedVersionInput"}
5712	if v.AwsAccountId == nil {
5713		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5714	}
5715	if v.DashboardId == nil {
5716		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
5717	}
5718	if v.VersionNumber == nil {
5719		invalidParams.Add(smithy.NewErrParamRequired("VersionNumber"))
5720	}
5721	if invalidParams.Len() > 0 {
5722		return invalidParams
5723	} else {
5724		return nil
5725	}
5726}
5727
5728func validateOpUpdateDataSetInput(v *UpdateDataSetInput) error {
5729	if v == nil {
5730		return nil
5731	}
5732	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSetInput"}
5733	if v.AwsAccountId == nil {
5734		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5735	}
5736	if v.DataSetId == nil {
5737		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
5738	}
5739	if v.Name == nil {
5740		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5741	}
5742	if v.PhysicalTableMap == nil {
5743		invalidParams.Add(smithy.NewErrParamRequired("PhysicalTableMap"))
5744	} else if v.PhysicalTableMap != nil {
5745		if err := validatePhysicalTableMap(v.PhysicalTableMap); err != nil {
5746			invalidParams.AddNested("PhysicalTableMap", err.(smithy.InvalidParamsError))
5747		}
5748	}
5749	if v.LogicalTableMap != nil {
5750		if err := validateLogicalTableMap(v.LogicalTableMap); err != nil {
5751			invalidParams.AddNested("LogicalTableMap", err.(smithy.InvalidParamsError))
5752		}
5753	}
5754	if len(v.ImportMode) == 0 {
5755		invalidParams.Add(smithy.NewErrParamRequired("ImportMode"))
5756	}
5757	if v.ColumnGroups != nil {
5758		if err := validateColumnGroupList(v.ColumnGroups); err != nil {
5759			invalidParams.AddNested("ColumnGroups", err.(smithy.InvalidParamsError))
5760		}
5761	}
5762	if v.RowLevelPermissionDataSet != nil {
5763		if err := validateRowLevelPermissionDataSet(v.RowLevelPermissionDataSet); err != nil {
5764			invalidParams.AddNested("RowLevelPermissionDataSet", err.(smithy.InvalidParamsError))
5765		}
5766	}
5767	if invalidParams.Len() > 0 {
5768		return invalidParams
5769	} else {
5770		return nil
5771	}
5772}
5773
5774func validateOpUpdateDataSetPermissionsInput(v *UpdateDataSetPermissionsInput) error {
5775	if v == nil {
5776		return nil
5777	}
5778	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSetPermissionsInput"}
5779	if v.AwsAccountId == nil {
5780		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5781	}
5782	if v.DataSetId == nil {
5783		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
5784	}
5785	if v.GrantPermissions != nil {
5786		if err := validateResourcePermissionList(v.GrantPermissions); err != nil {
5787			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
5788		}
5789	}
5790	if v.RevokePermissions != nil {
5791		if err := validateResourcePermissionList(v.RevokePermissions); err != nil {
5792			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
5793		}
5794	}
5795	if invalidParams.Len() > 0 {
5796		return invalidParams
5797	} else {
5798		return nil
5799	}
5800}
5801
5802func validateOpUpdateDataSourceInput(v *UpdateDataSourceInput) error {
5803	if v == nil {
5804		return nil
5805	}
5806	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSourceInput"}
5807	if v.AwsAccountId == nil {
5808		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5809	}
5810	if v.DataSourceId == nil {
5811		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
5812	}
5813	if v.Name == nil {
5814		invalidParams.Add(smithy.NewErrParamRequired("Name"))
5815	}
5816	if v.DataSourceParameters != nil {
5817		if err := validateDataSourceParameters(v.DataSourceParameters); err != nil {
5818			invalidParams.AddNested("DataSourceParameters", err.(smithy.InvalidParamsError))
5819		}
5820	}
5821	if v.Credentials != nil {
5822		if err := validateDataSourceCredentials(v.Credentials); err != nil {
5823			invalidParams.AddNested("Credentials", err.(smithy.InvalidParamsError))
5824		}
5825	}
5826	if v.VpcConnectionProperties != nil {
5827		if err := validateVpcConnectionProperties(v.VpcConnectionProperties); err != nil {
5828			invalidParams.AddNested("VpcConnectionProperties", err.(smithy.InvalidParamsError))
5829		}
5830	}
5831	if invalidParams.Len() > 0 {
5832		return invalidParams
5833	} else {
5834		return nil
5835	}
5836}
5837
5838func validateOpUpdateDataSourcePermissionsInput(v *UpdateDataSourcePermissionsInput) error {
5839	if v == nil {
5840		return nil
5841	}
5842	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSourcePermissionsInput"}
5843	if v.AwsAccountId == nil {
5844		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5845	}
5846	if v.DataSourceId == nil {
5847		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
5848	}
5849	if v.GrantPermissions != nil {
5850		if err := validateResourcePermissionList(v.GrantPermissions); err != nil {
5851			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
5852		}
5853	}
5854	if v.RevokePermissions != nil {
5855		if err := validateResourcePermissionList(v.RevokePermissions); err != nil {
5856			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
5857		}
5858	}
5859	if invalidParams.Len() > 0 {
5860		return invalidParams
5861	} else {
5862		return nil
5863	}
5864}
5865
5866func validateOpUpdateGroupInput(v *UpdateGroupInput) error {
5867	if v == nil {
5868		return nil
5869	}
5870	invalidParams := smithy.InvalidParamsError{Context: "UpdateGroupInput"}
5871	if v.GroupName == nil {
5872		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
5873	}
5874	if v.AwsAccountId == nil {
5875		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5876	}
5877	if v.Namespace == nil {
5878		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
5879	}
5880	if invalidParams.Len() > 0 {
5881		return invalidParams
5882	} else {
5883		return nil
5884	}
5885}
5886
5887func validateOpUpdateIAMPolicyAssignmentInput(v *UpdateIAMPolicyAssignmentInput) error {
5888	if v == nil {
5889		return nil
5890	}
5891	invalidParams := smithy.InvalidParamsError{Context: "UpdateIAMPolicyAssignmentInput"}
5892	if v.AwsAccountId == nil {
5893		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5894	}
5895	if v.AssignmentName == nil {
5896		invalidParams.Add(smithy.NewErrParamRequired("AssignmentName"))
5897	}
5898	if v.Namespace == nil {
5899		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
5900	}
5901	if invalidParams.Len() > 0 {
5902		return invalidParams
5903	} else {
5904		return nil
5905	}
5906}
5907
5908func validateOpUpdateTemplateAliasInput(v *UpdateTemplateAliasInput) error {
5909	if v == nil {
5910		return nil
5911	}
5912	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplateAliasInput"}
5913	if v.AwsAccountId == nil {
5914		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5915	}
5916	if v.TemplateId == nil {
5917		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
5918	}
5919	if v.AliasName == nil {
5920		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
5921	}
5922	if v.TemplateVersionNumber == nil {
5923		invalidParams.Add(smithy.NewErrParamRequired("TemplateVersionNumber"))
5924	}
5925	if invalidParams.Len() > 0 {
5926		return invalidParams
5927	} else {
5928		return nil
5929	}
5930}
5931
5932func validateOpUpdateTemplateInput(v *UpdateTemplateInput) error {
5933	if v == nil {
5934		return nil
5935	}
5936	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplateInput"}
5937	if v.AwsAccountId == nil {
5938		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5939	}
5940	if v.TemplateId == nil {
5941		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
5942	}
5943	if v.SourceEntity == nil {
5944		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
5945	} else if v.SourceEntity != nil {
5946		if err := validateTemplateSourceEntity(v.SourceEntity); err != nil {
5947			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
5948		}
5949	}
5950	if invalidParams.Len() > 0 {
5951		return invalidParams
5952	} else {
5953		return nil
5954	}
5955}
5956
5957func validateOpUpdateTemplatePermissionsInput(v *UpdateTemplatePermissionsInput) error {
5958	if v == nil {
5959		return nil
5960	}
5961	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplatePermissionsInput"}
5962	if v.AwsAccountId == nil {
5963		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5964	}
5965	if v.TemplateId == nil {
5966		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
5967	}
5968	if v.GrantPermissions != nil {
5969		if err := validateUpdateResourcePermissionList(v.GrantPermissions); err != nil {
5970			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
5971		}
5972	}
5973	if v.RevokePermissions != nil {
5974		if err := validateUpdateResourcePermissionList(v.RevokePermissions); err != nil {
5975			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
5976		}
5977	}
5978	if invalidParams.Len() > 0 {
5979		return invalidParams
5980	} else {
5981		return nil
5982	}
5983}
5984
5985func validateOpUpdateThemeAliasInput(v *UpdateThemeAliasInput) error {
5986	if v == nil {
5987		return nil
5988	}
5989	invalidParams := smithy.InvalidParamsError{Context: "UpdateThemeAliasInput"}
5990	if v.AwsAccountId == nil {
5991		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
5992	}
5993	if v.ThemeId == nil {
5994		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
5995	}
5996	if v.AliasName == nil {
5997		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
5998	}
5999	if v.ThemeVersionNumber == nil {
6000		invalidParams.Add(smithy.NewErrParamRequired("ThemeVersionNumber"))
6001	}
6002	if invalidParams.Len() > 0 {
6003		return invalidParams
6004	} else {
6005		return nil
6006	}
6007}
6008
6009func validateOpUpdateThemeInput(v *UpdateThemeInput) error {
6010	if v == nil {
6011		return nil
6012	}
6013	invalidParams := smithy.InvalidParamsError{Context: "UpdateThemeInput"}
6014	if v.AwsAccountId == nil {
6015		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
6016	}
6017	if v.ThemeId == nil {
6018		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
6019	}
6020	if v.BaseThemeId == nil {
6021		invalidParams.Add(smithy.NewErrParamRequired("BaseThemeId"))
6022	}
6023	if invalidParams.Len() > 0 {
6024		return invalidParams
6025	} else {
6026		return nil
6027	}
6028}
6029
6030func validateOpUpdateThemePermissionsInput(v *UpdateThemePermissionsInput) error {
6031	if v == nil {
6032		return nil
6033	}
6034	invalidParams := smithy.InvalidParamsError{Context: "UpdateThemePermissionsInput"}
6035	if v.AwsAccountId == nil {
6036		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
6037	}
6038	if v.ThemeId == nil {
6039		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
6040	}
6041	if v.GrantPermissions != nil {
6042		if err := validateUpdateResourcePermissionList(v.GrantPermissions); err != nil {
6043			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
6044		}
6045	}
6046	if v.RevokePermissions != nil {
6047		if err := validateUpdateResourcePermissionList(v.RevokePermissions); err != nil {
6048			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
6049		}
6050	}
6051	if invalidParams.Len() > 0 {
6052		return invalidParams
6053	} else {
6054		return nil
6055	}
6056}
6057
6058func validateOpUpdateUserInput(v *UpdateUserInput) error {
6059	if v == nil {
6060		return nil
6061	}
6062	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserInput"}
6063	if v.UserName == nil {
6064		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
6065	}
6066	if v.AwsAccountId == nil {
6067		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
6068	}
6069	if v.Namespace == nil {
6070		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
6071	}
6072	if v.Email == nil {
6073		invalidParams.Add(smithy.NewErrParamRequired("Email"))
6074	}
6075	if len(v.Role) == 0 {
6076		invalidParams.Add(smithy.NewErrParamRequired("Role"))
6077	}
6078	if invalidParams.Len() > 0 {
6079		return invalidParams
6080	} else {
6081		return nil
6082	}
6083}
6084