1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package pinpoint
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/pinpoint/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateApp struct {
14}
15
16func (*validateOpCreateApp) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateApp) 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.(*CreateAppInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateAppInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateCampaign struct {
34}
35
36func (*validateOpCreateCampaign) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateCampaign) 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.(*CreateCampaignInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateCampaignInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateEmailTemplate struct {
54}
55
56func (*validateOpCreateEmailTemplate) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateEmailTemplate) 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.(*CreateEmailTemplateInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateEmailTemplateInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateExportJob struct {
74}
75
76func (*validateOpCreateExportJob) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateExportJob) 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.(*CreateExportJobInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateExportJobInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateImportJob struct {
94}
95
96func (*validateOpCreateImportJob) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateImportJob) 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.(*CreateImportJobInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateImportJobInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateJourney struct {
114}
115
116func (*validateOpCreateJourney) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateJourney) 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.(*CreateJourneyInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateJourneyInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreatePushTemplate struct {
134}
135
136func (*validateOpCreatePushTemplate) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreatePushTemplate) 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.(*CreatePushTemplateInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreatePushTemplateInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateRecommenderConfiguration struct {
154}
155
156func (*validateOpCreateRecommenderConfiguration) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateRecommenderConfiguration) 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.(*CreateRecommenderConfigurationInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateRecommenderConfigurationInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateSegment struct {
174}
175
176func (*validateOpCreateSegment) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateSegment) 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.(*CreateSegmentInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateSegmentInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreateSmsTemplate struct {
194}
195
196func (*validateOpCreateSmsTemplate) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreateSmsTemplate) 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.(*CreateSmsTemplateInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreateSmsTemplateInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateVoiceTemplate struct {
214}
215
216func (*validateOpCreateVoiceTemplate) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateVoiceTemplate) 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.(*CreateVoiceTemplateInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateVoiceTemplateInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteAdmChannel struct {
234}
235
236func (*validateOpDeleteAdmChannel) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteAdmChannel) 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.(*DeleteAdmChannelInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteAdmChannelInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteApnsChannel struct {
254}
255
256func (*validateOpDeleteApnsChannel) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteApnsChannel) 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.(*DeleteApnsChannelInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteApnsChannelInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDeleteApnsSandboxChannel struct {
274}
275
276func (*validateOpDeleteApnsSandboxChannel) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDeleteApnsSandboxChannel) 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.(*DeleteApnsSandboxChannelInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDeleteApnsSandboxChannelInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDeleteApnsVoipChannel struct {
294}
295
296func (*validateOpDeleteApnsVoipChannel) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDeleteApnsVoipChannel) 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.(*DeleteApnsVoipChannelInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDeleteApnsVoipChannelInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDeleteApnsVoipSandboxChannel struct {
314}
315
316func (*validateOpDeleteApnsVoipSandboxChannel) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDeleteApnsVoipSandboxChannel) 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.(*DeleteApnsVoipSandboxChannelInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDeleteApnsVoipSandboxChannelInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDeleteApp struct {
334}
335
336func (*validateOpDeleteApp) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDeleteApp) 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.(*DeleteAppInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDeleteAppInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDeleteBaiduChannel struct {
354}
355
356func (*validateOpDeleteBaiduChannel) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDeleteBaiduChannel) 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.(*DeleteBaiduChannelInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDeleteBaiduChannelInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDeleteCampaign struct {
374}
375
376func (*validateOpDeleteCampaign) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDeleteCampaign) 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.(*DeleteCampaignInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDeleteCampaignInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDeleteEmailChannel struct {
394}
395
396func (*validateOpDeleteEmailChannel) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDeleteEmailChannel) 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.(*DeleteEmailChannelInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDeleteEmailChannelInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDeleteEmailTemplate struct {
414}
415
416func (*validateOpDeleteEmailTemplate) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDeleteEmailTemplate) 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.(*DeleteEmailTemplateInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDeleteEmailTemplateInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDeleteEndpoint struct {
434}
435
436func (*validateOpDeleteEndpoint) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDeleteEndpoint) 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.(*DeleteEndpointInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDeleteEndpointInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDeleteEventStream struct {
454}
455
456func (*validateOpDeleteEventStream) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDeleteEventStream) 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.(*DeleteEventStreamInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDeleteEventStreamInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDeleteGcmChannel struct {
474}
475
476func (*validateOpDeleteGcmChannel) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDeleteGcmChannel) 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.(*DeleteGcmChannelInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDeleteGcmChannelInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDeleteJourney struct {
494}
495
496func (*validateOpDeleteJourney) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDeleteJourney) 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.(*DeleteJourneyInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDeleteJourneyInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDeletePushTemplate struct {
514}
515
516func (*validateOpDeletePushTemplate) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDeletePushTemplate) 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.(*DeletePushTemplateInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDeletePushTemplateInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDeleteRecommenderConfiguration struct {
534}
535
536func (*validateOpDeleteRecommenderConfiguration) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDeleteRecommenderConfiguration) 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.(*DeleteRecommenderConfigurationInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDeleteRecommenderConfigurationInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDeleteSegment struct {
554}
555
556func (*validateOpDeleteSegment) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDeleteSegment) 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.(*DeleteSegmentInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDeleteSegmentInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpDeleteSmsChannel struct {
574}
575
576func (*validateOpDeleteSmsChannel) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpDeleteSmsChannel) 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.(*DeleteSmsChannelInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpDeleteSmsChannelInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpDeleteSmsTemplate struct {
594}
595
596func (*validateOpDeleteSmsTemplate) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpDeleteSmsTemplate) 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.(*DeleteSmsTemplateInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpDeleteSmsTemplateInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpDeleteUserEndpoints struct {
614}
615
616func (*validateOpDeleteUserEndpoints) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpDeleteUserEndpoints) 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.(*DeleteUserEndpointsInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpDeleteUserEndpointsInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpDeleteVoiceChannel struct {
634}
635
636func (*validateOpDeleteVoiceChannel) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpDeleteVoiceChannel) 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.(*DeleteVoiceChannelInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpDeleteVoiceChannelInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpDeleteVoiceTemplate struct {
654}
655
656func (*validateOpDeleteVoiceTemplate) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpDeleteVoiceTemplate) 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.(*DeleteVoiceTemplateInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpDeleteVoiceTemplateInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpGetAdmChannel struct {
674}
675
676func (*validateOpGetAdmChannel) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpGetAdmChannel) 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.(*GetAdmChannelInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpGetAdmChannelInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpGetApnsChannel struct {
694}
695
696func (*validateOpGetApnsChannel) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpGetApnsChannel) 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.(*GetApnsChannelInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpGetApnsChannelInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpGetApnsSandboxChannel struct {
714}
715
716func (*validateOpGetApnsSandboxChannel) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpGetApnsSandboxChannel) 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.(*GetApnsSandboxChannelInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpGetApnsSandboxChannelInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpGetApnsVoipChannel struct {
734}
735
736func (*validateOpGetApnsVoipChannel) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpGetApnsVoipChannel) 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.(*GetApnsVoipChannelInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpGetApnsVoipChannelInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpGetApnsVoipSandboxChannel struct {
754}
755
756func (*validateOpGetApnsVoipSandboxChannel) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpGetApnsVoipSandboxChannel) 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.(*GetApnsVoipSandboxChannelInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpGetApnsVoipSandboxChannelInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpGetApp struct {
774}
775
776func (*validateOpGetApp) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpGetApp) 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.(*GetAppInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpGetAppInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpGetApplicationDateRangeKpi struct {
794}
795
796func (*validateOpGetApplicationDateRangeKpi) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpGetApplicationDateRangeKpi) 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.(*GetApplicationDateRangeKpiInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpGetApplicationDateRangeKpiInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpGetApplicationSettings struct {
814}
815
816func (*validateOpGetApplicationSettings) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpGetApplicationSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
822) {
823	input, ok := in.Parameters.(*GetApplicationSettingsInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpGetApplicationSettingsInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpGetBaiduChannel struct {
834}
835
836func (*validateOpGetBaiduChannel) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpGetBaiduChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
842) {
843	input, ok := in.Parameters.(*GetBaiduChannelInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpGetBaiduChannelInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpGetCampaignActivities struct {
854}
855
856func (*validateOpGetCampaignActivities) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpGetCampaignActivities) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
862) {
863	input, ok := in.Parameters.(*GetCampaignActivitiesInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpGetCampaignActivitiesInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpGetCampaignDateRangeKpi struct {
874}
875
876func (*validateOpGetCampaignDateRangeKpi) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpGetCampaignDateRangeKpi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
882) {
883	input, ok := in.Parameters.(*GetCampaignDateRangeKpiInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpGetCampaignDateRangeKpiInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpGetCampaign struct {
894}
895
896func (*validateOpGetCampaign) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpGetCampaign) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
902) {
903	input, ok := in.Parameters.(*GetCampaignInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpGetCampaignInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpGetCampaigns struct {
914}
915
916func (*validateOpGetCampaigns) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpGetCampaigns) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
922) {
923	input, ok := in.Parameters.(*GetCampaignsInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpGetCampaignsInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpGetCampaignVersion struct {
934}
935
936func (*validateOpGetCampaignVersion) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpGetCampaignVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
942) {
943	input, ok := in.Parameters.(*GetCampaignVersionInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpGetCampaignVersionInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpGetCampaignVersions struct {
954}
955
956func (*validateOpGetCampaignVersions) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpGetCampaignVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
962) {
963	input, ok := in.Parameters.(*GetCampaignVersionsInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpGetCampaignVersionsInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpGetChannels struct {
974}
975
976func (*validateOpGetChannels) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpGetChannels) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
982) {
983	input, ok := in.Parameters.(*GetChannelsInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpGetChannelsInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpGetEmailChannel struct {
994}
995
996func (*validateOpGetEmailChannel) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpGetEmailChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1002) {
1003	input, ok := in.Parameters.(*GetEmailChannelInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpGetEmailChannelInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpGetEmailTemplate struct {
1014}
1015
1016func (*validateOpGetEmailTemplate) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpGetEmailTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1022) {
1023	input, ok := in.Parameters.(*GetEmailTemplateInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpGetEmailTemplateInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpGetEndpoint struct {
1034}
1035
1036func (*validateOpGetEndpoint) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpGetEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	input, ok := in.Parameters.(*GetEndpointInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpGetEndpointInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpGetEventStream struct {
1054}
1055
1056func (*validateOpGetEventStream) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpGetEventStream) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1062) {
1063	input, ok := in.Parameters.(*GetEventStreamInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpGetEventStreamInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpGetExportJob struct {
1074}
1075
1076func (*validateOpGetExportJob) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpGetExportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1082) {
1083	input, ok := in.Parameters.(*GetExportJobInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpGetExportJobInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpGetExportJobs struct {
1094}
1095
1096func (*validateOpGetExportJobs) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpGetExportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	input, ok := in.Parameters.(*GetExportJobsInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpGetExportJobsInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpGetGcmChannel struct {
1114}
1115
1116func (*validateOpGetGcmChannel) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpGetGcmChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1122) {
1123	input, ok := in.Parameters.(*GetGcmChannelInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpGetGcmChannelInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133type validateOpGetImportJob struct {
1134}
1135
1136func (*validateOpGetImportJob) ID() string {
1137	return "OperationInputValidation"
1138}
1139
1140func (m *validateOpGetImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1142) {
1143	input, ok := in.Parameters.(*GetImportJobInput)
1144	if !ok {
1145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146	}
1147	if err := validateOpGetImportJobInput(input); err != nil {
1148		return out, metadata, err
1149	}
1150	return next.HandleInitialize(ctx, in)
1151}
1152
1153type validateOpGetImportJobs struct {
1154}
1155
1156func (*validateOpGetImportJobs) ID() string {
1157	return "OperationInputValidation"
1158}
1159
1160func (m *validateOpGetImportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1162) {
1163	input, ok := in.Parameters.(*GetImportJobsInput)
1164	if !ok {
1165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1166	}
1167	if err := validateOpGetImportJobsInput(input); err != nil {
1168		return out, metadata, err
1169	}
1170	return next.HandleInitialize(ctx, in)
1171}
1172
1173type validateOpGetJourneyDateRangeKpi struct {
1174}
1175
1176func (*validateOpGetJourneyDateRangeKpi) ID() string {
1177	return "OperationInputValidation"
1178}
1179
1180func (m *validateOpGetJourneyDateRangeKpi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1182) {
1183	input, ok := in.Parameters.(*GetJourneyDateRangeKpiInput)
1184	if !ok {
1185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1186	}
1187	if err := validateOpGetJourneyDateRangeKpiInput(input); err != nil {
1188		return out, metadata, err
1189	}
1190	return next.HandleInitialize(ctx, in)
1191}
1192
1193type validateOpGetJourneyExecutionActivityMetrics struct {
1194}
1195
1196func (*validateOpGetJourneyExecutionActivityMetrics) ID() string {
1197	return "OperationInputValidation"
1198}
1199
1200func (m *validateOpGetJourneyExecutionActivityMetrics) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	input, ok := in.Parameters.(*GetJourneyExecutionActivityMetricsInput)
1204	if !ok {
1205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1206	}
1207	if err := validateOpGetJourneyExecutionActivityMetricsInput(input); err != nil {
1208		return out, metadata, err
1209	}
1210	return next.HandleInitialize(ctx, in)
1211}
1212
1213type validateOpGetJourneyExecutionMetrics struct {
1214}
1215
1216func (*validateOpGetJourneyExecutionMetrics) ID() string {
1217	return "OperationInputValidation"
1218}
1219
1220func (m *validateOpGetJourneyExecutionMetrics) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1222) {
1223	input, ok := in.Parameters.(*GetJourneyExecutionMetricsInput)
1224	if !ok {
1225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1226	}
1227	if err := validateOpGetJourneyExecutionMetricsInput(input); err != nil {
1228		return out, metadata, err
1229	}
1230	return next.HandleInitialize(ctx, in)
1231}
1232
1233type validateOpGetJourney struct {
1234}
1235
1236func (*validateOpGetJourney) ID() string {
1237	return "OperationInputValidation"
1238}
1239
1240func (m *validateOpGetJourney) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1242) {
1243	input, ok := in.Parameters.(*GetJourneyInput)
1244	if !ok {
1245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1246	}
1247	if err := validateOpGetJourneyInput(input); err != nil {
1248		return out, metadata, err
1249	}
1250	return next.HandleInitialize(ctx, in)
1251}
1252
1253type validateOpGetPushTemplate struct {
1254}
1255
1256func (*validateOpGetPushTemplate) ID() string {
1257	return "OperationInputValidation"
1258}
1259
1260func (m *validateOpGetPushTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1262) {
1263	input, ok := in.Parameters.(*GetPushTemplateInput)
1264	if !ok {
1265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1266	}
1267	if err := validateOpGetPushTemplateInput(input); err != nil {
1268		return out, metadata, err
1269	}
1270	return next.HandleInitialize(ctx, in)
1271}
1272
1273type validateOpGetRecommenderConfiguration struct {
1274}
1275
1276func (*validateOpGetRecommenderConfiguration) ID() string {
1277	return "OperationInputValidation"
1278}
1279
1280func (m *validateOpGetRecommenderConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1282) {
1283	input, ok := in.Parameters.(*GetRecommenderConfigurationInput)
1284	if !ok {
1285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1286	}
1287	if err := validateOpGetRecommenderConfigurationInput(input); err != nil {
1288		return out, metadata, err
1289	}
1290	return next.HandleInitialize(ctx, in)
1291}
1292
1293type validateOpGetSegmentExportJobs struct {
1294}
1295
1296func (*validateOpGetSegmentExportJobs) ID() string {
1297	return "OperationInputValidation"
1298}
1299
1300func (m *validateOpGetSegmentExportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1302) {
1303	input, ok := in.Parameters.(*GetSegmentExportJobsInput)
1304	if !ok {
1305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1306	}
1307	if err := validateOpGetSegmentExportJobsInput(input); err != nil {
1308		return out, metadata, err
1309	}
1310	return next.HandleInitialize(ctx, in)
1311}
1312
1313type validateOpGetSegmentImportJobs struct {
1314}
1315
1316func (*validateOpGetSegmentImportJobs) ID() string {
1317	return "OperationInputValidation"
1318}
1319
1320func (m *validateOpGetSegmentImportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1322) {
1323	input, ok := in.Parameters.(*GetSegmentImportJobsInput)
1324	if !ok {
1325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1326	}
1327	if err := validateOpGetSegmentImportJobsInput(input); err != nil {
1328		return out, metadata, err
1329	}
1330	return next.HandleInitialize(ctx, in)
1331}
1332
1333type validateOpGetSegment struct {
1334}
1335
1336func (*validateOpGetSegment) ID() string {
1337	return "OperationInputValidation"
1338}
1339
1340func (m *validateOpGetSegment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	input, ok := in.Parameters.(*GetSegmentInput)
1344	if !ok {
1345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1346	}
1347	if err := validateOpGetSegmentInput(input); err != nil {
1348		return out, metadata, err
1349	}
1350	return next.HandleInitialize(ctx, in)
1351}
1352
1353type validateOpGetSegments struct {
1354}
1355
1356func (*validateOpGetSegments) ID() string {
1357	return "OperationInputValidation"
1358}
1359
1360func (m *validateOpGetSegments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1362) {
1363	input, ok := in.Parameters.(*GetSegmentsInput)
1364	if !ok {
1365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1366	}
1367	if err := validateOpGetSegmentsInput(input); err != nil {
1368		return out, metadata, err
1369	}
1370	return next.HandleInitialize(ctx, in)
1371}
1372
1373type validateOpGetSegmentVersion struct {
1374}
1375
1376func (*validateOpGetSegmentVersion) ID() string {
1377	return "OperationInputValidation"
1378}
1379
1380func (m *validateOpGetSegmentVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1382) {
1383	input, ok := in.Parameters.(*GetSegmentVersionInput)
1384	if !ok {
1385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1386	}
1387	if err := validateOpGetSegmentVersionInput(input); err != nil {
1388		return out, metadata, err
1389	}
1390	return next.HandleInitialize(ctx, in)
1391}
1392
1393type validateOpGetSegmentVersions struct {
1394}
1395
1396func (*validateOpGetSegmentVersions) ID() string {
1397	return "OperationInputValidation"
1398}
1399
1400func (m *validateOpGetSegmentVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1402) {
1403	input, ok := in.Parameters.(*GetSegmentVersionsInput)
1404	if !ok {
1405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1406	}
1407	if err := validateOpGetSegmentVersionsInput(input); err != nil {
1408		return out, metadata, err
1409	}
1410	return next.HandleInitialize(ctx, in)
1411}
1412
1413type validateOpGetSmsChannel struct {
1414}
1415
1416func (*validateOpGetSmsChannel) ID() string {
1417	return "OperationInputValidation"
1418}
1419
1420func (m *validateOpGetSmsChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1422) {
1423	input, ok := in.Parameters.(*GetSmsChannelInput)
1424	if !ok {
1425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1426	}
1427	if err := validateOpGetSmsChannelInput(input); err != nil {
1428		return out, metadata, err
1429	}
1430	return next.HandleInitialize(ctx, in)
1431}
1432
1433type validateOpGetSmsTemplate struct {
1434}
1435
1436func (*validateOpGetSmsTemplate) ID() string {
1437	return "OperationInputValidation"
1438}
1439
1440func (m *validateOpGetSmsTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1442) {
1443	input, ok := in.Parameters.(*GetSmsTemplateInput)
1444	if !ok {
1445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1446	}
1447	if err := validateOpGetSmsTemplateInput(input); err != nil {
1448		return out, metadata, err
1449	}
1450	return next.HandleInitialize(ctx, in)
1451}
1452
1453type validateOpGetUserEndpoints struct {
1454}
1455
1456func (*validateOpGetUserEndpoints) ID() string {
1457	return "OperationInputValidation"
1458}
1459
1460func (m *validateOpGetUserEndpoints) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1462) {
1463	input, ok := in.Parameters.(*GetUserEndpointsInput)
1464	if !ok {
1465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1466	}
1467	if err := validateOpGetUserEndpointsInput(input); err != nil {
1468		return out, metadata, err
1469	}
1470	return next.HandleInitialize(ctx, in)
1471}
1472
1473type validateOpGetVoiceChannel struct {
1474}
1475
1476func (*validateOpGetVoiceChannel) ID() string {
1477	return "OperationInputValidation"
1478}
1479
1480func (m *validateOpGetVoiceChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1482) {
1483	input, ok := in.Parameters.(*GetVoiceChannelInput)
1484	if !ok {
1485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1486	}
1487	if err := validateOpGetVoiceChannelInput(input); err != nil {
1488		return out, metadata, err
1489	}
1490	return next.HandleInitialize(ctx, in)
1491}
1492
1493type validateOpGetVoiceTemplate struct {
1494}
1495
1496func (*validateOpGetVoiceTemplate) ID() string {
1497	return "OperationInputValidation"
1498}
1499
1500func (m *validateOpGetVoiceTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1502) {
1503	input, ok := in.Parameters.(*GetVoiceTemplateInput)
1504	if !ok {
1505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1506	}
1507	if err := validateOpGetVoiceTemplateInput(input); err != nil {
1508		return out, metadata, err
1509	}
1510	return next.HandleInitialize(ctx, in)
1511}
1512
1513type validateOpListJourneys struct {
1514}
1515
1516func (*validateOpListJourneys) ID() string {
1517	return "OperationInputValidation"
1518}
1519
1520func (m *validateOpListJourneys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1522) {
1523	input, ok := in.Parameters.(*ListJourneysInput)
1524	if !ok {
1525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1526	}
1527	if err := validateOpListJourneysInput(input); err != nil {
1528		return out, metadata, err
1529	}
1530	return next.HandleInitialize(ctx, in)
1531}
1532
1533type validateOpListTagsForResource struct {
1534}
1535
1536func (*validateOpListTagsForResource) ID() string {
1537	return "OperationInputValidation"
1538}
1539
1540func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1542) {
1543	input, ok := in.Parameters.(*ListTagsForResourceInput)
1544	if !ok {
1545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1546	}
1547	if err := validateOpListTagsForResourceInput(input); err != nil {
1548		return out, metadata, err
1549	}
1550	return next.HandleInitialize(ctx, in)
1551}
1552
1553type validateOpListTemplateVersions struct {
1554}
1555
1556func (*validateOpListTemplateVersions) ID() string {
1557	return "OperationInputValidation"
1558}
1559
1560func (m *validateOpListTemplateVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1562) {
1563	input, ok := in.Parameters.(*ListTemplateVersionsInput)
1564	if !ok {
1565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1566	}
1567	if err := validateOpListTemplateVersionsInput(input); err != nil {
1568		return out, metadata, err
1569	}
1570	return next.HandleInitialize(ctx, in)
1571}
1572
1573type validateOpPhoneNumberValidate struct {
1574}
1575
1576func (*validateOpPhoneNumberValidate) ID() string {
1577	return "OperationInputValidation"
1578}
1579
1580func (m *validateOpPhoneNumberValidate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1582) {
1583	input, ok := in.Parameters.(*PhoneNumberValidateInput)
1584	if !ok {
1585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1586	}
1587	if err := validateOpPhoneNumberValidateInput(input); err != nil {
1588		return out, metadata, err
1589	}
1590	return next.HandleInitialize(ctx, in)
1591}
1592
1593type validateOpPutEvents struct {
1594}
1595
1596func (*validateOpPutEvents) ID() string {
1597	return "OperationInputValidation"
1598}
1599
1600func (m *validateOpPutEvents) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1602) {
1603	input, ok := in.Parameters.(*PutEventsInput)
1604	if !ok {
1605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1606	}
1607	if err := validateOpPutEventsInput(input); err != nil {
1608		return out, metadata, err
1609	}
1610	return next.HandleInitialize(ctx, in)
1611}
1612
1613type validateOpPutEventStream struct {
1614}
1615
1616func (*validateOpPutEventStream) ID() string {
1617	return "OperationInputValidation"
1618}
1619
1620func (m *validateOpPutEventStream) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1622) {
1623	input, ok := in.Parameters.(*PutEventStreamInput)
1624	if !ok {
1625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1626	}
1627	if err := validateOpPutEventStreamInput(input); err != nil {
1628		return out, metadata, err
1629	}
1630	return next.HandleInitialize(ctx, in)
1631}
1632
1633type validateOpRemoveAttributes struct {
1634}
1635
1636func (*validateOpRemoveAttributes) ID() string {
1637	return "OperationInputValidation"
1638}
1639
1640func (m *validateOpRemoveAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1641	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1642) {
1643	input, ok := in.Parameters.(*RemoveAttributesInput)
1644	if !ok {
1645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1646	}
1647	if err := validateOpRemoveAttributesInput(input); err != nil {
1648		return out, metadata, err
1649	}
1650	return next.HandleInitialize(ctx, in)
1651}
1652
1653type validateOpSendMessages struct {
1654}
1655
1656func (*validateOpSendMessages) ID() string {
1657	return "OperationInputValidation"
1658}
1659
1660func (m *validateOpSendMessages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1661	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1662) {
1663	input, ok := in.Parameters.(*SendMessagesInput)
1664	if !ok {
1665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1666	}
1667	if err := validateOpSendMessagesInput(input); err != nil {
1668		return out, metadata, err
1669	}
1670	return next.HandleInitialize(ctx, in)
1671}
1672
1673type validateOpSendUsersMessages struct {
1674}
1675
1676func (*validateOpSendUsersMessages) ID() string {
1677	return "OperationInputValidation"
1678}
1679
1680func (m *validateOpSendUsersMessages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1681	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1682) {
1683	input, ok := in.Parameters.(*SendUsersMessagesInput)
1684	if !ok {
1685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1686	}
1687	if err := validateOpSendUsersMessagesInput(input); err != nil {
1688		return out, metadata, err
1689	}
1690	return next.HandleInitialize(ctx, in)
1691}
1692
1693type validateOpTagResource struct {
1694}
1695
1696func (*validateOpTagResource) ID() string {
1697	return "OperationInputValidation"
1698}
1699
1700func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1701	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1702) {
1703	input, ok := in.Parameters.(*TagResourceInput)
1704	if !ok {
1705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1706	}
1707	if err := validateOpTagResourceInput(input); err != nil {
1708		return out, metadata, err
1709	}
1710	return next.HandleInitialize(ctx, in)
1711}
1712
1713type validateOpUntagResource struct {
1714}
1715
1716func (*validateOpUntagResource) ID() string {
1717	return "OperationInputValidation"
1718}
1719
1720func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1721	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1722) {
1723	input, ok := in.Parameters.(*UntagResourceInput)
1724	if !ok {
1725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1726	}
1727	if err := validateOpUntagResourceInput(input); err != nil {
1728		return out, metadata, err
1729	}
1730	return next.HandleInitialize(ctx, in)
1731}
1732
1733type validateOpUpdateAdmChannel struct {
1734}
1735
1736func (*validateOpUpdateAdmChannel) ID() string {
1737	return "OperationInputValidation"
1738}
1739
1740func (m *validateOpUpdateAdmChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1741	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1742) {
1743	input, ok := in.Parameters.(*UpdateAdmChannelInput)
1744	if !ok {
1745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1746	}
1747	if err := validateOpUpdateAdmChannelInput(input); err != nil {
1748		return out, metadata, err
1749	}
1750	return next.HandleInitialize(ctx, in)
1751}
1752
1753type validateOpUpdateApnsChannel struct {
1754}
1755
1756func (*validateOpUpdateApnsChannel) ID() string {
1757	return "OperationInputValidation"
1758}
1759
1760func (m *validateOpUpdateApnsChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1761	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1762) {
1763	input, ok := in.Parameters.(*UpdateApnsChannelInput)
1764	if !ok {
1765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1766	}
1767	if err := validateOpUpdateApnsChannelInput(input); err != nil {
1768		return out, metadata, err
1769	}
1770	return next.HandleInitialize(ctx, in)
1771}
1772
1773type validateOpUpdateApnsSandboxChannel struct {
1774}
1775
1776func (*validateOpUpdateApnsSandboxChannel) ID() string {
1777	return "OperationInputValidation"
1778}
1779
1780func (m *validateOpUpdateApnsSandboxChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1781	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1782) {
1783	input, ok := in.Parameters.(*UpdateApnsSandboxChannelInput)
1784	if !ok {
1785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1786	}
1787	if err := validateOpUpdateApnsSandboxChannelInput(input); err != nil {
1788		return out, metadata, err
1789	}
1790	return next.HandleInitialize(ctx, in)
1791}
1792
1793type validateOpUpdateApnsVoipChannel struct {
1794}
1795
1796func (*validateOpUpdateApnsVoipChannel) ID() string {
1797	return "OperationInputValidation"
1798}
1799
1800func (m *validateOpUpdateApnsVoipChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1802) {
1803	input, ok := in.Parameters.(*UpdateApnsVoipChannelInput)
1804	if !ok {
1805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1806	}
1807	if err := validateOpUpdateApnsVoipChannelInput(input); err != nil {
1808		return out, metadata, err
1809	}
1810	return next.HandleInitialize(ctx, in)
1811}
1812
1813type validateOpUpdateApnsVoipSandboxChannel struct {
1814}
1815
1816func (*validateOpUpdateApnsVoipSandboxChannel) ID() string {
1817	return "OperationInputValidation"
1818}
1819
1820func (m *validateOpUpdateApnsVoipSandboxChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1822) {
1823	input, ok := in.Parameters.(*UpdateApnsVoipSandboxChannelInput)
1824	if !ok {
1825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1826	}
1827	if err := validateOpUpdateApnsVoipSandboxChannelInput(input); err != nil {
1828		return out, metadata, err
1829	}
1830	return next.HandleInitialize(ctx, in)
1831}
1832
1833type validateOpUpdateApplicationSettings struct {
1834}
1835
1836func (*validateOpUpdateApplicationSettings) ID() string {
1837	return "OperationInputValidation"
1838}
1839
1840func (m *validateOpUpdateApplicationSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1842) {
1843	input, ok := in.Parameters.(*UpdateApplicationSettingsInput)
1844	if !ok {
1845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1846	}
1847	if err := validateOpUpdateApplicationSettingsInput(input); err != nil {
1848		return out, metadata, err
1849	}
1850	return next.HandleInitialize(ctx, in)
1851}
1852
1853type validateOpUpdateBaiduChannel struct {
1854}
1855
1856func (*validateOpUpdateBaiduChannel) ID() string {
1857	return "OperationInputValidation"
1858}
1859
1860func (m *validateOpUpdateBaiduChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1862) {
1863	input, ok := in.Parameters.(*UpdateBaiduChannelInput)
1864	if !ok {
1865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1866	}
1867	if err := validateOpUpdateBaiduChannelInput(input); err != nil {
1868		return out, metadata, err
1869	}
1870	return next.HandleInitialize(ctx, in)
1871}
1872
1873type validateOpUpdateCampaign struct {
1874}
1875
1876func (*validateOpUpdateCampaign) ID() string {
1877	return "OperationInputValidation"
1878}
1879
1880func (m *validateOpUpdateCampaign) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1882) {
1883	input, ok := in.Parameters.(*UpdateCampaignInput)
1884	if !ok {
1885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1886	}
1887	if err := validateOpUpdateCampaignInput(input); err != nil {
1888		return out, metadata, err
1889	}
1890	return next.HandleInitialize(ctx, in)
1891}
1892
1893type validateOpUpdateEmailChannel struct {
1894}
1895
1896func (*validateOpUpdateEmailChannel) ID() string {
1897	return "OperationInputValidation"
1898}
1899
1900func (m *validateOpUpdateEmailChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1902) {
1903	input, ok := in.Parameters.(*UpdateEmailChannelInput)
1904	if !ok {
1905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1906	}
1907	if err := validateOpUpdateEmailChannelInput(input); err != nil {
1908		return out, metadata, err
1909	}
1910	return next.HandleInitialize(ctx, in)
1911}
1912
1913type validateOpUpdateEmailTemplate struct {
1914}
1915
1916func (*validateOpUpdateEmailTemplate) ID() string {
1917	return "OperationInputValidation"
1918}
1919
1920func (m *validateOpUpdateEmailTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1922) {
1923	input, ok := in.Parameters.(*UpdateEmailTemplateInput)
1924	if !ok {
1925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1926	}
1927	if err := validateOpUpdateEmailTemplateInput(input); err != nil {
1928		return out, metadata, err
1929	}
1930	return next.HandleInitialize(ctx, in)
1931}
1932
1933type validateOpUpdateEndpoint struct {
1934}
1935
1936func (*validateOpUpdateEndpoint) ID() string {
1937	return "OperationInputValidation"
1938}
1939
1940func (m *validateOpUpdateEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1942) {
1943	input, ok := in.Parameters.(*UpdateEndpointInput)
1944	if !ok {
1945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1946	}
1947	if err := validateOpUpdateEndpointInput(input); err != nil {
1948		return out, metadata, err
1949	}
1950	return next.HandleInitialize(ctx, in)
1951}
1952
1953type validateOpUpdateEndpointsBatch struct {
1954}
1955
1956func (*validateOpUpdateEndpointsBatch) ID() string {
1957	return "OperationInputValidation"
1958}
1959
1960func (m *validateOpUpdateEndpointsBatch) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1962) {
1963	input, ok := in.Parameters.(*UpdateEndpointsBatchInput)
1964	if !ok {
1965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1966	}
1967	if err := validateOpUpdateEndpointsBatchInput(input); err != nil {
1968		return out, metadata, err
1969	}
1970	return next.HandleInitialize(ctx, in)
1971}
1972
1973type validateOpUpdateGcmChannel struct {
1974}
1975
1976func (*validateOpUpdateGcmChannel) ID() string {
1977	return "OperationInputValidation"
1978}
1979
1980func (m *validateOpUpdateGcmChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1982) {
1983	input, ok := in.Parameters.(*UpdateGcmChannelInput)
1984	if !ok {
1985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1986	}
1987	if err := validateOpUpdateGcmChannelInput(input); err != nil {
1988		return out, metadata, err
1989	}
1990	return next.HandleInitialize(ctx, in)
1991}
1992
1993type validateOpUpdateJourney struct {
1994}
1995
1996func (*validateOpUpdateJourney) ID() string {
1997	return "OperationInputValidation"
1998}
1999
2000func (m *validateOpUpdateJourney) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2002) {
2003	input, ok := in.Parameters.(*UpdateJourneyInput)
2004	if !ok {
2005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2006	}
2007	if err := validateOpUpdateJourneyInput(input); err != nil {
2008		return out, metadata, err
2009	}
2010	return next.HandleInitialize(ctx, in)
2011}
2012
2013type validateOpUpdateJourneyState struct {
2014}
2015
2016func (*validateOpUpdateJourneyState) ID() string {
2017	return "OperationInputValidation"
2018}
2019
2020func (m *validateOpUpdateJourneyState) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2022) {
2023	input, ok := in.Parameters.(*UpdateJourneyStateInput)
2024	if !ok {
2025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2026	}
2027	if err := validateOpUpdateJourneyStateInput(input); err != nil {
2028		return out, metadata, err
2029	}
2030	return next.HandleInitialize(ctx, in)
2031}
2032
2033type validateOpUpdatePushTemplate struct {
2034}
2035
2036func (*validateOpUpdatePushTemplate) ID() string {
2037	return "OperationInputValidation"
2038}
2039
2040func (m *validateOpUpdatePushTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2042) {
2043	input, ok := in.Parameters.(*UpdatePushTemplateInput)
2044	if !ok {
2045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2046	}
2047	if err := validateOpUpdatePushTemplateInput(input); err != nil {
2048		return out, metadata, err
2049	}
2050	return next.HandleInitialize(ctx, in)
2051}
2052
2053type validateOpUpdateRecommenderConfiguration struct {
2054}
2055
2056func (*validateOpUpdateRecommenderConfiguration) ID() string {
2057	return "OperationInputValidation"
2058}
2059
2060func (m *validateOpUpdateRecommenderConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2062) {
2063	input, ok := in.Parameters.(*UpdateRecommenderConfigurationInput)
2064	if !ok {
2065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2066	}
2067	if err := validateOpUpdateRecommenderConfigurationInput(input); err != nil {
2068		return out, metadata, err
2069	}
2070	return next.HandleInitialize(ctx, in)
2071}
2072
2073type validateOpUpdateSegment struct {
2074}
2075
2076func (*validateOpUpdateSegment) ID() string {
2077	return "OperationInputValidation"
2078}
2079
2080func (m *validateOpUpdateSegment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2082) {
2083	input, ok := in.Parameters.(*UpdateSegmentInput)
2084	if !ok {
2085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2086	}
2087	if err := validateOpUpdateSegmentInput(input); err != nil {
2088		return out, metadata, err
2089	}
2090	return next.HandleInitialize(ctx, in)
2091}
2092
2093type validateOpUpdateSmsChannel struct {
2094}
2095
2096func (*validateOpUpdateSmsChannel) ID() string {
2097	return "OperationInputValidation"
2098}
2099
2100func (m *validateOpUpdateSmsChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2102) {
2103	input, ok := in.Parameters.(*UpdateSmsChannelInput)
2104	if !ok {
2105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2106	}
2107	if err := validateOpUpdateSmsChannelInput(input); err != nil {
2108		return out, metadata, err
2109	}
2110	return next.HandleInitialize(ctx, in)
2111}
2112
2113type validateOpUpdateSmsTemplate struct {
2114}
2115
2116func (*validateOpUpdateSmsTemplate) ID() string {
2117	return "OperationInputValidation"
2118}
2119
2120func (m *validateOpUpdateSmsTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2122) {
2123	input, ok := in.Parameters.(*UpdateSmsTemplateInput)
2124	if !ok {
2125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2126	}
2127	if err := validateOpUpdateSmsTemplateInput(input); err != nil {
2128		return out, metadata, err
2129	}
2130	return next.HandleInitialize(ctx, in)
2131}
2132
2133type validateOpUpdateTemplateActiveVersion struct {
2134}
2135
2136func (*validateOpUpdateTemplateActiveVersion) ID() string {
2137	return "OperationInputValidation"
2138}
2139
2140func (m *validateOpUpdateTemplateActiveVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2142) {
2143	input, ok := in.Parameters.(*UpdateTemplateActiveVersionInput)
2144	if !ok {
2145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2146	}
2147	if err := validateOpUpdateTemplateActiveVersionInput(input); err != nil {
2148		return out, metadata, err
2149	}
2150	return next.HandleInitialize(ctx, in)
2151}
2152
2153type validateOpUpdateVoiceChannel struct {
2154}
2155
2156func (*validateOpUpdateVoiceChannel) ID() string {
2157	return "OperationInputValidation"
2158}
2159
2160func (m *validateOpUpdateVoiceChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2162) {
2163	input, ok := in.Parameters.(*UpdateVoiceChannelInput)
2164	if !ok {
2165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2166	}
2167	if err := validateOpUpdateVoiceChannelInput(input); err != nil {
2168		return out, metadata, err
2169	}
2170	return next.HandleInitialize(ctx, in)
2171}
2172
2173type validateOpUpdateVoiceTemplate struct {
2174}
2175
2176func (*validateOpUpdateVoiceTemplate) ID() string {
2177	return "OperationInputValidation"
2178}
2179
2180func (m *validateOpUpdateVoiceTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2182) {
2183	input, ok := in.Parameters.(*UpdateVoiceTemplateInput)
2184	if !ok {
2185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2186	}
2187	if err := validateOpUpdateVoiceTemplateInput(input); err != nil {
2188		return out, metadata, err
2189	}
2190	return next.HandleInitialize(ctx, in)
2191}
2192
2193func addOpCreateAppValidationMiddleware(stack *middleware.Stack) error {
2194	return stack.Initialize.Add(&validateOpCreateApp{}, middleware.After)
2195}
2196
2197func addOpCreateCampaignValidationMiddleware(stack *middleware.Stack) error {
2198	return stack.Initialize.Add(&validateOpCreateCampaign{}, middleware.After)
2199}
2200
2201func addOpCreateEmailTemplateValidationMiddleware(stack *middleware.Stack) error {
2202	return stack.Initialize.Add(&validateOpCreateEmailTemplate{}, middleware.After)
2203}
2204
2205func addOpCreateExportJobValidationMiddleware(stack *middleware.Stack) error {
2206	return stack.Initialize.Add(&validateOpCreateExportJob{}, middleware.After)
2207}
2208
2209func addOpCreateImportJobValidationMiddleware(stack *middleware.Stack) error {
2210	return stack.Initialize.Add(&validateOpCreateImportJob{}, middleware.After)
2211}
2212
2213func addOpCreateJourneyValidationMiddleware(stack *middleware.Stack) error {
2214	return stack.Initialize.Add(&validateOpCreateJourney{}, middleware.After)
2215}
2216
2217func addOpCreatePushTemplateValidationMiddleware(stack *middleware.Stack) error {
2218	return stack.Initialize.Add(&validateOpCreatePushTemplate{}, middleware.After)
2219}
2220
2221func addOpCreateRecommenderConfigurationValidationMiddleware(stack *middleware.Stack) error {
2222	return stack.Initialize.Add(&validateOpCreateRecommenderConfiguration{}, middleware.After)
2223}
2224
2225func addOpCreateSegmentValidationMiddleware(stack *middleware.Stack) error {
2226	return stack.Initialize.Add(&validateOpCreateSegment{}, middleware.After)
2227}
2228
2229func addOpCreateSmsTemplateValidationMiddleware(stack *middleware.Stack) error {
2230	return stack.Initialize.Add(&validateOpCreateSmsTemplate{}, middleware.After)
2231}
2232
2233func addOpCreateVoiceTemplateValidationMiddleware(stack *middleware.Stack) error {
2234	return stack.Initialize.Add(&validateOpCreateVoiceTemplate{}, middleware.After)
2235}
2236
2237func addOpDeleteAdmChannelValidationMiddleware(stack *middleware.Stack) error {
2238	return stack.Initialize.Add(&validateOpDeleteAdmChannel{}, middleware.After)
2239}
2240
2241func addOpDeleteApnsChannelValidationMiddleware(stack *middleware.Stack) error {
2242	return stack.Initialize.Add(&validateOpDeleteApnsChannel{}, middleware.After)
2243}
2244
2245func addOpDeleteApnsSandboxChannelValidationMiddleware(stack *middleware.Stack) error {
2246	return stack.Initialize.Add(&validateOpDeleteApnsSandboxChannel{}, middleware.After)
2247}
2248
2249func addOpDeleteApnsVoipChannelValidationMiddleware(stack *middleware.Stack) error {
2250	return stack.Initialize.Add(&validateOpDeleteApnsVoipChannel{}, middleware.After)
2251}
2252
2253func addOpDeleteApnsVoipSandboxChannelValidationMiddleware(stack *middleware.Stack) error {
2254	return stack.Initialize.Add(&validateOpDeleteApnsVoipSandboxChannel{}, middleware.After)
2255}
2256
2257func addOpDeleteAppValidationMiddleware(stack *middleware.Stack) error {
2258	return stack.Initialize.Add(&validateOpDeleteApp{}, middleware.After)
2259}
2260
2261func addOpDeleteBaiduChannelValidationMiddleware(stack *middleware.Stack) error {
2262	return stack.Initialize.Add(&validateOpDeleteBaiduChannel{}, middleware.After)
2263}
2264
2265func addOpDeleteCampaignValidationMiddleware(stack *middleware.Stack) error {
2266	return stack.Initialize.Add(&validateOpDeleteCampaign{}, middleware.After)
2267}
2268
2269func addOpDeleteEmailChannelValidationMiddleware(stack *middleware.Stack) error {
2270	return stack.Initialize.Add(&validateOpDeleteEmailChannel{}, middleware.After)
2271}
2272
2273func addOpDeleteEmailTemplateValidationMiddleware(stack *middleware.Stack) error {
2274	return stack.Initialize.Add(&validateOpDeleteEmailTemplate{}, middleware.After)
2275}
2276
2277func addOpDeleteEndpointValidationMiddleware(stack *middleware.Stack) error {
2278	return stack.Initialize.Add(&validateOpDeleteEndpoint{}, middleware.After)
2279}
2280
2281func addOpDeleteEventStreamValidationMiddleware(stack *middleware.Stack) error {
2282	return stack.Initialize.Add(&validateOpDeleteEventStream{}, middleware.After)
2283}
2284
2285func addOpDeleteGcmChannelValidationMiddleware(stack *middleware.Stack) error {
2286	return stack.Initialize.Add(&validateOpDeleteGcmChannel{}, middleware.After)
2287}
2288
2289func addOpDeleteJourneyValidationMiddleware(stack *middleware.Stack) error {
2290	return stack.Initialize.Add(&validateOpDeleteJourney{}, middleware.After)
2291}
2292
2293func addOpDeletePushTemplateValidationMiddleware(stack *middleware.Stack) error {
2294	return stack.Initialize.Add(&validateOpDeletePushTemplate{}, middleware.After)
2295}
2296
2297func addOpDeleteRecommenderConfigurationValidationMiddleware(stack *middleware.Stack) error {
2298	return stack.Initialize.Add(&validateOpDeleteRecommenderConfiguration{}, middleware.After)
2299}
2300
2301func addOpDeleteSegmentValidationMiddleware(stack *middleware.Stack) error {
2302	return stack.Initialize.Add(&validateOpDeleteSegment{}, middleware.After)
2303}
2304
2305func addOpDeleteSmsChannelValidationMiddleware(stack *middleware.Stack) error {
2306	return stack.Initialize.Add(&validateOpDeleteSmsChannel{}, middleware.After)
2307}
2308
2309func addOpDeleteSmsTemplateValidationMiddleware(stack *middleware.Stack) error {
2310	return stack.Initialize.Add(&validateOpDeleteSmsTemplate{}, middleware.After)
2311}
2312
2313func addOpDeleteUserEndpointsValidationMiddleware(stack *middleware.Stack) error {
2314	return stack.Initialize.Add(&validateOpDeleteUserEndpoints{}, middleware.After)
2315}
2316
2317func addOpDeleteVoiceChannelValidationMiddleware(stack *middleware.Stack) error {
2318	return stack.Initialize.Add(&validateOpDeleteVoiceChannel{}, middleware.After)
2319}
2320
2321func addOpDeleteVoiceTemplateValidationMiddleware(stack *middleware.Stack) error {
2322	return stack.Initialize.Add(&validateOpDeleteVoiceTemplate{}, middleware.After)
2323}
2324
2325func addOpGetAdmChannelValidationMiddleware(stack *middleware.Stack) error {
2326	return stack.Initialize.Add(&validateOpGetAdmChannel{}, middleware.After)
2327}
2328
2329func addOpGetApnsChannelValidationMiddleware(stack *middleware.Stack) error {
2330	return stack.Initialize.Add(&validateOpGetApnsChannel{}, middleware.After)
2331}
2332
2333func addOpGetApnsSandboxChannelValidationMiddleware(stack *middleware.Stack) error {
2334	return stack.Initialize.Add(&validateOpGetApnsSandboxChannel{}, middleware.After)
2335}
2336
2337func addOpGetApnsVoipChannelValidationMiddleware(stack *middleware.Stack) error {
2338	return stack.Initialize.Add(&validateOpGetApnsVoipChannel{}, middleware.After)
2339}
2340
2341func addOpGetApnsVoipSandboxChannelValidationMiddleware(stack *middleware.Stack) error {
2342	return stack.Initialize.Add(&validateOpGetApnsVoipSandboxChannel{}, middleware.After)
2343}
2344
2345func addOpGetAppValidationMiddleware(stack *middleware.Stack) error {
2346	return stack.Initialize.Add(&validateOpGetApp{}, middleware.After)
2347}
2348
2349func addOpGetApplicationDateRangeKpiValidationMiddleware(stack *middleware.Stack) error {
2350	return stack.Initialize.Add(&validateOpGetApplicationDateRangeKpi{}, middleware.After)
2351}
2352
2353func addOpGetApplicationSettingsValidationMiddleware(stack *middleware.Stack) error {
2354	return stack.Initialize.Add(&validateOpGetApplicationSettings{}, middleware.After)
2355}
2356
2357func addOpGetBaiduChannelValidationMiddleware(stack *middleware.Stack) error {
2358	return stack.Initialize.Add(&validateOpGetBaiduChannel{}, middleware.After)
2359}
2360
2361func addOpGetCampaignActivitiesValidationMiddleware(stack *middleware.Stack) error {
2362	return stack.Initialize.Add(&validateOpGetCampaignActivities{}, middleware.After)
2363}
2364
2365func addOpGetCampaignDateRangeKpiValidationMiddleware(stack *middleware.Stack) error {
2366	return stack.Initialize.Add(&validateOpGetCampaignDateRangeKpi{}, middleware.After)
2367}
2368
2369func addOpGetCampaignValidationMiddleware(stack *middleware.Stack) error {
2370	return stack.Initialize.Add(&validateOpGetCampaign{}, middleware.After)
2371}
2372
2373func addOpGetCampaignsValidationMiddleware(stack *middleware.Stack) error {
2374	return stack.Initialize.Add(&validateOpGetCampaigns{}, middleware.After)
2375}
2376
2377func addOpGetCampaignVersionValidationMiddleware(stack *middleware.Stack) error {
2378	return stack.Initialize.Add(&validateOpGetCampaignVersion{}, middleware.After)
2379}
2380
2381func addOpGetCampaignVersionsValidationMiddleware(stack *middleware.Stack) error {
2382	return stack.Initialize.Add(&validateOpGetCampaignVersions{}, middleware.After)
2383}
2384
2385func addOpGetChannelsValidationMiddleware(stack *middleware.Stack) error {
2386	return stack.Initialize.Add(&validateOpGetChannels{}, middleware.After)
2387}
2388
2389func addOpGetEmailChannelValidationMiddleware(stack *middleware.Stack) error {
2390	return stack.Initialize.Add(&validateOpGetEmailChannel{}, middleware.After)
2391}
2392
2393func addOpGetEmailTemplateValidationMiddleware(stack *middleware.Stack) error {
2394	return stack.Initialize.Add(&validateOpGetEmailTemplate{}, middleware.After)
2395}
2396
2397func addOpGetEndpointValidationMiddleware(stack *middleware.Stack) error {
2398	return stack.Initialize.Add(&validateOpGetEndpoint{}, middleware.After)
2399}
2400
2401func addOpGetEventStreamValidationMiddleware(stack *middleware.Stack) error {
2402	return stack.Initialize.Add(&validateOpGetEventStream{}, middleware.After)
2403}
2404
2405func addOpGetExportJobValidationMiddleware(stack *middleware.Stack) error {
2406	return stack.Initialize.Add(&validateOpGetExportJob{}, middleware.After)
2407}
2408
2409func addOpGetExportJobsValidationMiddleware(stack *middleware.Stack) error {
2410	return stack.Initialize.Add(&validateOpGetExportJobs{}, middleware.After)
2411}
2412
2413func addOpGetGcmChannelValidationMiddleware(stack *middleware.Stack) error {
2414	return stack.Initialize.Add(&validateOpGetGcmChannel{}, middleware.After)
2415}
2416
2417func addOpGetImportJobValidationMiddleware(stack *middleware.Stack) error {
2418	return stack.Initialize.Add(&validateOpGetImportJob{}, middleware.After)
2419}
2420
2421func addOpGetImportJobsValidationMiddleware(stack *middleware.Stack) error {
2422	return stack.Initialize.Add(&validateOpGetImportJobs{}, middleware.After)
2423}
2424
2425func addOpGetJourneyDateRangeKpiValidationMiddleware(stack *middleware.Stack) error {
2426	return stack.Initialize.Add(&validateOpGetJourneyDateRangeKpi{}, middleware.After)
2427}
2428
2429func addOpGetJourneyExecutionActivityMetricsValidationMiddleware(stack *middleware.Stack) error {
2430	return stack.Initialize.Add(&validateOpGetJourneyExecutionActivityMetrics{}, middleware.After)
2431}
2432
2433func addOpGetJourneyExecutionMetricsValidationMiddleware(stack *middleware.Stack) error {
2434	return stack.Initialize.Add(&validateOpGetJourneyExecutionMetrics{}, middleware.After)
2435}
2436
2437func addOpGetJourneyValidationMiddleware(stack *middleware.Stack) error {
2438	return stack.Initialize.Add(&validateOpGetJourney{}, middleware.After)
2439}
2440
2441func addOpGetPushTemplateValidationMiddleware(stack *middleware.Stack) error {
2442	return stack.Initialize.Add(&validateOpGetPushTemplate{}, middleware.After)
2443}
2444
2445func addOpGetRecommenderConfigurationValidationMiddleware(stack *middleware.Stack) error {
2446	return stack.Initialize.Add(&validateOpGetRecommenderConfiguration{}, middleware.After)
2447}
2448
2449func addOpGetSegmentExportJobsValidationMiddleware(stack *middleware.Stack) error {
2450	return stack.Initialize.Add(&validateOpGetSegmentExportJobs{}, middleware.After)
2451}
2452
2453func addOpGetSegmentImportJobsValidationMiddleware(stack *middleware.Stack) error {
2454	return stack.Initialize.Add(&validateOpGetSegmentImportJobs{}, middleware.After)
2455}
2456
2457func addOpGetSegmentValidationMiddleware(stack *middleware.Stack) error {
2458	return stack.Initialize.Add(&validateOpGetSegment{}, middleware.After)
2459}
2460
2461func addOpGetSegmentsValidationMiddleware(stack *middleware.Stack) error {
2462	return stack.Initialize.Add(&validateOpGetSegments{}, middleware.After)
2463}
2464
2465func addOpGetSegmentVersionValidationMiddleware(stack *middleware.Stack) error {
2466	return stack.Initialize.Add(&validateOpGetSegmentVersion{}, middleware.After)
2467}
2468
2469func addOpGetSegmentVersionsValidationMiddleware(stack *middleware.Stack) error {
2470	return stack.Initialize.Add(&validateOpGetSegmentVersions{}, middleware.After)
2471}
2472
2473func addOpGetSmsChannelValidationMiddleware(stack *middleware.Stack) error {
2474	return stack.Initialize.Add(&validateOpGetSmsChannel{}, middleware.After)
2475}
2476
2477func addOpGetSmsTemplateValidationMiddleware(stack *middleware.Stack) error {
2478	return stack.Initialize.Add(&validateOpGetSmsTemplate{}, middleware.After)
2479}
2480
2481func addOpGetUserEndpointsValidationMiddleware(stack *middleware.Stack) error {
2482	return stack.Initialize.Add(&validateOpGetUserEndpoints{}, middleware.After)
2483}
2484
2485func addOpGetVoiceChannelValidationMiddleware(stack *middleware.Stack) error {
2486	return stack.Initialize.Add(&validateOpGetVoiceChannel{}, middleware.After)
2487}
2488
2489func addOpGetVoiceTemplateValidationMiddleware(stack *middleware.Stack) error {
2490	return stack.Initialize.Add(&validateOpGetVoiceTemplate{}, middleware.After)
2491}
2492
2493func addOpListJourneysValidationMiddleware(stack *middleware.Stack) error {
2494	return stack.Initialize.Add(&validateOpListJourneys{}, middleware.After)
2495}
2496
2497func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
2498	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
2499}
2500
2501func addOpListTemplateVersionsValidationMiddleware(stack *middleware.Stack) error {
2502	return stack.Initialize.Add(&validateOpListTemplateVersions{}, middleware.After)
2503}
2504
2505func addOpPhoneNumberValidateValidationMiddleware(stack *middleware.Stack) error {
2506	return stack.Initialize.Add(&validateOpPhoneNumberValidate{}, middleware.After)
2507}
2508
2509func addOpPutEventsValidationMiddleware(stack *middleware.Stack) error {
2510	return stack.Initialize.Add(&validateOpPutEvents{}, middleware.After)
2511}
2512
2513func addOpPutEventStreamValidationMiddleware(stack *middleware.Stack) error {
2514	return stack.Initialize.Add(&validateOpPutEventStream{}, middleware.After)
2515}
2516
2517func addOpRemoveAttributesValidationMiddleware(stack *middleware.Stack) error {
2518	return stack.Initialize.Add(&validateOpRemoveAttributes{}, middleware.After)
2519}
2520
2521func addOpSendMessagesValidationMiddleware(stack *middleware.Stack) error {
2522	return stack.Initialize.Add(&validateOpSendMessages{}, middleware.After)
2523}
2524
2525func addOpSendUsersMessagesValidationMiddleware(stack *middleware.Stack) error {
2526	return stack.Initialize.Add(&validateOpSendUsersMessages{}, middleware.After)
2527}
2528
2529func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
2530	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
2531}
2532
2533func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
2534	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
2535}
2536
2537func addOpUpdateAdmChannelValidationMiddleware(stack *middleware.Stack) error {
2538	return stack.Initialize.Add(&validateOpUpdateAdmChannel{}, middleware.After)
2539}
2540
2541func addOpUpdateApnsChannelValidationMiddleware(stack *middleware.Stack) error {
2542	return stack.Initialize.Add(&validateOpUpdateApnsChannel{}, middleware.After)
2543}
2544
2545func addOpUpdateApnsSandboxChannelValidationMiddleware(stack *middleware.Stack) error {
2546	return stack.Initialize.Add(&validateOpUpdateApnsSandboxChannel{}, middleware.After)
2547}
2548
2549func addOpUpdateApnsVoipChannelValidationMiddleware(stack *middleware.Stack) error {
2550	return stack.Initialize.Add(&validateOpUpdateApnsVoipChannel{}, middleware.After)
2551}
2552
2553func addOpUpdateApnsVoipSandboxChannelValidationMiddleware(stack *middleware.Stack) error {
2554	return stack.Initialize.Add(&validateOpUpdateApnsVoipSandboxChannel{}, middleware.After)
2555}
2556
2557func addOpUpdateApplicationSettingsValidationMiddleware(stack *middleware.Stack) error {
2558	return stack.Initialize.Add(&validateOpUpdateApplicationSettings{}, middleware.After)
2559}
2560
2561func addOpUpdateBaiduChannelValidationMiddleware(stack *middleware.Stack) error {
2562	return stack.Initialize.Add(&validateOpUpdateBaiduChannel{}, middleware.After)
2563}
2564
2565func addOpUpdateCampaignValidationMiddleware(stack *middleware.Stack) error {
2566	return stack.Initialize.Add(&validateOpUpdateCampaign{}, middleware.After)
2567}
2568
2569func addOpUpdateEmailChannelValidationMiddleware(stack *middleware.Stack) error {
2570	return stack.Initialize.Add(&validateOpUpdateEmailChannel{}, middleware.After)
2571}
2572
2573func addOpUpdateEmailTemplateValidationMiddleware(stack *middleware.Stack) error {
2574	return stack.Initialize.Add(&validateOpUpdateEmailTemplate{}, middleware.After)
2575}
2576
2577func addOpUpdateEndpointValidationMiddleware(stack *middleware.Stack) error {
2578	return stack.Initialize.Add(&validateOpUpdateEndpoint{}, middleware.After)
2579}
2580
2581func addOpUpdateEndpointsBatchValidationMiddleware(stack *middleware.Stack) error {
2582	return stack.Initialize.Add(&validateOpUpdateEndpointsBatch{}, middleware.After)
2583}
2584
2585func addOpUpdateGcmChannelValidationMiddleware(stack *middleware.Stack) error {
2586	return stack.Initialize.Add(&validateOpUpdateGcmChannel{}, middleware.After)
2587}
2588
2589func addOpUpdateJourneyValidationMiddleware(stack *middleware.Stack) error {
2590	return stack.Initialize.Add(&validateOpUpdateJourney{}, middleware.After)
2591}
2592
2593func addOpUpdateJourneyStateValidationMiddleware(stack *middleware.Stack) error {
2594	return stack.Initialize.Add(&validateOpUpdateJourneyState{}, middleware.After)
2595}
2596
2597func addOpUpdatePushTemplateValidationMiddleware(stack *middleware.Stack) error {
2598	return stack.Initialize.Add(&validateOpUpdatePushTemplate{}, middleware.After)
2599}
2600
2601func addOpUpdateRecommenderConfigurationValidationMiddleware(stack *middleware.Stack) error {
2602	return stack.Initialize.Add(&validateOpUpdateRecommenderConfiguration{}, middleware.After)
2603}
2604
2605func addOpUpdateSegmentValidationMiddleware(stack *middleware.Stack) error {
2606	return stack.Initialize.Add(&validateOpUpdateSegment{}, middleware.After)
2607}
2608
2609func addOpUpdateSmsChannelValidationMiddleware(stack *middleware.Stack) error {
2610	return stack.Initialize.Add(&validateOpUpdateSmsChannel{}, middleware.After)
2611}
2612
2613func addOpUpdateSmsTemplateValidationMiddleware(stack *middleware.Stack) error {
2614	return stack.Initialize.Add(&validateOpUpdateSmsTemplate{}, middleware.After)
2615}
2616
2617func addOpUpdateTemplateActiveVersionValidationMiddleware(stack *middleware.Stack) error {
2618	return stack.Initialize.Add(&validateOpUpdateTemplateActiveVersion{}, middleware.After)
2619}
2620
2621func addOpUpdateVoiceChannelValidationMiddleware(stack *middleware.Stack) error {
2622	return stack.Initialize.Add(&validateOpUpdateVoiceChannel{}, middleware.After)
2623}
2624
2625func addOpUpdateVoiceTemplateValidationMiddleware(stack *middleware.Stack) error {
2626	return stack.Initialize.Add(&validateOpUpdateVoiceTemplate{}, middleware.After)
2627}
2628
2629func validateActivity(v *types.Activity) error {
2630	if v == nil {
2631		return nil
2632	}
2633	invalidParams := smithy.InvalidParamsError{Context: "Activity"}
2634	if v.ConditionalSplit != nil {
2635		if err := validateConditionalSplitActivity(v.ConditionalSplit); err != nil {
2636			invalidParams.AddNested("ConditionalSplit", err.(smithy.InvalidParamsError))
2637		}
2638	}
2639	if v.Holdout != nil {
2640		if err := validateHoldoutActivity(v.Holdout); err != nil {
2641			invalidParams.AddNested("Holdout", err.(smithy.InvalidParamsError))
2642		}
2643	}
2644	if v.MultiCondition != nil {
2645		if err := validateMultiConditionalSplitActivity(v.MultiCondition); err != nil {
2646			invalidParams.AddNested("MultiCondition", err.(smithy.InvalidParamsError))
2647		}
2648	}
2649	if invalidParams.Len() > 0 {
2650		return invalidParams
2651	} else {
2652		return nil
2653	}
2654}
2655
2656func validateADMChannelRequest(v *types.ADMChannelRequest) error {
2657	if v == nil {
2658		return nil
2659	}
2660	invalidParams := smithy.InvalidParamsError{Context: "ADMChannelRequest"}
2661	if v.ClientId == nil {
2662		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
2663	}
2664	if v.ClientSecret == nil {
2665		invalidParams.Add(smithy.NewErrParamRequired("ClientSecret"))
2666	}
2667	if invalidParams.Len() > 0 {
2668		return invalidParams
2669	} else {
2670		return nil
2671	}
2672}
2673
2674func validateAttributeDimension(v *types.AttributeDimension) error {
2675	if v == nil {
2676		return nil
2677	}
2678	invalidParams := smithy.InvalidParamsError{Context: "AttributeDimension"}
2679	if v.Values == nil {
2680		invalidParams.Add(smithy.NewErrParamRequired("Values"))
2681	}
2682	if invalidParams.Len() > 0 {
2683		return invalidParams
2684	} else {
2685		return nil
2686	}
2687}
2688
2689func validateBaiduChannelRequest(v *types.BaiduChannelRequest) error {
2690	if v == nil {
2691		return nil
2692	}
2693	invalidParams := smithy.InvalidParamsError{Context: "BaiduChannelRequest"}
2694	if v.ApiKey == nil {
2695		invalidParams.Add(smithy.NewErrParamRequired("ApiKey"))
2696	}
2697	if v.SecretKey == nil {
2698		invalidParams.Add(smithy.NewErrParamRequired("SecretKey"))
2699	}
2700	if invalidParams.Len() > 0 {
2701		return invalidParams
2702	} else {
2703		return nil
2704	}
2705}
2706
2707func validateCampaignEventFilter(v *types.CampaignEventFilter) error {
2708	if v == nil {
2709		return nil
2710	}
2711	invalidParams := smithy.InvalidParamsError{Context: "CampaignEventFilter"}
2712	if v.Dimensions == nil {
2713		invalidParams.Add(smithy.NewErrParamRequired("Dimensions"))
2714	} else if v.Dimensions != nil {
2715		if err := validateEventDimensions(v.Dimensions); err != nil {
2716			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
2717		}
2718	}
2719	if len(v.FilterType) == 0 {
2720		invalidParams.Add(smithy.NewErrParamRequired("FilterType"))
2721	}
2722	if invalidParams.Len() > 0 {
2723		return invalidParams
2724	} else {
2725		return nil
2726	}
2727}
2728
2729func validateCondition(v *types.Condition) error {
2730	if v == nil {
2731		return nil
2732	}
2733	invalidParams := smithy.InvalidParamsError{Context: "Condition"}
2734	if v.Conditions != nil {
2735		if err := validateListOfSimpleCondition(v.Conditions); err != nil {
2736			invalidParams.AddNested("Conditions", err.(smithy.InvalidParamsError))
2737		}
2738	}
2739	if invalidParams.Len() > 0 {
2740		return invalidParams
2741	} else {
2742		return nil
2743	}
2744}
2745
2746func validateConditionalSplitActivity(v *types.ConditionalSplitActivity) error {
2747	if v == nil {
2748		return nil
2749	}
2750	invalidParams := smithy.InvalidParamsError{Context: "ConditionalSplitActivity"}
2751	if v.Condition != nil {
2752		if err := validateCondition(v.Condition); err != nil {
2753			invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError))
2754		}
2755	}
2756	if invalidParams.Len() > 0 {
2757		return invalidParams
2758	} else {
2759		return nil
2760	}
2761}
2762
2763func validateCreateApplicationRequest(v *types.CreateApplicationRequest) error {
2764	if v == nil {
2765		return nil
2766	}
2767	invalidParams := smithy.InvalidParamsError{Context: "CreateApplicationRequest"}
2768	if v.Name == nil {
2769		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2770	}
2771	if invalidParams.Len() > 0 {
2772		return invalidParams
2773	} else {
2774		return nil
2775	}
2776}
2777
2778func validateCreateRecommenderConfigurationShape(v *types.CreateRecommenderConfigurationShape) error {
2779	if v == nil {
2780		return nil
2781	}
2782	invalidParams := smithy.InvalidParamsError{Context: "CreateRecommenderConfigurationShape"}
2783	if v.RecommendationProviderRoleArn == nil {
2784		invalidParams.Add(smithy.NewErrParamRequired("RecommendationProviderRoleArn"))
2785	}
2786	if v.RecommendationProviderUri == nil {
2787		invalidParams.Add(smithy.NewErrParamRequired("RecommendationProviderUri"))
2788	}
2789	if invalidParams.Len() > 0 {
2790		return invalidParams
2791	} else {
2792		return nil
2793	}
2794}
2795
2796func validateCustomDeliveryConfiguration(v *types.CustomDeliveryConfiguration) error {
2797	if v == nil {
2798		return nil
2799	}
2800	invalidParams := smithy.InvalidParamsError{Context: "CustomDeliveryConfiguration"}
2801	if v.DeliveryUri == nil {
2802		invalidParams.Add(smithy.NewErrParamRequired("DeliveryUri"))
2803	}
2804	if invalidParams.Len() > 0 {
2805		return invalidParams
2806	} else {
2807		return nil
2808	}
2809}
2810
2811func validateEmailChannelRequest(v *types.EmailChannelRequest) error {
2812	if v == nil {
2813		return nil
2814	}
2815	invalidParams := smithy.InvalidParamsError{Context: "EmailChannelRequest"}
2816	if v.FromAddress == nil {
2817		invalidParams.Add(smithy.NewErrParamRequired("FromAddress"))
2818	}
2819	if v.Identity == nil {
2820		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
2821	}
2822	if invalidParams.Len() > 0 {
2823		return invalidParams
2824	} else {
2825		return nil
2826	}
2827}
2828
2829func validateEndpointBatchRequest(v *types.EndpointBatchRequest) error {
2830	if v == nil {
2831		return nil
2832	}
2833	invalidParams := smithy.InvalidParamsError{Context: "EndpointBatchRequest"}
2834	if v.Item == nil {
2835		invalidParams.Add(smithy.NewErrParamRequired("Item"))
2836	}
2837	if invalidParams.Len() > 0 {
2838		return invalidParams
2839	} else {
2840		return nil
2841	}
2842}
2843
2844func validateEvent(v *types.Event) error {
2845	if v == nil {
2846		return nil
2847	}
2848	invalidParams := smithy.InvalidParamsError{Context: "Event"}
2849	if v.EventType == nil {
2850		invalidParams.Add(smithy.NewErrParamRequired("EventType"))
2851	}
2852	if v.Session != nil {
2853		if err := validateSession(v.Session); err != nil {
2854			invalidParams.AddNested("Session", err.(smithy.InvalidParamsError))
2855		}
2856	}
2857	if v.Timestamp == nil {
2858		invalidParams.Add(smithy.NewErrParamRequired("Timestamp"))
2859	}
2860	if invalidParams.Len() > 0 {
2861		return invalidParams
2862	} else {
2863		return nil
2864	}
2865}
2866
2867func validateEventCondition(v *types.EventCondition) error {
2868	if v == nil {
2869		return nil
2870	}
2871	invalidParams := smithy.InvalidParamsError{Context: "EventCondition"}
2872	if v.Dimensions != nil {
2873		if err := validateEventDimensions(v.Dimensions); err != nil {
2874			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
2875		}
2876	}
2877	if invalidParams.Len() > 0 {
2878		return invalidParams
2879	} else {
2880		return nil
2881	}
2882}
2883
2884func validateEventDimensions(v *types.EventDimensions) error {
2885	if v == nil {
2886		return nil
2887	}
2888	invalidParams := smithy.InvalidParamsError{Context: "EventDimensions"}
2889	if v.Attributes != nil {
2890		if err := validateMapOfAttributeDimension(v.Attributes); err != nil {
2891			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
2892		}
2893	}
2894	if v.EventType != nil {
2895		if err := validateSetDimension(v.EventType); err != nil {
2896			invalidParams.AddNested("EventType", err.(smithy.InvalidParamsError))
2897		}
2898	}
2899	if v.Metrics != nil {
2900		if err := validateMapOfMetricDimension(v.Metrics); err != nil {
2901			invalidParams.AddNested("Metrics", err.(smithy.InvalidParamsError))
2902		}
2903	}
2904	if invalidParams.Len() > 0 {
2905		return invalidParams
2906	} else {
2907		return nil
2908	}
2909}
2910
2911func validateEventFilter(v *types.EventFilter) error {
2912	if v == nil {
2913		return nil
2914	}
2915	invalidParams := smithy.InvalidParamsError{Context: "EventFilter"}
2916	if v.Dimensions == nil {
2917		invalidParams.Add(smithy.NewErrParamRequired("Dimensions"))
2918	} else if v.Dimensions != nil {
2919		if err := validateEventDimensions(v.Dimensions); err != nil {
2920			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
2921		}
2922	}
2923	if len(v.FilterType) == 0 {
2924		invalidParams.Add(smithy.NewErrParamRequired("FilterType"))
2925	}
2926	if invalidParams.Len() > 0 {
2927		return invalidParams
2928	} else {
2929		return nil
2930	}
2931}
2932
2933func validateEventsBatch(v *types.EventsBatch) error {
2934	if v == nil {
2935		return nil
2936	}
2937	invalidParams := smithy.InvalidParamsError{Context: "EventsBatch"}
2938	if v.Endpoint == nil {
2939		invalidParams.Add(smithy.NewErrParamRequired("Endpoint"))
2940	}
2941	if v.Events == nil {
2942		invalidParams.Add(smithy.NewErrParamRequired("Events"))
2943	} else if v.Events != nil {
2944		if err := validateMapOfEvent(v.Events); err != nil {
2945			invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
2946		}
2947	}
2948	if invalidParams.Len() > 0 {
2949		return invalidParams
2950	} else {
2951		return nil
2952	}
2953}
2954
2955func validateEventsRequest(v *types.EventsRequest) error {
2956	if v == nil {
2957		return nil
2958	}
2959	invalidParams := smithy.InvalidParamsError{Context: "EventsRequest"}
2960	if v.BatchItem == nil {
2961		invalidParams.Add(smithy.NewErrParamRequired("BatchItem"))
2962	} else if v.BatchItem != nil {
2963		if err := validateMapOfEventsBatch(v.BatchItem); err != nil {
2964			invalidParams.AddNested("BatchItem", err.(smithy.InvalidParamsError))
2965		}
2966	}
2967	if invalidParams.Len() > 0 {
2968		return invalidParams
2969	} else {
2970		return nil
2971	}
2972}
2973
2974func validateEventStartCondition(v *types.EventStartCondition) error {
2975	if v == nil {
2976		return nil
2977	}
2978	invalidParams := smithy.InvalidParamsError{Context: "EventStartCondition"}
2979	if v.EventFilter != nil {
2980		if err := validateEventFilter(v.EventFilter); err != nil {
2981			invalidParams.AddNested("EventFilter", err.(smithy.InvalidParamsError))
2982		}
2983	}
2984	if invalidParams.Len() > 0 {
2985		return invalidParams
2986	} else {
2987		return nil
2988	}
2989}
2990
2991func validateExportJobRequest(v *types.ExportJobRequest) error {
2992	if v == nil {
2993		return nil
2994	}
2995	invalidParams := smithy.InvalidParamsError{Context: "ExportJobRequest"}
2996	if v.RoleArn == nil {
2997		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
2998	}
2999	if v.S3UrlPrefix == nil {
3000		invalidParams.Add(smithy.NewErrParamRequired("S3UrlPrefix"))
3001	}
3002	if invalidParams.Len() > 0 {
3003		return invalidParams
3004	} else {
3005		return nil
3006	}
3007}
3008
3009func validateGCMChannelRequest(v *types.GCMChannelRequest) error {
3010	if v == nil {
3011		return nil
3012	}
3013	invalidParams := smithy.InvalidParamsError{Context: "GCMChannelRequest"}
3014	if v.ApiKey == nil {
3015		invalidParams.Add(smithy.NewErrParamRequired("ApiKey"))
3016	}
3017	if invalidParams.Len() > 0 {
3018		return invalidParams
3019	} else {
3020		return nil
3021	}
3022}
3023
3024func validateGPSCoordinates(v *types.GPSCoordinates) error {
3025	if v == nil {
3026		return nil
3027	}
3028	invalidParams := smithy.InvalidParamsError{Context: "GPSCoordinates"}
3029	if invalidParams.Len() > 0 {
3030		return invalidParams
3031	} else {
3032		return nil
3033	}
3034}
3035
3036func validateGPSPointDimension(v *types.GPSPointDimension) error {
3037	if v == nil {
3038		return nil
3039	}
3040	invalidParams := smithy.InvalidParamsError{Context: "GPSPointDimension"}
3041	if v.Coordinates == nil {
3042		invalidParams.Add(smithy.NewErrParamRequired("Coordinates"))
3043	} else if v.Coordinates != nil {
3044		if err := validateGPSCoordinates(v.Coordinates); err != nil {
3045			invalidParams.AddNested("Coordinates", err.(smithy.InvalidParamsError))
3046		}
3047	}
3048	if invalidParams.Len() > 0 {
3049		return invalidParams
3050	} else {
3051		return nil
3052	}
3053}
3054
3055func validateHoldoutActivity(v *types.HoldoutActivity) error {
3056	if v == nil {
3057		return nil
3058	}
3059	invalidParams := smithy.InvalidParamsError{Context: "HoldoutActivity"}
3060	if invalidParams.Len() > 0 {
3061		return invalidParams
3062	} else {
3063		return nil
3064	}
3065}
3066
3067func validateImportJobRequest(v *types.ImportJobRequest) error {
3068	if v == nil {
3069		return nil
3070	}
3071	invalidParams := smithy.InvalidParamsError{Context: "ImportJobRequest"}
3072	if len(v.Format) == 0 {
3073		invalidParams.Add(smithy.NewErrParamRequired("Format"))
3074	}
3075	if v.RoleArn == nil {
3076		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
3077	}
3078	if v.S3Url == nil {
3079		invalidParams.Add(smithy.NewErrParamRequired("S3Url"))
3080	}
3081	if invalidParams.Len() > 0 {
3082		return invalidParams
3083	} else {
3084		return nil
3085	}
3086}
3087
3088func validateListOfMultiConditionalBranch(v []types.MultiConditionalBranch) error {
3089	if v == nil {
3090		return nil
3091	}
3092	invalidParams := smithy.InvalidParamsError{Context: "ListOfMultiConditionalBranch"}
3093	for i := range v {
3094		if err := validateMultiConditionalBranch(&v[i]); err != nil {
3095			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3096		}
3097	}
3098	if invalidParams.Len() > 0 {
3099		return invalidParams
3100	} else {
3101		return nil
3102	}
3103}
3104
3105func validateListOfSegmentDimensions(v []types.SegmentDimensions) error {
3106	if v == nil {
3107		return nil
3108	}
3109	invalidParams := smithy.InvalidParamsError{Context: "ListOfSegmentDimensions"}
3110	for i := range v {
3111		if err := validateSegmentDimensions(&v[i]); err != nil {
3112			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3113		}
3114	}
3115	if invalidParams.Len() > 0 {
3116		return invalidParams
3117	} else {
3118		return nil
3119	}
3120}
3121
3122func validateListOfSegmentGroup(v []types.SegmentGroup) error {
3123	if v == nil {
3124		return nil
3125	}
3126	invalidParams := smithy.InvalidParamsError{Context: "ListOfSegmentGroup"}
3127	for i := range v {
3128		if err := validateSegmentGroup(&v[i]); err != nil {
3129			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3130		}
3131	}
3132	if invalidParams.Len() > 0 {
3133		return invalidParams
3134	} else {
3135		return nil
3136	}
3137}
3138
3139func validateListOfSegmentReference(v []types.SegmentReference) error {
3140	if v == nil {
3141		return nil
3142	}
3143	invalidParams := smithy.InvalidParamsError{Context: "ListOfSegmentReference"}
3144	for i := range v {
3145		if err := validateSegmentReference(&v[i]); err != nil {
3146			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3147		}
3148	}
3149	if invalidParams.Len() > 0 {
3150		return invalidParams
3151	} else {
3152		return nil
3153	}
3154}
3155
3156func validateListOfSimpleCondition(v []types.SimpleCondition) error {
3157	if v == nil {
3158		return nil
3159	}
3160	invalidParams := smithy.InvalidParamsError{Context: "ListOfSimpleCondition"}
3161	for i := range v {
3162		if err := validateSimpleCondition(&v[i]); err != nil {
3163			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3164		}
3165	}
3166	if invalidParams.Len() > 0 {
3167		return invalidParams
3168	} else {
3169		return nil
3170	}
3171}
3172
3173func validateListOfWriteTreatmentResource(v []types.WriteTreatmentResource) error {
3174	if v == nil {
3175		return nil
3176	}
3177	invalidParams := smithy.InvalidParamsError{Context: "ListOfWriteTreatmentResource"}
3178	for i := range v {
3179		if err := validateWriteTreatmentResource(&v[i]); err != nil {
3180			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3181		}
3182	}
3183	if invalidParams.Len() > 0 {
3184		return invalidParams
3185	} else {
3186		return nil
3187	}
3188}
3189
3190func validateMapOfActivity(v map[string]types.Activity) error {
3191	if v == nil {
3192		return nil
3193	}
3194	invalidParams := smithy.InvalidParamsError{Context: "MapOfActivity"}
3195	for key := range v {
3196		value := v[key]
3197		if err := validateActivity(&value); err != nil {
3198			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
3199		}
3200	}
3201	if invalidParams.Len() > 0 {
3202		return invalidParams
3203	} else {
3204		return nil
3205	}
3206}
3207
3208func validateMapOfAttributeDimension(v map[string]types.AttributeDimension) error {
3209	if v == nil {
3210		return nil
3211	}
3212	invalidParams := smithy.InvalidParamsError{Context: "MapOfAttributeDimension"}
3213	for key := range v {
3214		value := v[key]
3215		if err := validateAttributeDimension(&value); err != nil {
3216			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
3217		}
3218	}
3219	if invalidParams.Len() > 0 {
3220		return invalidParams
3221	} else {
3222		return nil
3223	}
3224}
3225
3226func validateMapOfEvent(v map[string]types.Event) error {
3227	if v == nil {
3228		return nil
3229	}
3230	invalidParams := smithy.InvalidParamsError{Context: "MapOfEvent"}
3231	for key := range v {
3232		value := v[key]
3233		if err := validateEvent(&value); err != nil {
3234			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
3235		}
3236	}
3237	if invalidParams.Len() > 0 {
3238		return invalidParams
3239	} else {
3240		return nil
3241	}
3242}
3243
3244func validateMapOfEventsBatch(v map[string]types.EventsBatch) error {
3245	if v == nil {
3246		return nil
3247	}
3248	invalidParams := smithy.InvalidParamsError{Context: "MapOfEventsBatch"}
3249	for key := range v {
3250		value := v[key]
3251		if err := validateEventsBatch(&value); err != nil {
3252			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
3253		}
3254	}
3255	if invalidParams.Len() > 0 {
3256		return invalidParams
3257	} else {
3258		return nil
3259	}
3260}
3261
3262func validateMapOfMetricDimension(v map[string]types.MetricDimension) error {
3263	if v == nil {
3264		return nil
3265	}
3266	invalidParams := smithy.InvalidParamsError{Context: "MapOfMetricDimension"}
3267	for key := range v {
3268		value := v[key]
3269		if err := validateMetricDimension(&value); err != nil {
3270			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
3271		}
3272	}
3273	if invalidParams.Len() > 0 {
3274		return invalidParams
3275	} else {
3276		return nil
3277	}
3278}
3279
3280func validateMessageRequest(v *types.MessageRequest) error {
3281	if v == nil {
3282		return nil
3283	}
3284	invalidParams := smithy.InvalidParamsError{Context: "MessageRequest"}
3285	if v.MessageConfiguration == nil {
3286		invalidParams.Add(smithy.NewErrParamRequired("MessageConfiguration"))
3287	}
3288	if invalidParams.Len() > 0 {
3289		return invalidParams
3290	} else {
3291		return nil
3292	}
3293}
3294
3295func validateMetricDimension(v *types.MetricDimension) error {
3296	if v == nil {
3297		return nil
3298	}
3299	invalidParams := smithy.InvalidParamsError{Context: "MetricDimension"}
3300	if v.ComparisonOperator == nil {
3301		invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator"))
3302	}
3303	if invalidParams.Len() > 0 {
3304		return invalidParams
3305	} else {
3306		return nil
3307	}
3308}
3309
3310func validateMultiConditionalBranch(v *types.MultiConditionalBranch) error {
3311	if v == nil {
3312		return nil
3313	}
3314	invalidParams := smithy.InvalidParamsError{Context: "MultiConditionalBranch"}
3315	if v.Condition != nil {
3316		if err := validateSimpleCondition(v.Condition); err != nil {
3317			invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError))
3318		}
3319	}
3320	if invalidParams.Len() > 0 {
3321		return invalidParams
3322	} else {
3323		return nil
3324	}
3325}
3326
3327func validateMultiConditionalSplitActivity(v *types.MultiConditionalSplitActivity) error {
3328	if v == nil {
3329		return nil
3330	}
3331	invalidParams := smithy.InvalidParamsError{Context: "MultiConditionalSplitActivity"}
3332	if v.Branches != nil {
3333		if err := validateListOfMultiConditionalBranch(v.Branches); err != nil {
3334			invalidParams.AddNested("Branches", err.(smithy.InvalidParamsError))
3335		}
3336	}
3337	if invalidParams.Len() > 0 {
3338		return invalidParams
3339	} else {
3340		return nil
3341	}
3342}
3343
3344func validateRecencyDimension(v *types.RecencyDimension) error {
3345	if v == nil {
3346		return nil
3347	}
3348	invalidParams := smithy.InvalidParamsError{Context: "RecencyDimension"}
3349	if len(v.Duration) == 0 {
3350		invalidParams.Add(smithy.NewErrParamRequired("Duration"))
3351	}
3352	if len(v.RecencyType) == 0 {
3353		invalidParams.Add(smithy.NewErrParamRequired("RecencyType"))
3354	}
3355	if invalidParams.Len() > 0 {
3356		return invalidParams
3357	} else {
3358		return nil
3359	}
3360}
3361
3362func validateSchedule(v *types.Schedule) error {
3363	if v == nil {
3364		return nil
3365	}
3366	invalidParams := smithy.InvalidParamsError{Context: "Schedule"}
3367	if v.EventFilter != nil {
3368		if err := validateCampaignEventFilter(v.EventFilter); err != nil {
3369			invalidParams.AddNested("EventFilter", err.(smithy.InvalidParamsError))
3370		}
3371	}
3372	if v.StartTime == nil {
3373		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
3374	}
3375	if invalidParams.Len() > 0 {
3376		return invalidParams
3377	} else {
3378		return nil
3379	}
3380}
3381
3382func validateSegmentBehaviors(v *types.SegmentBehaviors) error {
3383	if v == nil {
3384		return nil
3385	}
3386	invalidParams := smithy.InvalidParamsError{Context: "SegmentBehaviors"}
3387	if v.Recency != nil {
3388		if err := validateRecencyDimension(v.Recency); err != nil {
3389			invalidParams.AddNested("Recency", err.(smithy.InvalidParamsError))
3390		}
3391	}
3392	if invalidParams.Len() > 0 {
3393		return invalidParams
3394	} else {
3395		return nil
3396	}
3397}
3398
3399func validateSegmentCondition(v *types.SegmentCondition) error {
3400	if v == nil {
3401		return nil
3402	}
3403	invalidParams := smithy.InvalidParamsError{Context: "SegmentCondition"}
3404	if v.SegmentId == nil {
3405		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
3406	}
3407	if invalidParams.Len() > 0 {
3408		return invalidParams
3409	} else {
3410		return nil
3411	}
3412}
3413
3414func validateSegmentDemographics(v *types.SegmentDemographics) error {
3415	if v == nil {
3416		return nil
3417	}
3418	invalidParams := smithy.InvalidParamsError{Context: "SegmentDemographics"}
3419	if v.AppVersion != nil {
3420		if err := validateSetDimension(v.AppVersion); err != nil {
3421			invalidParams.AddNested("AppVersion", err.(smithy.InvalidParamsError))
3422		}
3423	}
3424	if v.Channel != nil {
3425		if err := validateSetDimension(v.Channel); err != nil {
3426			invalidParams.AddNested("Channel", err.(smithy.InvalidParamsError))
3427		}
3428	}
3429	if v.DeviceType != nil {
3430		if err := validateSetDimension(v.DeviceType); err != nil {
3431			invalidParams.AddNested("DeviceType", err.(smithy.InvalidParamsError))
3432		}
3433	}
3434	if v.Make != nil {
3435		if err := validateSetDimension(v.Make); err != nil {
3436			invalidParams.AddNested("Make", err.(smithy.InvalidParamsError))
3437		}
3438	}
3439	if v.Model != nil {
3440		if err := validateSetDimension(v.Model); err != nil {
3441			invalidParams.AddNested("Model", err.(smithy.InvalidParamsError))
3442		}
3443	}
3444	if v.Platform != nil {
3445		if err := validateSetDimension(v.Platform); err != nil {
3446			invalidParams.AddNested("Platform", err.(smithy.InvalidParamsError))
3447		}
3448	}
3449	if invalidParams.Len() > 0 {
3450		return invalidParams
3451	} else {
3452		return nil
3453	}
3454}
3455
3456func validateSegmentDimensions(v *types.SegmentDimensions) error {
3457	if v == nil {
3458		return nil
3459	}
3460	invalidParams := smithy.InvalidParamsError{Context: "SegmentDimensions"}
3461	if v.Attributes != nil {
3462		if err := validateMapOfAttributeDimension(v.Attributes); err != nil {
3463			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
3464		}
3465	}
3466	if v.Behavior != nil {
3467		if err := validateSegmentBehaviors(v.Behavior); err != nil {
3468			invalidParams.AddNested("Behavior", err.(smithy.InvalidParamsError))
3469		}
3470	}
3471	if v.Demographic != nil {
3472		if err := validateSegmentDemographics(v.Demographic); err != nil {
3473			invalidParams.AddNested("Demographic", err.(smithy.InvalidParamsError))
3474		}
3475	}
3476	if v.Location != nil {
3477		if err := validateSegmentLocation(v.Location); err != nil {
3478			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
3479		}
3480	}
3481	if v.Metrics != nil {
3482		if err := validateMapOfMetricDimension(v.Metrics); err != nil {
3483			invalidParams.AddNested("Metrics", err.(smithy.InvalidParamsError))
3484		}
3485	}
3486	if v.UserAttributes != nil {
3487		if err := validateMapOfAttributeDimension(v.UserAttributes); err != nil {
3488			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
3489		}
3490	}
3491	if invalidParams.Len() > 0 {
3492		return invalidParams
3493	} else {
3494		return nil
3495	}
3496}
3497
3498func validateSegmentGroup(v *types.SegmentGroup) error {
3499	if v == nil {
3500		return nil
3501	}
3502	invalidParams := smithy.InvalidParamsError{Context: "SegmentGroup"}
3503	if v.Dimensions != nil {
3504		if err := validateListOfSegmentDimensions(v.Dimensions); err != nil {
3505			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
3506		}
3507	}
3508	if v.SourceSegments != nil {
3509		if err := validateListOfSegmentReference(v.SourceSegments); err != nil {
3510			invalidParams.AddNested("SourceSegments", err.(smithy.InvalidParamsError))
3511		}
3512	}
3513	if invalidParams.Len() > 0 {
3514		return invalidParams
3515	} else {
3516		return nil
3517	}
3518}
3519
3520func validateSegmentGroupList(v *types.SegmentGroupList) error {
3521	if v == nil {
3522		return nil
3523	}
3524	invalidParams := smithy.InvalidParamsError{Context: "SegmentGroupList"}
3525	if v.Groups != nil {
3526		if err := validateListOfSegmentGroup(v.Groups); err != nil {
3527			invalidParams.AddNested("Groups", err.(smithy.InvalidParamsError))
3528		}
3529	}
3530	if invalidParams.Len() > 0 {
3531		return invalidParams
3532	} else {
3533		return nil
3534	}
3535}
3536
3537func validateSegmentLocation(v *types.SegmentLocation) error {
3538	if v == nil {
3539		return nil
3540	}
3541	invalidParams := smithy.InvalidParamsError{Context: "SegmentLocation"}
3542	if v.Country != nil {
3543		if err := validateSetDimension(v.Country); err != nil {
3544			invalidParams.AddNested("Country", err.(smithy.InvalidParamsError))
3545		}
3546	}
3547	if v.GPSPoint != nil {
3548		if err := validateGPSPointDimension(v.GPSPoint); err != nil {
3549			invalidParams.AddNested("GPSPoint", err.(smithy.InvalidParamsError))
3550		}
3551	}
3552	if invalidParams.Len() > 0 {
3553		return invalidParams
3554	} else {
3555		return nil
3556	}
3557}
3558
3559func validateSegmentReference(v *types.SegmentReference) error {
3560	if v == nil {
3561		return nil
3562	}
3563	invalidParams := smithy.InvalidParamsError{Context: "SegmentReference"}
3564	if v.Id == nil {
3565		invalidParams.Add(smithy.NewErrParamRequired("Id"))
3566	}
3567	if invalidParams.Len() > 0 {
3568		return invalidParams
3569	} else {
3570		return nil
3571	}
3572}
3573
3574func validateSendUsersMessageRequest(v *types.SendUsersMessageRequest) error {
3575	if v == nil {
3576		return nil
3577	}
3578	invalidParams := smithy.InvalidParamsError{Context: "SendUsersMessageRequest"}
3579	if v.MessageConfiguration == nil {
3580		invalidParams.Add(smithy.NewErrParamRequired("MessageConfiguration"))
3581	}
3582	if v.Users == nil {
3583		invalidParams.Add(smithy.NewErrParamRequired("Users"))
3584	}
3585	if invalidParams.Len() > 0 {
3586		return invalidParams
3587	} else {
3588		return nil
3589	}
3590}
3591
3592func validateSession(v *types.Session) error {
3593	if v == nil {
3594		return nil
3595	}
3596	invalidParams := smithy.InvalidParamsError{Context: "Session"}
3597	if v.Id == nil {
3598		invalidParams.Add(smithy.NewErrParamRequired("Id"))
3599	}
3600	if v.StartTimestamp == nil {
3601		invalidParams.Add(smithy.NewErrParamRequired("StartTimestamp"))
3602	}
3603	if invalidParams.Len() > 0 {
3604		return invalidParams
3605	} else {
3606		return nil
3607	}
3608}
3609
3610func validateSetDimension(v *types.SetDimension) error {
3611	if v == nil {
3612		return nil
3613	}
3614	invalidParams := smithy.InvalidParamsError{Context: "SetDimension"}
3615	if v.Values == nil {
3616		invalidParams.Add(smithy.NewErrParamRequired("Values"))
3617	}
3618	if invalidParams.Len() > 0 {
3619		return invalidParams
3620	} else {
3621		return nil
3622	}
3623}
3624
3625func validateSimpleCondition(v *types.SimpleCondition) error {
3626	if v == nil {
3627		return nil
3628	}
3629	invalidParams := smithy.InvalidParamsError{Context: "SimpleCondition"}
3630	if v.EventCondition != nil {
3631		if err := validateEventCondition(v.EventCondition); err != nil {
3632			invalidParams.AddNested("EventCondition", err.(smithy.InvalidParamsError))
3633		}
3634	}
3635	if v.SegmentCondition != nil {
3636		if err := validateSegmentCondition(v.SegmentCondition); err != nil {
3637			invalidParams.AddNested("SegmentCondition", err.(smithy.InvalidParamsError))
3638		}
3639	}
3640	if v.SegmentDimensions != nil {
3641		if err := validateSegmentDimensions(v.SegmentDimensions); err != nil {
3642			invalidParams.AddNested("SegmentDimensions", err.(smithy.InvalidParamsError))
3643		}
3644	}
3645	if invalidParams.Len() > 0 {
3646		return invalidParams
3647	} else {
3648		return nil
3649	}
3650}
3651
3652func validateStartCondition(v *types.StartCondition) error {
3653	if v == nil {
3654		return nil
3655	}
3656	invalidParams := smithy.InvalidParamsError{Context: "StartCondition"}
3657	if v.EventStartCondition != nil {
3658		if err := validateEventStartCondition(v.EventStartCondition); err != nil {
3659			invalidParams.AddNested("EventStartCondition", err.(smithy.InvalidParamsError))
3660		}
3661	}
3662	if v.SegmentStartCondition != nil {
3663		if err := validateSegmentCondition(v.SegmentStartCondition); err != nil {
3664			invalidParams.AddNested("SegmentStartCondition", err.(smithy.InvalidParamsError))
3665		}
3666	}
3667	if invalidParams.Len() > 0 {
3668		return invalidParams
3669	} else {
3670		return nil
3671	}
3672}
3673
3674func validateTagsModel(v *types.TagsModel) error {
3675	if v == nil {
3676		return nil
3677	}
3678	invalidParams := smithy.InvalidParamsError{Context: "TagsModel"}
3679	if v.Tags == nil {
3680		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
3681	}
3682	if invalidParams.Len() > 0 {
3683		return invalidParams
3684	} else {
3685		return nil
3686	}
3687}
3688
3689func validateUpdateRecommenderConfigurationShape(v *types.UpdateRecommenderConfigurationShape) error {
3690	if v == nil {
3691		return nil
3692	}
3693	invalidParams := smithy.InvalidParamsError{Context: "UpdateRecommenderConfigurationShape"}
3694	if v.RecommendationProviderRoleArn == nil {
3695		invalidParams.Add(smithy.NewErrParamRequired("RecommendationProviderRoleArn"))
3696	}
3697	if v.RecommendationProviderUri == nil {
3698		invalidParams.Add(smithy.NewErrParamRequired("RecommendationProviderUri"))
3699	}
3700	if invalidParams.Len() > 0 {
3701		return invalidParams
3702	} else {
3703		return nil
3704	}
3705}
3706
3707func validateWriteCampaignRequest(v *types.WriteCampaignRequest) error {
3708	if v == nil {
3709		return nil
3710	}
3711	invalidParams := smithy.InvalidParamsError{Context: "WriteCampaignRequest"}
3712	if v.AdditionalTreatments != nil {
3713		if err := validateListOfWriteTreatmentResource(v.AdditionalTreatments); err != nil {
3714			invalidParams.AddNested("AdditionalTreatments", err.(smithy.InvalidParamsError))
3715		}
3716	}
3717	if v.CustomDeliveryConfiguration != nil {
3718		if err := validateCustomDeliveryConfiguration(v.CustomDeliveryConfiguration); err != nil {
3719			invalidParams.AddNested("CustomDeliveryConfiguration", err.(smithy.InvalidParamsError))
3720		}
3721	}
3722	if v.Schedule != nil {
3723		if err := validateSchedule(v.Schedule); err != nil {
3724			invalidParams.AddNested("Schedule", err.(smithy.InvalidParamsError))
3725		}
3726	}
3727	if invalidParams.Len() > 0 {
3728		return invalidParams
3729	} else {
3730		return nil
3731	}
3732}
3733
3734func validateWriteEventStream(v *types.WriteEventStream) error {
3735	if v == nil {
3736		return nil
3737	}
3738	invalidParams := smithy.InvalidParamsError{Context: "WriteEventStream"}
3739	if v.DestinationStreamArn == nil {
3740		invalidParams.Add(smithy.NewErrParamRequired("DestinationStreamArn"))
3741	}
3742	if v.RoleArn == nil {
3743		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
3744	}
3745	if invalidParams.Len() > 0 {
3746		return invalidParams
3747	} else {
3748		return nil
3749	}
3750}
3751
3752func validateWriteJourneyRequest(v *types.WriteJourneyRequest) error {
3753	if v == nil {
3754		return nil
3755	}
3756	invalidParams := smithy.InvalidParamsError{Context: "WriteJourneyRequest"}
3757	if v.Activities != nil {
3758		if err := validateMapOfActivity(v.Activities); err != nil {
3759			invalidParams.AddNested("Activities", err.(smithy.InvalidParamsError))
3760		}
3761	}
3762	if v.Name == nil {
3763		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3764	}
3765	if v.StartCondition != nil {
3766		if err := validateStartCondition(v.StartCondition); err != nil {
3767			invalidParams.AddNested("StartCondition", err.(smithy.InvalidParamsError))
3768		}
3769	}
3770	if invalidParams.Len() > 0 {
3771		return invalidParams
3772	} else {
3773		return nil
3774	}
3775}
3776
3777func validateWriteSegmentRequest(v *types.WriteSegmentRequest) error {
3778	if v == nil {
3779		return nil
3780	}
3781	invalidParams := smithy.InvalidParamsError{Context: "WriteSegmentRequest"}
3782	if v.Dimensions != nil {
3783		if err := validateSegmentDimensions(v.Dimensions); err != nil {
3784			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
3785		}
3786	}
3787	if v.SegmentGroups != nil {
3788		if err := validateSegmentGroupList(v.SegmentGroups); err != nil {
3789			invalidParams.AddNested("SegmentGroups", err.(smithy.InvalidParamsError))
3790		}
3791	}
3792	if invalidParams.Len() > 0 {
3793		return invalidParams
3794	} else {
3795		return nil
3796	}
3797}
3798
3799func validateWriteTreatmentResource(v *types.WriteTreatmentResource) error {
3800	if v == nil {
3801		return nil
3802	}
3803	invalidParams := smithy.InvalidParamsError{Context: "WriteTreatmentResource"}
3804	if v.CustomDeliveryConfiguration != nil {
3805		if err := validateCustomDeliveryConfiguration(v.CustomDeliveryConfiguration); err != nil {
3806			invalidParams.AddNested("CustomDeliveryConfiguration", err.(smithy.InvalidParamsError))
3807		}
3808	}
3809	if v.Schedule != nil {
3810		if err := validateSchedule(v.Schedule); err != nil {
3811			invalidParams.AddNested("Schedule", err.(smithy.InvalidParamsError))
3812		}
3813	}
3814	if invalidParams.Len() > 0 {
3815		return invalidParams
3816	} else {
3817		return nil
3818	}
3819}
3820
3821func validateOpCreateAppInput(v *CreateAppInput) error {
3822	if v == nil {
3823		return nil
3824	}
3825	invalidParams := smithy.InvalidParamsError{Context: "CreateAppInput"}
3826	if v.CreateApplicationRequest == nil {
3827		invalidParams.Add(smithy.NewErrParamRequired("CreateApplicationRequest"))
3828	} else if v.CreateApplicationRequest != nil {
3829		if err := validateCreateApplicationRequest(v.CreateApplicationRequest); err != nil {
3830			invalidParams.AddNested("CreateApplicationRequest", err.(smithy.InvalidParamsError))
3831		}
3832	}
3833	if invalidParams.Len() > 0 {
3834		return invalidParams
3835	} else {
3836		return nil
3837	}
3838}
3839
3840func validateOpCreateCampaignInput(v *CreateCampaignInput) error {
3841	if v == nil {
3842		return nil
3843	}
3844	invalidParams := smithy.InvalidParamsError{Context: "CreateCampaignInput"}
3845	if v.ApplicationId == nil {
3846		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
3847	}
3848	if v.WriteCampaignRequest == nil {
3849		invalidParams.Add(smithy.NewErrParamRequired("WriteCampaignRequest"))
3850	} else if v.WriteCampaignRequest != nil {
3851		if err := validateWriteCampaignRequest(v.WriteCampaignRequest); err != nil {
3852			invalidParams.AddNested("WriteCampaignRequest", err.(smithy.InvalidParamsError))
3853		}
3854	}
3855	if invalidParams.Len() > 0 {
3856		return invalidParams
3857	} else {
3858		return nil
3859	}
3860}
3861
3862func validateOpCreateEmailTemplateInput(v *CreateEmailTemplateInput) error {
3863	if v == nil {
3864		return nil
3865	}
3866	invalidParams := smithy.InvalidParamsError{Context: "CreateEmailTemplateInput"}
3867	if v.EmailTemplateRequest == nil {
3868		invalidParams.Add(smithy.NewErrParamRequired("EmailTemplateRequest"))
3869	}
3870	if v.TemplateName == nil {
3871		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
3872	}
3873	if invalidParams.Len() > 0 {
3874		return invalidParams
3875	} else {
3876		return nil
3877	}
3878}
3879
3880func validateOpCreateExportJobInput(v *CreateExportJobInput) error {
3881	if v == nil {
3882		return nil
3883	}
3884	invalidParams := smithy.InvalidParamsError{Context: "CreateExportJobInput"}
3885	if v.ApplicationId == nil {
3886		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
3887	}
3888	if v.ExportJobRequest == nil {
3889		invalidParams.Add(smithy.NewErrParamRequired("ExportJobRequest"))
3890	} else if v.ExportJobRequest != nil {
3891		if err := validateExportJobRequest(v.ExportJobRequest); err != nil {
3892			invalidParams.AddNested("ExportJobRequest", err.(smithy.InvalidParamsError))
3893		}
3894	}
3895	if invalidParams.Len() > 0 {
3896		return invalidParams
3897	} else {
3898		return nil
3899	}
3900}
3901
3902func validateOpCreateImportJobInput(v *CreateImportJobInput) error {
3903	if v == nil {
3904		return nil
3905	}
3906	invalidParams := smithy.InvalidParamsError{Context: "CreateImportJobInput"}
3907	if v.ApplicationId == nil {
3908		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
3909	}
3910	if v.ImportJobRequest == nil {
3911		invalidParams.Add(smithy.NewErrParamRequired("ImportJobRequest"))
3912	} else if v.ImportJobRequest != nil {
3913		if err := validateImportJobRequest(v.ImportJobRequest); err != nil {
3914			invalidParams.AddNested("ImportJobRequest", err.(smithy.InvalidParamsError))
3915		}
3916	}
3917	if invalidParams.Len() > 0 {
3918		return invalidParams
3919	} else {
3920		return nil
3921	}
3922}
3923
3924func validateOpCreateJourneyInput(v *CreateJourneyInput) error {
3925	if v == nil {
3926		return nil
3927	}
3928	invalidParams := smithy.InvalidParamsError{Context: "CreateJourneyInput"}
3929	if v.ApplicationId == nil {
3930		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
3931	}
3932	if v.WriteJourneyRequest == nil {
3933		invalidParams.Add(smithy.NewErrParamRequired("WriteJourneyRequest"))
3934	} else if v.WriteJourneyRequest != nil {
3935		if err := validateWriteJourneyRequest(v.WriteJourneyRequest); err != nil {
3936			invalidParams.AddNested("WriteJourneyRequest", err.(smithy.InvalidParamsError))
3937		}
3938	}
3939	if invalidParams.Len() > 0 {
3940		return invalidParams
3941	} else {
3942		return nil
3943	}
3944}
3945
3946func validateOpCreatePushTemplateInput(v *CreatePushTemplateInput) error {
3947	if v == nil {
3948		return nil
3949	}
3950	invalidParams := smithy.InvalidParamsError{Context: "CreatePushTemplateInput"}
3951	if v.PushNotificationTemplateRequest == nil {
3952		invalidParams.Add(smithy.NewErrParamRequired("PushNotificationTemplateRequest"))
3953	}
3954	if v.TemplateName == nil {
3955		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
3956	}
3957	if invalidParams.Len() > 0 {
3958		return invalidParams
3959	} else {
3960		return nil
3961	}
3962}
3963
3964func validateOpCreateRecommenderConfigurationInput(v *CreateRecommenderConfigurationInput) error {
3965	if v == nil {
3966		return nil
3967	}
3968	invalidParams := smithy.InvalidParamsError{Context: "CreateRecommenderConfigurationInput"}
3969	if v.CreateRecommenderConfiguration == nil {
3970		invalidParams.Add(smithy.NewErrParamRequired("CreateRecommenderConfiguration"))
3971	} else if v.CreateRecommenderConfiguration != nil {
3972		if err := validateCreateRecommenderConfigurationShape(v.CreateRecommenderConfiguration); err != nil {
3973			invalidParams.AddNested("CreateRecommenderConfiguration", err.(smithy.InvalidParamsError))
3974		}
3975	}
3976	if invalidParams.Len() > 0 {
3977		return invalidParams
3978	} else {
3979		return nil
3980	}
3981}
3982
3983func validateOpCreateSegmentInput(v *CreateSegmentInput) error {
3984	if v == nil {
3985		return nil
3986	}
3987	invalidParams := smithy.InvalidParamsError{Context: "CreateSegmentInput"}
3988	if v.ApplicationId == nil {
3989		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
3990	}
3991	if v.WriteSegmentRequest == nil {
3992		invalidParams.Add(smithy.NewErrParamRequired("WriteSegmentRequest"))
3993	} else if v.WriteSegmentRequest != nil {
3994		if err := validateWriteSegmentRequest(v.WriteSegmentRequest); err != nil {
3995			invalidParams.AddNested("WriteSegmentRequest", err.(smithy.InvalidParamsError))
3996		}
3997	}
3998	if invalidParams.Len() > 0 {
3999		return invalidParams
4000	} else {
4001		return nil
4002	}
4003}
4004
4005func validateOpCreateSmsTemplateInput(v *CreateSmsTemplateInput) error {
4006	if v == nil {
4007		return nil
4008	}
4009	invalidParams := smithy.InvalidParamsError{Context: "CreateSmsTemplateInput"}
4010	if v.SMSTemplateRequest == nil {
4011		invalidParams.Add(smithy.NewErrParamRequired("SMSTemplateRequest"))
4012	}
4013	if v.TemplateName == nil {
4014		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
4015	}
4016	if invalidParams.Len() > 0 {
4017		return invalidParams
4018	} else {
4019		return nil
4020	}
4021}
4022
4023func validateOpCreateVoiceTemplateInput(v *CreateVoiceTemplateInput) error {
4024	if v == nil {
4025		return nil
4026	}
4027	invalidParams := smithy.InvalidParamsError{Context: "CreateVoiceTemplateInput"}
4028	if v.TemplateName == nil {
4029		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
4030	}
4031	if v.VoiceTemplateRequest == nil {
4032		invalidParams.Add(smithy.NewErrParamRequired("VoiceTemplateRequest"))
4033	}
4034	if invalidParams.Len() > 0 {
4035		return invalidParams
4036	} else {
4037		return nil
4038	}
4039}
4040
4041func validateOpDeleteAdmChannelInput(v *DeleteAdmChannelInput) error {
4042	if v == nil {
4043		return nil
4044	}
4045	invalidParams := smithy.InvalidParamsError{Context: "DeleteAdmChannelInput"}
4046	if v.ApplicationId == nil {
4047		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4048	}
4049	if invalidParams.Len() > 0 {
4050		return invalidParams
4051	} else {
4052		return nil
4053	}
4054}
4055
4056func validateOpDeleteApnsChannelInput(v *DeleteApnsChannelInput) error {
4057	if v == nil {
4058		return nil
4059	}
4060	invalidParams := smithy.InvalidParamsError{Context: "DeleteApnsChannelInput"}
4061	if v.ApplicationId == nil {
4062		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4063	}
4064	if invalidParams.Len() > 0 {
4065		return invalidParams
4066	} else {
4067		return nil
4068	}
4069}
4070
4071func validateOpDeleteApnsSandboxChannelInput(v *DeleteApnsSandboxChannelInput) error {
4072	if v == nil {
4073		return nil
4074	}
4075	invalidParams := smithy.InvalidParamsError{Context: "DeleteApnsSandboxChannelInput"}
4076	if v.ApplicationId == nil {
4077		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4078	}
4079	if invalidParams.Len() > 0 {
4080		return invalidParams
4081	} else {
4082		return nil
4083	}
4084}
4085
4086func validateOpDeleteApnsVoipChannelInput(v *DeleteApnsVoipChannelInput) error {
4087	if v == nil {
4088		return nil
4089	}
4090	invalidParams := smithy.InvalidParamsError{Context: "DeleteApnsVoipChannelInput"}
4091	if v.ApplicationId == nil {
4092		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4093	}
4094	if invalidParams.Len() > 0 {
4095		return invalidParams
4096	} else {
4097		return nil
4098	}
4099}
4100
4101func validateOpDeleteApnsVoipSandboxChannelInput(v *DeleteApnsVoipSandboxChannelInput) error {
4102	if v == nil {
4103		return nil
4104	}
4105	invalidParams := smithy.InvalidParamsError{Context: "DeleteApnsVoipSandboxChannelInput"}
4106	if v.ApplicationId == nil {
4107		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4108	}
4109	if invalidParams.Len() > 0 {
4110		return invalidParams
4111	} else {
4112		return nil
4113	}
4114}
4115
4116func validateOpDeleteAppInput(v *DeleteAppInput) error {
4117	if v == nil {
4118		return nil
4119	}
4120	invalidParams := smithy.InvalidParamsError{Context: "DeleteAppInput"}
4121	if v.ApplicationId == nil {
4122		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4123	}
4124	if invalidParams.Len() > 0 {
4125		return invalidParams
4126	} else {
4127		return nil
4128	}
4129}
4130
4131func validateOpDeleteBaiduChannelInput(v *DeleteBaiduChannelInput) error {
4132	if v == nil {
4133		return nil
4134	}
4135	invalidParams := smithy.InvalidParamsError{Context: "DeleteBaiduChannelInput"}
4136	if v.ApplicationId == nil {
4137		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4138	}
4139	if invalidParams.Len() > 0 {
4140		return invalidParams
4141	} else {
4142		return nil
4143	}
4144}
4145
4146func validateOpDeleteCampaignInput(v *DeleteCampaignInput) error {
4147	if v == nil {
4148		return nil
4149	}
4150	invalidParams := smithy.InvalidParamsError{Context: "DeleteCampaignInput"}
4151	if v.ApplicationId == nil {
4152		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4153	}
4154	if v.CampaignId == nil {
4155		invalidParams.Add(smithy.NewErrParamRequired("CampaignId"))
4156	}
4157	if invalidParams.Len() > 0 {
4158		return invalidParams
4159	} else {
4160		return nil
4161	}
4162}
4163
4164func validateOpDeleteEmailChannelInput(v *DeleteEmailChannelInput) error {
4165	if v == nil {
4166		return nil
4167	}
4168	invalidParams := smithy.InvalidParamsError{Context: "DeleteEmailChannelInput"}
4169	if v.ApplicationId == nil {
4170		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4171	}
4172	if invalidParams.Len() > 0 {
4173		return invalidParams
4174	} else {
4175		return nil
4176	}
4177}
4178
4179func validateOpDeleteEmailTemplateInput(v *DeleteEmailTemplateInput) error {
4180	if v == nil {
4181		return nil
4182	}
4183	invalidParams := smithy.InvalidParamsError{Context: "DeleteEmailTemplateInput"}
4184	if v.TemplateName == nil {
4185		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
4186	}
4187	if invalidParams.Len() > 0 {
4188		return invalidParams
4189	} else {
4190		return nil
4191	}
4192}
4193
4194func validateOpDeleteEndpointInput(v *DeleteEndpointInput) error {
4195	if v == nil {
4196		return nil
4197	}
4198	invalidParams := smithy.InvalidParamsError{Context: "DeleteEndpointInput"}
4199	if v.ApplicationId == nil {
4200		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4201	}
4202	if v.EndpointId == nil {
4203		invalidParams.Add(smithy.NewErrParamRequired("EndpointId"))
4204	}
4205	if invalidParams.Len() > 0 {
4206		return invalidParams
4207	} else {
4208		return nil
4209	}
4210}
4211
4212func validateOpDeleteEventStreamInput(v *DeleteEventStreamInput) error {
4213	if v == nil {
4214		return nil
4215	}
4216	invalidParams := smithy.InvalidParamsError{Context: "DeleteEventStreamInput"}
4217	if v.ApplicationId == nil {
4218		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4219	}
4220	if invalidParams.Len() > 0 {
4221		return invalidParams
4222	} else {
4223		return nil
4224	}
4225}
4226
4227func validateOpDeleteGcmChannelInput(v *DeleteGcmChannelInput) error {
4228	if v == nil {
4229		return nil
4230	}
4231	invalidParams := smithy.InvalidParamsError{Context: "DeleteGcmChannelInput"}
4232	if v.ApplicationId == nil {
4233		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4234	}
4235	if invalidParams.Len() > 0 {
4236		return invalidParams
4237	} else {
4238		return nil
4239	}
4240}
4241
4242func validateOpDeleteJourneyInput(v *DeleteJourneyInput) error {
4243	if v == nil {
4244		return nil
4245	}
4246	invalidParams := smithy.InvalidParamsError{Context: "DeleteJourneyInput"}
4247	if v.ApplicationId == nil {
4248		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4249	}
4250	if v.JourneyId == nil {
4251		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
4252	}
4253	if invalidParams.Len() > 0 {
4254		return invalidParams
4255	} else {
4256		return nil
4257	}
4258}
4259
4260func validateOpDeletePushTemplateInput(v *DeletePushTemplateInput) error {
4261	if v == nil {
4262		return nil
4263	}
4264	invalidParams := smithy.InvalidParamsError{Context: "DeletePushTemplateInput"}
4265	if v.TemplateName == nil {
4266		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
4267	}
4268	if invalidParams.Len() > 0 {
4269		return invalidParams
4270	} else {
4271		return nil
4272	}
4273}
4274
4275func validateOpDeleteRecommenderConfigurationInput(v *DeleteRecommenderConfigurationInput) error {
4276	if v == nil {
4277		return nil
4278	}
4279	invalidParams := smithy.InvalidParamsError{Context: "DeleteRecommenderConfigurationInput"}
4280	if v.RecommenderId == nil {
4281		invalidParams.Add(smithy.NewErrParamRequired("RecommenderId"))
4282	}
4283	if invalidParams.Len() > 0 {
4284		return invalidParams
4285	} else {
4286		return nil
4287	}
4288}
4289
4290func validateOpDeleteSegmentInput(v *DeleteSegmentInput) error {
4291	if v == nil {
4292		return nil
4293	}
4294	invalidParams := smithy.InvalidParamsError{Context: "DeleteSegmentInput"}
4295	if v.ApplicationId == nil {
4296		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4297	}
4298	if v.SegmentId == nil {
4299		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
4300	}
4301	if invalidParams.Len() > 0 {
4302		return invalidParams
4303	} else {
4304		return nil
4305	}
4306}
4307
4308func validateOpDeleteSmsChannelInput(v *DeleteSmsChannelInput) error {
4309	if v == nil {
4310		return nil
4311	}
4312	invalidParams := smithy.InvalidParamsError{Context: "DeleteSmsChannelInput"}
4313	if v.ApplicationId == nil {
4314		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4315	}
4316	if invalidParams.Len() > 0 {
4317		return invalidParams
4318	} else {
4319		return nil
4320	}
4321}
4322
4323func validateOpDeleteSmsTemplateInput(v *DeleteSmsTemplateInput) error {
4324	if v == nil {
4325		return nil
4326	}
4327	invalidParams := smithy.InvalidParamsError{Context: "DeleteSmsTemplateInput"}
4328	if v.TemplateName == nil {
4329		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
4330	}
4331	if invalidParams.Len() > 0 {
4332		return invalidParams
4333	} else {
4334		return nil
4335	}
4336}
4337
4338func validateOpDeleteUserEndpointsInput(v *DeleteUserEndpointsInput) error {
4339	if v == nil {
4340		return nil
4341	}
4342	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserEndpointsInput"}
4343	if v.ApplicationId == nil {
4344		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4345	}
4346	if v.UserId == nil {
4347		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
4348	}
4349	if invalidParams.Len() > 0 {
4350		return invalidParams
4351	} else {
4352		return nil
4353	}
4354}
4355
4356func validateOpDeleteVoiceChannelInput(v *DeleteVoiceChannelInput) error {
4357	if v == nil {
4358		return nil
4359	}
4360	invalidParams := smithy.InvalidParamsError{Context: "DeleteVoiceChannelInput"}
4361	if v.ApplicationId == nil {
4362		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4363	}
4364	if invalidParams.Len() > 0 {
4365		return invalidParams
4366	} else {
4367		return nil
4368	}
4369}
4370
4371func validateOpDeleteVoiceTemplateInput(v *DeleteVoiceTemplateInput) error {
4372	if v == nil {
4373		return nil
4374	}
4375	invalidParams := smithy.InvalidParamsError{Context: "DeleteVoiceTemplateInput"}
4376	if v.TemplateName == nil {
4377		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
4378	}
4379	if invalidParams.Len() > 0 {
4380		return invalidParams
4381	} else {
4382		return nil
4383	}
4384}
4385
4386func validateOpGetAdmChannelInput(v *GetAdmChannelInput) error {
4387	if v == nil {
4388		return nil
4389	}
4390	invalidParams := smithy.InvalidParamsError{Context: "GetAdmChannelInput"}
4391	if v.ApplicationId == nil {
4392		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4393	}
4394	if invalidParams.Len() > 0 {
4395		return invalidParams
4396	} else {
4397		return nil
4398	}
4399}
4400
4401func validateOpGetApnsChannelInput(v *GetApnsChannelInput) error {
4402	if v == nil {
4403		return nil
4404	}
4405	invalidParams := smithy.InvalidParamsError{Context: "GetApnsChannelInput"}
4406	if v.ApplicationId == nil {
4407		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4408	}
4409	if invalidParams.Len() > 0 {
4410		return invalidParams
4411	} else {
4412		return nil
4413	}
4414}
4415
4416func validateOpGetApnsSandboxChannelInput(v *GetApnsSandboxChannelInput) error {
4417	if v == nil {
4418		return nil
4419	}
4420	invalidParams := smithy.InvalidParamsError{Context: "GetApnsSandboxChannelInput"}
4421	if v.ApplicationId == nil {
4422		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4423	}
4424	if invalidParams.Len() > 0 {
4425		return invalidParams
4426	} else {
4427		return nil
4428	}
4429}
4430
4431func validateOpGetApnsVoipChannelInput(v *GetApnsVoipChannelInput) error {
4432	if v == nil {
4433		return nil
4434	}
4435	invalidParams := smithy.InvalidParamsError{Context: "GetApnsVoipChannelInput"}
4436	if v.ApplicationId == nil {
4437		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4438	}
4439	if invalidParams.Len() > 0 {
4440		return invalidParams
4441	} else {
4442		return nil
4443	}
4444}
4445
4446func validateOpGetApnsVoipSandboxChannelInput(v *GetApnsVoipSandboxChannelInput) error {
4447	if v == nil {
4448		return nil
4449	}
4450	invalidParams := smithy.InvalidParamsError{Context: "GetApnsVoipSandboxChannelInput"}
4451	if v.ApplicationId == nil {
4452		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4453	}
4454	if invalidParams.Len() > 0 {
4455		return invalidParams
4456	} else {
4457		return nil
4458	}
4459}
4460
4461func validateOpGetAppInput(v *GetAppInput) error {
4462	if v == nil {
4463		return nil
4464	}
4465	invalidParams := smithy.InvalidParamsError{Context: "GetAppInput"}
4466	if v.ApplicationId == nil {
4467		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4468	}
4469	if invalidParams.Len() > 0 {
4470		return invalidParams
4471	} else {
4472		return nil
4473	}
4474}
4475
4476func validateOpGetApplicationDateRangeKpiInput(v *GetApplicationDateRangeKpiInput) error {
4477	if v == nil {
4478		return nil
4479	}
4480	invalidParams := smithy.InvalidParamsError{Context: "GetApplicationDateRangeKpiInput"}
4481	if v.ApplicationId == nil {
4482		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4483	}
4484	if v.KpiName == nil {
4485		invalidParams.Add(smithy.NewErrParamRequired("KpiName"))
4486	}
4487	if invalidParams.Len() > 0 {
4488		return invalidParams
4489	} else {
4490		return nil
4491	}
4492}
4493
4494func validateOpGetApplicationSettingsInput(v *GetApplicationSettingsInput) error {
4495	if v == nil {
4496		return nil
4497	}
4498	invalidParams := smithy.InvalidParamsError{Context: "GetApplicationSettingsInput"}
4499	if v.ApplicationId == nil {
4500		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4501	}
4502	if invalidParams.Len() > 0 {
4503		return invalidParams
4504	} else {
4505		return nil
4506	}
4507}
4508
4509func validateOpGetBaiduChannelInput(v *GetBaiduChannelInput) error {
4510	if v == nil {
4511		return nil
4512	}
4513	invalidParams := smithy.InvalidParamsError{Context: "GetBaiduChannelInput"}
4514	if v.ApplicationId == nil {
4515		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4516	}
4517	if invalidParams.Len() > 0 {
4518		return invalidParams
4519	} else {
4520		return nil
4521	}
4522}
4523
4524func validateOpGetCampaignActivitiesInput(v *GetCampaignActivitiesInput) error {
4525	if v == nil {
4526		return nil
4527	}
4528	invalidParams := smithy.InvalidParamsError{Context: "GetCampaignActivitiesInput"}
4529	if v.ApplicationId == nil {
4530		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4531	}
4532	if v.CampaignId == nil {
4533		invalidParams.Add(smithy.NewErrParamRequired("CampaignId"))
4534	}
4535	if invalidParams.Len() > 0 {
4536		return invalidParams
4537	} else {
4538		return nil
4539	}
4540}
4541
4542func validateOpGetCampaignDateRangeKpiInput(v *GetCampaignDateRangeKpiInput) error {
4543	if v == nil {
4544		return nil
4545	}
4546	invalidParams := smithy.InvalidParamsError{Context: "GetCampaignDateRangeKpiInput"}
4547	if v.ApplicationId == nil {
4548		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4549	}
4550	if v.CampaignId == nil {
4551		invalidParams.Add(smithy.NewErrParamRequired("CampaignId"))
4552	}
4553	if v.KpiName == nil {
4554		invalidParams.Add(smithy.NewErrParamRequired("KpiName"))
4555	}
4556	if invalidParams.Len() > 0 {
4557		return invalidParams
4558	} else {
4559		return nil
4560	}
4561}
4562
4563func validateOpGetCampaignInput(v *GetCampaignInput) error {
4564	if v == nil {
4565		return nil
4566	}
4567	invalidParams := smithy.InvalidParamsError{Context: "GetCampaignInput"}
4568	if v.ApplicationId == nil {
4569		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4570	}
4571	if v.CampaignId == nil {
4572		invalidParams.Add(smithy.NewErrParamRequired("CampaignId"))
4573	}
4574	if invalidParams.Len() > 0 {
4575		return invalidParams
4576	} else {
4577		return nil
4578	}
4579}
4580
4581func validateOpGetCampaignsInput(v *GetCampaignsInput) error {
4582	if v == nil {
4583		return nil
4584	}
4585	invalidParams := smithy.InvalidParamsError{Context: "GetCampaignsInput"}
4586	if v.ApplicationId == nil {
4587		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4588	}
4589	if invalidParams.Len() > 0 {
4590		return invalidParams
4591	} else {
4592		return nil
4593	}
4594}
4595
4596func validateOpGetCampaignVersionInput(v *GetCampaignVersionInput) error {
4597	if v == nil {
4598		return nil
4599	}
4600	invalidParams := smithy.InvalidParamsError{Context: "GetCampaignVersionInput"}
4601	if v.ApplicationId == nil {
4602		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4603	}
4604	if v.CampaignId == nil {
4605		invalidParams.Add(smithy.NewErrParamRequired("CampaignId"))
4606	}
4607	if v.Version == nil {
4608		invalidParams.Add(smithy.NewErrParamRequired("Version"))
4609	}
4610	if invalidParams.Len() > 0 {
4611		return invalidParams
4612	} else {
4613		return nil
4614	}
4615}
4616
4617func validateOpGetCampaignVersionsInput(v *GetCampaignVersionsInput) error {
4618	if v == nil {
4619		return nil
4620	}
4621	invalidParams := smithy.InvalidParamsError{Context: "GetCampaignVersionsInput"}
4622	if v.ApplicationId == nil {
4623		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4624	}
4625	if v.CampaignId == nil {
4626		invalidParams.Add(smithy.NewErrParamRequired("CampaignId"))
4627	}
4628	if invalidParams.Len() > 0 {
4629		return invalidParams
4630	} else {
4631		return nil
4632	}
4633}
4634
4635func validateOpGetChannelsInput(v *GetChannelsInput) error {
4636	if v == nil {
4637		return nil
4638	}
4639	invalidParams := smithy.InvalidParamsError{Context: "GetChannelsInput"}
4640	if v.ApplicationId == nil {
4641		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4642	}
4643	if invalidParams.Len() > 0 {
4644		return invalidParams
4645	} else {
4646		return nil
4647	}
4648}
4649
4650func validateOpGetEmailChannelInput(v *GetEmailChannelInput) error {
4651	if v == nil {
4652		return nil
4653	}
4654	invalidParams := smithy.InvalidParamsError{Context: "GetEmailChannelInput"}
4655	if v.ApplicationId == nil {
4656		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4657	}
4658	if invalidParams.Len() > 0 {
4659		return invalidParams
4660	} else {
4661		return nil
4662	}
4663}
4664
4665func validateOpGetEmailTemplateInput(v *GetEmailTemplateInput) error {
4666	if v == nil {
4667		return nil
4668	}
4669	invalidParams := smithy.InvalidParamsError{Context: "GetEmailTemplateInput"}
4670	if v.TemplateName == nil {
4671		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
4672	}
4673	if invalidParams.Len() > 0 {
4674		return invalidParams
4675	} else {
4676		return nil
4677	}
4678}
4679
4680func validateOpGetEndpointInput(v *GetEndpointInput) error {
4681	if v == nil {
4682		return nil
4683	}
4684	invalidParams := smithy.InvalidParamsError{Context: "GetEndpointInput"}
4685	if v.ApplicationId == nil {
4686		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4687	}
4688	if v.EndpointId == nil {
4689		invalidParams.Add(smithy.NewErrParamRequired("EndpointId"))
4690	}
4691	if invalidParams.Len() > 0 {
4692		return invalidParams
4693	} else {
4694		return nil
4695	}
4696}
4697
4698func validateOpGetEventStreamInput(v *GetEventStreamInput) error {
4699	if v == nil {
4700		return nil
4701	}
4702	invalidParams := smithy.InvalidParamsError{Context: "GetEventStreamInput"}
4703	if v.ApplicationId == nil {
4704		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4705	}
4706	if invalidParams.Len() > 0 {
4707		return invalidParams
4708	} else {
4709		return nil
4710	}
4711}
4712
4713func validateOpGetExportJobInput(v *GetExportJobInput) error {
4714	if v == nil {
4715		return nil
4716	}
4717	invalidParams := smithy.InvalidParamsError{Context: "GetExportJobInput"}
4718	if v.ApplicationId == nil {
4719		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4720	}
4721	if v.JobId == nil {
4722		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
4723	}
4724	if invalidParams.Len() > 0 {
4725		return invalidParams
4726	} else {
4727		return nil
4728	}
4729}
4730
4731func validateOpGetExportJobsInput(v *GetExportJobsInput) error {
4732	if v == nil {
4733		return nil
4734	}
4735	invalidParams := smithy.InvalidParamsError{Context: "GetExportJobsInput"}
4736	if v.ApplicationId == nil {
4737		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4738	}
4739	if invalidParams.Len() > 0 {
4740		return invalidParams
4741	} else {
4742		return nil
4743	}
4744}
4745
4746func validateOpGetGcmChannelInput(v *GetGcmChannelInput) error {
4747	if v == nil {
4748		return nil
4749	}
4750	invalidParams := smithy.InvalidParamsError{Context: "GetGcmChannelInput"}
4751	if v.ApplicationId == nil {
4752		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4753	}
4754	if invalidParams.Len() > 0 {
4755		return invalidParams
4756	} else {
4757		return nil
4758	}
4759}
4760
4761func validateOpGetImportJobInput(v *GetImportJobInput) error {
4762	if v == nil {
4763		return nil
4764	}
4765	invalidParams := smithy.InvalidParamsError{Context: "GetImportJobInput"}
4766	if v.ApplicationId == nil {
4767		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4768	}
4769	if v.JobId == nil {
4770		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
4771	}
4772	if invalidParams.Len() > 0 {
4773		return invalidParams
4774	} else {
4775		return nil
4776	}
4777}
4778
4779func validateOpGetImportJobsInput(v *GetImportJobsInput) error {
4780	if v == nil {
4781		return nil
4782	}
4783	invalidParams := smithy.InvalidParamsError{Context: "GetImportJobsInput"}
4784	if v.ApplicationId == nil {
4785		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4786	}
4787	if invalidParams.Len() > 0 {
4788		return invalidParams
4789	} else {
4790		return nil
4791	}
4792}
4793
4794func validateOpGetJourneyDateRangeKpiInput(v *GetJourneyDateRangeKpiInput) error {
4795	if v == nil {
4796		return nil
4797	}
4798	invalidParams := smithy.InvalidParamsError{Context: "GetJourneyDateRangeKpiInput"}
4799	if v.ApplicationId == nil {
4800		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4801	}
4802	if v.JourneyId == nil {
4803		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
4804	}
4805	if v.KpiName == nil {
4806		invalidParams.Add(smithy.NewErrParamRequired("KpiName"))
4807	}
4808	if invalidParams.Len() > 0 {
4809		return invalidParams
4810	} else {
4811		return nil
4812	}
4813}
4814
4815func validateOpGetJourneyExecutionActivityMetricsInput(v *GetJourneyExecutionActivityMetricsInput) error {
4816	if v == nil {
4817		return nil
4818	}
4819	invalidParams := smithy.InvalidParamsError{Context: "GetJourneyExecutionActivityMetricsInput"}
4820	if v.ApplicationId == nil {
4821		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4822	}
4823	if v.JourneyActivityId == nil {
4824		invalidParams.Add(smithy.NewErrParamRequired("JourneyActivityId"))
4825	}
4826	if v.JourneyId == nil {
4827		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
4828	}
4829	if invalidParams.Len() > 0 {
4830		return invalidParams
4831	} else {
4832		return nil
4833	}
4834}
4835
4836func validateOpGetJourneyExecutionMetricsInput(v *GetJourneyExecutionMetricsInput) error {
4837	if v == nil {
4838		return nil
4839	}
4840	invalidParams := smithy.InvalidParamsError{Context: "GetJourneyExecutionMetricsInput"}
4841	if v.ApplicationId == nil {
4842		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4843	}
4844	if v.JourneyId == nil {
4845		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
4846	}
4847	if invalidParams.Len() > 0 {
4848		return invalidParams
4849	} else {
4850		return nil
4851	}
4852}
4853
4854func validateOpGetJourneyInput(v *GetJourneyInput) error {
4855	if v == nil {
4856		return nil
4857	}
4858	invalidParams := smithy.InvalidParamsError{Context: "GetJourneyInput"}
4859	if v.ApplicationId == nil {
4860		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4861	}
4862	if v.JourneyId == nil {
4863		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
4864	}
4865	if invalidParams.Len() > 0 {
4866		return invalidParams
4867	} else {
4868		return nil
4869	}
4870}
4871
4872func validateOpGetPushTemplateInput(v *GetPushTemplateInput) error {
4873	if v == nil {
4874		return nil
4875	}
4876	invalidParams := smithy.InvalidParamsError{Context: "GetPushTemplateInput"}
4877	if v.TemplateName == nil {
4878		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
4879	}
4880	if invalidParams.Len() > 0 {
4881		return invalidParams
4882	} else {
4883		return nil
4884	}
4885}
4886
4887func validateOpGetRecommenderConfigurationInput(v *GetRecommenderConfigurationInput) error {
4888	if v == nil {
4889		return nil
4890	}
4891	invalidParams := smithy.InvalidParamsError{Context: "GetRecommenderConfigurationInput"}
4892	if v.RecommenderId == nil {
4893		invalidParams.Add(smithy.NewErrParamRequired("RecommenderId"))
4894	}
4895	if invalidParams.Len() > 0 {
4896		return invalidParams
4897	} else {
4898		return nil
4899	}
4900}
4901
4902func validateOpGetSegmentExportJobsInput(v *GetSegmentExportJobsInput) error {
4903	if v == nil {
4904		return nil
4905	}
4906	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentExportJobsInput"}
4907	if v.ApplicationId == nil {
4908		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4909	}
4910	if v.SegmentId == nil {
4911		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
4912	}
4913	if invalidParams.Len() > 0 {
4914		return invalidParams
4915	} else {
4916		return nil
4917	}
4918}
4919
4920func validateOpGetSegmentImportJobsInput(v *GetSegmentImportJobsInput) error {
4921	if v == nil {
4922		return nil
4923	}
4924	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentImportJobsInput"}
4925	if v.ApplicationId == nil {
4926		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4927	}
4928	if v.SegmentId == nil {
4929		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
4930	}
4931	if invalidParams.Len() > 0 {
4932		return invalidParams
4933	} else {
4934		return nil
4935	}
4936}
4937
4938func validateOpGetSegmentInput(v *GetSegmentInput) error {
4939	if v == nil {
4940		return nil
4941	}
4942	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentInput"}
4943	if v.ApplicationId == nil {
4944		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4945	}
4946	if v.SegmentId == nil {
4947		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
4948	}
4949	if invalidParams.Len() > 0 {
4950		return invalidParams
4951	} else {
4952		return nil
4953	}
4954}
4955
4956func validateOpGetSegmentsInput(v *GetSegmentsInput) error {
4957	if v == nil {
4958		return nil
4959	}
4960	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentsInput"}
4961	if v.ApplicationId == nil {
4962		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4963	}
4964	if invalidParams.Len() > 0 {
4965		return invalidParams
4966	} else {
4967		return nil
4968	}
4969}
4970
4971func validateOpGetSegmentVersionInput(v *GetSegmentVersionInput) error {
4972	if v == nil {
4973		return nil
4974	}
4975	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentVersionInput"}
4976	if v.ApplicationId == nil {
4977		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4978	}
4979	if v.SegmentId == nil {
4980		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
4981	}
4982	if v.Version == nil {
4983		invalidParams.Add(smithy.NewErrParamRequired("Version"))
4984	}
4985	if invalidParams.Len() > 0 {
4986		return invalidParams
4987	} else {
4988		return nil
4989	}
4990}
4991
4992func validateOpGetSegmentVersionsInput(v *GetSegmentVersionsInput) error {
4993	if v == nil {
4994		return nil
4995	}
4996	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentVersionsInput"}
4997	if v.ApplicationId == nil {
4998		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
4999	}
5000	if v.SegmentId == nil {
5001		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
5002	}
5003	if invalidParams.Len() > 0 {
5004		return invalidParams
5005	} else {
5006		return nil
5007	}
5008}
5009
5010func validateOpGetSmsChannelInput(v *GetSmsChannelInput) error {
5011	if v == nil {
5012		return nil
5013	}
5014	invalidParams := smithy.InvalidParamsError{Context: "GetSmsChannelInput"}
5015	if v.ApplicationId == nil {
5016		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5017	}
5018	if invalidParams.Len() > 0 {
5019		return invalidParams
5020	} else {
5021		return nil
5022	}
5023}
5024
5025func validateOpGetSmsTemplateInput(v *GetSmsTemplateInput) error {
5026	if v == nil {
5027		return nil
5028	}
5029	invalidParams := smithy.InvalidParamsError{Context: "GetSmsTemplateInput"}
5030	if v.TemplateName == nil {
5031		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
5032	}
5033	if invalidParams.Len() > 0 {
5034		return invalidParams
5035	} else {
5036		return nil
5037	}
5038}
5039
5040func validateOpGetUserEndpointsInput(v *GetUserEndpointsInput) error {
5041	if v == nil {
5042		return nil
5043	}
5044	invalidParams := smithy.InvalidParamsError{Context: "GetUserEndpointsInput"}
5045	if v.ApplicationId == nil {
5046		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5047	}
5048	if v.UserId == nil {
5049		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
5050	}
5051	if invalidParams.Len() > 0 {
5052		return invalidParams
5053	} else {
5054		return nil
5055	}
5056}
5057
5058func validateOpGetVoiceChannelInput(v *GetVoiceChannelInput) error {
5059	if v == nil {
5060		return nil
5061	}
5062	invalidParams := smithy.InvalidParamsError{Context: "GetVoiceChannelInput"}
5063	if v.ApplicationId == nil {
5064		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5065	}
5066	if invalidParams.Len() > 0 {
5067		return invalidParams
5068	} else {
5069		return nil
5070	}
5071}
5072
5073func validateOpGetVoiceTemplateInput(v *GetVoiceTemplateInput) error {
5074	if v == nil {
5075		return nil
5076	}
5077	invalidParams := smithy.InvalidParamsError{Context: "GetVoiceTemplateInput"}
5078	if v.TemplateName == nil {
5079		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
5080	}
5081	if invalidParams.Len() > 0 {
5082		return invalidParams
5083	} else {
5084		return nil
5085	}
5086}
5087
5088func validateOpListJourneysInput(v *ListJourneysInput) error {
5089	if v == nil {
5090		return nil
5091	}
5092	invalidParams := smithy.InvalidParamsError{Context: "ListJourneysInput"}
5093	if v.ApplicationId == nil {
5094		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5095	}
5096	if invalidParams.Len() > 0 {
5097		return invalidParams
5098	} else {
5099		return nil
5100	}
5101}
5102
5103func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
5104	if v == nil {
5105		return nil
5106	}
5107	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
5108	if v.ResourceArn == nil {
5109		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
5110	}
5111	if invalidParams.Len() > 0 {
5112		return invalidParams
5113	} else {
5114		return nil
5115	}
5116}
5117
5118func validateOpListTemplateVersionsInput(v *ListTemplateVersionsInput) error {
5119	if v == nil {
5120		return nil
5121	}
5122	invalidParams := smithy.InvalidParamsError{Context: "ListTemplateVersionsInput"}
5123	if v.TemplateName == nil {
5124		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
5125	}
5126	if v.TemplateType == nil {
5127		invalidParams.Add(smithy.NewErrParamRequired("TemplateType"))
5128	}
5129	if invalidParams.Len() > 0 {
5130		return invalidParams
5131	} else {
5132		return nil
5133	}
5134}
5135
5136func validateOpPhoneNumberValidateInput(v *PhoneNumberValidateInput) error {
5137	if v == nil {
5138		return nil
5139	}
5140	invalidParams := smithy.InvalidParamsError{Context: "PhoneNumberValidateInput"}
5141	if v.NumberValidateRequest == nil {
5142		invalidParams.Add(smithy.NewErrParamRequired("NumberValidateRequest"))
5143	}
5144	if invalidParams.Len() > 0 {
5145		return invalidParams
5146	} else {
5147		return nil
5148	}
5149}
5150
5151func validateOpPutEventsInput(v *PutEventsInput) error {
5152	if v == nil {
5153		return nil
5154	}
5155	invalidParams := smithy.InvalidParamsError{Context: "PutEventsInput"}
5156	if v.ApplicationId == nil {
5157		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5158	}
5159	if v.EventsRequest == nil {
5160		invalidParams.Add(smithy.NewErrParamRequired("EventsRequest"))
5161	} else if v.EventsRequest != nil {
5162		if err := validateEventsRequest(v.EventsRequest); err != nil {
5163			invalidParams.AddNested("EventsRequest", err.(smithy.InvalidParamsError))
5164		}
5165	}
5166	if invalidParams.Len() > 0 {
5167		return invalidParams
5168	} else {
5169		return nil
5170	}
5171}
5172
5173func validateOpPutEventStreamInput(v *PutEventStreamInput) error {
5174	if v == nil {
5175		return nil
5176	}
5177	invalidParams := smithy.InvalidParamsError{Context: "PutEventStreamInput"}
5178	if v.ApplicationId == nil {
5179		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5180	}
5181	if v.WriteEventStream == nil {
5182		invalidParams.Add(smithy.NewErrParamRequired("WriteEventStream"))
5183	} else if v.WriteEventStream != nil {
5184		if err := validateWriteEventStream(v.WriteEventStream); err != nil {
5185			invalidParams.AddNested("WriteEventStream", err.(smithy.InvalidParamsError))
5186		}
5187	}
5188	if invalidParams.Len() > 0 {
5189		return invalidParams
5190	} else {
5191		return nil
5192	}
5193}
5194
5195func validateOpRemoveAttributesInput(v *RemoveAttributesInput) error {
5196	if v == nil {
5197		return nil
5198	}
5199	invalidParams := smithy.InvalidParamsError{Context: "RemoveAttributesInput"}
5200	if v.ApplicationId == nil {
5201		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5202	}
5203	if v.AttributeType == nil {
5204		invalidParams.Add(smithy.NewErrParamRequired("AttributeType"))
5205	}
5206	if v.UpdateAttributesRequest == nil {
5207		invalidParams.Add(smithy.NewErrParamRequired("UpdateAttributesRequest"))
5208	}
5209	if invalidParams.Len() > 0 {
5210		return invalidParams
5211	} else {
5212		return nil
5213	}
5214}
5215
5216func validateOpSendMessagesInput(v *SendMessagesInput) error {
5217	if v == nil {
5218		return nil
5219	}
5220	invalidParams := smithy.InvalidParamsError{Context: "SendMessagesInput"}
5221	if v.ApplicationId == nil {
5222		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5223	}
5224	if v.MessageRequest == nil {
5225		invalidParams.Add(smithy.NewErrParamRequired("MessageRequest"))
5226	} else if v.MessageRequest != nil {
5227		if err := validateMessageRequest(v.MessageRequest); err != nil {
5228			invalidParams.AddNested("MessageRequest", err.(smithy.InvalidParamsError))
5229		}
5230	}
5231	if invalidParams.Len() > 0 {
5232		return invalidParams
5233	} else {
5234		return nil
5235	}
5236}
5237
5238func validateOpSendUsersMessagesInput(v *SendUsersMessagesInput) error {
5239	if v == nil {
5240		return nil
5241	}
5242	invalidParams := smithy.InvalidParamsError{Context: "SendUsersMessagesInput"}
5243	if v.ApplicationId == nil {
5244		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5245	}
5246	if v.SendUsersMessageRequest == nil {
5247		invalidParams.Add(smithy.NewErrParamRequired("SendUsersMessageRequest"))
5248	} else if v.SendUsersMessageRequest != nil {
5249		if err := validateSendUsersMessageRequest(v.SendUsersMessageRequest); err != nil {
5250			invalidParams.AddNested("SendUsersMessageRequest", err.(smithy.InvalidParamsError))
5251		}
5252	}
5253	if invalidParams.Len() > 0 {
5254		return invalidParams
5255	} else {
5256		return nil
5257	}
5258}
5259
5260func validateOpTagResourceInput(v *TagResourceInput) error {
5261	if v == nil {
5262		return nil
5263	}
5264	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
5265	if v.ResourceArn == nil {
5266		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
5267	}
5268	if v.TagsModel == nil {
5269		invalidParams.Add(smithy.NewErrParamRequired("TagsModel"))
5270	} else if v.TagsModel != nil {
5271		if err := validateTagsModel(v.TagsModel); err != nil {
5272			invalidParams.AddNested("TagsModel", err.(smithy.InvalidParamsError))
5273		}
5274	}
5275	if invalidParams.Len() > 0 {
5276		return invalidParams
5277	} else {
5278		return nil
5279	}
5280}
5281
5282func validateOpUntagResourceInput(v *UntagResourceInput) error {
5283	if v == nil {
5284		return nil
5285	}
5286	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
5287	if v.ResourceArn == nil {
5288		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
5289	}
5290	if v.TagKeys == nil {
5291		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
5292	}
5293	if invalidParams.Len() > 0 {
5294		return invalidParams
5295	} else {
5296		return nil
5297	}
5298}
5299
5300func validateOpUpdateAdmChannelInput(v *UpdateAdmChannelInput) error {
5301	if v == nil {
5302		return nil
5303	}
5304	invalidParams := smithy.InvalidParamsError{Context: "UpdateAdmChannelInput"}
5305	if v.ADMChannelRequest == nil {
5306		invalidParams.Add(smithy.NewErrParamRequired("ADMChannelRequest"))
5307	} else if v.ADMChannelRequest != nil {
5308		if err := validateADMChannelRequest(v.ADMChannelRequest); err != nil {
5309			invalidParams.AddNested("ADMChannelRequest", err.(smithy.InvalidParamsError))
5310		}
5311	}
5312	if v.ApplicationId == nil {
5313		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5314	}
5315	if invalidParams.Len() > 0 {
5316		return invalidParams
5317	} else {
5318		return nil
5319	}
5320}
5321
5322func validateOpUpdateApnsChannelInput(v *UpdateApnsChannelInput) error {
5323	if v == nil {
5324		return nil
5325	}
5326	invalidParams := smithy.InvalidParamsError{Context: "UpdateApnsChannelInput"}
5327	if v.APNSChannelRequest == nil {
5328		invalidParams.Add(smithy.NewErrParamRequired("APNSChannelRequest"))
5329	}
5330	if v.ApplicationId == nil {
5331		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5332	}
5333	if invalidParams.Len() > 0 {
5334		return invalidParams
5335	} else {
5336		return nil
5337	}
5338}
5339
5340func validateOpUpdateApnsSandboxChannelInput(v *UpdateApnsSandboxChannelInput) error {
5341	if v == nil {
5342		return nil
5343	}
5344	invalidParams := smithy.InvalidParamsError{Context: "UpdateApnsSandboxChannelInput"}
5345	if v.APNSSandboxChannelRequest == nil {
5346		invalidParams.Add(smithy.NewErrParamRequired("APNSSandboxChannelRequest"))
5347	}
5348	if v.ApplicationId == nil {
5349		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5350	}
5351	if invalidParams.Len() > 0 {
5352		return invalidParams
5353	} else {
5354		return nil
5355	}
5356}
5357
5358func validateOpUpdateApnsVoipChannelInput(v *UpdateApnsVoipChannelInput) error {
5359	if v == nil {
5360		return nil
5361	}
5362	invalidParams := smithy.InvalidParamsError{Context: "UpdateApnsVoipChannelInput"}
5363	if v.APNSVoipChannelRequest == nil {
5364		invalidParams.Add(smithy.NewErrParamRequired("APNSVoipChannelRequest"))
5365	}
5366	if v.ApplicationId == nil {
5367		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5368	}
5369	if invalidParams.Len() > 0 {
5370		return invalidParams
5371	} else {
5372		return nil
5373	}
5374}
5375
5376func validateOpUpdateApnsVoipSandboxChannelInput(v *UpdateApnsVoipSandboxChannelInput) error {
5377	if v == nil {
5378		return nil
5379	}
5380	invalidParams := smithy.InvalidParamsError{Context: "UpdateApnsVoipSandboxChannelInput"}
5381	if v.APNSVoipSandboxChannelRequest == nil {
5382		invalidParams.Add(smithy.NewErrParamRequired("APNSVoipSandboxChannelRequest"))
5383	}
5384	if v.ApplicationId == nil {
5385		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5386	}
5387	if invalidParams.Len() > 0 {
5388		return invalidParams
5389	} else {
5390		return nil
5391	}
5392}
5393
5394func validateOpUpdateApplicationSettingsInput(v *UpdateApplicationSettingsInput) error {
5395	if v == nil {
5396		return nil
5397	}
5398	invalidParams := smithy.InvalidParamsError{Context: "UpdateApplicationSettingsInput"}
5399	if v.ApplicationId == nil {
5400		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5401	}
5402	if v.WriteApplicationSettingsRequest == nil {
5403		invalidParams.Add(smithy.NewErrParamRequired("WriteApplicationSettingsRequest"))
5404	}
5405	if invalidParams.Len() > 0 {
5406		return invalidParams
5407	} else {
5408		return nil
5409	}
5410}
5411
5412func validateOpUpdateBaiduChannelInput(v *UpdateBaiduChannelInput) error {
5413	if v == nil {
5414		return nil
5415	}
5416	invalidParams := smithy.InvalidParamsError{Context: "UpdateBaiduChannelInput"}
5417	if v.ApplicationId == nil {
5418		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5419	}
5420	if v.BaiduChannelRequest == nil {
5421		invalidParams.Add(smithy.NewErrParamRequired("BaiduChannelRequest"))
5422	} else if v.BaiduChannelRequest != nil {
5423		if err := validateBaiduChannelRequest(v.BaiduChannelRequest); err != nil {
5424			invalidParams.AddNested("BaiduChannelRequest", err.(smithy.InvalidParamsError))
5425		}
5426	}
5427	if invalidParams.Len() > 0 {
5428		return invalidParams
5429	} else {
5430		return nil
5431	}
5432}
5433
5434func validateOpUpdateCampaignInput(v *UpdateCampaignInput) error {
5435	if v == nil {
5436		return nil
5437	}
5438	invalidParams := smithy.InvalidParamsError{Context: "UpdateCampaignInput"}
5439	if v.ApplicationId == nil {
5440		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5441	}
5442	if v.CampaignId == nil {
5443		invalidParams.Add(smithy.NewErrParamRequired("CampaignId"))
5444	}
5445	if v.WriteCampaignRequest == nil {
5446		invalidParams.Add(smithy.NewErrParamRequired("WriteCampaignRequest"))
5447	} else if v.WriteCampaignRequest != nil {
5448		if err := validateWriteCampaignRequest(v.WriteCampaignRequest); err != nil {
5449			invalidParams.AddNested("WriteCampaignRequest", err.(smithy.InvalidParamsError))
5450		}
5451	}
5452	if invalidParams.Len() > 0 {
5453		return invalidParams
5454	} else {
5455		return nil
5456	}
5457}
5458
5459func validateOpUpdateEmailChannelInput(v *UpdateEmailChannelInput) error {
5460	if v == nil {
5461		return nil
5462	}
5463	invalidParams := smithy.InvalidParamsError{Context: "UpdateEmailChannelInput"}
5464	if v.ApplicationId == nil {
5465		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5466	}
5467	if v.EmailChannelRequest == nil {
5468		invalidParams.Add(smithy.NewErrParamRequired("EmailChannelRequest"))
5469	} else if v.EmailChannelRequest != nil {
5470		if err := validateEmailChannelRequest(v.EmailChannelRequest); err != nil {
5471			invalidParams.AddNested("EmailChannelRequest", err.(smithy.InvalidParamsError))
5472		}
5473	}
5474	if invalidParams.Len() > 0 {
5475		return invalidParams
5476	} else {
5477		return nil
5478	}
5479}
5480
5481func validateOpUpdateEmailTemplateInput(v *UpdateEmailTemplateInput) error {
5482	if v == nil {
5483		return nil
5484	}
5485	invalidParams := smithy.InvalidParamsError{Context: "UpdateEmailTemplateInput"}
5486	if v.EmailTemplateRequest == nil {
5487		invalidParams.Add(smithy.NewErrParamRequired("EmailTemplateRequest"))
5488	}
5489	if v.TemplateName == nil {
5490		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
5491	}
5492	if invalidParams.Len() > 0 {
5493		return invalidParams
5494	} else {
5495		return nil
5496	}
5497}
5498
5499func validateOpUpdateEndpointInput(v *UpdateEndpointInput) error {
5500	if v == nil {
5501		return nil
5502	}
5503	invalidParams := smithy.InvalidParamsError{Context: "UpdateEndpointInput"}
5504	if v.ApplicationId == nil {
5505		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5506	}
5507	if v.EndpointId == nil {
5508		invalidParams.Add(smithy.NewErrParamRequired("EndpointId"))
5509	}
5510	if v.EndpointRequest == nil {
5511		invalidParams.Add(smithy.NewErrParamRequired("EndpointRequest"))
5512	}
5513	if invalidParams.Len() > 0 {
5514		return invalidParams
5515	} else {
5516		return nil
5517	}
5518}
5519
5520func validateOpUpdateEndpointsBatchInput(v *UpdateEndpointsBatchInput) error {
5521	if v == nil {
5522		return nil
5523	}
5524	invalidParams := smithy.InvalidParamsError{Context: "UpdateEndpointsBatchInput"}
5525	if v.ApplicationId == nil {
5526		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5527	}
5528	if v.EndpointBatchRequest == nil {
5529		invalidParams.Add(smithy.NewErrParamRequired("EndpointBatchRequest"))
5530	} else if v.EndpointBatchRequest != nil {
5531		if err := validateEndpointBatchRequest(v.EndpointBatchRequest); err != nil {
5532			invalidParams.AddNested("EndpointBatchRequest", err.(smithy.InvalidParamsError))
5533		}
5534	}
5535	if invalidParams.Len() > 0 {
5536		return invalidParams
5537	} else {
5538		return nil
5539	}
5540}
5541
5542func validateOpUpdateGcmChannelInput(v *UpdateGcmChannelInput) error {
5543	if v == nil {
5544		return nil
5545	}
5546	invalidParams := smithy.InvalidParamsError{Context: "UpdateGcmChannelInput"}
5547	if v.ApplicationId == nil {
5548		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5549	}
5550	if v.GCMChannelRequest == nil {
5551		invalidParams.Add(smithy.NewErrParamRequired("GCMChannelRequest"))
5552	} else if v.GCMChannelRequest != nil {
5553		if err := validateGCMChannelRequest(v.GCMChannelRequest); err != nil {
5554			invalidParams.AddNested("GCMChannelRequest", err.(smithy.InvalidParamsError))
5555		}
5556	}
5557	if invalidParams.Len() > 0 {
5558		return invalidParams
5559	} else {
5560		return nil
5561	}
5562}
5563
5564func validateOpUpdateJourneyInput(v *UpdateJourneyInput) error {
5565	if v == nil {
5566		return nil
5567	}
5568	invalidParams := smithy.InvalidParamsError{Context: "UpdateJourneyInput"}
5569	if v.ApplicationId == nil {
5570		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5571	}
5572	if v.JourneyId == nil {
5573		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
5574	}
5575	if v.WriteJourneyRequest == nil {
5576		invalidParams.Add(smithy.NewErrParamRequired("WriteJourneyRequest"))
5577	} else if v.WriteJourneyRequest != nil {
5578		if err := validateWriteJourneyRequest(v.WriteJourneyRequest); err != nil {
5579			invalidParams.AddNested("WriteJourneyRequest", err.(smithy.InvalidParamsError))
5580		}
5581	}
5582	if invalidParams.Len() > 0 {
5583		return invalidParams
5584	} else {
5585		return nil
5586	}
5587}
5588
5589func validateOpUpdateJourneyStateInput(v *UpdateJourneyStateInput) error {
5590	if v == nil {
5591		return nil
5592	}
5593	invalidParams := smithy.InvalidParamsError{Context: "UpdateJourneyStateInput"}
5594	if v.ApplicationId == nil {
5595		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5596	}
5597	if v.JourneyId == nil {
5598		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
5599	}
5600	if v.JourneyStateRequest == nil {
5601		invalidParams.Add(smithy.NewErrParamRequired("JourneyStateRequest"))
5602	}
5603	if invalidParams.Len() > 0 {
5604		return invalidParams
5605	} else {
5606		return nil
5607	}
5608}
5609
5610func validateOpUpdatePushTemplateInput(v *UpdatePushTemplateInput) error {
5611	if v == nil {
5612		return nil
5613	}
5614	invalidParams := smithy.InvalidParamsError{Context: "UpdatePushTemplateInput"}
5615	if v.PushNotificationTemplateRequest == nil {
5616		invalidParams.Add(smithy.NewErrParamRequired("PushNotificationTemplateRequest"))
5617	}
5618	if v.TemplateName == nil {
5619		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
5620	}
5621	if invalidParams.Len() > 0 {
5622		return invalidParams
5623	} else {
5624		return nil
5625	}
5626}
5627
5628func validateOpUpdateRecommenderConfigurationInput(v *UpdateRecommenderConfigurationInput) error {
5629	if v == nil {
5630		return nil
5631	}
5632	invalidParams := smithy.InvalidParamsError{Context: "UpdateRecommenderConfigurationInput"}
5633	if v.RecommenderId == nil {
5634		invalidParams.Add(smithy.NewErrParamRequired("RecommenderId"))
5635	}
5636	if v.UpdateRecommenderConfiguration == nil {
5637		invalidParams.Add(smithy.NewErrParamRequired("UpdateRecommenderConfiguration"))
5638	} else if v.UpdateRecommenderConfiguration != nil {
5639		if err := validateUpdateRecommenderConfigurationShape(v.UpdateRecommenderConfiguration); err != nil {
5640			invalidParams.AddNested("UpdateRecommenderConfiguration", err.(smithy.InvalidParamsError))
5641		}
5642	}
5643	if invalidParams.Len() > 0 {
5644		return invalidParams
5645	} else {
5646		return nil
5647	}
5648}
5649
5650func validateOpUpdateSegmentInput(v *UpdateSegmentInput) error {
5651	if v == nil {
5652		return nil
5653	}
5654	invalidParams := smithy.InvalidParamsError{Context: "UpdateSegmentInput"}
5655	if v.ApplicationId == nil {
5656		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5657	}
5658	if v.SegmentId == nil {
5659		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
5660	}
5661	if v.WriteSegmentRequest == nil {
5662		invalidParams.Add(smithy.NewErrParamRequired("WriteSegmentRequest"))
5663	} else if v.WriteSegmentRequest != nil {
5664		if err := validateWriteSegmentRequest(v.WriteSegmentRequest); err != nil {
5665			invalidParams.AddNested("WriteSegmentRequest", err.(smithy.InvalidParamsError))
5666		}
5667	}
5668	if invalidParams.Len() > 0 {
5669		return invalidParams
5670	} else {
5671		return nil
5672	}
5673}
5674
5675func validateOpUpdateSmsChannelInput(v *UpdateSmsChannelInput) error {
5676	if v == nil {
5677		return nil
5678	}
5679	invalidParams := smithy.InvalidParamsError{Context: "UpdateSmsChannelInput"}
5680	if v.ApplicationId == nil {
5681		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5682	}
5683	if v.SMSChannelRequest == nil {
5684		invalidParams.Add(smithy.NewErrParamRequired("SMSChannelRequest"))
5685	}
5686	if invalidParams.Len() > 0 {
5687		return invalidParams
5688	} else {
5689		return nil
5690	}
5691}
5692
5693func validateOpUpdateSmsTemplateInput(v *UpdateSmsTemplateInput) error {
5694	if v == nil {
5695		return nil
5696	}
5697	invalidParams := smithy.InvalidParamsError{Context: "UpdateSmsTemplateInput"}
5698	if v.SMSTemplateRequest == nil {
5699		invalidParams.Add(smithy.NewErrParamRequired("SMSTemplateRequest"))
5700	}
5701	if v.TemplateName == nil {
5702		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
5703	}
5704	if invalidParams.Len() > 0 {
5705		return invalidParams
5706	} else {
5707		return nil
5708	}
5709}
5710
5711func validateOpUpdateTemplateActiveVersionInput(v *UpdateTemplateActiveVersionInput) error {
5712	if v == nil {
5713		return nil
5714	}
5715	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplateActiveVersionInput"}
5716	if v.TemplateActiveVersionRequest == nil {
5717		invalidParams.Add(smithy.NewErrParamRequired("TemplateActiveVersionRequest"))
5718	}
5719	if v.TemplateName == nil {
5720		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
5721	}
5722	if v.TemplateType == nil {
5723		invalidParams.Add(smithy.NewErrParamRequired("TemplateType"))
5724	}
5725	if invalidParams.Len() > 0 {
5726		return invalidParams
5727	} else {
5728		return nil
5729	}
5730}
5731
5732func validateOpUpdateVoiceChannelInput(v *UpdateVoiceChannelInput) error {
5733	if v == nil {
5734		return nil
5735	}
5736	invalidParams := smithy.InvalidParamsError{Context: "UpdateVoiceChannelInput"}
5737	if v.ApplicationId == nil {
5738		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
5739	}
5740	if v.VoiceChannelRequest == nil {
5741		invalidParams.Add(smithy.NewErrParamRequired("VoiceChannelRequest"))
5742	}
5743	if invalidParams.Len() > 0 {
5744		return invalidParams
5745	} else {
5746		return nil
5747	}
5748}
5749
5750func validateOpUpdateVoiceTemplateInput(v *UpdateVoiceTemplateInput) error {
5751	if v == nil {
5752		return nil
5753	}
5754	invalidParams := smithy.InvalidParamsError{Context: "UpdateVoiceTemplateInput"}
5755	if v.TemplateName == nil {
5756		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
5757	}
5758	if v.VoiceTemplateRequest == nil {
5759		invalidParams.Add(smithy.NewErrParamRequired("VoiceTemplateRequest"))
5760	}
5761	if invalidParams.Len() > 0 {
5762		return invalidParams
5763	} else {
5764		return nil
5765	}
5766}
5767