1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package pinpointemail
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/pinpointemail/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateConfigurationSetEventDestination struct {
14}
15
16func (*validateOpCreateConfigurationSetEventDestination) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateConfigurationSetEventDestination) 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.(*CreateConfigurationSetEventDestinationInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateConfigurationSetEventDestinationInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateConfigurationSet struct {
34}
35
36func (*validateOpCreateConfigurationSet) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateConfigurationSet) 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.(*CreateConfigurationSetInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateConfigurationSetInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateDedicatedIpPool struct {
54}
55
56func (*validateOpCreateDedicatedIpPool) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateDedicatedIpPool) 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.(*CreateDedicatedIpPoolInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateDedicatedIpPoolInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateDeliverabilityTestReport struct {
74}
75
76func (*validateOpCreateDeliverabilityTestReport) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateDeliverabilityTestReport) 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.(*CreateDeliverabilityTestReportInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateDeliverabilityTestReportInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateEmailIdentity struct {
94}
95
96func (*validateOpCreateEmailIdentity) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateEmailIdentity) 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.(*CreateEmailIdentityInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateEmailIdentityInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeleteConfigurationSetEventDestination struct {
114}
115
116func (*validateOpDeleteConfigurationSetEventDestination) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeleteConfigurationSetEventDestination) 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.(*DeleteConfigurationSetEventDestinationInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeleteConfigurationSetEventDestinationInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteConfigurationSet struct {
134}
135
136func (*validateOpDeleteConfigurationSet) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteConfigurationSet) 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.(*DeleteConfigurationSetInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteConfigurationSetInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteDedicatedIpPool struct {
154}
155
156func (*validateOpDeleteDedicatedIpPool) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteDedicatedIpPool) 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.(*DeleteDedicatedIpPoolInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteDedicatedIpPoolInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteEmailIdentity struct {
174}
175
176func (*validateOpDeleteEmailIdentity) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteEmailIdentity) 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.(*DeleteEmailIdentityInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteEmailIdentityInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpGetBlacklistReports struct {
194}
195
196func (*validateOpGetBlacklistReports) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpGetBlacklistReports) 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.(*GetBlacklistReportsInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpGetBlacklistReportsInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpGetConfigurationSetEventDestinations struct {
214}
215
216func (*validateOpGetConfigurationSetEventDestinations) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpGetConfigurationSetEventDestinations) 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.(*GetConfigurationSetEventDestinationsInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpGetConfigurationSetEventDestinationsInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpGetConfigurationSet struct {
234}
235
236func (*validateOpGetConfigurationSet) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpGetConfigurationSet) 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.(*GetConfigurationSetInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpGetConfigurationSetInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpGetDedicatedIp struct {
254}
255
256func (*validateOpGetDedicatedIp) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpGetDedicatedIp) 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.(*GetDedicatedIpInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpGetDedicatedIpInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpGetDeliverabilityTestReport struct {
274}
275
276func (*validateOpGetDeliverabilityTestReport) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpGetDeliverabilityTestReport) 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.(*GetDeliverabilityTestReportInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpGetDeliverabilityTestReportInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpGetDomainDeliverabilityCampaign struct {
294}
295
296func (*validateOpGetDomainDeliverabilityCampaign) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpGetDomainDeliverabilityCampaign) 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.(*GetDomainDeliverabilityCampaignInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpGetDomainDeliverabilityCampaignInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpGetDomainStatisticsReport struct {
314}
315
316func (*validateOpGetDomainStatisticsReport) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpGetDomainStatisticsReport) 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.(*GetDomainStatisticsReportInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpGetDomainStatisticsReportInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpGetEmailIdentity struct {
334}
335
336func (*validateOpGetEmailIdentity) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpGetEmailIdentity) 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.(*GetEmailIdentityInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpGetEmailIdentityInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpListDomainDeliverabilityCampaigns struct {
354}
355
356func (*validateOpListDomainDeliverabilityCampaigns) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpListDomainDeliverabilityCampaigns) 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.(*ListDomainDeliverabilityCampaignsInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpListDomainDeliverabilityCampaignsInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpListTagsForResource struct {
374}
375
376func (*validateOpListTagsForResource) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpListTagsForResourceInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpPutConfigurationSetDeliveryOptions struct {
394}
395
396func (*validateOpPutConfigurationSetDeliveryOptions) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpPutConfigurationSetDeliveryOptions) 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.(*PutConfigurationSetDeliveryOptionsInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpPutConfigurationSetDeliveryOptionsInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpPutConfigurationSetReputationOptions struct {
414}
415
416func (*validateOpPutConfigurationSetReputationOptions) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpPutConfigurationSetReputationOptions) 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.(*PutConfigurationSetReputationOptionsInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpPutConfigurationSetReputationOptionsInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpPutConfigurationSetSendingOptions struct {
434}
435
436func (*validateOpPutConfigurationSetSendingOptions) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpPutConfigurationSetSendingOptions) 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.(*PutConfigurationSetSendingOptionsInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpPutConfigurationSetSendingOptionsInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpPutConfigurationSetTrackingOptions struct {
454}
455
456func (*validateOpPutConfigurationSetTrackingOptions) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpPutConfigurationSetTrackingOptions) 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.(*PutConfigurationSetTrackingOptionsInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpPutConfigurationSetTrackingOptionsInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpPutDedicatedIpInPool struct {
474}
475
476func (*validateOpPutDedicatedIpInPool) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpPutDedicatedIpInPool) 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.(*PutDedicatedIpInPoolInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpPutDedicatedIpInPoolInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpPutDedicatedIpWarmupAttributes struct {
494}
495
496func (*validateOpPutDedicatedIpWarmupAttributes) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpPutDedicatedIpWarmupAttributes) 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.(*PutDedicatedIpWarmupAttributesInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpPutDedicatedIpWarmupAttributesInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpPutDeliverabilityDashboardOption struct {
514}
515
516func (*validateOpPutDeliverabilityDashboardOption) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpPutDeliverabilityDashboardOption) 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.(*PutDeliverabilityDashboardOptionInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpPutDeliverabilityDashboardOptionInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpPutEmailIdentityDkimAttributes struct {
534}
535
536func (*validateOpPutEmailIdentityDkimAttributes) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpPutEmailIdentityDkimAttributes) 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.(*PutEmailIdentityDkimAttributesInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpPutEmailIdentityDkimAttributesInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpPutEmailIdentityFeedbackAttributes struct {
554}
555
556func (*validateOpPutEmailIdentityFeedbackAttributes) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpPutEmailIdentityFeedbackAttributes) 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.(*PutEmailIdentityFeedbackAttributesInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpPutEmailIdentityFeedbackAttributesInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpPutEmailIdentityMailFromAttributes struct {
574}
575
576func (*validateOpPutEmailIdentityMailFromAttributes) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpPutEmailIdentityMailFromAttributes) 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.(*PutEmailIdentityMailFromAttributesInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpPutEmailIdentityMailFromAttributesInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpSendEmail struct {
594}
595
596func (*validateOpSendEmail) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpSendEmail) 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.(*SendEmailInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpSendEmailInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpTagResource struct {
614}
615
616func (*validateOpTagResource) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpTagResource) 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.(*TagResourceInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpTagResourceInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpUntagResource struct {
634}
635
636func (*validateOpUntagResource) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpUntagResource) 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.(*UntagResourceInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpUntagResourceInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpUpdateConfigurationSetEventDestination struct {
654}
655
656func (*validateOpUpdateConfigurationSetEventDestination) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpUpdateConfigurationSetEventDestination) 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.(*UpdateConfigurationSetEventDestinationInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpUpdateConfigurationSetEventDestinationInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673func addOpCreateConfigurationSetEventDestinationValidationMiddleware(stack *middleware.Stack) error {
674	return stack.Initialize.Add(&validateOpCreateConfigurationSetEventDestination{}, middleware.After)
675}
676
677func addOpCreateConfigurationSetValidationMiddleware(stack *middleware.Stack) error {
678	return stack.Initialize.Add(&validateOpCreateConfigurationSet{}, middleware.After)
679}
680
681func addOpCreateDedicatedIpPoolValidationMiddleware(stack *middleware.Stack) error {
682	return stack.Initialize.Add(&validateOpCreateDedicatedIpPool{}, middleware.After)
683}
684
685func addOpCreateDeliverabilityTestReportValidationMiddleware(stack *middleware.Stack) error {
686	return stack.Initialize.Add(&validateOpCreateDeliverabilityTestReport{}, middleware.After)
687}
688
689func addOpCreateEmailIdentityValidationMiddleware(stack *middleware.Stack) error {
690	return stack.Initialize.Add(&validateOpCreateEmailIdentity{}, middleware.After)
691}
692
693func addOpDeleteConfigurationSetEventDestinationValidationMiddleware(stack *middleware.Stack) error {
694	return stack.Initialize.Add(&validateOpDeleteConfigurationSetEventDestination{}, middleware.After)
695}
696
697func addOpDeleteConfigurationSetValidationMiddleware(stack *middleware.Stack) error {
698	return stack.Initialize.Add(&validateOpDeleteConfigurationSet{}, middleware.After)
699}
700
701func addOpDeleteDedicatedIpPoolValidationMiddleware(stack *middleware.Stack) error {
702	return stack.Initialize.Add(&validateOpDeleteDedicatedIpPool{}, middleware.After)
703}
704
705func addOpDeleteEmailIdentityValidationMiddleware(stack *middleware.Stack) error {
706	return stack.Initialize.Add(&validateOpDeleteEmailIdentity{}, middleware.After)
707}
708
709func addOpGetBlacklistReportsValidationMiddleware(stack *middleware.Stack) error {
710	return stack.Initialize.Add(&validateOpGetBlacklistReports{}, middleware.After)
711}
712
713func addOpGetConfigurationSetEventDestinationsValidationMiddleware(stack *middleware.Stack) error {
714	return stack.Initialize.Add(&validateOpGetConfigurationSetEventDestinations{}, middleware.After)
715}
716
717func addOpGetConfigurationSetValidationMiddleware(stack *middleware.Stack) error {
718	return stack.Initialize.Add(&validateOpGetConfigurationSet{}, middleware.After)
719}
720
721func addOpGetDedicatedIpValidationMiddleware(stack *middleware.Stack) error {
722	return stack.Initialize.Add(&validateOpGetDedicatedIp{}, middleware.After)
723}
724
725func addOpGetDeliverabilityTestReportValidationMiddleware(stack *middleware.Stack) error {
726	return stack.Initialize.Add(&validateOpGetDeliverabilityTestReport{}, middleware.After)
727}
728
729func addOpGetDomainDeliverabilityCampaignValidationMiddleware(stack *middleware.Stack) error {
730	return stack.Initialize.Add(&validateOpGetDomainDeliverabilityCampaign{}, middleware.After)
731}
732
733func addOpGetDomainStatisticsReportValidationMiddleware(stack *middleware.Stack) error {
734	return stack.Initialize.Add(&validateOpGetDomainStatisticsReport{}, middleware.After)
735}
736
737func addOpGetEmailIdentityValidationMiddleware(stack *middleware.Stack) error {
738	return stack.Initialize.Add(&validateOpGetEmailIdentity{}, middleware.After)
739}
740
741func addOpListDomainDeliverabilityCampaignsValidationMiddleware(stack *middleware.Stack) error {
742	return stack.Initialize.Add(&validateOpListDomainDeliverabilityCampaigns{}, middleware.After)
743}
744
745func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
746	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
747}
748
749func addOpPutConfigurationSetDeliveryOptionsValidationMiddleware(stack *middleware.Stack) error {
750	return stack.Initialize.Add(&validateOpPutConfigurationSetDeliveryOptions{}, middleware.After)
751}
752
753func addOpPutConfigurationSetReputationOptionsValidationMiddleware(stack *middleware.Stack) error {
754	return stack.Initialize.Add(&validateOpPutConfigurationSetReputationOptions{}, middleware.After)
755}
756
757func addOpPutConfigurationSetSendingOptionsValidationMiddleware(stack *middleware.Stack) error {
758	return stack.Initialize.Add(&validateOpPutConfigurationSetSendingOptions{}, middleware.After)
759}
760
761func addOpPutConfigurationSetTrackingOptionsValidationMiddleware(stack *middleware.Stack) error {
762	return stack.Initialize.Add(&validateOpPutConfigurationSetTrackingOptions{}, middleware.After)
763}
764
765func addOpPutDedicatedIpInPoolValidationMiddleware(stack *middleware.Stack) error {
766	return stack.Initialize.Add(&validateOpPutDedicatedIpInPool{}, middleware.After)
767}
768
769func addOpPutDedicatedIpWarmupAttributesValidationMiddleware(stack *middleware.Stack) error {
770	return stack.Initialize.Add(&validateOpPutDedicatedIpWarmupAttributes{}, middleware.After)
771}
772
773func addOpPutDeliverabilityDashboardOptionValidationMiddleware(stack *middleware.Stack) error {
774	return stack.Initialize.Add(&validateOpPutDeliverabilityDashboardOption{}, middleware.After)
775}
776
777func addOpPutEmailIdentityDkimAttributesValidationMiddleware(stack *middleware.Stack) error {
778	return stack.Initialize.Add(&validateOpPutEmailIdentityDkimAttributes{}, middleware.After)
779}
780
781func addOpPutEmailIdentityFeedbackAttributesValidationMiddleware(stack *middleware.Stack) error {
782	return stack.Initialize.Add(&validateOpPutEmailIdentityFeedbackAttributes{}, middleware.After)
783}
784
785func addOpPutEmailIdentityMailFromAttributesValidationMiddleware(stack *middleware.Stack) error {
786	return stack.Initialize.Add(&validateOpPutEmailIdentityMailFromAttributes{}, middleware.After)
787}
788
789func addOpSendEmailValidationMiddleware(stack *middleware.Stack) error {
790	return stack.Initialize.Add(&validateOpSendEmail{}, middleware.After)
791}
792
793func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
794	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
795}
796
797func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
798	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
799}
800
801func addOpUpdateConfigurationSetEventDestinationValidationMiddleware(stack *middleware.Stack) error {
802	return stack.Initialize.Add(&validateOpUpdateConfigurationSetEventDestination{}, middleware.After)
803}
804
805func validateBody(v *types.Body) error {
806	if v == nil {
807		return nil
808	}
809	invalidParams := smithy.InvalidParamsError{Context: "Body"}
810	if v.Text != nil {
811		if err := validateContent(v.Text); err != nil {
812			invalidParams.AddNested("Text", err.(smithy.InvalidParamsError))
813		}
814	}
815	if v.Html != nil {
816		if err := validateContent(v.Html); err != nil {
817			invalidParams.AddNested("Html", err.(smithy.InvalidParamsError))
818		}
819	}
820	if invalidParams.Len() > 0 {
821		return invalidParams
822	} else {
823		return nil
824	}
825}
826
827func validateCloudWatchDestination(v *types.CloudWatchDestination) error {
828	if v == nil {
829		return nil
830	}
831	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchDestination"}
832	if v.DimensionConfigurations == nil {
833		invalidParams.Add(smithy.NewErrParamRequired("DimensionConfigurations"))
834	} else if v.DimensionConfigurations != nil {
835		if err := validateCloudWatchDimensionConfigurations(v.DimensionConfigurations); err != nil {
836			invalidParams.AddNested("DimensionConfigurations", err.(smithy.InvalidParamsError))
837		}
838	}
839	if invalidParams.Len() > 0 {
840		return invalidParams
841	} else {
842		return nil
843	}
844}
845
846func validateCloudWatchDimensionConfiguration(v *types.CloudWatchDimensionConfiguration) error {
847	if v == nil {
848		return nil
849	}
850	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchDimensionConfiguration"}
851	if v.DimensionName == nil {
852		invalidParams.Add(smithy.NewErrParamRequired("DimensionName"))
853	}
854	if len(v.DimensionValueSource) == 0 {
855		invalidParams.Add(smithy.NewErrParamRequired("DimensionValueSource"))
856	}
857	if v.DefaultDimensionValue == nil {
858		invalidParams.Add(smithy.NewErrParamRequired("DefaultDimensionValue"))
859	}
860	if invalidParams.Len() > 0 {
861		return invalidParams
862	} else {
863		return nil
864	}
865}
866
867func validateCloudWatchDimensionConfigurations(v []types.CloudWatchDimensionConfiguration) error {
868	if v == nil {
869		return nil
870	}
871	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchDimensionConfigurations"}
872	for i := range v {
873		if err := validateCloudWatchDimensionConfiguration(&v[i]); err != nil {
874			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
875		}
876	}
877	if invalidParams.Len() > 0 {
878		return invalidParams
879	} else {
880		return nil
881	}
882}
883
884func validateContent(v *types.Content) error {
885	if v == nil {
886		return nil
887	}
888	invalidParams := smithy.InvalidParamsError{Context: "Content"}
889	if v.Data == nil {
890		invalidParams.Add(smithy.NewErrParamRequired("Data"))
891	}
892	if invalidParams.Len() > 0 {
893		return invalidParams
894	} else {
895		return nil
896	}
897}
898
899func validateEmailContent(v *types.EmailContent) error {
900	if v == nil {
901		return nil
902	}
903	invalidParams := smithy.InvalidParamsError{Context: "EmailContent"}
904	if v.Simple != nil {
905		if err := validateMessage(v.Simple); err != nil {
906			invalidParams.AddNested("Simple", err.(smithy.InvalidParamsError))
907		}
908	}
909	if v.Raw != nil {
910		if err := validateRawMessage(v.Raw); err != nil {
911			invalidParams.AddNested("Raw", err.(smithy.InvalidParamsError))
912		}
913	}
914	if invalidParams.Len() > 0 {
915		return invalidParams
916	} else {
917		return nil
918	}
919}
920
921func validateEventDestinationDefinition(v *types.EventDestinationDefinition) error {
922	if v == nil {
923		return nil
924	}
925	invalidParams := smithy.InvalidParamsError{Context: "EventDestinationDefinition"}
926	if v.KinesisFirehoseDestination != nil {
927		if err := validateKinesisFirehoseDestination(v.KinesisFirehoseDestination); err != nil {
928			invalidParams.AddNested("KinesisFirehoseDestination", err.(smithy.InvalidParamsError))
929		}
930	}
931	if v.CloudWatchDestination != nil {
932		if err := validateCloudWatchDestination(v.CloudWatchDestination); err != nil {
933			invalidParams.AddNested("CloudWatchDestination", err.(smithy.InvalidParamsError))
934		}
935	}
936	if v.SnsDestination != nil {
937		if err := validateSnsDestination(v.SnsDestination); err != nil {
938			invalidParams.AddNested("SnsDestination", err.(smithy.InvalidParamsError))
939		}
940	}
941	if invalidParams.Len() > 0 {
942		return invalidParams
943	} else {
944		return nil
945	}
946}
947
948func validateKinesisFirehoseDestination(v *types.KinesisFirehoseDestination) error {
949	if v == nil {
950		return nil
951	}
952	invalidParams := smithy.InvalidParamsError{Context: "KinesisFirehoseDestination"}
953	if v.IamRoleArn == nil {
954		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
955	}
956	if v.DeliveryStreamArn == nil {
957		invalidParams.Add(smithy.NewErrParamRequired("DeliveryStreamArn"))
958	}
959	if invalidParams.Len() > 0 {
960		return invalidParams
961	} else {
962		return nil
963	}
964}
965
966func validateMessage(v *types.Message) error {
967	if v == nil {
968		return nil
969	}
970	invalidParams := smithy.InvalidParamsError{Context: "Message"}
971	if v.Subject == nil {
972		invalidParams.Add(smithy.NewErrParamRequired("Subject"))
973	} else if v.Subject != nil {
974		if err := validateContent(v.Subject); err != nil {
975			invalidParams.AddNested("Subject", err.(smithy.InvalidParamsError))
976		}
977	}
978	if v.Body == nil {
979		invalidParams.Add(smithy.NewErrParamRequired("Body"))
980	} else if v.Body != nil {
981		if err := validateBody(v.Body); err != nil {
982			invalidParams.AddNested("Body", err.(smithy.InvalidParamsError))
983		}
984	}
985	if invalidParams.Len() > 0 {
986		return invalidParams
987	} else {
988		return nil
989	}
990}
991
992func validateMessageTag(v *types.MessageTag) error {
993	if v == nil {
994		return nil
995	}
996	invalidParams := smithy.InvalidParamsError{Context: "MessageTag"}
997	if v.Name == nil {
998		invalidParams.Add(smithy.NewErrParamRequired("Name"))
999	}
1000	if v.Value == nil {
1001		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1002	}
1003	if invalidParams.Len() > 0 {
1004		return invalidParams
1005	} else {
1006		return nil
1007	}
1008}
1009
1010func validateMessageTagList(v []types.MessageTag) error {
1011	if v == nil {
1012		return nil
1013	}
1014	invalidParams := smithy.InvalidParamsError{Context: "MessageTagList"}
1015	for i := range v {
1016		if err := validateMessageTag(&v[i]); err != nil {
1017			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1018		}
1019	}
1020	if invalidParams.Len() > 0 {
1021		return invalidParams
1022	} else {
1023		return nil
1024	}
1025}
1026
1027func validateRawMessage(v *types.RawMessage) error {
1028	if v == nil {
1029		return nil
1030	}
1031	invalidParams := smithy.InvalidParamsError{Context: "RawMessage"}
1032	if v.Data == nil {
1033		invalidParams.Add(smithy.NewErrParamRequired("Data"))
1034	}
1035	if invalidParams.Len() > 0 {
1036		return invalidParams
1037	} else {
1038		return nil
1039	}
1040}
1041
1042func validateSnsDestination(v *types.SnsDestination) error {
1043	if v == nil {
1044		return nil
1045	}
1046	invalidParams := smithy.InvalidParamsError{Context: "SnsDestination"}
1047	if v.TopicArn == nil {
1048		invalidParams.Add(smithy.NewErrParamRequired("TopicArn"))
1049	}
1050	if invalidParams.Len() > 0 {
1051		return invalidParams
1052	} else {
1053		return nil
1054	}
1055}
1056
1057func validateTag(v *types.Tag) error {
1058	if v == nil {
1059		return nil
1060	}
1061	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
1062	if v.Key == nil {
1063		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1064	}
1065	if v.Value == nil {
1066		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1067	}
1068	if invalidParams.Len() > 0 {
1069		return invalidParams
1070	} else {
1071		return nil
1072	}
1073}
1074
1075func validateTagList(v []types.Tag) error {
1076	if v == nil {
1077		return nil
1078	}
1079	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
1080	for i := range v {
1081		if err := validateTag(&v[i]); err != nil {
1082			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1083		}
1084	}
1085	if invalidParams.Len() > 0 {
1086		return invalidParams
1087	} else {
1088		return nil
1089	}
1090}
1091
1092func validateTrackingOptions(v *types.TrackingOptions) error {
1093	if v == nil {
1094		return nil
1095	}
1096	invalidParams := smithy.InvalidParamsError{Context: "TrackingOptions"}
1097	if v.CustomRedirectDomain == nil {
1098		invalidParams.Add(smithy.NewErrParamRequired("CustomRedirectDomain"))
1099	}
1100	if invalidParams.Len() > 0 {
1101		return invalidParams
1102	} else {
1103		return nil
1104	}
1105}
1106
1107func validateOpCreateConfigurationSetEventDestinationInput(v *CreateConfigurationSetEventDestinationInput) error {
1108	if v == nil {
1109		return nil
1110	}
1111	invalidParams := smithy.InvalidParamsError{Context: "CreateConfigurationSetEventDestinationInput"}
1112	if v.ConfigurationSetName == nil {
1113		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1114	}
1115	if v.EventDestinationName == nil {
1116		invalidParams.Add(smithy.NewErrParamRequired("EventDestinationName"))
1117	}
1118	if v.EventDestination == nil {
1119		invalidParams.Add(smithy.NewErrParamRequired("EventDestination"))
1120	} else if v.EventDestination != nil {
1121		if err := validateEventDestinationDefinition(v.EventDestination); err != nil {
1122			invalidParams.AddNested("EventDestination", err.(smithy.InvalidParamsError))
1123		}
1124	}
1125	if invalidParams.Len() > 0 {
1126		return invalidParams
1127	} else {
1128		return nil
1129	}
1130}
1131
1132func validateOpCreateConfigurationSetInput(v *CreateConfigurationSetInput) error {
1133	if v == nil {
1134		return nil
1135	}
1136	invalidParams := smithy.InvalidParamsError{Context: "CreateConfigurationSetInput"}
1137	if v.ConfigurationSetName == nil {
1138		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1139	}
1140	if v.TrackingOptions != nil {
1141		if err := validateTrackingOptions(v.TrackingOptions); err != nil {
1142			invalidParams.AddNested("TrackingOptions", err.(smithy.InvalidParamsError))
1143		}
1144	}
1145	if v.Tags != nil {
1146		if err := validateTagList(v.Tags); err != nil {
1147			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1148		}
1149	}
1150	if invalidParams.Len() > 0 {
1151		return invalidParams
1152	} else {
1153		return nil
1154	}
1155}
1156
1157func validateOpCreateDedicatedIpPoolInput(v *CreateDedicatedIpPoolInput) error {
1158	if v == nil {
1159		return nil
1160	}
1161	invalidParams := smithy.InvalidParamsError{Context: "CreateDedicatedIpPoolInput"}
1162	if v.PoolName == nil {
1163		invalidParams.Add(smithy.NewErrParamRequired("PoolName"))
1164	}
1165	if v.Tags != nil {
1166		if err := validateTagList(v.Tags); err != nil {
1167			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1168		}
1169	}
1170	if invalidParams.Len() > 0 {
1171		return invalidParams
1172	} else {
1173		return nil
1174	}
1175}
1176
1177func validateOpCreateDeliverabilityTestReportInput(v *CreateDeliverabilityTestReportInput) error {
1178	if v == nil {
1179		return nil
1180	}
1181	invalidParams := smithy.InvalidParamsError{Context: "CreateDeliverabilityTestReportInput"}
1182	if v.FromEmailAddress == nil {
1183		invalidParams.Add(smithy.NewErrParamRequired("FromEmailAddress"))
1184	}
1185	if v.Content == nil {
1186		invalidParams.Add(smithy.NewErrParamRequired("Content"))
1187	} else if v.Content != nil {
1188		if err := validateEmailContent(v.Content); err != nil {
1189			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
1190		}
1191	}
1192	if v.Tags != nil {
1193		if err := validateTagList(v.Tags); err != nil {
1194			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1195		}
1196	}
1197	if invalidParams.Len() > 0 {
1198		return invalidParams
1199	} else {
1200		return nil
1201	}
1202}
1203
1204func validateOpCreateEmailIdentityInput(v *CreateEmailIdentityInput) error {
1205	if v == nil {
1206		return nil
1207	}
1208	invalidParams := smithy.InvalidParamsError{Context: "CreateEmailIdentityInput"}
1209	if v.EmailIdentity == nil {
1210		invalidParams.Add(smithy.NewErrParamRequired("EmailIdentity"))
1211	}
1212	if v.Tags != nil {
1213		if err := validateTagList(v.Tags); err != nil {
1214			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1215		}
1216	}
1217	if invalidParams.Len() > 0 {
1218		return invalidParams
1219	} else {
1220		return nil
1221	}
1222}
1223
1224func validateOpDeleteConfigurationSetEventDestinationInput(v *DeleteConfigurationSetEventDestinationInput) error {
1225	if v == nil {
1226		return nil
1227	}
1228	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationSetEventDestinationInput"}
1229	if v.ConfigurationSetName == nil {
1230		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1231	}
1232	if v.EventDestinationName == nil {
1233		invalidParams.Add(smithy.NewErrParamRequired("EventDestinationName"))
1234	}
1235	if invalidParams.Len() > 0 {
1236		return invalidParams
1237	} else {
1238		return nil
1239	}
1240}
1241
1242func validateOpDeleteConfigurationSetInput(v *DeleteConfigurationSetInput) error {
1243	if v == nil {
1244		return nil
1245	}
1246	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationSetInput"}
1247	if v.ConfigurationSetName == nil {
1248		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1249	}
1250	if invalidParams.Len() > 0 {
1251		return invalidParams
1252	} else {
1253		return nil
1254	}
1255}
1256
1257func validateOpDeleteDedicatedIpPoolInput(v *DeleteDedicatedIpPoolInput) error {
1258	if v == nil {
1259		return nil
1260	}
1261	invalidParams := smithy.InvalidParamsError{Context: "DeleteDedicatedIpPoolInput"}
1262	if v.PoolName == nil {
1263		invalidParams.Add(smithy.NewErrParamRequired("PoolName"))
1264	}
1265	if invalidParams.Len() > 0 {
1266		return invalidParams
1267	} else {
1268		return nil
1269	}
1270}
1271
1272func validateOpDeleteEmailIdentityInput(v *DeleteEmailIdentityInput) error {
1273	if v == nil {
1274		return nil
1275	}
1276	invalidParams := smithy.InvalidParamsError{Context: "DeleteEmailIdentityInput"}
1277	if v.EmailIdentity == nil {
1278		invalidParams.Add(smithy.NewErrParamRequired("EmailIdentity"))
1279	}
1280	if invalidParams.Len() > 0 {
1281		return invalidParams
1282	} else {
1283		return nil
1284	}
1285}
1286
1287func validateOpGetBlacklistReportsInput(v *GetBlacklistReportsInput) error {
1288	if v == nil {
1289		return nil
1290	}
1291	invalidParams := smithy.InvalidParamsError{Context: "GetBlacklistReportsInput"}
1292	if v.BlacklistItemNames == nil {
1293		invalidParams.Add(smithy.NewErrParamRequired("BlacklistItemNames"))
1294	}
1295	if invalidParams.Len() > 0 {
1296		return invalidParams
1297	} else {
1298		return nil
1299	}
1300}
1301
1302func validateOpGetConfigurationSetEventDestinationsInput(v *GetConfigurationSetEventDestinationsInput) error {
1303	if v == nil {
1304		return nil
1305	}
1306	invalidParams := smithy.InvalidParamsError{Context: "GetConfigurationSetEventDestinationsInput"}
1307	if v.ConfigurationSetName == nil {
1308		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1309	}
1310	if invalidParams.Len() > 0 {
1311		return invalidParams
1312	} else {
1313		return nil
1314	}
1315}
1316
1317func validateOpGetConfigurationSetInput(v *GetConfigurationSetInput) error {
1318	if v == nil {
1319		return nil
1320	}
1321	invalidParams := smithy.InvalidParamsError{Context: "GetConfigurationSetInput"}
1322	if v.ConfigurationSetName == nil {
1323		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1324	}
1325	if invalidParams.Len() > 0 {
1326		return invalidParams
1327	} else {
1328		return nil
1329	}
1330}
1331
1332func validateOpGetDedicatedIpInput(v *GetDedicatedIpInput) error {
1333	if v == nil {
1334		return nil
1335	}
1336	invalidParams := smithy.InvalidParamsError{Context: "GetDedicatedIpInput"}
1337	if v.Ip == nil {
1338		invalidParams.Add(smithy.NewErrParamRequired("Ip"))
1339	}
1340	if invalidParams.Len() > 0 {
1341		return invalidParams
1342	} else {
1343		return nil
1344	}
1345}
1346
1347func validateOpGetDeliverabilityTestReportInput(v *GetDeliverabilityTestReportInput) error {
1348	if v == nil {
1349		return nil
1350	}
1351	invalidParams := smithy.InvalidParamsError{Context: "GetDeliverabilityTestReportInput"}
1352	if v.ReportId == nil {
1353		invalidParams.Add(smithy.NewErrParamRequired("ReportId"))
1354	}
1355	if invalidParams.Len() > 0 {
1356		return invalidParams
1357	} else {
1358		return nil
1359	}
1360}
1361
1362func validateOpGetDomainDeliverabilityCampaignInput(v *GetDomainDeliverabilityCampaignInput) error {
1363	if v == nil {
1364		return nil
1365	}
1366	invalidParams := smithy.InvalidParamsError{Context: "GetDomainDeliverabilityCampaignInput"}
1367	if v.CampaignId == nil {
1368		invalidParams.Add(smithy.NewErrParamRequired("CampaignId"))
1369	}
1370	if invalidParams.Len() > 0 {
1371		return invalidParams
1372	} else {
1373		return nil
1374	}
1375}
1376
1377func validateOpGetDomainStatisticsReportInput(v *GetDomainStatisticsReportInput) error {
1378	if v == nil {
1379		return nil
1380	}
1381	invalidParams := smithy.InvalidParamsError{Context: "GetDomainStatisticsReportInput"}
1382	if v.Domain == nil {
1383		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
1384	}
1385	if v.StartDate == nil {
1386		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
1387	}
1388	if v.EndDate == nil {
1389		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
1390	}
1391	if invalidParams.Len() > 0 {
1392		return invalidParams
1393	} else {
1394		return nil
1395	}
1396}
1397
1398func validateOpGetEmailIdentityInput(v *GetEmailIdentityInput) error {
1399	if v == nil {
1400		return nil
1401	}
1402	invalidParams := smithy.InvalidParamsError{Context: "GetEmailIdentityInput"}
1403	if v.EmailIdentity == nil {
1404		invalidParams.Add(smithy.NewErrParamRequired("EmailIdentity"))
1405	}
1406	if invalidParams.Len() > 0 {
1407		return invalidParams
1408	} else {
1409		return nil
1410	}
1411}
1412
1413func validateOpListDomainDeliverabilityCampaignsInput(v *ListDomainDeliverabilityCampaignsInput) error {
1414	if v == nil {
1415		return nil
1416	}
1417	invalidParams := smithy.InvalidParamsError{Context: "ListDomainDeliverabilityCampaignsInput"}
1418	if v.StartDate == nil {
1419		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
1420	}
1421	if v.EndDate == nil {
1422		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
1423	}
1424	if v.SubscribedDomain == nil {
1425		invalidParams.Add(smithy.NewErrParamRequired("SubscribedDomain"))
1426	}
1427	if invalidParams.Len() > 0 {
1428		return invalidParams
1429	} else {
1430		return nil
1431	}
1432}
1433
1434func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1435	if v == nil {
1436		return nil
1437	}
1438	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1439	if v.ResourceArn == nil {
1440		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1441	}
1442	if invalidParams.Len() > 0 {
1443		return invalidParams
1444	} else {
1445		return nil
1446	}
1447}
1448
1449func validateOpPutConfigurationSetDeliveryOptionsInput(v *PutConfigurationSetDeliveryOptionsInput) error {
1450	if v == nil {
1451		return nil
1452	}
1453	invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationSetDeliveryOptionsInput"}
1454	if v.ConfigurationSetName == nil {
1455		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1456	}
1457	if invalidParams.Len() > 0 {
1458		return invalidParams
1459	} else {
1460		return nil
1461	}
1462}
1463
1464func validateOpPutConfigurationSetReputationOptionsInput(v *PutConfigurationSetReputationOptionsInput) error {
1465	if v == nil {
1466		return nil
1467	}
1468	invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationSetReputationOptionsInput"}
1469	if v.ConfigurationSetName == nil {
1470		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1471	}
1472	if invalidParams.Len() > 0 {
1473		return invalidParams
1474	} else {
1475		return nil
1476	}
1477}
1478
1479func validateOpPutConfigurationSetSendingOptionsInput(v *PutConfigurationSetSendingOptionsInput) error {
1480	if v == nil {
1481		return nil
1482	}
1483	invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationSetSendingOptionsInput"}
1484	if v.ConfigurationSetName == nil {
1485		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1486	}
1487	if invalidParams.Len() > 0 {
1488		return invalidParams
1489	} else {
1490		return nil
1491	}
1492}
1493
1494func validateOpPutConfigurationSetTrackingOptionsInput(v *PutConfigurationSetTrackingOptionsInput) error {
1495	if v == nil {
1496		return nil
1497	}
1498	invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationSetTrackingOptionsInput"}
1499	if v.ConfigurationSetName == nil {
1500		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1501	}
1502	if invalidParams.Len() > 0 {
1503		return invalidParams
1504	} else {
1505		return nil
1506	}
1507}
1508
1509func validateOpPutDedicatedIpInPoolInput(v *PutDedicatedIpInPoolInput) error {
1510	if v == nil {
1511		return nil
1512	}
1513	invalidParams := smithy.InvalidParamsError{Context: "PutDedicatedIpInPoolInput"}
1514	if v.Ip == nil {
1515		invalidParams.Add(smithy.NewErrParamRequired("Ip"))
1516	}
1517	if v.DestinationPoolName == nil {
1518		invalidParams.Add(smithy.NewErrParamRequired("DestinationPoolName"))
1519	}
1520	if invalidParams.Len() > 0 {
1521		return invalidParams
1522	} else {
1523		return nil
1524	}
1525}
1526
1527func validateOpPutDedicatedIpWarmupAttributesInput(v *PutDedicatedIpWarmupAttributesInput) error {
1528	if v == nil {
1529		return nil
1530	}
1531	invalidParams := smithy.InvalidParamsError{Context: "PutDedicatedIpWarmupAttributesInput"}
1532	if v.Ip == nil {
1533		invalidParams.Add(smithy.NewErrParamRequired("Ip"))
1534	}
1535	if v.WarmupPercentage == nil {
1536		invalidParams.Add(smithy.NewErrParamRequired("WarmupPercentage"))
1537	}
1538	if invalidParams.Len() > 0 {
1539		return invalidParams
1540	} else {
1541		return nil
1542	}
1543}
1544
1545func validateOpPutDeliverabilityDashboardOptionInput(v *PutDeliverabilityDashboardOptionInput) error {
1546	if v == nil {
1547		return nil
1548	}
1549	invalidParams := smithy.InvalidParamsError{Context: "PutDeliverabilityDashboardOptionInput"}
1550	if invalidParams.Len() > 0 {
1551		return invalidParams
1552	} else {
1553		return nil
1554	}
1555}
1556
1557func validateOpPutEmailIdentityDkimAttributesInput(v *PutEmailIdentityDkimAttributesInput) error {
1558	if v == nil {
1559		return nil
1560	}
1561	invalidParams := smithy.InvalidParamsError{Context: "PutEmailIdentityDkimAttributesInput"}
1562	if v.EmailIdentity == nil {
1563		invalidParams.Add(smithy.NewErrParamRequired("EmailIdentity"))
1564	}
1565	if invalidParams.Len() > 0 {
1566		return invalidParams
1567	} else {
1568		return nil
1569	}
1570}
1571
1572func validateOpPutEmailIdentityFeedbackAttributesInput(v *PutEmailIdentityFeedbackAttributesInput) error {
1573	if v == nil {
1574		return nil
1575	}
1576	invalidParams := smithy.InvalidParamsError{Context: "PutEmailIdentityFeedbackAttributesInput"}
1577	if v.EmailIdentity == nil {
1578		invalidParams.Add(smithy.NewErrParamRequired("EmailIdentity"))
1579	}
1580	if invalidParams.Len() > 0 {
1581		return invalidParams
1582	} else {
1583		return nil
1584	}
1585}
1586
1587func validateOpPutEmailIdentityMailFromAttributesInput(v *PutEmailIdentityMailFromAttributesInput) error {
1588	if v == nil {
1589		return nil
1590	}
1591	invalidParams := smithy.InvalidParamsError{Context: "PutEmailIdentityMailFromAttributesInput"}
1592	if v.EmailIdentity == nil {
1593		invalidParams.Add(smithy.NewErrParamRequired("EmailIdentity"))
1594	}
1595	if invalidParams.Len() > 0 {
1596		return invalidParams
1597	} else {
1598		return nil
1599	}
1600}
1601
1602func validateOpSendEmailInput(v *SendEmailInput) error {
1603	if v == nil {
1604		return nil
1605	}
1606	invalidParams := smithy.InvalidParamsError{Context: "SendEmailInput"}
1607	if v.Destination == nil {
1608		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
1609	}
1610	if v.Content == nil {
1611		invalidParams.Add(smithy.NewErrParamRequired("Content"))
1612	} else if v.Content != nil {
1613		if err := validateEmailContent(v.Content); err != nil {
1614			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
1615		}
1616	}
1617	if v.EmailTags != nil {
1618		if err := validateMessageTagList(v.EmailTags); err != nil {
1619			invalidParams.AddNested("EmailTags", err.(smithy.InvalidParamsError))
1620		}
1621	}
1622	if invalidParams.Len() > 0 {
1623		return invalidParams
1624	} else {
1625		return nil
1626	}
1627}
1628
1629func validateOpTagResourceInput(v *TagResourceInput) error {
1630	if v == nil {
1631		return nil
1632	}
1633	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1634	if v.ResourceArn == nil {
1635		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1636	}
1637	if v.Tags == nil {
1638		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1639	} else if v.Tags != nil {
1640		if err := validateTagList(v.Tags); err != nil {
1641			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1642		}
1643	}
1644	if invalidParams.Len() > 0 {
1645		return invalidParams
1646	} else {
1647		return nil
1648	}
1649}
1650
1651func validateOpUntagResourceInput(v *UntagResourceInput) error {
1652	if v == nil {
1653		return nil
1654	}
1655	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1656	if v.ResourceArn == nil {
1657		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1658	}
1659	if v.TagKeys == nil {
1660		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1661	}
1662	if invalidParams.Len() > 0 {
1663		return invalidParams
1664	} else {
1665		return nil
1666	}
1667}
1668
1669func validateOpUpdateConfigurationSetEventDestinationInput(v *UpdateConfigurationSetEventDestinationInput) error {
1670	if v == nil {
1671		return nil
1672	}
1673	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfigurationSetEventDestinationInput"}
1674	if v.ConfigurationSetName == nil {
1675		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
1676	}
1677	if v.EventDestinationName == nil {
1678		invalidParams.Add(smithy.NewErrParamRequired("EventDestinationName"))
1679	}
1680	if v.EventDestination == nil {
1681		invalidParams.Add(smithy.NewErrParamRequired("EventDestination"))
1682	} else if v.EventDestination != nil {
1683		if err := validateEventDestinationDefinition(v.EventDestination); err != nil {
1684			invalidParams.AddNested("EventDestination", err.(smithy.InvalidParamsError))
1685		}
1686	}
1687	if invalidParams.Len() > 0 {
1688		return invalidParams
1689	} else {
1690		return nil
1691	}
1692}
1693