1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package lexmodelsv2
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/lexmodelsv2/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpBuildBotLocale struct {
14}
15
16func (*validateOpBuildBotLocale) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpBuildBotLocale) 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.(*BuildBotLocaleInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpBuildBotLocaleInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateBotAlias struct {
34}
35
36func (*validateOpCreateBotAlias) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateBotAlias) 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.(*CreateBotAliasInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateBotAliasInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateBot struct {
54}
55
56func (*validateOpCreateBot) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateBot) 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.(*CreateBotInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateBotInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateBotLocale struct {
74}
75
76func (*validateOpCreateBotLocale) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateBotLocale) 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.(*CreateBotLocaleInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateBotLocaleInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateBotVersion struct {
94}
95
96func (*validateOpCreateBotVersion) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateBotVersion) 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.(*CreateBotVersionInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateBotVersionInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateIntent struct {
114}
115
116func (*validateOpCreateIntent) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateIntent) 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.(*CreateIntentInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateIntentInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateSlot struct {
134}
135
136func (*validateOpCreateSlot) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateSlot) 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.(*CreateSlotInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateSlotInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateSlotType struct {
154}
155
156func (*validateOpCreateSlotType) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateSlotType) 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.(*CreateSlotTypeInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateSlotTypeInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteBotAlias struct {
174}
175
176func (*validateOpDeleteBotAlias) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteBotAlias) 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.(*DeleteBotAliasInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteBotAliasInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteBot struct {
194}
195
196func (*validateOpDeleteBot) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteBot) 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.(*DeleteBotInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteBotInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDeleteBotLocale struct {
214}
215
216func (*validateOpDeleteBotLocale) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDeleteBotLocale) 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.(*DeleteBotLocaleInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDeleteBotLocaleInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteBotVersion struct {
234}
235
236func (*validateOpDeleteBotVersion) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteBotVersion) 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.(*DeleteBotVersionInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteBotVersionInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteIntent struct {
254}
255
256func (*validateOpDeleteIntent) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteIntent) 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.(*DeleteIntentInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteIntentInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDeleteSlot struct {
274}
275
276func (*validateOpDeleteSlot) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDeleteSlot) 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.(*DeleteSlotInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDeleteSlotInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDeleteSlotType struct {
294}
295
296func (*validateOpDeleteSlotType) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDeleteSlotType) 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.(*DeleteSlotTypeInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDeleteSlotTypeInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDescribeBotAlias struct {
314}
315
316func (*validateOpDescribeBotAlias) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDescribeBotAlias) 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.(*DescribeBotAliasInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDescribeBotAliasInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDescribeBot struct {
334}
335
336func (*validateOpDescribeBot) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDescribeBot) 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.(*DescribeBotInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDescribeBotInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDescribeBotLocale struct {
354}
355
356func (*validateOpDescribeBotLocale) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDescribeBotLocale) 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.(*DescribeBotLocaleInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDescribeBotLocaleInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDescribeBotVersion struct {
374}
375
376func (*validateOpDescribeBotVersion) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDescribeBotVersion) 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.(*DescribeBotVersionInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDescribeBotVersionInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDescribeIntent struct {
394}
395
396func (*validateOpDescribeIntent) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDescribeIntent) 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.(*DescribeIntentInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDescribeIntentInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDescribeSlot struct {
414}
415
416func (*validateOpDescribeSlot) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDescribeSlot) 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.(*DescribeSlotInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDescribeSlotInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDescribeSlotType struct {
434}
435
436func (*validateOpDescribeSlotType) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDescribeSlotType) 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.(*DescribeSlotTypeInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDescribeSlotTypeInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpListBotAliases struct {
454}
455
456func (*validateOpListBotAliases) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpListBotAliases) 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.(*ListBotAliasesInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpListBotAliasesInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpListBotLocales struct {
474}
475
476func (*validateOpListBotLocales) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpListBotLocales) 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.(*ListBotLocalesInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpListBotLocalesInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpListBots struct {
494}
495
496func (*validateOpListBots) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpListBots) 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.(*ListBotsInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpListBotsInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpListBotVersions struct {
514}
515
516func (*validateOpListBotVersions) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpListBotVersions) 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.(*ListBotVersionsInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpListBotVersionsInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpListBuiltInIntents struct {
534}
535
536func (*validateOpListBuiltInIntents) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpListBuiltInIntents) 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.(*ListBuiltInIntentsInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpListBuiltInIntentsInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpListBuiltInSlotTypes struct {
554}
555
556func (*validateOpListBuiltInSlotTypes) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpListBuiltInSlotTypes) 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.(*ListBuiltInSlotTypesInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpListBuiltInSlotTypesInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpListIntents struct {
574}
575
576func (*validateOpListIntents) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpListIntents) 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.(*ListIntentsInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpListIntentsInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpListSlots struct {
594}
595
596func (*validateOpListSlots) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpListSlots) 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.(*ListSlotsInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpListSlotsInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpListSlotTypes struct {
614}
615
616func (*validateOpListSlotTypes) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpListSlotTypes) 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.(*ListSlotTypesInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpListSlotTypesInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpListTagsForResource struct {
634}
635
636func (*validateOpListTagsForResource) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpListTagsForResourceInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpTagResource struct {
654}
655
656func (*validateOpTagResource) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpTagResource) 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.(*TagResourceInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpTagResourceInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpUntagResource struct {
674}
675
676func (*validateOpUntagResource) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpUntagResource) 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.(*UntagResourceInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpUntagResourceInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpUpdateBotAlias struct {
694}
695
696func (*validateOpUpdateBotAlias) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpUpdateBotAlias) 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.(*UpdateBotAliasInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpUpdateBotAliasInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpUpdateBot struct {
714}
715
716func (*validateOpUpdateBot) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpUpdateBot) 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.(*UpdateBotInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpUpdateBotInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpUpdateBotLocale struct {
734}
735
736func (*validateOpUpdateBotLocale) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpUpdateBotLocale) 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.(*UpdateBotLocaleInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpUpdateBotLocaleInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpUpdateIntent struct {
754}
755
756func (*validateOpUpdateIntent) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpUpdateIntent) 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.(*UpdateIntentInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpUpdateIntentInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpUpdateSlot struct {
774}
775
776func (*validateOpUpdateSlot) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpUpdateSlot) 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.(*UpdateSlotInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpUpdateSlotInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpUpdateSlotType struct {
794}
795
796func (*validateOpUpdateSlotType) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpUpdateSlotType) 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.(*UpdateSlotTypeInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpUpdateSlotTypeInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813func addOpBuildBotLocaleValidationMiddleware(stack *middleware.Stack) error {
814	return stack.Initialize.Add(&validateOpBuildBotLocale{}, middleware.After)
815}
816
817func addOpCreateBotAliasValidationMiddleware(stack *middleware.Stack) error {
818	return stack.Initialize.Add(&validateOpCreateBotAlias{}, middleware.After)
819}
820
821func addOpCreateBotValidationMiddleware(stack *middleware.Stack) error {
822	return stack.Initialize.Add(&validateOpCreateBot{}, middleware.After)
823}
824
825func addOpCreateBotLocaleValidationMiddleware(stack *middleware.Stack) error {
826	return stack.Initialize.Add(&validateOpCreateBotLocale{}, middleware.After)
827}
828
829func addOpCreateBotVersionValidationMiddleware(stack *middleware.Stack) error {
830	return stack.Initialize.Add(&validateOpCreateBotVersion{}, middleware.After)
831}
832
833func addOpCreateIntentValidationMiddleware(stack *middleware.Stack) error {
834	return stack.Initialize.Add(&validateOpCreateIntent{}, middleware.After)
835}
836
837func addOpCreateSlotValidationMiddleware(stack *middleware.Stack) error {
838	return stack.Initialize.Add(&validateOpCreateSlot{}, middleware.After)
839}
840
841func addOpCreateSlotTypeValidationMiddleware(stack *middleware.Stack) error {
842	return stack.Initialize.Add(&validateOpCreateSlotType{}, middleware.After)
843}
844
845func addOpDeleteBotAliasValidationMiddleware(stack *middleware.Stack) error {
846	return stack.Initialize.Add(&validateOpDeleteBotAlias{}, middleware.After)
847}
848
849func addOpDeleteBotValidationMiddleware(stack *middleware.Stack) error {
850	return stack.Initialize.Add(&validateOpDeleteBot{}, middleware.After)
851}
852
853func addOpDeleteBotLocaleValidationMiddleware(stack *middleware.Stack) error {
854	return stack.Initialize.Add(&validateOpDeleteBotLocale{}, middleware.After)
855}
856
857func addOpDeleteBotVersionValidationMiddleware(stack *middleware.Stack) error {
858	return stack.Initialize.Add(&validateOpDeleteBotVersion{}, middleware.After)
859}
860
861func addOpDeleteIntentValidationMiddleware(stack *middleware.Stack) error {
862	return stack.Initialize.Add(&validateOpDeleteIntent{}, middleware.After)
863}
864
865func addOpDeleteSlotValidationMiddleware(stack *middleware.Stack) error {
866	return stack.Initialize.Add(&validateOpDeleteSlot{}, middleware.After)
867}
868
869func addOpDeleteSlotTypeValidationMiddleware(stack *middleware.Stack) error {
870	return stack.Initialize.Add(&validateOpDeleteSlotType{}, middleware.After)
871}
872
873func addOpDescribeBotAliasValidationMiddleware(stack *middleware.Stack) error {
874	return stack.Initialize.Add(&validateOpDescribeBotAlias{}, middleware.After)
875}
876
877func addOpDescribeBotValidationMiddleware(stack *middleware.Stack) error {
878	return stack.Initialize.Add(&validateOpDescribeBot{}, middleware.After)
879}
880
881func addOpDescribeBotLocaleValidationMiddleware(stack *middleware.Stack) error {
882	return stack.Initialize.Add(&validateOpDescribeBotLocale{}, middleware.After)
883}
884
885func addOpDescribeBotVersionValidationMiddleware(stack *middleware.Stack) error {
886	return stack.Initialize.Add(&validateOpDescribeBotVersion{}, middleware.After)
887}
888
889func addOpDescribeIntentValidationMiddleware(stack *middleware.Stack) error {
890	return stack.Initialize.Add(&validateOpDescribeIntent{}, middleware.After)
891}
892
893func addOpDescribeSlotValidationMiddleware(stack *middleware.Stack) error {
894	return stack.Initialize.Add(&validateOpDescribeSlot{}, middleware.After)
895}
896
897func addOpDescribeSlotTypeValidationMiddleware(stack *middleware.Stack) error {
898	return stack.Initialize.Add(&validateOpDescribeSlotType{}, middleware.After)
899}
900
901func addOpListBotAliasesValidationMiddleware(stack *middleware.Stack) error {
902	return stack.Initialize.Add(&validateOpListBotAliases{}, middleware.After)
903}
904
905func addOpListBotLocalesValidationMiddleware(stack *middleware.Stack) error {
906	return stack.Initialize.Add(&validateOpListBotLocales{}, middleware.After)
907}
908
909func addOpListBotsValidationMiddleware(stack *middleware.Stack) error {
910	return stack.Initialize.Add(&validateOpListBots{}, middleware.After)
911}
912
913func addOpListBotVersionsValidationMiddleware(stack *middleware.Stack) error {
914	return stack.Initialize.Add(&validateOpListBotVersions{}, middleware.After)
915}
916
917func addOpListBuiltInIntentsValidationMiddleware(stack *middleware.Stack) error {
918	return stack.Initialize.Add(&validateOpListBuiltInIntents{}, middleware.After)
919}
920
921func addOpListBuiltInSlotTypesValidationMiddleware(stack *middleware.Stack) error {
922	return stack.Initialize.Add(&validateOpListBuiltInSlotTypes{}, middleware.After)
923}
924
925func addOpListIntentsValidationMiddleware(stack *middleware.Stack) error {
926	return stack.Initialize.Add(&validateOpListIntents{}, middleware.After)
927}
928
929func addOpListSlotsValidationMiddleware(stack *middleware.Stack) error {
930	return stack.Initialize.Add(&validateOpListSlots{}, middleware.After)
931}
932
933func addOpListSlotTypesValidationMiddleware(stack *middleware.Stack) error {
934	return stack.Initialize.Add(&validateOpListSlotTypes{}, middleware.After)
935}
936
937func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
938	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
939}
940
941func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
942	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
943}
944
945func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
946	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
947}
948
949func addOpUpdateBotAliasValidationMiddleware(stack *middleware.Stack) error {
950	return stack.Initialize.Add(&validateOpUpdateBotAlias{}, middleware.After)
951}
952
953func addOpUpdateBotValidationMiddleware(stack *middleware.Stack) error {
954	return stack.Initialize.Add(&validateOpUpdateBot{}, middleware.After)
955}
956
957func addOpUpdateBotLocaleValidationMiddleware(stack *middleware.Stack) error {
958	return stack.Initialize.Add(&validateOpUpdateBotLocale{}, middleware.After)
959}
960
961func addOpUpdateIntentValidationMiddleware(stack *middleware.Stack) error {
962	return stack.Initialize.Add(&validateOpUpdateIntent{}, middleware.After)
963}
964
965func addOpUpdateSlotValidationMiddleware(stack *middleware.Stack) error {
966	return stack.Initialize.Add(&validateOpUpdateSlot{}, middleware.After)
967}
968
969func addOpUpdateSlotTypeValidationMiddleware(stack *middleware.Stack) error {
970	return stack.Initialize.Add(&validateOpUpdateSlotType{}, middleware.After)
971}
972
973func validateAudioLogDestination(v *types.AudioLogDestination) error {
974	if v == nil {
975		return nil
976	}
977	invalidParams := smithy.InvalidParamsError{Context: "AudioLogDestination"}
978	if v.S3Bucket == nil {
979		invalidParams.Add(smithy.NewErrParamRequired("S3Bucket"))
980	} else if v.S3Bucket != nil {
981		if err := validateS3BucketLogDestination(v.S3Bucket); err != nil {
982			invalidParams.AddNested("S3Bucket", err.(smithy.InvalidParamsError))
983		}
984	}
985	if invalidParams.Len() > 0 {
986		return invalidParams
987	} else {
988		return nil
989	}
990}
991
992func validateAudioLogSetting(v *types.AudioLogSetting) error {
993	if v == nil {
994		return nil
995	}
996	invalidParams := smithy.InvalidParamsError{Context: "AudioLogSetting"}
997	if v.Destination == nil {
998		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
999	} else if v.Destination != nil {
1000		if err := validateAudioLogDestination(v.Destination); err != nil {
1001			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
1002		}
1003	}
1004	if invalidParams.Len() > 0 {
1005		return invalidParams
1006	} else {
1007		return nil
1008	}
1009}
1010
1011func validateAudioLogSettingsList(v []types.AudioLogSetting) error {
1012	if v == nil {
1013		return nil
1014	}
1015	invalidParams := smithy.InvalidParamsError{Context: "AudioLogSettingsList"}
1016	for i := range v {
1017		if err := validateAudioLogSetting(&v[i]); err != nil {
1018			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1019		}
1020	}
1021	if invalidParams.Len() > 0 {
1022		return invalidParams
1023	} else {
1024		return nil
1025	}
1026}
1027
1028func validateBotAliasLocaleSettings(v *types.BotAliasLocaleSettings) error {
1029	if v == nil {
1030		return nil
1031	}
1032	invalidParams := smithy.InvalidParamsError{Context: "BotAliasLocaleSettings"}
1033	if v.CodeHookSpecification != nil {
1034		if err := validateCodeHookSpecification(v.CodeHookSpecification); err != nil {
1035			invalidParams.AddNested("CodeHookSpecification", err.(smithy.InvalidParamsError))
1036		}
1037	}
1038	if invalidParams.Len() > 0 {
1039		return invalidParams
1040	} else {
1041		return nil
1042	}
1043}
1044
1045func validateBotAliasLocaleSettingsMap(v map[string]types.BotAliasLocaleSettings) error {
1046	if v == nil {
1047		return nil
1048	}
1049	invalidParams := smithy.InvalidParamsError{Context: "BotAliasLocaleSettingsMap"}
1050	for key := range v {
1051		value := v[key]
1052		if err := validateBotAliasLocaleSettings(&value); err != nil {
1053			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
1054		}
1055	}
1056	if invalidParams.Len() > 0 {
1057		return invalidParams
1058	} else {
1059		return nil
1060	}
1061}
1062
1063func validateBotFilter(v *types.BotFilter) error {
1064	if v == nil {
1065		return nil
1066	}
1067	invalidParams := smithy.InvalidParamsError{Context: "BotFilter"}
1068	if len(v.Name) == 0 {
1069		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1070	}
1071	if v.Values == nil {
1072		invalidParams.Add(smithy.NewErrParamRequired("Values"))
1073	}
1074	if len(v.Operator) == 0 {
1075		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
1076	}
1077	if invalidParams.Len() > 0 {
1078		return invalidParams
1079	} else {
1080		return nil
1081	}
1082}
1083
1084func validateBotFilters(v []types.BotFilter) error {
1085	if v == nil {
1086		return nil
1087	}
1088	invalidParams := smithy.InvalidParamsError{Context: "BotFilters"}
1089	for i := range v {
1090		if err := validateBotFilter(&v[i]); err != nil {
1091			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1092		}
1093	}
1094	if invalidParams.Len() > 0 {
1095		return invalidParams
1096	} else {
1097		return nil
1098	}
1099}
1100
1101func validateBotLocaleFilter(v *types.BotLocaleFilter) error {
1102	if v == nil {
1103		return nil
1104	}
1105	invalidParams := smithy.InvalidParamsError{Context: "BotLocaleFilter"}
1106	if len(v.Name) == 0 {
1107		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1108	}
1109	if v.Values == nil {
1110		invalidParams.Add(smithy.NewErrParamRequired("Values"))
1111	}
1112	if len(v.Operator) == 0 {
1113		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
1114	}
1115	if invalidParams.Len() > 0 {
1116		return invalidParams
1117	} else {
1118		return nil
1119	}
1120}
1121
1122func validateBotLocaleFilters(v []types.BotLocaleFilter) error {
1123	if v == nil {
1124		return nil
1125	}
1126	invalidParams := smithy.InvalidParamsError{Context: "BotLocaleFilters"}
1127	for i := range v {
1128		if err := validateBotLocaleFilter(&v[i]); err != nil {
1129			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1130		}
1131	}
1132	if invalidParams.Len() > 0 {
1133		return invalidParams
1134	} else {
1135		return nil
1136	}
1137}
1138
1139func validateBotLocaleSortBy(v *types.BotLocaleSortBy) error {
1140	if v == nil {
1141		return nil
1142	}
1143	invalidParams := smithy.InvalidParamsError{Context: "BotLocaleSortBy"}
1144	if len(v.Attribute) == 0 {
1145		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
1146	}
1147	if len(v.Order) == 0 {
1148		invalidParams.Add(smithy.NewErrParamRequired("Order"))
1149	}
1150	if invalidParams.Len() > 0 {
1151		return invalidParams
1152	} else {
1153		return nil
1154	}
1155}
1156
1157func validateBotSortBy(v *types.BotSortBy) error {
1158	if v == nil {
1159		return nil
1160	}
1161	invalidParams := smithy.InvalidParamsError{Context: "BotSortBy"}
1162	if len(v.Attribute) == 0 {
1163		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
1164	}
1165	if len(v.Order) == 0 {
1166		invalidParams.Add(smithy.NewErrParamRequired("Order"))
1167	}
1168	if invalidParams.Len() > 0 {
1169		return invalidParams
1170	} else {
1171		return nil
1172	}
1173}
1174
1175func validateBotVersionLocaleDetails(v *types.BotVersionLocaleDetails) error {
1176	if v == nil {
1177		return nil
1178	}
1179	invalidParams := smithy.InvalidParamsError{Context: "BotVersionLocaleDetails"}
1180	if v.SourceBotVersion == nil {
1181		invalidParams.Add(smithy.NewErrParamRequired("SourceBotVersion"))
1182	}
1183	if invalidParams.Len() > 0 {
1184		return invalidParams
1185	} else {
1186		return nil
1187	}
1188}
1189
1190func validateBotVersionLocaleSpecification(v map[string]types.BotVersionLocaleDetails) error {
1191	if v == nil {
1192		return nil
1193	}
1194	invalidParams := smithy.InvalidParamsError{Context: "BotVersionLocaleSpecification"}
1195	for key := range v {
1196		value := v[key]
1197		if err := validateBotVersionLocaleDetails(&value); err != nil {
1198			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
1199		}
1200	}
1201	if invalidParams.Len() > 0 {
1202		return invalidParams
1203	} else {
1204		return nil
1205	}
1206}
1207
1208func validateBotVersionSortBy(v *types.BotVersionSortBy) error {
1209	if v == nil {
1210		return nil
1211	}
1212	invalidParams := smithy.InvalidParamsError{Context: "BotVersionSortBy"}
1213	if len(v.Attribute) == 0 {
1214		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
1215	}
1216	if len(v.Order) == 0 {
1217		invalidParams.Add(smithy.NewErrParamRequired("Order"))
1218	}
1219	if invalidParams.Len() > 0 {
1220		return invalidParams
1221	} else {
1222		return nil
1223	}
1224}
1225
1226func validateBuiltInIntentSortBy(v *types.BuiltInIntentSortBy) error {
1227	if v == nil {
1228		return nil
1229	}
1230	invalidParams := smithy.InvalidParamsError{Context: "BuiltInIntentSortBy"}
1231	if len(v.Attribute) == 0 {
1232		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
1233	}
1234	if len(v.Order) == 0 {
1235		invalidParams.Add(smithy.NewErrParamRequired("Order"))
1236	}
1237	if invalidParams.Len() > 0 {
1238		return invalidParams
1239	} else {
1240		return nil
1241	}
1242}
1243
1244func validateBuiltInSlotTypeSortBy(v *types.BuiltInSlotTypeSortBy) error {
1245	if v == nil {
1246		return nil
1247	}
1248	invalidParams := smithy.InvalidParamsError{Context: "BuiltInSlotTypeSortBy"}
1249	if len(v.Attribute) == 0 {
1250		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
1251	}
1252	if len(v.Order) == 0 {
1253		invalidParams.Add(smithy.NewErrParamRequired("Order"))
1254	}
1255	if invalidParams.Len() > 0 {
1256		return invalidParams
1257	} else {
1258		return nil
1259	}
1260}
1261
1262func validateButton(v *types.Button) error {
1263	if v == nil {
1264		return nil
1265	}
1266	invalidParams := smithy.InvalidParamsError{Context: "Button"}
1267	if v.Text == nil {
1268		invalidParams.Add(smithy.NewErrParamRequired("Text"))
1269	}
1270	if v.Value == nil {
1271		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1272	}
1273	if invalidParams.Len() > 0 {
1274		return invalidParams
1275	} else {
1276		return nil
1277	}
1278}
1279
1280func validateButtonsList(v []types.Button) error {
1281	if v == nil {
1282		return nil
1283	}
1284	invalidParams := smithy.InvalidParamsError{Context: "ButtonsList"}
1285	for i := range v {
1286		if err := validateButton(&v[i]); err != nil {
1287			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1288		}
1289	}
1290	if invalidParams.Len() > 0 {
1291		return invalidParams
1292	} else {
1293		return nil
1294	}
1295}
1296
1297func validateCloudWatchLogGroupLogDestination(v *types.CloudWatchLogGroupLogDestination) error {
1298	if v == nil {
1299		return nil
1300	}
1301	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLogGroupLogDestination"}
1302	if v.CloudWatchLogGroupArn == nil {
1303		invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogGroupArn"))
1304	}
1305	if v.LogPrefix == nil {
1306		invalidParams.Add(smithy.NewErrParamRequired("LogPrefix"))
1307	}
1308	if invalidParams.Len() > 0 {
1309		return invalidParams
1310	} else {
1311		return nil
1312	}
1313}
1314
1315func validateCodeHookSpecification(v *types.CodeHookSpecification) error {
1316	if v == nil {
1317		return nil
1318	}
1319	invalidParams := smithy.InvalidParamsError{Context: "CodeHookSpecification"}
1320	if v.LambdaCodeHook == nil {
1321		invalidParams.Add(smithy.NewErrParamRequired("LambdaCodeHook"))
1322	} else if v.LambdaCodeHook != nil {
1323		if err := validateLambdaCodeHook(v.LambdaCodeHook); err != nil {
1324			invalidParams.AddNested("LambdaCodeHook", err.(smithy.InvalidParamsError))
1325		}
1326	}
1327	if invalidParams.Len() > 0 {
1328		return invalidParams
1329	} else {
1330		return nil
1331	}
1332}
1333
1334func validateConversationLogSettings(v *types.ConversationLogSettings) error {
1335	if v == nil {
1336		return nil
1337	}
1338	invalidParams := smithy.InvalidParamsError{Context: "ConversationLogSettings"}
1339	if v.TextLogSettings != nil {
1340		if err := validateTextLogSettingsList(v.TextLogSettings); err != nil {
1341			invalidParams.AddNested("TextLogSettings", err.(smithy.InvalidParamsError))
1342		}
1343	}
1344	if v.AudioLogSettings != nil {
1345		if err := validateAudioLogSettingsList(v.AudioLogSettings); err != nil {
1346			invalidParams.AddNested("AudioLogSettings", err.(smithy.InvalidParamsError))
1347		}
1348	}
1349	if invalidParams.Len() > 0 {
1350		return invalidParams
1351	} else {
1352		return nil
1353	}
1354}
1355
1356func validateCustomPayload(v *types.CustomPayload) error {
1357	if v == nil {
1358		return nil
1359	}
1360	invalidParams := smithy.InvalidParamsError{Context: "CustomPayload"}
1361	if v.Value == nil {
1362		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1363	}
1364	if invalidParams.Len() > 0 {
1365		return invalidParams
1366	} else {
1367		return nil
1368	}
1369}
1370
1371func validateDataPrivacy(v *types.DataPrivacy) error {
1372	if v == nil {
1373		return nil
1374	}
1375	invalidParams := smithy.InvalidParamsError{Context: "DataPrivacy"}
1376	if invalidParams.Len() > 0 {
1377		return invalidParams
1378	} else {
1379		return nil
1380	}
1381}
1382
1383func validateDialogCodeHookSettings(v *types.DialogCodeHookSettings) error {
1384	if v == nil {
1385		return nil
1386	}
1387	invalidParams := smithy.InvalidParamsError{Context: "DialogCodeHookSettings"}
1388	if invalidParams.Len() > 0 {
1389		return invalidParams
1390	} else {
1391		return nil
1392	}
1393}
1394
1395func validateFulfillmentCodeHookSettings(v *types.FulfillmentCodeHookSettings) error {
1396	if v == nil {
1397		return nil
1398	}
1399	invalidParams := smithy.InvalidParamsError{Context: "FulfillmentCodeHookSettings"}
1400	if invalidParams.Len() > 0 {
1401		return invalidParams
1402	} else {
1403		return nil
1404	}
1405}
1406
1407func validateImageResponseCard(v *types.ImageResponseCard) error {
1408	if v == nil {
1409		return nil
1410	}
1411	invalidParams := smithy.InvalidParamsError{Context: "ImageResponseCard"}
1412	if v.Title == nil {
1413		invalidParams.Add(smithy.NewErrParamRequired("Title"))
1414	}
1415	if v.Buttons != nil {
1416		if err := validateButtonsList(v.Buttons); err != nil {
1417			invalidParams.AddNested("Buttons", err.(smithy.InvalidParamsError))
1418		}
1419	}
1420	if invalidParams.Len() > 0 {
1421		return invalidParams
1422	} else {
1423		return nil
1424	}
1425}
1426
1427func validateInputContext(v *types.InputContext) error {
1428	if v == nil {
1429		return nil
1430	}
1431	invalidParams := smithy.InvalidParamsError{Context: "InputContext"}
1432	if v.Name == nil {
1433		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1434	}
1435	if invalidParams.Len() > 0 {
1436		return invalidParams
1437	} else {
1438		return nil
1439	}
1440}
1441
1442func validateInputContextsList(v []types.InputContext) error {
1443	if v == nil {
1444		return nil
1445	}
1446	invalidParams := smithy.InvalidParamsError{Context: "InputContextsList"}
1447	for i := range v {
1448		if err := validateInputContext(&v[i]); err != nil {
1449			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1450		}
1451	}
1452	if invalidParams.Len() > 0 {
1453		return invalidParams
1454	} else {
1455		return nil
1456	}
1457}
1458
1459func validateIntentClosingSetting(v *types.IntentClosingSetting) error {
1460	if v == nil {
1461		return nil
1462	}
1463	invalidParams := smithy.InvalidParamsError{Context: "IntentClosingSetting"}
1464	if v.ClosingResponse == nil {
1465		invalidParams.Add(smithy.NewErrParamRequired("ClosingResponse"))
1466	} else if v.ClosingResponse != nil {
1467		if err := validateResponseSpecification(v.ClosingResponse); err != nil {
1468			invalidParams.AddNested("ClosingResponse", err.(smithy.InvalidParamsError))
1469		}
1470	}
1471	if invalidParams.Len() > 0 {
1472		return invalidParams
1473	} else {
1474		return nil
1475	}
1476}
1477
1478func validateIntentConfirmationSetting(v *types.IntentConfirmationSetting) error {
1479	if v == nil {
1480		return nil
1481	}
1482	invalidParams := smithy.InvalidParamsError{Context: "IntentConfirmationSetting"}
1483	if v.PromptSpecification == nil {
1484		invalidParams.Add(smithy.NewErrParamRequired("PromptSpecification"))
1485	} else if v.PromptSpecification != nil {
1486		if err := validatePromptSpecification(v.PromptSpecification); err != nil {
1487			invalidParams.AddNested("PromptSpecification", err.(smithy.InvalidParamsError))
1488		}
1489	}
1490	if v.DeclinationResponse == nil {
1491		invalidParams.Add(smithy.NewErrParamRequired("DeclinationResponse"))
1492	} else if v.DeclinationResponse != nil {
1493		if err := validateResponseSpecification(v.DeclinationResponse); err != nil {
1494			invalidParams.AddNested("DeclinationResponse", err.(smithy.InvalidParamsError))
1495		}
1496	}
1497	if invalidParams.Len() > 0 {
1498		return invalidParams
1499	} else {
1500		return nil
1501	}
1502}
1503
1504func validateIntentFilter(v *types.IntentFilter) error {
1505	if v == nil {
1506		return nil
1507	}
1508	invalidParams := smithy.InvalidParamsError{Context: "IntentFilter"}
1509	if len(v.Name) == 0 {
1510		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1511	}
1512	if v.Values == nil {
1513		invalidParams.Add(smithy.NewErrParamRequired("Values"))
1514	}
1515	if len(v.Operator) == 0 {
1516		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
1517	}
1518	if invalidParams.Len() > 0 {
1519		return invalidParams
1520	} else {
1521		return nil
1522	}
1523}
1524
1525func validateIntentFilters(v []types.IntentFilter) error {
1526	if v == nil {
1527		return nil
1528	}
1529	invalidParams := smithy.InvalidParamsError{Context: "IntentFilters"}
1530	for i := range v {
1531		if err := validateIntentFilter(&v[i]); err != nil {
1532			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1533		}
1534	}
1535	if invalidParams.Len() > 0 {
1536		return invalidParams
1537	} else {
1538		return nil
1539	}
1540}
1541
1542func validateIntentSortBy(v *types.IntentSortBy) error {
1543	if v == nil {
1544		return nil
1545	}
1546	invalidParams := smithy.InvalidParamsError{Context: "IntentSortBy"}
1547	if len(v.Attribute) == 0 {
1548		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
1549	}
1550	if len(v.Order) == 0 {
1551		invalidParams.Add(smithy.NewErrParamRequired("Order"))
1552	}
1553	if invalidParams.Len() > 0 {
1554		return invalidParams
1555	} else {
1556		return nil
1557	}
1558}
1559
1560func validateKendraConfiguration(v *types.KendraConfiguration) error {
1561	if v == nil {
1562		return nil
1563	}
1564	invalidParams := smithy.InvalidParamsError{Context: "KendraConfiguration"}
1565	if v.KendraIndex == nil {
1566		invalidParams.Add(smithy.NewErrParamRequired("KendraIndex"))
1567	}
1568	if invalidParams.Len() > 0 {
1569		return invalidParams
1570	} else {
1571		return nil
1572	}
1573}
1574
1575func validateLambdaCodeHook(v *types.LambdaCodeHook) error {
1576	if v == nil {
1577		return nil
1578	}
1579	invalidParams := smithy.InvalidParamsError{Context: "LambdaCodeHook"}
1580	if v.LambdaARN == nil {
1581		invalidParams.Add(smithy.NewErrParamRequired("LambdaARN"))
1582	}
1583	if v.CodeHookInterfaceVersion == nil {
1584		invalidParams.Add(smithy.NewErrParamRequired("CodeHookInterfaceVersion"))
1585	}
1586	if invalidParams.Len() > 0 {
1587		return invalidParams
1588	} else {
1589		return nil
1590	}
1591}
1592
1593func validateMessage(v *types.Message) error {
1594	if v == nil {
1595		return nil
1596	}
1597	invalidParams := smithy.InvalidParamsError{Context: "Message"}
1598	if v.PlainTextMessage != nil {
1599		if err := validatePlainTextMessage(v.PlainTextMessage); err != nil {
1600			invalidParams.AddNested("PlainTextMessage", err.(smithy.InvalidParamsError))
1601		}
1602	}
1603	if v.CustomPayload != nil {
1604		if err := validateCustomPayload(v.CustomPayload); err != nil {
1605			invalidParams.AddNested("CustomPayload", err.(smithy.InvalidParamsError))
1606		}
1607	}
1608	if v.SsmlMessage != nil {
1609		if err := validateSSMLMessage(v.SsmlMessage); err != nil {
1610			invalidParams.AddNested("SsmlMessage", err.(smithy.InvalidParamsError))
1611		}
1612	}
1613	if v.ImageResponseCard != nil {
1614		if err := validateImageResponseCard(v.ImageResponseCard); err != nil {
1615			invalidParams.AddNested("ImageResponseCard", err.(smithy.InvalidParamsError))
1616		}
1617	}
1618	if invalidParams.Len() > 0 {
1619		return invalidParams
1620	} else {
1621		return nil
1622	}
1623}
1624
1625func validateMessageGroup(v *types.MessageGroup) error {
1626	if v == nil {
1627		return nil
1628	}
1629	invalidParams := smithy.InvalidParamsError{Context: "MessageGroup"}
1630	if v.Message == nil {
1631		invalidParams.Add(smithy.NewErrParamRequired("Message"))
1632	} else if v.Message != nil {
1633		if err := validateMessage(v.Message); err != nil {
1634			invalidParams.AddNested("Message", err.(smithy.InvalidParamsError))
1635		}
1636	}
1637	if v.Variations != nil {
1638		if err := validateMessageVariationsList(v.Variations); err != nil {
1639			invalidParams.AddNested("Variations", err.(smithy.InvalidParamsError))
1640		}
1641	}
1642	if invalidParams.Len() > 0 {
1643		return invalidParams
1644	} else {
1645		return nil
1646	}
1647}
1648
1649func validateMessageGroupsList(v []types.MessageGroup) error {
1650	if v == nil {
1651		return nil
1652	}
1653	invalidParams := smithy.InvalidParamsError{Context: "MessageGroupsList"}
1654	for i := range v {
1655		if err := validateMessageGroup(&v[i]); err != nil {
1656			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1657		}
1658	}
1659	if invalidParams.Len() > 0 {
1660		return invalidParams
1661	} else {
1662		return nil
1663	}
1664}
1665
1666func validateMessageVariationsList(v []types.Message) error {
1667	if v == nil {
1668		return nil
1669	}
1670	invalidParams := smithy.InvalidParamsError{Context: "MessageVariationsList"}
1671	for i := range v {
1672		if err := validateMessage(&v[i]); err != nil {
1673			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1674		}
1675	}
1676	if invalidParams.Len() > 0 {
1677		return invalidParams
1678	} else {
1679		return nil
1680	}
1681}
1682
1683func validateObfuscationSetting(v *types.ObfuscationSetting) error {
1684	if v == nil {
1685		return nil
1686	}
1687	invalidParams := smithy.InvalidParamsError{Context: "ObfuscationSetting"}
1688	if len(v.ObfuscationSettingType) == 0 {
1689		invalidParams.Add(smithy.NewErrParamRequired("ObfuscationSettingType"))
1690	}
1691	if invalidParams.Len() > 0 {
1692		return invalidParams
1693	} else {
1694		return nil
1695	}
1696}
1697
1698func validateOutputContext(v *types.OutputContext) error {
1699	if v == nil {
1700		return nil
1701	}
1702	invalidParams := smithy.InvalidParamsError{Context: "OutputContext"}
1703	if v.Name == nil {
1704		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1705	}
1706	if v.TimeToLiveInSeconds == nil {
1707		invalidParams.Add(smithy.NewErrParamRequired("TimeToLiveInSeconds"))
1708	}
1709	if v.TurnsToLive == nil {
1710		invalidParams.Add(smithy.NewErrParamRequired("TurnsToLive"))
1711	}
1712	if invalidParams.Len() > 0 {
1713		return invalidParams
1714	} else {
1715		return nil
1716	}
1717}
1718
1719func validateOutputContextsList(v []types.OutputContext) error {
1720	if v == nil {
1721		return nil
1722	}
1723	invalidParams := smithy.InvalidParamsError{Context: "OutputContextsList"}
1724	for i := range v {
1725		if err := validateOutputContext(&v[i]); err != nil {
1726			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1727		}
1728	}
1729	if invalidParams.Len() > 0 {
1730		return invalidParams
1731	} else {
1732		return nil
1733	}
1734}
1735
1736func validatePlainTextMessage(v *types.PlainTextMessage) error {
1737	if v == nil {
1738		return nil
1739	}
1740	invalidParams := smithy.InvalidParamsError{Context: "PlainTextMessage"}
1741	if v.Value == nil {
1742		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1743	}
1744	if invalidParams.Len() > 0 {
1745		return invalidParams
1746	} else {
1747		return nil
1748	}
1749}
1750
1751func validatePromptSpecification(v *types.PromptSpecification) error {
1752	if v == nil {
1753		return nil
1754	}
1755	invalidParams := smithy.InvalidParamsError{Context: "PromptSpecification"}
1756	if v.MessageGroups == nil {
1757		invalidParams.Add(smithy.NewErrParamRequired("MessageGroups"))
1758	} else if v.MessageGroups != nil {
1759		if err := validateMessageGroupsList(v.MessageGroups); err != nil {
1760			invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError))
1761		}
1762	}
1763	if v.MaxRetries == nil {
1764		invalidParams.Add(smithy.NewErrParamRequired("MaxRetries"))
1765	}
1766	if invalidParams.Len() > 0 {
1767		return invalidParams
1768	} else {
1769		return nil
1770	}
1771}
1772
1773func validateResponseSpecification(v *types.ResponseSpecification) error {
1774	if v == nil {
1775		return nil
1776	}
1777	invalidParams := smithy.InvalidParamsError{Context: "ResponseSpecification"}
1778	if v.MessageGroups == nil {
1779		invalidParams.Add(smithy.NewErrParamRequired("MessageGroups"))
1780	} else if v.MessageGroups != nil {
1781		if err := validateMessageGroupsList(v.MessageGroups); err != nil {
1782			invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError))
1783		}
1784	}
1785	if invalidParams.Len() > 0 {
1786		return invalidParams
1787	} else {
1788		return nil
1789	}
1790}
1791
1792func validateS3BucketLogDestination(v *types.S3BucketLogDestination) error {
1793	if v == nil {
1794		return nil
1795	}
1796	invalidParams := smithy.InvalidParamsError{Context: "S3BucketLogDestination"}
1797	if v.S3BucketArn == nil {
1798		invalidParams.Add(smithy.NewErrParamRequired("S3BucketArn"))
1799	}
1800	if v.LogPrefix == nil {
1801		invalidParams.Add(smithy.NewErrParamRequired("LogPrefix"))
1802	}
1803	if invalidParams.Len() > 0 {
1804		return invalidParams
1805	} else {
1806		return nil
1807	}
1808}
1809
1810func validateSampleUtterance(v *types.SampleUtterance) error {
1811	if v == nil {
1812		return nil
1813	}
1814	invalidParams := smithy.InvalidParamsError{Context: "SampleUtterance"}
1815	if v.Utterance == nil {
1816		invalidParams.Add(smithy.NewErrParamRequired("Utterance"))
1817	}
1818	if invalidParams.Len() > 0 {
1819		return invalidParams
1820	} else {
1821		return nil
1822	}
1823}
1824
1825func validateSampleUtterancesList(v []types.SampleUtterance) error {
1826	if v == nil {
1827		return nil
1828	}
1829	invalidParams := smithy.InvalidParamsError{Context: "SampleUtterancesList"}
1830	for i := range v {
1831		if err := validateSampleUtterance(&v[i]); err != nil {
1832			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1833		}
1834	}
1835	if invalidParams.Len() > 0 {
1836		return invalidParams
1837	} else {
1838		return nil
1839	}
1840}
1841
1842func validateSampleValue(v *types.SampleValue) error {
1843	if v == nil {
1844		return nil
1845	}
1846	invalidParams := smithy.InvalidParamsError{Context: "SampleValue"}
1847	if v.Value == nil {
1848		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1849	}
1850	if invalidParams.Len() > 0 {
1851		return invalidParams
1852	} else {
1853		return nil
1854	}
1855}
1856
1857func validateSentimentAnalysisSettings(v *types.SentimentAnalysisSettings) error {
1858	if v == nil {
1859		return nil
1860	}
1861	invalidParams := smithy.InvalidParamsError{Context: "SentimentAnalysisSettings"}
1862	if invalidParams.Len() > 0 {
1863		return invalidParams
1864	} else {
1865		return nil
1866	}
1867}
1868
1869func validateSlotDefaultValue(v *types.SlotDefaultValue) error {
1870	if v == nil {
1871		return nil
1872	}
1873	invalidParams := smithy.InvalidParamsError{Context: "SlotDefaultValue"}
1874	if v.DefaultValue == nil {
1875		invalidParams.Add(smithy.NewErrParamRequired("DefaultValue"))
1876	}
1877	if invalidParams.Len() > 0 {
1878		return invalidParams
1879	} else {
1880		return nil
1881	}
1882}
1883
1884func validateSlotDefaultValueList(v []types.SlotDefaultValue) error {
1885	if v == nil {
1886		return nil
1887	}
1888	invalidParams := smithy.InvalidParamsError{Context: "SlotDefaultValueList"}
1889	for i := range v {
1890		if err := validateSlotDefaultValue(&v[i]); err != nil {
1891			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1892		}
1893	}
1894	if invalidParams.Len() > 0 {
1895		return invalidParams
1896	} else {
1897		return nil
1898	}
1899}
1900
1901func validateSlotDefaultValueSpecification(v *types.SlotDefaultValueSpecification) error {
1902	if v == nil {
1903		return nil
1904	}
1905	invalidParams := smithy.InvalidParamsError{Context: "SlotDefaultValueSpecification"}
1906	if v.DefaultValueList == nil {
1907		invalidParams.Add(smithy.NewErrParamRequired("DefaultValueList"))
1908	} else if v.DefaultValueList != nil {
1909		if err := validateSlotDefaultValueList(v.DefaultValueList); err != nil {
1910			invalidParams.AddNested("DefaultValueList", err.(smithy.InvalidParamsError))
1911		}
1912	}
1913	if invalidParams.Len() > 0 {
1914		return invalidParams
1915	} else {
1916		return nil
1917	}
1918}
1919
1920func validateSlotFilter(v *types.SlotFilter) error {
1921	if v == nil {
1922		return nil
1923	}
1924	invalidParams := smithy.InvalidParamsError{Context: "SlotFilter"}
1925	if len(v.Name) == 0 {
1926		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1927	}
1928	if v.Values == nil {
1929		invalidParams.Add(smithy.NewErrParamRequired("Values"))
1930	}
1931	if len(v.Operator) == 0 {
1932		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
1933	}
1934	if invalidParams.Len() > 0 {
1935		return invalidParams
1936	} else {
1937		return nil
1938	}
1939}
1940
1941func validateSlotFilters(v []types.SlotFilter) error {
1942	if v == nil {
1943		return nil
1944	}
1945	invalidParams := smithy.InvalidParamsError{Context: "SlotFilters"}
1946	for i := range v {
1947		if err := validateSlotFilter(&v[i]); err != nil {
1948			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1949		}
1950	}
1951	if invalidParams.Len() > 0 {
1952		return invalidParams
1953	} else {
1954		return nil
1955	}
1956}
1957
1958func validateSlotPrioritiesList(v []types.SlotPriority) error {
1959	if v == nil {
1960		return nil
1961	}
1962	invalidParams := smithy.InvalidParamsError{Context: "SlotPrioritiesList"}
1963	for i := range v {
1964		if err := validateSlotPriority(&v[i]); err != nil {
1965			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1966		}
1967	}
1968	if invalidParams.Len() > 0 {
1969		return invalidParams
1970	} else {
1971		return nil
1972	}
1973}
1974
1975func validateSlotPriority(v *types.SlotPriority) error {
1976	if v == nil {
1977		return nil
1978	}
1979	invalidParams := smithy.InvalidParamsError{Context: "SlotPriority"}
1980	if v.Priority == nil {
1981		invalidParams.Add(smithy.NewErrParamRequired("Priority"))
1982	}
1983	if v.SlotId == nil {
1984		invalidParams.Add(smithy.NewErrParamRequired("SlotId"))
1985	}
1986	if invalidParams.Len() > 0 {
1987		return invalidParams
1988	} else {
1989		return nil
1990	}
1991}
1992
1993func validateSlotSortBy(v *types.SlotSortBy) error {
1994	if v == nil {
1995		return nil
1996	}
1997	invalidParams := smithy.InvalidParamsError{Context: "SlotSortBy"}
1998	if len(v.Attribute) == 0 {
1999		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
2000	}
2001	if len(v.Order) == 0 {
2002		invalidParams.Add(smithy.NewErrParamRequired("Order"))
2003	}
2004	if invalidParams.Len() > 0 {
2005		return invalidParams
2006	} else {
2007		return nil
2008	}
2009}
2010
2011func validateSlotTypeFilter(v *types.SlotTypeFilter) error {
2012	if v == nil {
2013		return nil
2014	}
2015	invalidParams := smithy.InvalidParamsError{Context: "SlotTypeFilter"}
2016	if len(v.Name) == 0 {
2017		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2018	}
2019	if v.Values == nil {
2020		invalidParams.Add(smithy.NewErrParamRequired("Values"))
2021	}
2022	if len(v.Operator) == 0 {
2023		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
2024	}
2025	if invalidParams.Len() > 0 {
2026		return invalidParams
2027	} else {
2028		return nil
2029	}
2030}
2031
2032func validateSlotTypeFilters(v []types.SlotTypeFilter) error {
2033	if v == nil {
2034		return nil
2035	}
2036	invalidParams := smithy.InvalidParamsError{Context: "SlotTypeFilters"}
2037	for i := range v {
2038		if err := validateSlotTypeFilter(&v[i]); err != nil {
2039			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2040		}
2041	}
2042	if invalidParams.Len() > 0 {
2043		return invalidParams
2044	} else {
2045		return nil
2046	}
2047}
2048
2049func validateSlotTypeSortBy(v *types.SlotTypeSortBy) error {
2050	if v == nil {
2051		return nil
2052	}
2053	invalidParams := smithy.InvalidParamsError{Context: "SlotTypeSortBy"}
2054	if len(v.Attribute) == 0 {
2055		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
2056	}
2057	if len(v.Order) == 0 {
2058		invalidParams.Add(smithy.NewErrParamRequired("Order"))
2059	}
2060	if invalidParams.Len() > 0 {
2061		return invalidParams
2062	} else {
2063		return nil
2064	}
2065}
2066
2067func validateSlotTypeValue(v *types.SlotTypeValue) error {
2068	if v == nil {
2069		return nil
2070	}
2071	invalidParams := smithy.InvalidParamsError{Context: "SlotTypeValue"}
2072	if v.SampleValue != nil {
2073		if err := validateSampleValue(v.SampleValue); err != nil {
2074			invalidParams.AddNested("SampleValue", err.(smithy.InvalidParamsError))
2075		}
2076	}
2077	if v.Synonyms != nil {
2078		if err := validateSynonymList(v.Synonyms); err != nil {
2079			invalidParams.AddNested("Synonyms", err.(smithy.InvalidParamsError))
2080		}
2081	}
2082	if invalidParams.Len() > 0 {
2083		return invalidParams
2084	} else {
2085		return nil
2086	}
2087}
2088
2089func validateSlotTypeValues(v []types.SlotTypeValue) error {
2090	if v == nil {
2091		return nil
2092	}
2093	invalidParams := smithy.InvalidParamsError{Context: "SlotTypeValues"}
2094	for i := range v {
2095		if err := validateSlotTypeValue(&v[i]); err != nil {
2096			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2097		}
2098	}
2099	if invalidParams.Len() > 0 {
2100		return invalidParams
2101	} else {
2102		return nil
2103	}
2104}
2105
2106func validateSlotValueElicitationSetting(v *types.SlotValueElicitationSetting) error {
2107	if v == nil {
2108		return nil
2109	}
2110	invalidParams := smithy.InvalidParamsError{Context: "SlotValueElicitationSetting"}
2111	if v.DefaultValueSpecification != nil {
2112		if err := validateSlotDefaultValueSpecification(v.DefaultValueSpecification); err != nil {
2113			invalidParams.AddNested("DefaultValueSpecification", err.(smithy.InvalidParamsError))
2114		}
2115	}
2116	if len(v.SlotConstraint) == 0 {
2117		invalidParams.Add(smithy.NewErrParamRequired("SlotConstraint"))
2118	}
2119	if v.PromptSpecification != nil {
2120		if err := validatePromptSpecification(v.PromptSpecification); err != nil {
2121			invalidParams.AddNested("PromptSpecification", err.(smithy.InvalidParamsError))
2122		}
2123	}
2124	if v.SampleUtterances != nil {
2125		if err := validateSampleUtterancesList(v.SampleUtterances); err != nil {
2126			invalidParams.AddNested("SampleUtterances", err.(smithy.InvalidParamsError))
2127		}
2128	}
2129	if v.WaitAndContinueSpecification != nil {
2130		if err := validateWaitAndContinueSpecification(v.WaitAndContinueSpecification); err != nil {
2131			invalidParams.AddNested("WaitAndContinueSpecification", err.(smithy.InvalidParamsError))
2132		}
2133	}
2134	if invalidParams.Len() > 0 {
2135		return invalidParams
2136	} else {
2137		return nil
2138	}
2139}
2140
2141func validateSlotValueRegexFilter(v *types.SlotValueRegexFilter) error {
2142	if v == nil {
2143		return nil
2144	}
2145	invalidParams := smithy.InvalidParamsError{Context: "SlotValueRegexFilter"}
2146	if v.Pattern == nil {
2147		invalidParams.Add(smithy.NewErrParamRequired("Pattern"))
2148	}
2149	if invalidParams.Len() > 0 {
2150		return invalidParams
2151	} else {
2152		return nil
2153	}
2154}
2155
2156func validateSlotValueSelectionSetting(v *types.SlotValueSelectionSetting) error {
2157	if v == nil {
2158		return nil
2159	}
2160	invalidParams := smithy.InvalidParamsError{Context: "SlotValueSelectionSetting"}
2161	if len(v.ResolutionStrategy) == 0 {
2162		invalidParams.Add(smithy.NewErrParamRequired("ResolutionStrategy"))
2163	}
2164	if v.RegexFilter != nil {
2165		if err := validateSlotValueRegexFilter(v.RegexFilter); err != nil {
2166			invalidParams.AddNested("RegexFilter", err.(smithy.InvalidParamsError))
2167		}
2168	}
2169	if invalidParams.Len() > 0 {
2170		return invalidParams
2171	} else {
2172		return nil
2173	}
2174}
2175
2176func validateSSMLMessage(v *types.SSMLMessage) error {
2177	if v == nil {
2178		return nil
2179	}
2180	invalidParams := smithy.InvalidParamsError{Context: "SSMLMessage"}
2181	if v.Value == nil {
2182		invalidParams.Add(smithy.NewErrParamRequired("Value"))
2183	}
2184	if invalidParams.Len() > 0 {
2185		return invalidParams
2186	} else {
2187		return nil
2188	}
2189}
2190
2191func validateStillWaitingResponseSpecification(v *types.StillWaitingResponseSpecification) error {
2192	if v == nil {
2193		return nil
2194	}
2195	invalidParams := smithy.InvalidParamsError{Context: "StillWaitingResponseSpecification"}
2196	if v.MessageGroups == nil {
2197		invalidParams.Add(smithy.NewErrParamRequired("MessageGroups"))
2198	} else if v.MessageGroups != nil {
2199		if err := validateMessageGroupsList(v.MessageGroups); err != nil {
2200			invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError))
2201		}
2202	}
2203	if v.FrequencyInSeconds == nil {
2204		invalidParams.Add(smithy.NewErrParamRequired("FrequencyInSeconds"))
2205	}
2206	if v.TimeoutInSeconds == nil {
2207		invalidParams.Add(smithy.NewErrParamRequired("TimeoutInSeconds"))
2208	}
2209	if invalidParams.Len() > 0 {
2210		return invalidParams
2211	} else {
2212		return nil
2213	}
2214}
2215
2216func validateSynonymList(v []types.SampleValue) error {
2217	if v == nil {
2218		return nil
2219	}
2220	invalidParams := smithy.InvalidParamsError{Context: "SynonymList"}
2221	for i := range v {
2222		if err := validateSampleValue(&v[i]); err != nil {
2223			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2224		}
2225	}
2226	if invalidParams.Len() > 0 {
2227		return invalidParams
2228	} else {
2229		return nil
2230	}
2231}
2232
2233func validateTextLogDestination(v *types.TextLogDestination) error {
2234	if v == nil {
2235		return nil
2236	}
2237	invalidParams := smithy.InvalidParamsError{Context: "TextLogDestination"}
2238	if v.CloudWatch == nil {
2239		invalidParams.Add(smithy.NewErrParamRequired("CloudWatch"))
2240	} else if v.CloudWatch != nil {
2241		if err := validateCloudWatchLogGroupLogDestination(v.CloudWatch); err != nil {
2242			invalidParams.AddNested("CloudWatch", err.(smithy.InvalidParamsError))
2243		}
2244	}
2245	if invalidParams.Len() > 0 {
2246		return invalidParams
2247	} else {
2248		return nil
2249	}
2250}
2251
2252func validateTextLogSetting(v *types.TextLogSetting) error {
2253	if v == nil {
2254		return nil
2255	}
2256	invalidParams := smithy.InvalidParamsError{Context: "TextLogSetting"}
2257	if v.Destination == nil {
2258		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
2259	} else if v.Destination != nil {
2260		if err := validateTextLogDestination(v.Destination); err != nil {
2261			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
2262		}
2263	}
2264	if invalidParams.Len() > 0 {
2265		return invalidParams
2266	} else {
2267		return nil
2268	}
2269}
2270
2271func validateTextLogSettingsList(v []types.TextLogSetting) error {
2272	if v == nil {
2273		return nil
2274	}
2275	invalidParams := smithy.InvalidParamsError{Context: "TextLogSettingsList"}
2276	for i := range v {
2277		if err := validateTextLogSetting(&v[i]); err != nil {
2278			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2279		}
2280	}
2281	if invalidParams.Len() > 0 {
2282		return invalidParams
2283	} else {
2284		return nil
2285	}
2286}
2287
2288func validateVoiceSettings(v *types.VoiceSettings) error {
2289	if v == nil {
2290		return nil
2291	}
2292	invalidParams := smithy.InvalidParamsError{Context: "VoiceSettings"}
2293	if v.VoiceId == nil {
2294		invalidParams.Add(smithy.NewErrParamRequired("VoiceId"))
2295	}
2296	if invalidParams.Len() > 0 {
2297		return invalidParams
2298	} else {
2299		return nil
2300	}
2301}
2302
2303func validateWaitAndContinueSpecification(v *types.WaitAndContinueSpecification) error {
2304	if v == nil {
2305		return nil
2306	}
2307	invalidParams := smithy.InvalidParamsError{Context: "WaitAndContinueSpecification"}
2308	if v.WaitingResponse == nil {
2309		invalidParams.Add(smithy.NewErrParamRequired("WaitingResponse"))
2310	} else if v.WaitingResponse != nil {
2311		if err := validateResponseSpecification(v.WaitingResponse); err != nil {
2312			invalidParams.AddNested("WaitingResponse", err.(smithy.InvalidParamsError))
2313		}
2314	}
2315	if v.ContinueResponse == nil {
2316		invalidParams.Add(smithy.NewErrParamRequired("ContinueResponse"))
2317	} else if v.ContinueResponse != nil {
2318		if err := validateResponseSpecification(v.ContinueResponse); err != nil {
2319			invalidParams.AddNested("ContinueResponse", err.(smithy.InvalidParamsError))
2320		}
2321	}
2322	if v.StillWaitingResponse != nil {
2323		if err := validateStillWaitingResponseSpecification(v.StillWaitingResponse); err != nil {
2324			invalidParams.AddNested("StillWaitingResponse", err.(smithy.InvalidParamsError))
2325		}
2326	}
2327	if invalidParams.Len() > 0 {
2328		return invalidParams
2329	} else {
2330		return nil
2331	}
2332}
2333
2334func validateOpBuildBotLocaleInput(v *BuildBotLocaleInput) error {
2335	if v == nil {
2336		return nil
2337	}
2338	invalidParams := smithy.InvalidParamsError{Context: "BuildBotLocaleInput"}
2339	if v.BotId == nil {
2340		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2341	}
2342	if v.BotVersion == nil {
2343		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2344	}
2345	if v.LocaleId == nil {
2346		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2347	}
2348	if invalidParams.Len() > 0 {
2349		return invalidParams
2350	} else {
2351		return nil
2352	}
2353}
2354
2355func validateOpCreateBotAliasInput(v *CreateBotAliasInput) error {
2356	if v == nil {
2357		return nil
2358	}
2359	invalidParams := smithy.InvalidParamsError{Context: "CreateBotAliasInput"}
2360	if v.BotAliasName == nil {
2361		invalidParams.Add(smithy.NewErrParamRequired("BotAliasName"))
2362	}
2363	if v.BotAliasLocaleSettings != nil {
2364		if err := validateBotAliasLocaleSettingsMap(v.BotAliasLocaleSettings); err != nil {
2365			invalidParams.AddNested("BotAliasLocaleSettings", err.(smithy.InvalidParamsError))
2366		}
2367	}
2368	if v.ConversationLogSettings != nil {
2369		if err := validateConversationLogSettings(v.ConversationLogSettings); err != nil {
2370			invalidParams.AddNested("ConversationLogSettings", err.(smithy.InvalidParamsError))
2371		}
2372	}
2373	if v.SentimentAnalysisSettings != nil {
2374		if err := validateSentimentAnalysisSettings(v.SentimentAnalysisSettings); err != nil {
2375			invalidParams.AddNested("SentimentAnalysisSettings", err.(smithy.InvalidParamsError))
2376		}
2377	}
2378	if v.BotId == nil {
2379		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2380	}
2381	if invalidParams.Len() > 0 {
2382		return invalidParams
2383	} else {
2384		return nil
2385	}
2386}
2387
2388func validateOpCreateBotInput(v *CreateBotInput) error {
2389	if v == nil {
2390		return nil
2391	}
2392	invalidParams := smithy.InvalidParamsError{Context: "CreateBotInput"}
2393	if v.BotName == nil {
2394		invalidParams.Add(smithy.NewErrParamRequired("BotName"))
2395	}
2396	if v.RoleArn == nil {
2397		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
2398	}
2399	if v.DataPrivacy == nil {
2400		invalidParams.Add(smithy.NewErrParamRequired("DataPrivacy"))
2401	} else if v.DataPrivacy != nil {
2402		if err := validateDataPrivacy(v.DataPrivacy); err != nil {
2403			invalidParams.AddNested("DataPrivacy", err.(smithy.InvalidParamsError))
2404		}
2405	}
2406	if v.IdleSessionTTLInSeconds == nil {
2407		invalidParams.Add(smithy.NewErrParamRequired("IdleSessionTTLInSeconds"))
2408	}
2409	if invalidParams.Len() > 0 {
2410		return invalidParams
2411	} else {
2412		return nil
2413	}
2414}
2415
2416func validateOpCreateBotLocaleInput(v *CreateBotLocaleInput) error {
2417	if v == nil {
2418		return nil
2419	}
2420	invalidParams := smithy.InvalidParamsError{Context: "CreateBotLocaleInput"}
2421	if v.BotId == nil {
2422		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2423	}
2424	if v.BotVersion == nil {
2425		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2426	}
2427	if v.LocaleId == nil {
2428		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2429	}
2430	if v.NluIntentConfidenceThreshold == nil {
2431		invalidParams.Add(smithy.NewErrParamRequired("NluIntentConfidenceThreshold"))
2432	}
2433	if v.VoiceSettings != nil {
2434		if err := validateVoiceSettings(v.VoiceSettings); err != nil {
2435			invalidParams.AddNested("VoiceSettings", err.(smithy.InvalidParamsError))
2436		}
2437	}
2438	if invalidParams.Len() > 0 {
2439		return invalidParams
2440	} else {
2441		return nil
2442	}
2443}
2444
2445func validateOpCreateBotVersionInput(v *CreateBotVersionInput) error {
2446	if v == nil {
2447		return nil
2448	}
2449	invalidParams := smithy.InvalidParamsError{Context: "CreateBotVersionInput"}
2450	if v.BotId == nil {
2451		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2452	}
2453	if v.BotVersionLocaleSpecification == nil {
2454		invalidParams.Add(smithy.NewErrParamRequired("BotVersionLocaleSpecification"))
2455	} else if v.BotVersionLocaleSpecification != nil {
2456		if err := validateBotVersionLocaleSpecification(v.BotVersionLocaleSpecification); err != nil {
2457			invalidParams.AddNested("BotVersionLocaleSpecification", err.(smithy.InvalidParamsError))
2458		}
2459	}
2460	if invalidParams.Len() > 0 {
2461		return invalidParams
2462	} else {
2463		return nil
2464	}
2465}
2466
2467func validateOpCreateIntentInput(v *CreateIntentInput) error {
2468	if v == nil {
2469		return nil
2470	}
2471	invalidParams := smithy.InvalidParamsError{Context: "CreateIntentInput"}
2472	if v.IntentName == nil {
2473		invalidParams.Add(smithy.NewErrParamRequired("IntentName"))
2474	}
2475	if v.SampleUtterances != nil {
2476		if err := validateSampleUtterancesList(v.SampleUtterances); err != nil {
2477			invalidParams.AddNested("SampleUtterances", err.(smithy.InvalidParamsError))
2478		}
2479	}
2480	if v.DialogCodeHook != nil {
2481		if err := validateDialogCodeHookSettings(v.DialogCodeHook); err != nil {
2482			invalidParams.AddNested("DialogCodeHook", err.(smithy.InvalidParamsError))
2483		}
2484	}
2485	if v.FulfillmentCodeHook != nil {
2486		if err := validateFulfillmentCodeHookSettings(v.FulfillmentCodeHook); err != nil {
2487			invalidParams.AddNested("FulfillmentCodeHook", err.(smithy.InvalidParamsError))
2488		}
2489	}
2490	if v.IntentConfirmationSetting != nil {
2491		if err := validateIntentConfirmationSetting(v.IntentConfirmationSetting); err != nil {
2492			invalidParams.AddNested("IntentConfirmationSetting", err.(smithy.InvalidParamsError))
2493		}
2494	}
2495	if v.IntentClosingSetting != nil {
2496		if err := validateIntentClosingSetting(v.IntentClosingSetting); err != nil {
2497			invalidParams.AddNested("IntentClosingSetting", err.(smithy.InvalidParamsError))
2498		}
2499	}
2500	if v.InputContexts != nil {
2501		if err := validateInputContextsList(v.InputContexts); err != nil {
2502			invalidParams.AddNested("InputContexts", err.(smithy.InvalidParamsError))
2503		}
2504	}
2505	if v.OutputContexts != nil {
2506		if err := validateOutputContextsList(v.OutputContexts); err != nil {
2507			invalidParams.AddNested("OutputContexts", err.(smithy.InvalidParamsError))
2508		}
2509	}
2510	if v.KendraConfiguration != nil {
2511		if err := validateKendraConfiguration(v.KendraConfiguration); err != nil {
2512			invalidParams.AddNested("KendraConfiguration", err.(smithy.InvalidParamsError))
2513		}
2514	}
2515	if v.BotId == nil {
2516		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2517	}
2518	if v.BotVersion == nil {
2519		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2520	}
2521	if v.LocaleId == nil {
2522		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2523	}
2524	if invalidParams.Len() > 0 {
2525		return invalidParams
2526	} else {
2527		return nil
2528	}
2529}
2530
2531func validateOpCreateSlotInput(v *CreateSlotInput) error {
2532	if v == nil {
2533		return nil
2534	}
2535	invalidParams := smithy.InvalidParamsError{Context: "CreateSlotInput"}
2536	if v.SlotName == nil {
2537		invalidParams.Add(smithy.NewErrParamRequired("SlotName"))
2538	}
2539	if v.SlotTypeId == nil {
2540		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId"))
2541	}
2542	if v.ValueElicitationSetting == nil {
2543		invalidParams.Add(smithy.NewErrParamRequired("ValueElicitationSetting"))
2544	} else if v.ValueElicitationSetting != nil {
2545		if err := validateSlotValueElicitationSetting(v.ValueElicitationSetting); err != nil {
2546			invalidParams.AddNested("ValueElicitationSetting", err.(smithy.InvalidParamsError))
2547		}
2548	}
2549	if v.ObfuscationSetting != nil {
2550		if err := validateObfuscationSetting(v.ObfuscationSetting); err != nil {
2551			invalidParams.AddNested("ObfuscationSetting", err.(smithy.InvalidParamsError))
2552		}
2553	}
2554	if v.BotId == nil {
2555		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2556	}
2557	if v.BotVersion == nil {
2558		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2559	}
2560	if v.LocaleId == nil {
2561		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2562	}
2563	if v.IntentId == nil {
2564		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
2565	}
2566	if invalidParams.Len() > 0 {
2567		return invalidParams
2568	} else {
2569		return nil
2570	}
2571}
2572
2573func validateOpCreateSlotTypeInput(v *CreateSlotTypeInput) error {
2574	if v == nil {
2575		return nil
2576	}
2577	invalidParams := smithy.InvalidParamsError{Context: "CreateSlotTypeInput"}
2578	if v.SlotTypeName == nil {
2579		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeName"))
2580	}
2581	if v.SlotTypeValues != nil {
2582		if err := validateSlotTypeValues(v.SlotTypeValues); err != nil {
2583			invalidParams.AddNested("SlotTypeValues", err.(smithy.InvalidParamsError))
2584		}
2585	}
2586	if v.ValueSelectionSetting == nil {
2587		invalidParams.Add(smithy.NewErrParamRequired("ValueSelectionSetting"))
2588	} else if v.ValueSelectionSetting != nil {
2589		if err := validateSlotValueSelectionSetting(v.ValueSelectionSetting); err != nil {
2590			invalidParams.AddNested("ValueSelectionSetting", err.(smithy.InvalidParamsError))
2591		}
2592	}
2593	if v.BotId == nil {
2594		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2595	}
2596	if v.BotVersion == nil {
2597		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2598	}
2599	if v.LocaleId == nil {
2600		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2601	}
2602	if invalidParams.Len() > 0 {
2603		return invalidParams
2604	} else {
2605		return nil
2606	}
2607}
2608
2609func validateOpDeleteBotAliasInput(v *DeleteBotAliasInput) error {
2610	if v == nil {
2611		return nil
2612	}
2613	invalidParams := smithy.InvalidParamsError{Context: "DeleteBotAliasInput"}
2614	if v.BotAliasId == nil {
2615		invalidParams.Add(smithy.NewErrParamRequired("BotAliasId"))
2616	}
2617	if v.BotId == nil {
2618		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2619	}
2620	if invalidParams.Len() > 0 {
2621		return invalidParams
2622	} else {
2623		return nil
2624	}
2625}
2626
2627func validateOpDeleteBotInput(v *DeleteBotInput) error {
2628	if v == nil {
2629		return nil
2630	}
2631	invalidParams := smithy.InvalidParamsError{Context: "DeleteBotInput"}
2632	if v.BotId == nil {
2633		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2634	}
2635	if invalidParams.Len() > 0 {
2636		return invalidParams
2637	} else {
2638		return nil
2639	}
2640}
2641
2642func validateOpDeleteBotLocaleInput(v *DeleteBotLocaleInput) error {
2643	if v == nil {
2644		return nil
2645	}
2646	invalidParams := smithy.InvalidParamsError{Context: "DeleteBotLocaleInput"}
2647	if v.BotId == nil {
2648		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2649	}
2650	if v.BotVersion == nil {
2651		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2652	}
2653	if v.LocaleId == nil {
2654		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2655	}
2656	if invalidParams.Len() > 0 {
2657		return invalidParams
2658	} else {
2659		return nil
2660	}
2661}
2662
2663func validateOpDeleteBotVersionInput(v *DeleteBotVersionInput) error {
2664	if v == nil {
2665		return nil
2666	}
2667	invalidParams := smithy.InvalidParamsError{Context: "DeleteBotVersionInput"}
2668	if v.BotId == nil {
2669		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2670	}
2671	if v.BotVersion == nil {
2672		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2673	}
2674	if invalidParams.Len() > 0 {
2675		return invalidParams
2676	} else {
2677		return nil
2678	}
2679}
2680
2681func validateOpDeleteIntentInput(v *DeleteIntentInput) error {
2682	if v == nil {
2683		return nil
2684	}
2685	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntentInput"}
2686	if v.IntentId == nil {
2687		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
2688	}
2689	if v.BotId == nil {
2690		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2691	}
2692	if v.BotVersion == nil {
2693		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2694	}
2695	if v.LocaleId == nil {
2696		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2697	}
2698	if invalidParams.Len() > 0 {
2699		return invalidParams
2700	} else {
2701		return nil
2702	}
2703}
2704
2705func validateOpDeleteSlotInput(v *DeleteSlotInput) error {
2706	if v == nil {
2707		return nil
2708	}
2709	invalidParams := smithy.InvalidParamsError{Context: "DeleteSlotInput"}
2710	if v.SlotId == nil {
2711		invalidParams.Add(smithy.NewErrParamRequired("SlotId"))
2712	}
2713	if v.BotId == nil {
2714		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2715	}
2716	if v.BotVersion == nil {
2717		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2718	}
2719	if v.LocaleId == nil {
2720		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2721	}
2722	if v.IntentId == nil {
2723		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
2724	}
2725	if invalidParams.Len() > 0 {
2726		return invalidParams
2727	} else {
2728		return nil
2729	}
2730}
2731
2732func validateOpDeleteSlotTypeInput(v *DeleteSlotTypeInput) error {
2733	if v == nil {
2734		return nil
2735	}
2736	invalidParams := smithy.InvalidParamsError{Context: "DeleteSlotTypeInput"}
2737	if v.SlotTypeId == nil {
2738		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId"))
2739	}
2740	if v.BotId == nil {
2741		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2742	}
2743	if v.BotVersion == nil {
2744		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2745	}
2746	if v.LocaleId == nil {
2747		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2748	}
2749	if invalidParams.Len() > 0 {
2750		return invalidParams
2751	} else {
2752		return nil
2753	}
2754}
2755
2756func validateOpDescribeBotAliasInput(v *DescribeBotAliasInput) error {
2757	if v == nil {
2758		return nil
2759	}
2760	invalidParams := smithy.InvalidParamsError{Context: "DescribeBotAliasInput"}
2761	if v.BotAliasId == nil {
2762		invalidParams.Add(smithy.NewErrParamRequired("BotAliasId"))
2763	}
2764	if v.BotId == nil {
2765		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2766	}
2767	if invalidParams.Len() > 0 {
2768		return invalidParams
2769	} else {
2770		return nil
2771	}
2772}
2773
2774func validateOpDescribeBotInput(v *DescribeBotInput) error {
2775	if v == nil {
2776		return nil
2777	}
2778	invalidParams := smithy.InvalidParamsError{Context: "DescribeBotInput"}
2779	if v.BotId == nil {
2780		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2781	}
2782	if invalidParams.Len() > 0 {
2783		return invalidParams
2784	} else {
2785		return nil
2786	}
2787}
2788
2789func validateOpDescribeBotLocaleInput(v *DescribeBotLocaleInput) error {
2790	if v == nil {
2791		return nil
2792	}
2793	invalidParams := smithy.InvalidParamsError{Context: "DescribeBotLocaleInput"}
2794	if v.BotId == nil {
2795		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2796	}
2797	if v.BotVersion == nil {
2798		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2799	}
2800	if v.LocaleId == nil {
2801		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2802	}
2803	if invalidParams.Len() > 0 {
2804		return invalidParams
2805	} else {
2806		return nil
2807	}
2808}
2809
2810func validateOpDescribeBotVersionInput(v *DescribeBotVersionInput) error {
2811	if v == nil {
2812		return nil
2813	}
2814	invalidParams := smithy.InvalidParamsError{Context: "DescribeBotVersionInput"}
2815	if v.BotId == nil {
2816		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2817	}
2818	if v.BotVersion == nil {
2819		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2820	}
2821	if invalidParams.Len() > 0 {
2822		return invalidParams
2823	} else {
2824		return nil
2825	}
2826}
2827
2828func validateOpDescribeIntentInput(v *DescribeIntentInput) error {
2829	if v == nil {
2830		return nil
2831	}
2832	invalidParams := smithy.InvalidParamsError{Context: "DescribeIntentInput"}
2833	if v.IntentId == nil {
2834		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
2835	}
2836	if v.BotId == nil {
2837		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2838	}
2839	if v.BotVersion == nil {
2840		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2841	}
2842	if v.LocaleId == nil {
2843		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2844	}
2845	if invalidParams.Len() > 0 {
2846		return invalidParams
2847	} else {
2848		return nil
2849	}
2850}
2851
2852func validateOpDescribeSlotInput(v *DescribeSlotInput) error {
2853	if v == nil {
2854		return nil
2855	}
2856	invalidParams := smithy.InvalidParamsError{Context: "DescribeSlotInput"}
2857	if v.SlotId == nil {
2858		invalidParams.Add(smithy.NewErrParamRequired("SlotId"))
2859	}
2860	if v.BotId == nil {
2861		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2862	}
2863	if v.BotVersion == nil {
2864		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2865	}
2866	if v.LocaleId == nil {
2867		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2868	}
2869	if v.IntentId == nil {
2870		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
2871	}
2872	if invalidParams.Len() > 0 {
2873		return invalidParams
2874	} else {
2875		return nil
2876	}
2877}
2878
2879func validateOpDescribeSlotTypeInput(v *DescribeSlotTypeInput) error {
2880	if v == nil {
2881		return nil
2882	}
2883	invalidParams := smithy.InvalidParamsError{Context: "DescribeSlotTypeInput"}
2884	if v.SlotTypeId == nil {
2885		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId"))
2886	}
2887	if v.BotId == nil {
2888		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2889	}
2890	if v.BotVersion == nil {
2891		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2892	}
2893	if v.LocaleId == nil {
2894		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2895	}
2896	if invalidParams.Len() > 0 {
2897		return invalidParams
2898	} else {
2899		return nil
2900	}
2901}
2902
2903func validateOpListBotAliasesInput(v *ListBotAliasesInput) error {
2904	if v == nil {
2905		return nil
2906	}
2907	invalidParams := smithy.InvalidParamsError{Context: "ListBotAliasesInput"}
2908	if v.BotId == nil {
2909		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2910	}
2911	if invalidParams.Len() > 0 {
2912		return invalidParams
2913	} else {
2914		return nil
2915	}
2916}
2917
2918func validateOpListBotLocalesInput(v *ListBotLocalesInput) error {
2919	if v == nil {
2920		return nil
2921	}
2922	invalidParams := smithy.InvalidParamsError{Context: "ListBotLocalesInput"}
2923	if v.BotId == nil {
2924		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2925	}
2926	if v.BotVersion == nil {
2927		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
2928	}
2929	if v.SortBy != nil {
2930		if err := validateBotLocaleSortBy(v.SortBy); err != nil {
2931			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
2932		}
2933	}
2934	if v.Filters != nil {
2935		if err := validateBotLocaleFilters(v.Filters); err != nil {
2936			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
2937		}
2938	}
2939	if invalidParams.Len() > 0 {
2940		return invalidParams
2941	} else {
2942		return nil
2943	}
2944}
2945
2946func validateOpListBotsInput(v *ListBotsInput) error {
2947	if v == nil {
2948		return nil
2949	}
2950	invalidParams := smithy.InvalidParamsError{Context: "ListBotsInput"}
2951	if v.SortBy != nil {
2952		if err := validateBotSortBy(v.SortBy); err != nil {
2953			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
2954		}
2955	}
2956	if v.Filters != nil {
2957		if err := validateBotFilters(v.Filters); err != nil {
2958			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
2959		}
2960	}
2961	if invalidParams.Len() > 0 {
2962		return invalidParams
2963	} else {
2964		return nil
2965	}
2966}
2967
2968func validateOpListBotVersionsInput(v *ListBotVersionsInput) error {
2969	if v == nil {
2970		return nil
2971	}
2972	invalidParams := smithy.InvalidParamsError{Context: "ListBotVersionsInput"}
2973	if v.BotId == nil {
2974		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
2975	}
2976	if v.SortBy != nil {
2977		if err := validateBotVersionSortBy(v.SortBy); err != nil {
2978			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
2979		}
2980	}
2981	if invalidParams.Len() > 0 {
2982		return invalidParams
2983	} else {
2984		return nil
2985	}
2986}
2987
2988func validateOpListBuiltInIntentsInput(v *ListBuiltInIntentsInput) error {
2989	if v == nil {
2990		return nil
2991	}
2992	invalidParams := smithy.InvalidParamsError{Context: "ListBuiltInIntentsInput"}
2993	if v.LocaleId == nil {
2994		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
2995	}
2996	if v.SortBy != nil {
2997		if err := validateBuiltInIntentSortBy(v.SortBy); err != nil {
2998			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
2999		}
3000	}
3001	if invalidParams.Len() > 0 {
3002		return invalidParams
3003	} else {
3004		return nil
3005	}
3006}
3007
3008func validateOpListBuiltInSlotTypesInput(v *ListBuiltInSlotTypesInput) error {
3009	if v == nil {
3010		return nil
3011	}
3012	invalidParams := smithy.InvalidParamsError{Context: "ListBuiltInSlotTypesInput"}
3013	if v.LocaleId == nil {
3014		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
3015	}
3016	if v.SortBy != nil {
3017		if err := validateBuiltInSlotTypeSortBy(v.SortBy); err != nil {
3018			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
3019		}
3020	}
3021	if invalidParams.Len() > 0 {
3022		return invalidParams
3023	} else {
3024		return nil
3025	}
3026}
3027
3028func validateOpListIntentsInput(v *ListIntentsInput) error {
3029	if v == nil {
3030		return nil
3031	}
3032	invalidParams := smithy.InvalidParamsError{Context: "ListIntentsInput"}
3033	if v.BotId == nil {
3034		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
3035	}
3036	if v.BotVersion == nil {
3037		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
3038	}
3039	if v.LocaleId == nil {
3040		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
3041	}
3042	if v.SortBy != nil {
3043		if err := validateIntentSortBy(v.SortBy); err != nil {
3044			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
3045		}
3046	}
3047	if v.Filters != nil {
3048		if err := validateIntentFilters(v.Filters); err != nil {
3049			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
3050		}
3051	}
3052	if invalidParams.Len() > 0 {
3053		return invalidParams
3054	} else {
3055		return nil
3056	}
3057}
3058
3059func validateOpListSlotsInput(v *ListSlotsInput) error {
3060	if v == nil {
3061		return nil
3062	}
3063	invalidParams := smithy.InvalidParamsError{Context: "ListSlotsInput"}
3064	if v.BotId == nil {
3065		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
3066	}
3067	if v.BotVersion == nil {
3068		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
3069	}
3070	if v.LocaleId == nil {
3071		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
3072	}
3073	if v.IntentId == nil {
3074		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
3075	}
3076	if v.SortBy != nil {
3077		if err := validateSlotSortBy(v.SortBy); err != nil {
3078			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
3079		}
3080	}
3081	if v.Filters != nil {
3082		if err := validateSlotFilters(v.Filters); err != nil {
3083			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
3084		}
3085	}
3086	if invalidParams.Len() > 0 {
3087		return invalidParams
3088	} else {
3089		return nil
3090	}
3091}
3092
3093func validateOpListSlotTypesInput(v *ListSlotTypesInput) error {
3094	if v == nil {
3095		return nil
3096	}
3097	invalidParams := smithy.InvalidParamsError{Context: "ListSlotTypesInput"}
3098	if v.BotId == nil {
3099		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
3100	}
3101	if v.BotVersion == nil {
3102		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
3103	}
3104	if v.LocaleId == nil {
3105		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
3106	}
3107	if v.SortBy != nil {
3108		if err := validateSlotTypeSortBy(v.SortBy); err != nil {
3109			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
3110		}
3111	}
3112	if v.Filters != nil {
3113		if err := validateSlotTypeFilters(v.Filters); err != nil {
3114			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
3115		}
3116	}
3117	if invalidParams.Len() > 0 {
3118		return invalidParams
3119	} else {
3120		return nil
3121	}
3122}
3123
3124func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
3125	if v == nil {
3126		return nil
3127	}
3128	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
3129	if v.ResourceARN == nil {
3130		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
3131	}
3132	if invalidParams.Len() > 0 {
3133		return invalidParams
3134	} else {
3135		return nil
3136	}
3137}
3138
3139func validateOpTagResourceInput(v *TagResourceInput) error {
3140	if v == nil {
3141		return nil
3142	}
3143	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
3144	if v.ResourceARN == nil {
3145		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
3146	}
3147	if v.Tags == nil {
3148		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
3149	}
3150	if invalidParams.Len() > 0 {
3151		return invalidParams
3152	} else {
3153		return nil
3154	}
3155}
3156
3157func validateOpUntagResourceInput(v *UntagResourceInput) error {
3158	if v == nil {
3159		return nil
3160	}
3161	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
3162	if v.ResourceARN == nil {
3163		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
3164	}
3165	if v.TagKeys == nil {
3166		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
3167	}
3168	if invalidParams.Len() > 0 {
3169		return invalidParams
3170	} else {
3171		return nil
3172	}
3173}
3174
3175func validateOpUpdateBotAliasInput(v *UpdateBotAliasInput) error {
3176	if v == nil {
3177		return nil
3178	}
3179	invalidParams := smithy.InvalidParamsError{Context: "UpdateBotAliasInput"}
3180	if v.BotAliasId == nil {
3181		invalidParams.Add(smithy.NewErrParamRequired("BotAliasId"))
3182	}
3183	if v.BotAliasName == nil {
3184		invalidParams.Add(smithy.NewErrParamRequired("BotAliasName"))
3185	}
3186	if v.BotAliasLocaleSettings != nil {
3187		if err := validateBotAliasLocaleSettingsMap(v.BotAliasLocaleSettings); err != nil {
3188			invalidParams.AddNested("BotAliasLocaleSettings", err.(smithy.InvalidParamsError))
3189		}
3190	}
3191	if v.ConversationLogSettings != nil {
3192		if err := validateConversationLogSettings(v.ConversationLogSettings); err != nil {
3193			invalidParams.AddNested("ConversationLogSettings", err.(smithy.InvalidParamsError))
3194		}
3195	}
3196	if v.SentimentAnalysisSettings != nil {
3197		if err := validateSentimentAnalysisSettings(v.SentimentAnalysisSettings); err != nil {
3198			invalidParams.AddNested("SentimentAnalysisSettings", err.(smithy.InvalidParamsError))
3199		}
3200	}
3201	if v.BotId == nil {
3202		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
3203	}
3204	if invalidParams.Len() > 0 {
3205		return invalidParams
3206	} else {
3207		return nil
3208	}
3209}
3210
3211func validateOpUpdateBotInput(v *UpdateBotInput) error {
3212	if v == nil {
3213		return nil
3214	}
3215	invalidParams := smithy.InvalidParamsError{Context: "UpdateBotInput"}
3216	if v.BotId == nil {
3217		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
3218	}
3219	if v.BotName == nil {
3220		invalidParams.Add(smithy.NewErrParamRequired("BotName"))
3221	}
3222	if v.RoleArn == nil {
3223		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
3224	}
3225	if v.DataPrivacy == nil {
3226		invalidParams.Add(smithy.NewErrParamRequired("DataPrivacy"))
3227	} else if v.DataPrivacy != nil {
3228		if err := validateDataPrivacy(v.DataPrivacy); err != nil {
3229			invalidParams.AddNested("DataPrivacy", err.(smithy.InvalidParamsError))
3230		}
3231	}
3232	if v.IdleSessionTTLInSeconds == nil {
3233		invalidParams.Add(smithy.NewErrParamRequired("IdleSessionTTLInSeconds"))
3234	}
3235	if invalidParams.Len() > 0 {
3236		return invalidParams
3237	} else {
3238		return nil
3239	}
3240}
3241
3242func validateOpUpdateBotLocaleInput(v *UpdateBotLocaleInput) error {
3243	if v == nil {
3244		return nil
3245	}
3246	invalidParams := smithy.InvalidParamsError{Context: "UpdateBotLocaleInput"}
3247	if v.BotId == nil {
3248		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
3249	}
3250	if v.BotVersion == nil {
3251		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
3252	}
3253	if v.LocaleId == nil {
3254		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
3255	}
3256	if v.NluIntentConfidenceThreshold == nil {
3257		invalidParams.Add(smithy.NewErrParamRequired("NluIntentConfidenceThreshold"))
3258	}
3259	if v.VoiceSettings != nil {
3260		if err := validateVoiceSettings(v.VoiceSettings); err != nil {
3261			invalidParams.AddNested("VoiceSettings", err.(smithy.InvalidParamsError))
3262		}
3263	}
3264	if invalidParams.Len() > 0 {
3265		return invalidParams
3266	} else {
3267		return nil
3268	}
3269}
3270
3271func validateOpUpdateIntentInput(v *UpdateIntentInput) error {
3272	if v == nil {
3273		return nil
3274	}
3275	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntentInput"}
3276	if v.IntentId == nil {
3277		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
3278	}
3279	if v.IntentName == nil {
3280		invalidParams.Add(smithy.NewErrParamRequired("IntentName"))
3281	}
3282	if v.SampleUtterances != nil {
3283		if err := validateSampleUtterancesList(v.SampleUtterances); err != nil {
3284			invalidParams.AddNested("SampleUtterances", err.(smithy.InvalidParamsError))
3285		}
3286	}
3287	if v.DialogCodeHook != nil {
3288		if err := validateDialogCodeHookSettings(v.DialogCodeHook); err != nil {
3289			invalidParams.AddNested("DialogCodeHook", err.(smithy.InvalidParamsError))
3290		}
3291	}
3292	if v.FulfillmentCodeHook != nil {
3293		if err := validateFulfillmentCodeHookSettings(v.FulfillmentCodeHook); err != nil {
3294			invalidParams.AddNested("FulfillmentCodeHook", err.(smithy.InvalidParamsError))
3295		}
3296	}
3297	if v.SlotPriorities != nil {
3298		if err := validateSlotPrioritiesList(v.SlotPriorities); err != nil {
3299			invalidParams.AddNested("SlotPriorities", err.(smithy.InvalidParamsError))
3300		}
3301	}
3302	if v.IntentConfirmationSetting != nil {
3303		if err := validateIntentConfirmationSetting(v.IntentConfirmationSetting); err != nil {
3304			invalidParams.AddNested("IntentConfirmationSetting", err.(smithy.InvalidParamsError))
3305		}
3306	}
3307	if v.IntentClosingSetting != nil {
3308		if err := validateIntentClosingSetting(v.IntentClosingSetting); err != nil {
3309			invalidParams.AddNested("IntentClosingSetting", err.(smithy.InvalidParamsError))
3310		}
3311	}
3312	if v.InputContexts != nil {
3313		if err := validateInputContextsList(v.InputContexts); err != nil {
3314			invalidParams.AddNested("InputContexts", err.(smithy.InvalidParamsError))
3315		}
3316	}
3317	if v.OutputContexts != nil {
3318		if err := validateOutputContextsList(v.OutputContexts); err != nil {
3319			invalidParams.AddNested("OutputContexts", err.(smithy.InvalidParamsError))
3320		}
3321	}
3322	if v.KendraConfiguration != nil {
3323		if err := validateKendraConfiguration(v.KendraConfiguration); err != nil {
3324			invalidParams.AddNested("KendraConfiguration", err.(smithy.InvalidParamsError))
3325		}
3326	}
3327	if v.BotId == nil {
3328		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
3329	}
3330	if v.BotVersion == nil {
3331		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
3332	}
3333	if v.LocaleId == nil {
3334		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
3335	}
3336	if invalidParams.Len() > 0 {
3337		return invalidParams
3338	} else {
3339		return nil
3340	}
3341}
3342
3343func validateOpUpdateSlotInput(v *UpdateSlotInput) error {
3344	if v == nil {
3345		return nil
3346	}
3347	invalidParams := smithy.InvalidParamsError{Context: "UpdateSlotInput"}
3348	if v.SlotId == nil {
3349		invalidParams.Add(smithy.NewErrParamRequired("SlotId"))
3350	}
3351	if v.SlotName == nil {
3352		invalidParams.Add(smithy.NewErrParamRequired("SlotName"))
3353	}
3354	if v.SlotTypeId == nil {
3355		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId"))
3356	}
3357	if v.ValueElicitationSetting == nil {
3358		invalidParams.Add(smithy.NewErrParamRequired("ValueElicitationSetting"))
3359	} else if v.ValueElicitationSetting != nil {
3360		if err := validateSlotValueElicitationSetting(v.ValueElicitationSetting); err != nil {
3361			invalidParams.AddNested("ValueElicitationSetting", err.(smithy.InvalidParamsError))
3362		}
3363	}
3364	if v.ObfuscationSetting != nil {
3365		if err := validateObfuscationSetting(v.ObfuscationSetting); err != nil {
3366			invalidParams.AddNested("ObfuscationSetting", err.(smithy.InvalidParamsError))
3367		}
3368	}
3369	if v.BotId == nil {
3370		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
3371	}
3372	if v.BotVersion == nil {
3373		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
3374	}
3375	if v.LocaleId == nil {
3376		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
3377	}
3378	if v.IntentId == nil {
3379		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
3380	}
3381	if invalidParams.Len() > 0 {
3382		return invalidParams
3383	} else {
3384		return nil
3385	}
3386}
3387
3388func validateOpUpdateSlotTypeInput(v *UpdateSlotTypeInput) error {
3389	if v == nil {
3390		return nil
3391	}
3392	invalidParams := smithy.InvalidParamsError{Context: "UpdateSlotTypeInput"}
3393	if v.SlotTypeId == nil {
3394		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId"))
3395	}
3396	if v.SlotTypeName == nil {
3397		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeName"))
3398	}
3399	if v.SlotTypeValues != nil {
3400		if err := validateSlotTypeValues(v.SlotTypeValues); err != nil {
3401			invalidParams.AddNested("SlotTypeValues", err.(smithy.InvalidParamsError))
3402		}
3403	}
3404	if v.ValueSelectionSetting == nil {
3405		invalidParams.Add(smithy.NewErrParamRequired("ValueSelectionSetting"))
3406	} else if v.ValueSelectionSetting != nil {
3407		if err := validateSlotValueSelectionSetting(v.ValueSelectionSetting); err != nil {
3408			invalidParams.AddNested("ValueSelectionSetting", err.(smithy.InvalidParamsError))
3409		}
3410	}
3411	if v.BotId == nil {
3412		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
3413	}
3414	if v.BotVersion == nil {
3415		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
3416	}
3417	if v.LocaleId == nil {
3418		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
3419	}
3420	if invalidParams.Len() > 0 {
3421		return invalidParams
3422	} else {
3423		return nil
3424	}
3425}
3426